@cubejs-client/core 1.3.15 → 1.3.16

package/dist/{cubejs-client-core.js → cubejs-client-core.cjs.js}

@@ -3,25 +3,26 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var _slicedToArray = require('@babel/runtime/helpers/slicedToArray');
-var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var _asyncToGenerator = require('@babel/runtime/helpers/asyncToGenerator');
 var _typeof = require('@babel/runtime/helpers/typeof');
 var _classCallCheck = require('@babel/runtime/helpers/classCallCheck');
 var _createClass = require('@babel/runtime/helpers/createClass');
-var _asyncToGenerator = require('@babel/runtime/helpers/asyncToGenerator');
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
 var _regeneratorRuntime = require('@babel/runtime/regenerator');
-require('core-js/modules/es.array.filter.js');
 require('core-js/modules/es.array.for-each.js');
 require('core-js/modules/es.symbol.js');
+require('core-js/modules/es.array.filter.js');
 require('core-js/modules/es.array.is-array.js');
+require('core-js/modules/es.object.define-properties.js');
+require('core-js/modules/es.object.define-property.js');
+require('core-js/modules/es.object.get-own-property-descriptor.js');
+require('core-js/modules/es.object.get-own-property-descriptors.js');
 require('core-js/modules/es.array.map.js');
+require('core-js/modules/es.array.reduce.js');
 require('core-js/modules/es.number.constructor.js');
 require('core-js/modules/es.object.entries.js');
 require('core-js/modules/es.object.keys.js');
 require('core-js/modules/es.object.to-string.js');
-require('core-js/modules/es.object.define-properties.js');
-require('core-js/modules/es.object.define-property.js');
-require('core-js/modules/es.object.get-own-property-descriptor.js');
-require('core-js/modules/es.object.get-own-property-descriptors.js');
 require('core-js/modules/es.promise.js');
 require('core-js/modules/web.dom-collections.for-each.js');
 require('core-js/modules/web.timers.js');
@@ -36,7 +37,6 @@ require('core-js/modules/es.array.includes.js');
 require('core-js/modules/es.array.index-of.js');
 require('core-js/modules/es.array.iterator.js');
 require('core-js/modules/es.array.join.js');
-require('core-js/modules/es.array.reduce.js');
 require('core-js/modules/es.date.to-string.js');
 require('core-js/modules/es.map.js');
 require('core-js/modules/es.number.is-nan.js');
@@ -53,7 +53,9 @@ require('core-js/modules/web.dom-collections.iterator.js');
 var dayjs = require('dayjs');
 var ramda = require('ramda');
 require('core-js/modules/es.array.every.js');
+require('core-js/modules/es.array.flat-map.js');
 require('core-js/modules/es.array.splice.js');
+require('core-js/modules/es.array.unscopables.flat-map.js');
 require('core-js/modules/es.array.slice.js');
 require('core-js/modules/es.parse-int.js');
 require('core-js/modules/es.string.ends-with.js');
@@ -77,11 +79,11 @@ var _wrapNativeSuper = require('@babel/runtime/helpers/wrapNativeSuper');
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
 var _slicedToArray__default = /*#__PURE__*/_interopDefaultLegacy(_slicedToArray);
-var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
+var _asyncToGenerator__default = /*#__PURE__*/_interopDefaultLegacy(_asyncToGenerator);
 var _typeof__default = /*#__PURE__*/_interopDefaultLegacy(_typeof);
 var _classCallCheck__default = /*#__PURE__*/_interopDefaultLegacy(_classCallCheck);
 var _createClass__default = /*#__PURE__*/_interopDefaultLegacy(_createClass);
-var _asyncToGenerator__default = /*#__PURE__*/_interopDefaultLegacy(_asyncToGenerator);
+var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
 var _regeneratorRuntime__default = /*#__PURE__*/_interopDefaultLegacy(_regeneratorRuntime);
 var _objectWithoutProperties__default = /*#__PURE__*/_interopDefaultLegacy(_objectWithoutProperties);
 var _toConsumableArray__default = /*#__PURE__*/_interopDefaultLegacy(_toConsumableArray);
@@ -101,6 +103,9 @@ function _objectSpread$4(e) { for (var r = 1; r < arguments.length; r++) { var t
 dayjs__default['default'].extend(quarterOfYear__default['default']);
 dayjs__default['default'].extend(duration__default['default']);
 dayjs__default['default'].extend(isoWeek__default['default']);
+
+// TODO: Define a better type as unitOfTime.DurationConstructor in moment.js
+
 var GRANULARITIES = [{
   name: undefined,
   title: 'w/o grouping'
@@ -315,9 +320,6 @@ var timeSeriesFromCustomInterval = function timeSeriesFromCustomInterval(from, t
 
 /**
  * Returns the lowest time unit for the interval
- * @protected
- * @param {string} interval
- * @returns {string}
  */
 var diffTimeUnitForInterval = function diffTimeUnitForInterval(interval) {
   if (/second/i.test(interval)) {
@@ -381,40 +383,38 @@ function ownKeys$3(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymb
 function _objectSpread$3(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys$3(Object(t), !0).forEach(function (r) { _defineProperty__default['default'](e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys$3(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 function removeEmptyQueryFields(_query) {
   var query = _query || {};
-  return ramda.fromPairs(ramda.toPairs(query).map(function (_ref) {
+  return ramda.fromPairs(ramda.toPairs(query).flatMap(function (_ref) {
     var _ref2 = _slicedToArray__default['default'](_ref, 2),
       key = _ref2[0],
       value = _ref2[1];
     if (['measures', 'dimensions', 'segments', 'timeDimensions', 'filters'].includes(key)) {
       if (Array.isArray(value) && value.length === 0) {
-        return null;
+        return [];
       }
     }
     if (key === 'order' && value) {
-      if (Array.isArray(value) && !value.length) {
-        return null;
+      if (Array.isArray(value) && value.length === 0) {
+        return [];
       } else if (!Object.keys(value).length) {
-        return null;
+        return [];
       }
     }
-    return [key, value];
-  }).filter(Boolean));
+    return [[key, value]];
+  }));
 }
 function validateQuery(_query) {
   var query = _query || {};
   return removeEmptyQueryFields(_objectSpread$3(_objectSpread$3({}, query), {}, {
     filters: (query.filters || []).filter(function (f) {
-      return f.operator;
+      return 'operator' in f;
     }),
     timeDimensions: (query.timeDimensions || []).filter(function (td) {
       return !(!td.dateRange && !td.granularity);
     })
   }));
 }
-function areQueriesEqual() {
-  var query1 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  var query2 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  return ramda.equals(Object.entries(query1 && query1.order || {}), Object.entries(query2 && query2.order || {})) && ramda.equals(query1, query2);
+function areQueriesEqual(query1, query2) {
+  return ramda.equals(Object.entries((query1 === null || query1 === void 0 ? void 0 : query1.order) || {}), Object.entries((query2 === null || query2 === void 0 ? void 0 : query2.order) || {})) && ramda.equals(query1, query2);
 }
 function defaultOrder(query) {
   var granularity = (query.timeDimensions || []).find(function (d) {
@@ -429,9 +429,7 @@ function defaultOrder(query) {
   }
   return {};
 }
-function defaultHeuristics(newState) {
-  var oldQuery = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  var options = arguments.length > 2 ? arguments[2] : undefined;
+function defaultHeuristics(newState, oldQuery, options) {
   var _clone = ramda.clone(newState),
     query = _clone.query,
     props = _objectWithoutProperties__default['default'](_clone, _excluded$2);
@@ -439,6 +437,8 @@ function defaultHeuristics(newState) {
     sessionGranularity = options.sessionGranularity;
   var granularity = sessionGranularity || DEFAULT_GRANULARITY;
   var state = _objectSpread$3({
+    shouldApplyHeuristicOrder: false,
+    pivotConfig: null,
     query: query
   }, props);
   var newQuery = null;
@@ -446,7 +446,10 @@ function defaultHeuristics(newState) {
     newQuery = query;
   }
   if (Array.isArray(newQuery) || Array.isArray(oldQuery)) {
-    return newState;
+    return _objectSpread$3({
+      shouldApplyHeuristicOrder: false,
+      pivotConfig: null
+    }, newState);
   }
   if (newQuery) {
     if ((oldQuery.timeDimensions || []).length === 1 && (newQuery.timeDimensions || []).length === 1 && newQuery.timeDimensions[0].granularity && oldQuery.timeDimensions[0].granularity !== newQuery.timeDimensions[0].granularity) {
@@ -462,8 +465,8 @@ function defaultHeuristics(newState) {
       newQuery = _objectSpread$3(_objectSpread$3({}, newQuery), {}, {
         timeDimensions: defaultTimeDimension ? [{
           dimension: defaultTimeDimension,
-          granularity: td && td.granularity || granularity,
-          dateRange: td && td.dateRange
+          granularity: (td === null || td === void 0 ? void 0 : td.granularity) || granularity,
+          dateRange: td === null || td === void 0 ? void 0 : td.dateRange
         }] : []
       });
       return _objectSpread$3(_objectSpread$3({}, state), {}, {
@@ -520,8 +523,9 @@ function defaultHeuristics(newState) {
   if (state.chartType) {
     var newChartType = state.chartType;
     if ((newChartType === 'line' || newChartType === 'area') && (oldQuery.timeDimensions || []).length === 1 && !oldQuery.timeDimensions[0].granularity) {
-      var _oldQuery$timeDimensi = _slicedToArray__default['default'](oldQuery.timeDimensions, 1),
-        _td = _oldQuery$timeDimensi[0];
+      var _ref8 = oldQuery.timeDimensions,
+        _ref9 = _slicedToArray__default['default'](_ref8, 1),
+        _td = _ref9[0];
       return _objectSpread$3(_objectSpread$3({}, state), {}, {
         pivotConfig: null,
         query: _objectSpread$3(_objectSpread$3({}, oldQuery), {}, {
@@ -532,8 +536,9 @@ function defaultHeuristics(newState) {
       });
     }
     if ((newChartType === 'pie' || newChartType === 'table' || newChartType === 'number') && (oldQuery.timeDimensions || []).length === 1 && oldQuery.timeDimensions[0].granularity) {
-      var _oldQuery$timeDimensi2 = _slicedToArray__default['default'](oldQuery.timeDimensions, 1),
-        _td2 = _oldQuery$timeDimensi2[0];
+      var _ref10 = oldQuery.timeDimensions,
+        _ref11 = _slicedToArray__default['default'](_ref10, 1),
+        _td2 = _ref11[0];
       return _objectSpread$3(_objectSpread$3({}, state), {}, {
         pivotConfig: null,
         shouldApplyHeuristicOrder: true,
@@ -552,13 +557,14 @@ function isQueryPresent(query) {
     return false;
   }
   return (Array.isArray(query) ? query : [query]).every(function (q) {
-    return q.measures && q.measures.length || q.dimensions && q.dimensions.length || q.timeDimensions && q.timeDimensions.length;
+    var _q$measures, _q$dimensions, _q$timeDimensions;
+    return ((_q$measures = q.measures) === null || _q$measures === void 0 ? void 0 : _q$measures.length) || ((_q$dimensions = q.dimensions) === null || _q$dimensions === void 0 ? void 0 : _q$dimensions.length) || ((_q$timeDimensions = q.timeDimensions) === null || _q$timeDimensions === void 0 ? void 0 : _q$timeDimensions.length);
   });
 }
 function movePivotItem(pivotConfig, sourceIndex, destinationIndex, sourceAxis, destinationAxis) {
   var nextPivotConfig = _objectSpread$3(_objectSpread$3({}, pivotConfig), {}, {
-    x: _toConsumableArray__default['default'](pivotConfig.x),
-    y: _toConsumableArray__default['default'](pivotConfig.y)
+    x: _toConsumableArray__default['default'](pivotConfig.x || []),
+    y: _toConsumableArray__default['default'](pivotConfig.y || [])
   });
   var id = pivotConfig[sourceAxis][sourceIndex];
   var lastIndex = nextPivotConfig[destinationAxis].length - 1;
@@ -584,8 +590,11 @@ function moveItemInArray(list, sourceIndex, destinationIndex) {
 function flattenFilters() {
   var filters = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
   return filters.reduce(function (memo, filter) {
-    if (filter.or || filter.and) {
-      return [].concat(_toConsumableArray__default['default'](memo), _toConsumableArray__default['default'](flattenFilters(filter.or || filter.and)));
+    if ('or' in filter) {
+      return [].concat(_toConsumableArray__default['default'](memo), _toConsumableArray__default['default'](flattenFilters(filter.or)));
+    }
+    if ('and' in filter) {
+      return [].concat(_toConsumableArray__default['default'](memo), _toConsumableArray__default['default'](flattenFilters(filter.and)));
     }
     return [].concat(_toConsumableArray__default['default'](memo), [filter]);
   }, []);
@@ -602,8 +611,12 @@ function getQueryMembers() {
   (query.timeDimensions || []).forEach(function (td) {
     return members.add(td.dimension);
   });
-  flattenFilters(query.filters).forEach(function (filter) {
-    return members.add(filter.dimension || filter.member);
+  var filters = flattenFilters(query.filters);
+  filters.forEach(function (filter) {
+    var member = filter.dimension || filter.member;
+    if (typeof member === 'string') {
+      members.add(member);
+    }
   });
   return _toConsumableArray__default['default'](members);
 }
@@ -612,10 +625,10 @@ function getOrderMembersFromOrder(orderMembers, order) {
   var indexedOrderMembers = ramda.indexBy(ramda.prop('id'), orderMembers);
   var entries = Array.isArray(order) ? order : Object.entries(order || {});
   var nextOrderMembers = [];
-  entries.forEach(function (_ref8) {
-    var _ref9 = _slicedToArray__default['default'](_ref8, 2),
-      memberId = _ref9[0],
-      currentOrder = _ref9[1];
+  entries.forEach(function (_ref12) {
+    var _ref13 = _slicedToArray__default['default'](_ref12, 2),
+      memberId = _ref13[0],
+      currentOrder = _ref13[1];
     if (currentOrder !== 'none' && indexedOrderMembers[memberId]) {
       ids.add(memberId);
       nextOrderMembers.push(_objectSpread$3(_objectSpread$3({}, indexedOrderMembers[memberId]), {}, {
@@ -632,11 +645,13 @@ function getOrderMembersFromOrder(orderMembers, order) {
   });
   return nextOrderMembers;
 }
-function aliasSeries(values, index, pivotConfig, duplicateMeasures) {
+function aliasSeries(values, index, pivotConfig) {
+  var _pivotConfig$aliasSer;
+  var duplicateMeasures = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : new Set();
   var nonNullValues = values.filter(function (value) {
     return value != null;
   });
-  if (pivotConfig && pivotConfig.aliasSeries && pivotConfig.aliasSeries[index]) {
+  if (pivotConfig !== null && pivotConfig !== void 0 && (_pivotConfig$aliasSer = pivotConfig.aliasSeries) !== null && _pivotConfig$aliasSer !== void 0 && _pivotConfig$aliasSer[index]) {
     return [pivotConfig.aliasSeries[index]].concat(_toConsumableArray__default['default'](nonNullValues));
   } else if (duplicateMeasures.has(nonNullValues[0])) {
     return [index].concat(_toConsumableArray__default['default'](nonNullValues));
@@ -649,7 +664,7 @@ var _excluded$1 = ["x"],
   _excluded3 = ["title", "shortTitle"];
 function ownKeys$2(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread$2(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys$2(Object(t), !0).forEach(function (r) { _defineProperty__default['default'](e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys$2(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-var groupByToPairs = function groupByToPairs(keyFn) {
+var groupByToPairs = function groupByToPairsImpl(keyFn) {
   var acc = new Map();
   return function (data) {
     data.forEach(function (row) {
@@ -676,18 +691,29 @@ var QUERY_TYPE = {
   COMPARE_DATE_RANGE_QUERY: 'compareDateRangeQuery',
   BLENDING_QUERY: 'blendingQuery'
 };
+/**
+ * Provides a convenient interface for data manipulation.
+ */
 var ResultSet = /*#__PURE__*/function () {
   function ResultSet(loadResponse) {
     var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
     _classCallCheck__default['default'](this, ResultSet);
-    this.loadResponse = loadResponse;
-    if (this.loadResponse.queryType != null) {
+    _defineProperty__default['default'](this, "loadResponse", void 0);
+    _defineProperty__default['default'](this, "loadResponses", void 0);
+    _defineProperty__default['default'](this, "queryType", void 0);
+    _defineProperty__default['default'](this, "parseDateMeasures", void 0);
+    _defineProperty__default['default'](this, "options", void 0);
+    _defineProperty__default['default'](this, "backwardCompatibleData", void 0);
+    if ('queryType' in loadResponse && loadResponse.queryType != null) {
+      this.loadResponse = loadResponse;
       this.queryType = loadResponse.queryType;
       this.loadResponses = loadResponse.results;
     } else {
       this.queryType = QUERY_TYPE.REGULAR_QUERY;
-      this.loadResponse.pivotQuery = _objectSpread$2(_objectSpread$2({}, loadResponse.query), {}, {
-        queryType: this.queryType
+      this.loadResponse = _objectSpread$2(_objectSpread$2({}, loadResponse), {}, {
+        pivotQuery: _objectSpread$2(_objectSpread$2({}, loadResponse.query), {}, {
+          queryType: this.queryType
+        })
       });
       this.loadResponses = [loadResponse];
     }
@@ -698,9 +724,70 @@ var ResultSet = /*#__PURE__*/function () {
     this.options = options;
     this.backwardCompatibleData = [];
   }
+
+  /**
+   * Returns a measure drill down query.
+   *
+   * Provided you have a measure with the defined `drillMembers` on the `Orders` cube
+   * ```js
+   * measures: {
+   *   count: {
+   *     type: `count`,
+   *     drillMembers: [Orders.status, Users.city, count],
+   *   },
+   *   // ...
+   * }
+   * ```
+   *
+   * Then you can use the `drillDown` method to see the rows that contribute to that metric
+   * ```js
+   * resultSet.drillDown(
+   *   {
+   *     xValues,
+   *     yValues,
+   *   },
+   *   // you should pass the `pivotConfig` if you have used it for axes manipulation
+   *   pivotConfig
+   * )
+   * ```
+   *
+   * the result will be a query with the required filters applied and the dimensions/measures filled out
+   * ```js
+   * {
+   *   measures: ['Orders.count'],
+   *   dimensions: ['Orders.status', 'Users.city'],
+   *   filters: [
+   *     // dimension and measure filters
+   *   ],
+   *   timeDimensions: [
+   *     //...
+   *   ]
+   * }
+   * ```
+   *
+   * In case when you want to add `order` or `limit` to the query, you can simply spread it
+   *
+   * ```js
+   * // An example for React
+   * const drillDownResponse = useCubeQuery(
+   *    {
+   *      ...drillDownQuery,
+   *      limit: 30,
+   *      order: {
+   *        'Orders.ts': 'desc'
+   *      }
+   *    },
+   *    {
+   *      skip: !drillDownQuery
+   *    }
+   *  );
+   * ```
+   * @returns Drill down query
+   */
   return _createClass__default['default'](ResultSet, [{
     key: "drillDown",
     value: function drillDown(drillDownLocator, pivotConfig) {
+      var _drillDownLocator$xVa, _drillDownLocator$yVa, _measures$measureName, _measures$measureName2;
       if (this.queryType === QUERY_TYPE.COMPARE_DATE_RANGE_QUERY) {
         throw new Error('compareDateRange drillDown query is not currently supported');
       }
@@ -708,16 +795,14 @@ var ResultSet = /*#__PURE__*/function () {
         throw new Error('Data blending drillDown query is not currently supported');
       }
       var query = this.loadResponses[0].query;
-      var _drillDownLocator$xVa = drillDownLocator.xValues,
-        xValues = _drillDownLocator$xVa === void 0 ? [] : _drillDownLocator$xVa,
-        _drillDownLocator$yVa = drillDownLocator.yValues,
-        yValues = _drillDownLocator$yVa === void 0 ? [] : _drillDownLocator$yVa;
+      var xValues = (_drillDownLocator$xVa = drillDownLocator === null || drillDownLocator === void 0 ? void 0 : drillDownLocator.xValues) !== null && _drillDownLocator$xVa !== void 0 ? _drillDownLocator$xVa : [];
+      var yValues = (_drillDownLocator$yVa = drillDownLocator === null || drillDownLocator === void 0 ? void 0 : drillDownLocator.yValues) !== null && _drillDownLocator$yVa !== void 0 ? _drillDownLocator$yVa : [];
       var normalizedPivotConfig = this.normalizePivotConfig(pivotConfig);
       var values = [];
-      normalizedPivotConfig.x.forEach(function (member, currentIndex) {
+      normalizedPivotConfig === null || normalizedPivotConfig === void 0 || normalizedPivotConfig.x.forEach(function (member, currentIndex) {
         return values.push([member, xValues[currentIndex]]);
       });
-      normalizedPivotConfig.y.forEach(function (member, currentIndex) {
+      normalizedPivotConfig === null || normalizedPivotConfig === void 0 || normalizedPivotConfig.y.forEach(function (member, currentIndex) {
         return values.push([member, yValues[currentIndex]]);
       });
       var _this$query = this.query(),
@@ -738,7 +823,7 @@ var ResultSet = /*#__PURE__*/function () {
         var _Object$keys2 = _slicedToArray__default['default'](_Object$keys, 1);
         measureName = _Object$keys2[0];
       }
-      if (!(measures[measureName] && measures[measureName].drillMembers || []).length) {
+      if (!((_measures$measureName = (_measures$measureName2 = measures[measureName]) === null || _measures$measureName2 === void 0 || (_measures$measureName2 = _measures$measureName2.drillMembers) === null || _measures$measureName2 === void 0 ? void 0 : _measures$measureName2.length) !== null && _measures$measureName !== void 0 ? _measures$measureName : 0)) {
         return null;
       }
       var filters = [{
@@ -760,8 +845,9 @@ var ResultSet = /*#__PURE__*/function () {
           dimension = _member$split2[1],
           granularity = _member$split2[2];
         if (granularity !== undefined) {
+          var _query$timeDimensions;
           var range = _dayRange(value, value).snapTo(granularity);
-          var originalTimeDimension = query.timeDimensions.find(function (td) {
+          var originalTimeDimension = (_query$timeDimensions = query.timeDimensions) === null || _query$timeDimensions === void 0 ? void 0 : _query$timeDimensions.find(function (td) {
             return td.dimension;
           });
           var dateRange = [range.start, range.end];
@@ -790,7 +876,7 @@ var ResultSet = /*#__PURE__*/function () {
           });
         }
       });
-      if (timeDimensions.length === 0 && query.timeDimensions.length > 0 && query.timeDimensions[0].granularity == null) {
+      if (timeDimensions.length === 0 && Array.isArray(query.timeDimensions) && query.timeDimensions.length > 0 && query.timeDimensions[0].granularity == null) {
         timeDimensions.push(query.timeDimensions[0]);
       }
       return _objectSpread$2(_objectSpread$2(_objectSpread$2({}, measures[measureName].drillMembersGrouped), {}, {
@@ -803,6 +889,36 @@ var ResultSet = /*#__PURE__*/function () {
         timezone: query.timezone
       });
     }
+
+    /**
+     * Returns an array of series with key, title and series data.
+     * ```js
+     * // For the query
+     * {
+     *   measures: ['Stories.count'],
+     *   timeDimensions: [{
+     *     dimension: 'Stories.time',
+     *     dateRange: ['2015-01-01', '2015-12-31'],
+     *     granularity: 'month'
+     *   }]
+     * }
+     *
+     * // ResultSet.series() will return
+     * [
+     *   {
+     *     key: 'Stories.count',
+     *     title: 'Stories Count',
+     *     shortTitle: 'Count',
+     *     series: [
+     *       { x: '2015-01-01T00:00:00', value: 27120 },
+     *       { x: '2015-02-01T00:00:00', value: 25861 },
+     *       { x: '2015-03-01T00:00:00', value: 29661 },
+     *       //...
+     *     ],
+     *   },
+     * ]
+     * ```
+     */
   }, {
     key: "series",
     value: function series(pivotConfig) {
@@ -836,20 +952,22 @@ var ResultSet = /*#__PURE__*/function () {
           return axis.filter(function (d) {
             return d !== 'measures';
           }).map(function (d) {
-            return row[d] != null ? row[d] : null;
+            var val = row[d];
+            return val != null ? val : null;
           }).concat(measure ? [measure] : []);
         };
         if (axis.find(function (d) {
           return d === 'measures';
         }) && (query.measures || []).length) {
-          return query.measures.map(value);
+          return (query.measures || []).map(value);
         }
         return [value()];
       };
     }
   }, {
     key: "axisValuesString",
-    value: function axisValuesString(axisValues, delimiter) {
+    value: function axisValuesString(axisValues) {
+      var delimiter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ', ';
       var formatValue = function formatValue(v) {
         if (v == null) {
           return '∅';
@@ -859,7 +977,7 @@ var ResultSet = /*#__PURE__*/function () {
           return v;
         }
       };
-      return axisValues.map(formatValue).join(delimiter || ', ');
+      return axisValues.map(formatValue).join(delimiter);
     }
   }, {
     key: "normalizePivotConfig",
@@ -872,17 +990,22 @@ var ResultSet = /*#__PURE__*/function () {
       if (!timeDimension.granularity) {
         return null;
       }
-      var dateRange = timeDimension.dateRange;
+      var dateRange;
+      dateRange = timeDimension.dateRange;
       if (!dateRange) {
         var member = ResultSet.timeDimensionMember(timeDimension);
-        var dates = ramda.pipe(ramda.map(function (row) {
-          return row[member] && internalDayjs(row[member]);
-        }), ramda.filter(Boolean))(this.timeDimensionBackwardCompatibleData(resultIndex));
+        var rawRows = this.timeDimensionBackwardCompatibleData(resultIndex || 0);
+        var dates = rawRows.map(function (row) {
+          var value = row[member];
+          return value ? internalDayjs(value) : null;
+        }).filter(function (d) {
+          return Boolean(d);
+        });
         dateRange = dates.length && [ramda.reduce(ramda.minBy(function (d) {
           return d.toDate();
-        }), dates[0], dates), ramda.reduce(ramda.maxBy(function (d) {
+        }), dates[0], dates).toString(), ramda.reduce(ramda.maxBy(function (d) {
           return d.toDate();
-        }), dates[0], dates)] || null;
+        }), dates[0], dates).toString()] || null;
       }
       if (!dateRange) {
         return null;
@@ -898,16 +1021,58 @@ var ResultSet = /*#__PURE__*/function () {
       if (isPredefinedGranularity(timeDimension.granularity)) {
         return TIME_SERIES[timeDimension.granularity](padToDay ? range.snapTo('d') : range);
       }
-      if (!annotations["".concat(timeDimension.dimension, ".").concat(timeDimension.granularity)]) {
+      if (!(annotations !== null && annotations !== void 0 && annotations["".concat(timeDimension.dimension, ".").concat(timeDimension.granularity)])) {
         throw new Error("Granularity \"".concat(timeDimension.granularity, "\" not found in time dimension \"").concat(timeDimension.dimension, "\""));
       }
       return timeSeriesFromCustomInterval(start, end, annotations["".concat(timeDimension.dimension, ".").concat(timeDimension.granularity)].granularity);
     }
+
+    /**
+     * Base method for pivoting [ResultSet](#result-set) data.
+     * Most of the time shouldn't be used directly and [chartPivot](#result-set-chart-pivot)
+     * or [tablePivot](#table-pivot) should be used instead.
+     *
+     * You can find the examples of using the `pivotConfig` [here](#types-pivot-config)
+     * ```js
+     * // For query
+     * {
+     *   measures: ['Stories.count'],
+     *   timeDimensions: [{
+     *     dimension: 'Stories.time',
+     *     dateRange: ['2015-01-01', '2015-03-31'],
+     *     granularity: 'month'
+     *   }]
+     * }
+     *
+     * // ResultSet.pivot({ x: ['Stories.time'], y: ['measures'] }) will return
+     * [
+     *   {
+     *     xValues: ["2015-01-01T00:00:00"],
+     *     yValuesArray: [
+     *       [['Stories.count'], 27120]
+     *     ]
+     *   },
+     *   {
+     *     xValues: ["2015-02-01T00:00:00"],
+     *     yValuesArray: [
+     *       [['Stories.count'], 25861]
+     *     ]
+     *   },
+     *   {
+     *     xValues: ["2015-03-01T00:00:00"],
+     *     yValuesArray: [
+     *       [['Stories.count'], 29661]
+     *     ]
+     *   }
+     * ]
+     * ```
+     * @returns An array of pivoted rows.
+     */
   }, {
     key: "pivot",
     value: function pivot(pivotConfig) {
       var _this2 = this;
-      pivotConfig = this.normalizePivotConfig(pivotConfig);
+      var normalizedPivotConfig = this.normalizePivotConfig(pivotConfig);
       var query = this.loadResponse.pivotQuery;
       var pivotImpl = function pivotImpl() {
         var resultIndex = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
@@ -916,9 +1081,9 @@ var ResultSet = /*#__PURE__*/function () {
           return _this2.axisValuesString(xValues);
         });
         var measureValue = function measureValue(row, measure) {
-          return row[measure] || pivotConfig.fillWithValue || 0;
+          return row[measure] || normalizedPivotConfig.fillWithValue || 0;
         };
-        if (pivotConfig.fillMissingDates && pivotConfig.x.length === 1 && ramda.equals(pivotConfig.x, (query.timeDimensions || []).filter(function (td) {
+        if (normalizedPivotConfig.fillMissingDates && normalizedPivotConfig.x.length === 1 && ramda.equals(normalizedPivotConfig.x, (query.timeDimensions || []).filter(function (td) {
           return Boolean(td.granularity);
         }).map(function (td) {
           return ResultSet.timeDimensionMember(td);
@@ -928,21 +1093,22 @@ var ResultSet = /*#__PURE__*/function () {
           });
           if (series[0]) {
             groupByXAxis = function groupByXAxis(rows) {
+              var _series$resultIndex$m, _series$resultIndex;
               var byXValues = ramda.groupBy(function (_ref12) {
                 var xValues = _ref12.xValues;
                 return xValues[0];
               }, rows);
-              return series[resultIndex].map(function (d) {
+              return (_series$resultIndex$m = (_series$resultIndex = series[resultIndex]) === null || _series$resultIndex === void 0 ? void 0 : _series$resultIndex.map(function (d) {
                 return [d, byXValues[d] || [{
                   xValues: [d],
                   row: {}
                 }]];
-              });
+              })) !== null && _series$resultIndex$m !== void 0 ? _series$resultIndex$m : [];
             };
           }
         }
         var xGrouped = ramda.pipe(ramda.map(function (row) {
-          return _this2.axisValues(pivotConfig.x, resultIndex)(row).map(function (xValues) {
+          return _this2.axisValues(normalizedPivotConfig.x, resultIndex)(row).map(function (xValues) {
             return {
               xValues: xValues,
               row: row
@@ -955,7 +1121,7 @@ var ResultSet = /*#__PURE__*/function () {
             rows = _ref14[1];
           rows.forEach(function (_ref15) {
             var row = _ref15.row;
-            _this2.axisValues(pivotConfig.y, resultIndex)(row).forEach(function (values) {
+            _this2.axisValues(normalizedPivotConfig.y, resultIndex)(row).forEach(function (values) {
               if (Object.keys(row).length > 0) {
                 yValuesMap[values.join()] = values;
               }
@@ -963,7 +1129,7 @@ var ResultSet = /*#__PURE__*/function () {
           });
         });
         var allYValues = Object.values(yValuesMap);
-        var measureOnX = Boolean(pivotConfig.x.find(function (d) {
+        var measureOnX = Boolean(normalizedPivotConfig.x.find(function (d) {
           return d === 'measures';
         }));
         return xGrouped.map(function (_ref16) {
@@ -973,7 +1139,7 @@ var ResultSet = /*#__PURE__*/function () {
           var yGrouped = {};
           rows.forEach(function (_ref18) {
             var row = _ref18.row;
-            var arr = _this2.axisValues(pivotConfig.y, resultIndex)(row).map(function (yValues) {
+            var arr = _this2.axisValues(normalizedPivotConfig.y, resultIndex)(row).map(function (yValues) {
               return {
                 yValues: yValues,
                 row: row
@@ -997,17 +1163,18 @@ var ResultSet = /*#__PURE__*/function () {
       var pivots = this.loadResponses.length > 1 ? this.loadResponses.map(function (_, index) {
         return pivotImpl(index);
       }) : [];
-      return pivots.length ? this.mergePivots(pivots, pivotConfig.joinDateRange) : pivotImpl();
+      return pivots.length ? this.mergePivots(pivots, normalizedPivotConfig.joinDateRange || false) : pivotImpl();
     }
   }, {
     key: "mergePivots",
     value: function mergePivots(pivots, joinDateRange) {
       var minLengthPivot = pivots.reduce(function (memo, current) {
         return memo != null && current.length >= memo.length ? memo : current;
-      }, null);
+      }, null) || [];
       return minLengthPivot.map(function (_, index) {
         var xValues = joinDateRange ? [pivots.map(function (pivot) {
-          return pivot[index] && pivot[index].xValues || [];
+          var _pivot$index;
+          return ((_pivot$index = pivot[index]) === null || _pivot$index === void 0 ? void 0 : _pivot$index.xValues) || [];
         }).join(', ')] : minLengthPivot[index].xValues;
         return {
           xValues: xValues,
@@ -1017,12 +1184,88 @@ var ResultSet = /*#__PURE__*/function () {
         };
       });
     }
-  }, {
-    key: "pivotedRows",
-    value: function pivotedRows(pivotConfig) {
-      // TODO
-      return this.chartPivot(pivotConfig);
-    }
+
+    /**
+     * Returns normalized query result data in the following format.
+     *
+     * You can find the examples of using the `pivotConfig` [here](#types-pivot-config)
+     * ```js
+     * // For the query
+     * {
+     *   measures: ['Stories.count'],
+     *   timeDimensions: [{
+     *     dimension: 'Stories.time',
+     *     dateRange: ['2015-01-01', '2015-12-31'],
+     *     granularity: 'month'
+     *   }]
+     * }
+     *
+     * // ResultSet.chartPivot() will return
+     * [
+     *   { "x":"2015-01-01T00:00:00", "Stories.count": 27120, "xValues": ["2015-01-01T00:00:00"] },
+     *   { "x":"2015-02-01T00:00:00", "Stories.count": 25861, "xValues": ["2015-02-01T00:00:00"]  },
+     *   { "x":"2015-03-01T00:00:00", "Stories.count": 29661, "xValues": ["2015-03-01T00:00:00"]  },
+     *   //...
+     * ]
+     *
+     * ```
+     * When using `chartPivot()` or `seriesNames()`, you can pass `aliasSeries` in the [pivotConfig](#types-pivot-config)
+     * to give each series a unique prefix. This is useful for `blending queries` which use the same measure multiple times.
+     *
+     * ```js
+     * // For the queries
+     * {
+     *   measures: ['Stories.count'],
+     *   timeDimensions: [
+     *     {
+     *       dimension: 'Stories.time',
+     *       dateRange: ['2015-01-01', '2015-12-31'],
+     *       granularity: 'month',
+     *     },
+     *   ],
+     * },
+     * {
+     *   measures: ['Stories.count'],
+     *   timeDimensions: [
+     *     {
+     *       dimension: 'Stories.time',
+     *       dateRange: ['2015-01-01', '2015-12-31'],
+     *       granularity: 'month',
+     *     },
+     *   ],
+     *   filters: [
+     *     {
+     *       member: 'Stores.read',
+     *       operator: 'equals',
+     *       value: ['true'],
+     *     },
+     *   ],
+     * },
+     *
+     * // ResultSet.chartPivot({ aliasSeries: ['one', 'two'] }) will return
+     * [
+     *   {
+     *     x: '2015-01-01T00:00:00',
+     *     'one,Stories.count': 27120,
+     *     'two,Stories.count': 8933,
+     *     xValues: ['2015-01-01T00:00:00'],
+     *   },
+     *   {
+     *     x: '2015-02-01T00:00:00',
+     *     'one,Stories.count': 25861,
+     *     'two,Stories.count': 8344,
+     *     xValues: ['2015-02-01T00:00:00'],
+     *   },
+     *   {
+     *     x: '2015-03-01T00:00:00',
+     *     'one,Stories.count': 29661,
+     *     'two,Stories.count': 9023,
+     *     xValues: ['2015-03-01T00:00:00'],
+     *   },
+     *   //...
+     * ]
+     * ```
+     */
   }, {
     key: "chartPivot",
     value: function chartPivot(pivotConfig) {
@@ -1038,8 +1281,9 @@ var ResultSet = /*#__PURE__*/function () {
       var duplicateMeasures = new Set();
       if (this.queryType === QUERY_TYPE.BLENDING_QUERY) {
         var allMeasures = ramda.flatten(this.loadResponses.map(function (_ref19) {
+          var _query$measures;
           var query = _ref19.query;
-          return query.measures;
+          return (_query$measures = query.measures) !== null && _query$measures !== void 0 ? _query$measures : [];
         }));
         allMeasures.filter(function (e, i, a) {
           return a.indexOf(e) !== i;
@@ -1063,6 +1307,34 @@ var ResultSet = /*#__PURE__*/function () {
         }, yValuesMap);
       });
     }
+
+    /**
+     * Returns normalized query result data prepared for visualization in the table format.
+     *
+     * You can find the examples of using the `pivotConfig` [here](#types-pivot-config)
+     *
+     * For example:
+     * ```js
+     * // For the query
+     * {
+     *   measures: ['Stories.count'],
+     *   timeDimensions: [{
+     *     dimension: 'Stories.time',
+     *     dateRange: ['2015-01-01', '2015-12-31'],
+     *     granularity: 'month'
+     *   }]
+     * }
+     *
+     * // ResultSet.tablePivot() will return
+     * [
+     *   { "Stories.time": "2015-01-01T00:00:00", "Stories.count": 27120 },
+     *   { "Stories.time": "2015-02-01T00:00:00", "Stories.count": 25861 },
+     *   { "Stories.time": "2015-03-01T00:00:00", "Stories.count": 29661 },
+     *   //...
+     * ]
+     * ```
+     * @returns An array of pivoted rows
+     */
   }, {
     key: "tablePivot",
     value: function tablePivot(pivotConfig) {
@@ -1071,21 +1343,127 @@ var ResultSet = /*#__PURE__*/function () {
       return this.pivot(normalizedPivotConfig).map(function (_ref23) {
         var xValues = _ref23.xValues,
           yValuesArray = _ref23.yValuesArray;
-        return ramda.fromPairs(normalizedPivotConfig.x.map(function (key, index) {
-          return [key, xValues[index]];
-        }).concat(isMeasuresPresent ? yValuesArray.map(function (_ref24) {
+        return ramda.fromPairs([].concat(_toConsumableArray__default['default'](normalizedPivotConfig.x.map(function (key, index) {
+          var _xValues$index;
+          return [key, (_xValues$index = xValues[index]) !== null && _xValues$index !== void 0 ? _xValues$index : ''];
+        })), _toConsumableArray__default['default'](isMeasuresPresent ? yValuesArray.map(function (_ref24) {
           var _ref25 = _slicedToArray__default['default'](_ref24, 2),
             yValues = _ref25[0],
             measure = _ref25[1];
           return [yValues.length ? yValues.join() : 'value', measure];
-        }) : []));
+        }) : [])));
       });
     }
+
+    /**
+     * Returns an array of column definitions for `tablePivot`.
+     *
+     * For example:
+     * ```js
+     * // For the query
+     * {
+     *   measures: ['Stories.count'],
+     *   timeDimensions: [{
+     *     dimension: 'Stories.time',
+     *     dateRange: ['2015-01-01', '2015-12-31'],
+     *     granularity: 'month'
+     *   }]
+     * }
+     *
+     * // ResultSet.tableColumns() will return
+     * [
+     *   {
+     *     key: 'Stories.time',
+     *     dataIndex: 'Stories.time',
+     *     title: 'Stories Time',
+     *     shortTitle: 'Time',
+     *     type: 'time',
+     *     format: undefined,
+     *   },
+     *   {
+     *     key: 'Stories.count',
+     *     dataIndex: 'Stories.count',
+     *     title: 'Stories Count',
+     *     shortTitle: 'Count',
+     *     type: 'count',
+     *     format: undefined,
+     *   },
+     *   //...
+     * ]
+     * ```
+     *
+     * In case we want to pivot the table axes
+     * ```js
+     * // Let's take this query as an example
+     * {
+     *   measures: ['Orders.count'],
+     *   dimensions: ['Users.country', 'Users.gender']
+     * }
+     *
+     * // and put the dimensions on `y` axis
+     * resultSet.tableColumns({
+     *   x: [],
+     *   y: ['Users.country', 'Users.gender', 'measures']
+     * })
+     * ```
+     *
+     * then `tableColumns` will group the table head and return
+     * ```js
+     * {
+     *   key: 'Germany',
+     *   type: 'string',
+     *   title: 'Users Country Germany',
+     *   shortTitle: 'Germany',
+     *   meta: undefined,
+     *   format: undefined,
+     *   children: [
+     *     {
+     *       key: 'male',
+     *       type: 'string',
+     *       title: 'Users Gender male',
+     *       shortTitle: 'male',
+     *       meta: undefined,
+     *       format: undefined,
+     *       children: [
+     *         {
+     *           // ...
+     *           dataIndex: 'Germany.male.Orders.count',
+     *           shortTitle: 'Count',
+     *         },
+     *       ],
+     *     },
+     *     {
+     *       // ...
+     *       shortTitle: 'female',
+     *       children: [
+     *         {
+     *           // ...
+     *           dataIndex: 'Germany.female.Orders.count',
+     *           shortTitle: 'Count',
+     *         },
+     *       ],
+     *     },
+     *   ],
+     * },
+     * // ...
+     * ```
+     * @returns An array of columns
+     */
   }, {
     key: "tableColumns",
     value: function tableColumns(pivotConfig) {
+      var _pivot$;
       var normalizedPivotConfig = this.normalizePivotConfig(pivotConfig || {});
-      var annotations = ramda.pipe(ramda.pluck('annotation'), ramda.reduce(ramda.mergeDeepLeft(), {}))(this.loadResponses);
+      var annotations = this.loadResponses.map(function (r) {
+        return r.annotation;
+      }).reduce(function (acc, annotation) {
+        return ramda.mergeDeepLeft(acc, annotation);
+      }, {
+        dimensions: {},
+        measures: {},
+        timeDimensions: {},
+        segments: {}
+      });
       var flatMeta = Object.values(annotations).reduce(function (a, b) {
         return _objectSpread$2(_objectSpread$2({}, a), b);
       }, {});
@@ -1107,16 +1485,17 @@ var ResultSet = /*#__PURE__*/function () {
         };
       };
       var pivot = this.pivot(normalizedPivotConfig);
-      (pivot[0] && pivot[0].yValuesArray || []).forEach(function (_ref27) {
+      (((_pivot$ = pivot[0]) === null || _pivot$ === void 0 ? void 0 : _pivot$.yValuesArray) || []).forEach(function (_ref27) {
         var _ref28 = _slicedToArray__default['default'](_ref27, 1),
           yValues = _ref28[0];
         if (yValues.length > 0) {
           var currentItem = schema;
           yValues.forEach(function (value, index) {
+            var _currentItem;
             currentItem["_".concat(value)] = {
               key: value,
               memberId: normalizedPivotConfig.y[index] === 'measures' ? value : normalizedPivotConfig.y[index],
-              children: currentItem["_".concat(value)] && currentItem["_".concat(value)].children || {}
+              children: ((_currentItem = currentItem["_".concat(value)]) === null || _currentItem === void 0 ? void 0 : _currentItem.children) || {}
             };
             currentItem = currentItem["_".concat(value)].children;
           });
@@ -1162,7 +1541,7 @@ var ResultSet = /*#__PURE__*/function () {
         });
       }
 
-      // Syntatic column to display the measure value
+      // Synthetic column to display the measure value
       if (!normalizedPivotConfig.y.length && normalizedPivotConfig.x.includes('measures')) {
         otherColumns.push({
           key: 'value',
@@ -1195,23 +1574,53 @@ var ResultSet = /*#__PURE__*/function () {
   }, {
     key: "categories",
     value: function categories(pivotConfig) {
-      // TODO
       return this.chartPivot(pivotConfig);
     }
+
+    /**
+     * Returns an array of series objects, containing `key` and `title` parameters.
+     * ```js
+     * // For query
+     * {
+     *   measures: ['Stories.count'],
+     *   timeDimensions: [{
+     *     dimension: 'Stories.time',
+     *     dateRange: ['2015-01-01', '2015-12-31'],
+     *     granularity: 'month'
+     *   }]
+     * }
+     *
+     * // ResultSet.seriesNames() will return
+     * [
+     *   {
+     *     key: 'Stories.count',
+     *     title: 'Stories Count',
+     *     shortTitle: 'Count',
+     *     yValues: ['Stories.count'],
+     *   },
+     * ]
+     * ```
+     * @returns An array of series names
+     */
   }, {
     key: "seriesNames",
     value: function seriesNames(pivotConfig) {
       var _this4 = this;
-      pivotConfig = this.normalizePivotConfig(pivotConfig);
-      var measures = ramda.pipe(ramda.pluck('annotation'), ramda.pluck('measures'), ramda.mergeAll)(this.loadResponses);
+      var normalizedPivotConfig = this.normalizePivotConfig(pivotConfig);
+      var measures = this.loadResponses.map(function (r) {
+        return r.annotation.measures;
+      }).reduce(function (acc, m) {
+        return _objectSpread$2(_objectSpread$2({}, acc), m);
+      }, {});
       var seriesNames = unnest(this.loadResponses.map(function (_, index) {
-        return ramda.pipe(ramda.map(_this4.axisValues(pivotConfig.y, index)), unnest, ramda.uniq)(_this4.timeDimensionBackwardCompatibleData(index));
+        return ramda.pipe(ramda.map(_this4.axisValues(normalizedPivotConfig.y, index)), unnest, ramda.uniq)(_this4.timeDimensionBackwardCompatibleData(index));
       }));
       var duplicateMeasures = new Set();
       if (this.queryType === QUERY_TYPE.BLENDING_QUERY) {
         var allMeasures = ramda.flatten(this.loadResponses.map(function (_ref30) {
+          var _query$measures2;
           var query = _ref30.query;
-          return query.measures;
+          return (_query$measures2 = query.measures) !== null && _query$measures2 !== void 0 ? _query$measures2 : [];
         }));
         allMeasures.filter(function (e, i, a) {
           return a.indexOf(e) !== i;
@@ -1220,12 +1629,12 @@ var ResultSet = /*#__PURE__*/function () {
         });
       }
       return seriesNames.map(function (axisValues, i) {
-        var aliasedAxis = aliasSeries(axisValues, i, pivotConfig, duplicateMeasures);
+        var aliasedAxis = aliasSeries(axisValues, i, normalizedPivotConfig, duplicateMeasures);
         return {
-          title: _this4.axisValuesString(pivotConfig.y.find(function (d) {
+          title: _this4.axisValuesString(normalizedPivotConfig.y.find(function (d) {
             return d === 'measures';
           }) ? ramda.dropLast(1, aliasedAxis).concat(measures[ResultSet.measureFromAxis(axisValues)].title) : aliasedAxis, ', '),
-          shortTitle: _this4.axisValuesString(pivotConfig.y.find(function (d) {
+          shortTitle: _this4.axisValuesString(normalizedPivotConfig.y.find(function (d) {
             return d === 'measures';
           }) ? ramda.dropLast(1, aliasedAxis).concat(measures[ResultSet.measureFromAxis(axisValues)].shortTitle) : aliasedAxis, ', '),
           key: _this4.axisValuesString(aliasedAxis, ','),
@@ -1246,6 +1655,10 @@ var ResultSet = /*#__PURE__*/function () {
     value: function pivotQuery() {
       return this.loadResponse.pivotQuery || null;
     }
+
+    /**
+     * @return the total number of rows if the `total` option was set, when sending the query
+     */
   }, {
     key: "totalRows",
     value: function totalRows() {
@@ -1282,11 +1695,10 @@ var ResultSet = /*#__PURE__*/function () {
         });
         this.backwardCompatibleData[resultIndex] = data.map(function (row) {
           return _objectSpread$2(_objectSpread$2({}, row), ramda.fromPairs(Object.keys(row).filter(function (field) {
-            return timeDimensions.find(function (d) {
+            var foundTd = timeDimensions.find(function (d) {
               return d.dimension === field;
-            }) && !row[ResultSet.timeDimensionMember(timeDimensions.find(function (d) {
-              return d.dimension === field;
-            }))];
+            });
+            return foundTd && !row[ResultSet.timeDimensionMember(foundTd)];
           }).map(function (field) {
             return [ResultSet.timeDimensionMember(timeDimensions.find(function (d) {
               return d.dimension === field;
@@ -1296,6 +1708,15 @@ var ResultSet = /*#__PURE__*/function () {
       }
       return this.backwardCompatibleData[resultIndex];
     }
+
+    /**
+     * Can be used when you need access to the methods that can't be used with some query types (eg `compareDateRangeQuery` or `blendingQuery`)
+     * ```js
+     * resultSet.decompose().forEach((currentResultSet) => {
+     *   console.log(currentResultSet.rawData());
+     * });
+     * ```
+     */
   }, {
     key: "decompose",
     value: function decompose() {
@@ -1310,6 +1731,10 @@ var ResultSet = /*#__PURE__*/function () {
         }, _this5.options);
       });
     }
+
+    /**
+     * Can be used to stash the `ResultSet` in a storage and restored later with [deserialize](#result-set-deserialize)
+     */
   }, {
     key: "serialize",
     value: function serialize() {
@@ -1327,28 +1752,41 @@ var ResultSet = /*#__PURE__*/function () {
     value: function timeDimensionMember(td) {
       return "".concat(td.dimension, ".").concat(td.granularity);
     }
+
+    /**
+     * ```js
+     * import { ResultSet } from '@cubejs-client/core';
+     *
+     * const resultSet = await cubeApi.load(query);
+     * // You can store the result somewhere
+     * const tmp = resultSet.serialize();
+     *
+     * // and restore it later
+     * const resultSet = ResultSet.deserialize(tmp);
+     * ```
+     * @param data the result of [serialize](#result-set-serialize)
+     * @param options
+     */
   }, {
     key: "deserialize",
-    value: function deserialize(data) {
-      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    value: function deserialize(data, options) {
       return new ResultSet(data.loadResponse, options);
     }
   }, {
     key: "getNormalizedPivotConfig",
-    value: function getNormalizedPivotConfig() {
-      var query = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-      var pivotConfig = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+    value: function getNormalizedPivotConfig(query, pivotConfig) {
       var defaultPivotConfig = {
         x: [],
         y: [],
         fillMissingDates: true,
         joinDateRange: false
       };
-      var _query$measures = query.measures,
-        measures = _query$measures === void 0 ? [] : _query$measures,
-        _query$dimensions = query.dimensions,
-        dimensions = _query$dimensions === void 0 ? [] : _query$dimensions;
-      var timeDimensions = (query.timeDimensions || []).filter(function (td) {
+      var _ref31 = query || {},
+        _ref31$measures = _ref31.measures,
+        measures = _ref31$measures === void 0 ? [] : _ref31$measures,
+        _ref31$dimensions = _ref31.dimensions,
+        dimensions = _ref31$dimensions === void 0 ? [] : _ref31$dimensions;
+      var timeDimensions = ((query === null || query === void 0 ? void 0 : query.timeDimensions) || []).filter(function (td) {
         return !!td.granularity;
       });
       pivotConfig = pivotConfig || (timeDimensions.length ? {
@@ -1360,48 +1798,48 @@ var ResultSet = /*#__PURE__*/function () {
         x: dimensions,
         y: []
       });
-      pivotConfig = ramda.mergeDeepLeft(pivotConfig, defaultPivotConfig);
+      var normalizedPivotConfig = ramda.mergeDeepLeft(pivotConfig, defaultPivotConfig);
       var substituteTimeDimensionMembers = function substituteTimeDimensionMembers(axis) {
         return axis.map(function (subDim) {
           return timeDimensions.find(function (td) {
             return td.dimension === subDim;
           }) && !dimensions.find(function (d) {
             return d === subDim;
-          }) ? ResultSet.timeDimensionMember(query.timeDimensions.find(function (td) {
+          }) ? ResultSet.timeDimensionMember(((query === null || query === void 0 ? void 0 : query.timeDimensions) || []).find(function (td) {
             return td.dimension === subDim;
           })) : subDim;
         });
       };
-      pivotConfig.x = substituteTimeDimensionMembers(pivotConfig.x);
-      pivotConfig.y = substituteTimeDimensionMembers(pivotConfig.y);
-      var allIncludedDimensions = pivotConfig.x.concat(pivotConfig.y);
+      normalizedPivotConfig.x = substituteTimeDimensionMembers(normalizedPivotConfig.x);
+      normalizedPivotConfig.y = substituteTimeDimensionMembers(normalizedPivotConfig.y);
+      var allIncludedDimensions = normalizedPivotConfig.x.concat(normalizedPivotConfig.y);
       var allDimensions = timeDimensions.map(function (td) {
         return ResultSet.timeDimensionMember(td);
       }).concat(dimensions);
       var dimensionFilter = function dimensionFilter(key) {
         return allDimensions.includes(key) || key === 'measures';
       };
-      pivotConfig.x = pivotConfig.x.concat(allDimensions.filter(function (d) {
+      normalizedPivotConfig.x = normalizedPivotConfig.x.concat(allDimensions.filter(function (d) {
         return !allIncludedDimensions.includes(d) && d !== 'compareDateRange';
       })).filter(dimensionFilter);
-      pivotConfig.y = pivotConfig.y.filter(dimensionFilter);
-      if (!pivotConfig.x.concat(pivotConfig.y).find(function (d) {
+      normalizedPivotConfig.y = normalizedPivotConfig.y.filter(dimensionFilter);
+      if (!normalizedPivotConfig.x.concat(normalizedPivotConfig.y).find(function (d) {
         return d === 'measures';
       })) {
-        pivotConfig.y.push('measures');
+        normalizedPivotConfig.y.push('measures');
       }
-      if (dimensions.includes('compareDateRange') && !pivotConfig.y.concat(pivotConfig.x).includes('compareDateRange')) {
-        pivotConfig.y.unshift('compareDateRange');
+      if (dimensions.includes('compareDateRange') && !normalizedPivotConfig.y.concat(normalizedPivotConfig.x).includes('compareDateRange')) {
+        normalizedPivotConfig.y.unshift('compareDateRange');
       }
       if (!measures.length) {
-        pivotConfig.x = pivotConfig.x.filter(function (d) {
+        normalizedPivotConfig.x = normalizedPivotConfig.x.filter(function (d) {
           return d !== 'measures';
         });
-        pivotConfig.y = pivotConfig.y.filter(function (d) {
+        normalizedPivotConfig.y = normalizedPivotConfig.y.filter(function (d) {
           return d !== 'measures';
         });
       }
-      return pivotConfig;
+      return normalizedPivotConfig;
     }
   }]);
 }();
@@ -1409,12 +1847,13 @@ var ResultSet = /*#__PURE__*/function () {
 var SqlQuery = /*#__PURE__*/function () {
   function SqlQuery(sqlQuery) {
     _classCallCheck__default['default'](this, SqlQuery);
+    _defineProperty__default['default'](this, "sqlQuery", void 0);
     this.sqlQuery = sqlQuery;
   }
   return _createClass__default['default'](SqlQuery, [{
     key: "rawQuery",
     value: function rawQuery() {
-      return this.sqlQuery.sql;
+      return this.sqlQuery;
     }
   }, {
     key: "sql",
@@ -1519,6 +1958,18 @@ var operators = {
 var Meta = /*#__PURE__*/function () {
   function Meta(metaResponse) {
     _classCallCheck__default['default'](this, Meta);
+    /**
+     * Raw meta response
+     */
+    _defineProperty__default['default'](this, "meta", void 0);
+    /**
+     * An array of all available cubes with their members
+     */
+    _defineProperty__default['default'](this, "cubes", void 0);
+    /**
+     * A map of all cubes where the key is a cube name
+     */
+    _defineProperty__default['default'](this, "cubesMap", void 0);
     this.meta = metaResponse;
     var cubes = this.meta.cubes;
     this.cubes = cubes;
@@ -1530,9 +1981,16 @@ var Meta = /*#__PURE__*/function () {
       }];
     }));
   }
+
+  /**
+   * Get all members of a specific type for a given query.
+   * If empty query is provided no filtering is done based on query context and all available members are retrieved.
+   * @param _query - context query to provide filtering of members available to add to this query
+   * @param memberType
+   */
   return _createClass__default['default'](Meta, [{
     key: "membersForQuery",
-    value: function membersForQuery(query, memberType) {
+    value: function membersForQuery(_query, memberType) {
       return ramda.unnest(this.cubes.map(function (c) {
         return c[memberType];
       })).sort(function (a, b) {
@@ -1545,19 +2003,35 @@ var Meta = /*#__PURE__*/function () {
       var memberKeys = ['measures', 'dimensions', 'segments', 'timeDimensions'];
       return this.cubes.reduce(function (memo, cube) {
         memberKeys.forEach(function (key) {
-          var members = cube[key];
-          if (key === 'timeDimensions') {
-            members = cube.dimensions.filter(function (m) {
-              return m.type === 'time';
-            });
+          var members = [];
+
+          // eslint-disable-next-line default-case
+          switch (key) {
+            case 'measures':
+              members = cube.measures || [];
+              break;
+            case 'dimensions':
+              members = cube.dimensions || [];
+              break;
+            case 'segments':
+              members = cube.segments || [];
+              break;
+            case 'timeDimensions':
+              members = cube.dimensions.filter(function (m) {
+                return m.type === 'time';
+              }) || [];
+              break;
           }
-          memo[key] = [].concat(_toConsumableArray__default['default'](memo[key]), [{
+
+          // TODO: Convince TS this is working
+          // @ts-ignore
+          memo[key].push({
             cubeName: cube.name,
             cubeTitle: cube.title,
             type: cube.type,
             "public": cube["public"],
             members: members
-          }]);
+          });
         });
         return memo;
       }, {
@@ -1567,6 +2041,24 @@ var Meta = /*#__PURE__*/function () {
         timeDimensions: []
       });
     }
+
+    /**
+     * Get meta information for a cube member
+     * meta information contains:
+     * ```javascript
+     * {
+     *   name,
+     *   title,
+     *   shortTitle,
+     *   type,
+     *   description,
+     *   format
+     * }
+     * ```
+     * @param memberName - Fully qualified member name in a form `Cube.memberName`
+     * @param memberType
+     * @return An object containing meta information about member
+     */
   }, {
     key: "resolveMember",
     value: function resolveMember(memberName, memberType) {
@@ -1612,6 +2104,9 @@ var Meta = /*#__PURE__*/function () {
     key: "filterOperatorsForMember",
     value: function filterOperatorsForMember(memberName, memberType) {
       var member = this.resolveMember(memberName, memberType);
+      if ('error' in member || !('type' in member) || member.type === 'boolean') {
+        return operators.string;
+      }
       return operators[member.type] || operators.string;
     }
   }]);
@@ -1620,6 +2115,7 @@ var Meta = /*#__PURE__*/function () {
 var ProgressResult = /*#__PURE__*/function () {
   function ProgressResult(progressResponse) {
     _classCallCheck__default['default'](this, ProgressResult);
+    _defineProperty__default['default'](this, "progressResponse", void 0);
     this.progressResponse = progressResponse;
   }
   return _createClass__default['default'](ProgressResult, [{
@@ -1635,9 +2131,12 @@ var ProgressResult = /*#__PURE__*/function () {
   }]);
 }();
 
-var _excluded = ["baseRequestId"];
+var _excluded = ["baseRequestId", "signal"];
 function ownKeys$1(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread$1(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys$1(Object(t), !0).forEach(function (r) { _defineProperty__default['default'](e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys$1(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+/**
+ * Default transport implementation.
+ */
 var HttpTransport = /*#__PURE__*/function () {
   function HttpTransport(_ref) {
     var authorization = _ref.authorization,
@@ -1646,20 +2145,30 @@ var HttpTransport = /*#__PURE__*/function () {
       _ref$headers = _ref.headers,
       headers = _ref$headers === void 0 ? {} : _ref$headers,
       credentials = _ref.credentials,
-      fetchTimeout = _ref.fetchTimeout;
+      fetchTimeout = _ref.fetchTimeout,
+      signal = _ref.signal;
     _classCallCheck__default['default'](this, HttpTransport);
+    _defineProperty__default['default'](this, "authorization", void 0);
+    _defineProperty__default['default'](this, "apiUrl", void 0);
+    _defineProperty__default['default'](this, "method", void 0);
+    _defineProperty__default['default'](this, "headers", void 0);
+    _defineProperty__default['default'](this, "credentials", void 0);
+    _defineProperty__default['default'](this, "fetchTimeout", void 0);
+    _defineProperty__default['default'](this, "signal", void 0);
     this.authorization = authorization;
     this.apiUrl = apiUrl;
     this.method = method;
     this.headers = headers;
     this.credentials = credentials;
     this.fetchTimeout = fetchTimeout;
+    this.signal = signal;
   }
   return _createClass__default['default'](HttpTransport, [{
     key: "request",
     value: function request(method, _ref2) {
       var _this = this;
       var baseRequestId = _ref2.baseRequestId,
+        signal = _ref2.signal,
         params = _objectWithoutProperties__default['default'](_ref2, _excluded);
       var spanCounter = 1;
       var searchParams = new URLSearchParams(params && Object.keys(params).map(function (k) {
@@ -1685,35 +2194,39 @@ var HttpTransport = /*#__PURE__*/function () {
           }, _this.headers),
           credentials: _this.credentials,
           body: requestMethod === 'POST' ? JSON.stringify(params) : null,
-          signal: _this.fetchTimeout ? AbortSignal.timeout(_this.fetchTimeout) : undefined
+          signal: signal || _this.signal || (_this.fetchTimeout ? AbortSignal.timeout(_this.fetchTimeout) : undefined)
         });
       };
       return {
         /* eslint no-unsafe-finally: off */subscribe: function subscribe(callback) {
           var _this2 = this;
           return _asyncToGenerator__default['default'](/*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee() {
-            var result;
+            var result, _result;
             return _regeneratorRuntime__default['default'].wrap(function _callee$(_context) {
               while (1) switch (_context.prev = _context.next) {
                 case 0:
-                  result = {
-                    error: 'network Error' // add default error message
-                  };
-                  _context.prev = 1;
-                  _context.next = 4;
+                  _context.prev = 0;
+                  _context.next = 3;
                   return runRequest();
-                case 4:
+                case 3:
                   result = _context.sent;
-                case 5:
-                  _context.prev = 5;
                   return _context.abrupt("return", callback(result, function () {
                     return _this2.subscribe(callback);
                   }));
-                case 8:
+                case 7:
+                  _context.prev = 7;
+                  _context.t0 = _context["catch"](0);
+                  _result = {
+                    error: 'network Error'
+                  };
+                  return _context.abrupt("return", callback(_result, function () {
+                    return _this2.subscribe(callback);
+                  }));
+                case 11:
                 case "end":
                   return _context.stop();
               }
-            }, _callee, null, [[1,, 5, 8]]);
+            }, _callee, null, [[0, 7]]);
           }))();
         }
       };
@@ -1728,6 +2241,8 @@ var RequestError = /*#__PURE__*/function (_Error) {
     var _this;
     _classCallCheck__default['default'](this, RequestError);
     _this = _callSuper(this, RequestError, [message]);
+    _defineProperty__default['default'](_this, "response", void 0);
+    _defineProperty__default['default'](_this, "status", void 0);
     _this.response = response;
     _this.status = status;
     return _this;
@@ -1738,57 +2253,67 @@ var RequestError = /*#__PURE__*/function (_Error) {
 
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty__default['default'](e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-var mutexCounter = 0;
-var MUTEX_ERROR = 'Mutex has been changed';
+
+// If we can't infer any members at all, then return any.
 
 /**
- * Query result dataset formats enum.
+ * @deprecated use DryRunResponse
  */
-var ResultType = {
-  DEFAULT: 'default',
-  COMPACT: 'compact'
-};
+
+var mutexCounter = 0;
+var MUTEX_ERROR = 'Mutex has been changed';
 function mutexPromise(promise) {
-  return new Promise(/*#__PURE__*/function () {
-    var _ref = _asyncToGenerator__default['default'](/*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee(resolve, reject) {
-      return _regeneratorRuntime__default['default'].wrap(function _callee$(_context) {
-        while (1) switch (_context.prev = _context.next) {
-          case 0:
-            _context.prev = 0;
-            _context.t0 = resolve;
-            _context.next = 4;
-            return promise;
-          case 4:
-            _context.t1 = _context.sent;
-            (0, _context.t0)(_context.t1);
-            _context.next = 11;
-            break;
-          case 8:
-            _context.prev = 8;
-            _context.t2 = _context["catch"](0);
-            if (_context.t2 !== MUTEX_ERROR) {
-              reject(_context.t2);
-            }
-          case 11:
-          case "end":
-            return _context.stop();
-        }
-      }, _callee, null, [[0, 8]]);
-    }));
-    return function (_x, _x2) {
-      return _ref.apply(this, arguments);
-    };
-  }());
+  return promise.then(function (result) {
+    return result;
+  })["catch"](function (error) {
+    if (error !== MUTEX_ERROR) {
+      throw error;
+    }
+  });
 }
+/**
+ * Main class for accessing Cube API
+ */
 var CubeApi = /*#__PURE__*/function () {
+  /**
+   * Creates an instance of the `CubeApi`. The API entry point.
+   *
+   * ```js
+   * import cube from '@cubejs-client/core';
+   * const cubeApi = cube(
+   *   'CUBE-API-TOKEN',
+   *   { apiUrl: 'http://localhost:4000/cubejs-api/v1' }
+   * );
+   * ```
+   *
+   * You can also pass an async function or a promise that will resolve to the API token
+   *
+   * ```js
+   * import cube from '@cubejs-client/core';
+   * const cubeApi = cube(
+   *   async () => await Auth.getJwtToken(),
+   *   { apiUrl: 'http://localhost:4000/cubejs-api/v1' }
+   * );
+   * ```
+   */
   function CubeApi(apiToken, options) {
     _classCallCheck__default['default'](this, CubeApi);
-    if (apiToken !== null && !Array.isArray(apiToken) && _typeof__default['default'](apiToken) === 'object') {
+    _defineProperty__default['default'](this, "apiToken", void 0);
+    _defineProperty__default['default'](this, "apiUrl", void 0);
+    _defineProperty__default['default'](this, "method", void 0);
+    _defineProperty__default['default'](this, "headers", void 0);
+    _defineProperty__default['default'](this, "credentials", void 0);
+    _defineProperty__default['default'](this, "transport", void 0);
+    _defineProperty__default['default'](this, "pollInterval", void 0);
+    _defineProperty__default['default'](this, "parseDateMeasures", void 0);
+    _defineProperty__default['default'](this, "castNumerics", void 0);
+    _defineProperty__default['default'](this, "networkErrorRetries", void 0);
+    _defineProperty__default['default'](this, "updateAuthorizationPromise", void 0);
+    if (apiToken && !Array.isArray(apiToken) && _typeof__default['default'](apiToken) === 'object') {
       options = apiToken;
       apiToken = undefined;
     }
-    options = options || {};
-    if (!options.transport && !options.apiUrl) {
+    if (!options || !options.transport && !options.apiUrl) {
       throw new Error('The `apiUrl` option is required');
     }
     this.apiToken = apiToken;
@@ -1797,11 +2322,13 @@ var CubeApi = /*#__PURE__*/function () {
     this.headers = options.headers || {};
     this.credentials = options.credentials;
     this.transport = options.transport || new HttpTransport({
-      authorization: typeof apiToken === 'function' ? undefined : apiToken,
+      authorization: typeof apiToken === 'string' ? apiToken : undefined,
       apiUrl: this.apiUrl,
       method: this.method,
       headers: this.headers,
-      credentials: this.credentials
+      credentials: this.credentials,
+      fetchTimeout: options.fetchTimeout,
+      signal: options.signal
     });
     this.pollInterval = options.pollInterval || 5;
     this.parseDateMeasures = options.parseDateMeasures;
@@ -1836,218 +2363,225 @@ var CubeApi = /*#__PURE__*/function () {
       var skipAuthorizationUpdate = true;
       var unsubscribed = false;
       var checkMutex = /*#__PURE__*/function () {
-        var _ref2 = _asyncToGenerator__default['default'](/*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee2() {
+        var _ref = _asyncToGenerator__default['default'](/*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee() {
           var requestInstance;
-          return _regeneratorRuntime__default['default'].wrap(function _callee2$(_context2) {
-            while (1) switch (_context2.prev = _context2.next) {
+          return _regeneratorRuntime__default['default'].wrap(function _callee$(_context) {
+            while (1) switch (_context.prev = _context.next) {
               case 0:
-                _context2.next = 2;
+                _context.next = 2;
                 return requestPromise;
               case 2:
-                requestInstance = _context2.sent;
-                if (!(options.mutexObj && options.mutexObj[mutexKey] !== mutexValue)) {
-                  _context2.next = 9;
+                requestInstance = _context.sent;
+                if (!(options && options.mutexObj && options.mutexObj[mutexKey] !== mutexValue)) {
+                  _context.next = 9;
                   break;
                 }
                 unsubscribed = true;
                 if (!requestInstance.unsubscribe) {
-                  _context2.next = 8;
+                  _context.next = 8;
                   break;
                 }
-                _context2.next = 8;
+                _context.next = 8;
                 return requestInstance.unsubscribe();
               case 8:
                 throw MUTEX_ERROR;
               case 9:
               case "end":
-                return _context2.stop();
+                return _context.stop();
             }
-          }, _callee2);
+          }, _callee);
         }));
         return function checkMutex() {
-          return _ref2.apply(this, arguments);
+          return _ref.apply(this, arguments);
         };
       }();
       var networkRetries = this.networkErrorRetries;
       var loadImpl = /*#__PURE__*/function () {
-        var _ref3 = _asyncToGenerator__default['default'](/*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee5(response, next) {
-          var requestInstance, subscribeNext, continueWait, body, text, error, result;
-          return _regeneratorRuntime__default['default'].wrap(function _callee5$(_context5) {
-            while (1) switch (_context5.prev = _context5.next) {
+        var _ref2 = _asyncToGenerator__default['default'](/*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee4(response, next) {
+          var _options2, _response$error, _options5;
+          var requestInstance, subscribeNext, continueWait, body, text, _options3, _options4, _error, result;
+          return _regeneratorRuntime__default['default'].wrap(function _callee4$(_context4) {
+            while (1) switch (_context4.prev = _context4.next) {
               case 0:
-                _context5.next = 2;
+                _context4.next = 2;
                 return requestPromise;
               case 2:
-                requestInstance = _context5.sent;
+                requestInstance = _context4.sent;
                 subscribeNext = /*#__PURE__*/function () {
-                  var _ref4 = _asyncToGenerator__default['default'](/*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee3() {
-                    return _regeneratorRuntime__default['default'].wrap(function _callee3$(_context3) {
-                      while (1) switch (_context3.prev = _context3.next) {
+                  var _ref3 = _asyncToGenerator__default['default'](/*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee2() {
+                    var _options;
+                    return _regeneratorRuntime__default['default'].wrap(function _callee2$(_context2) {
+                      while (1) switch (_context2.prev = _context2.next) {
                         case 0:
-                          if (!(options.subscribe && !unsubscribed)) {
-                            _context3.next = 8;
+                          if (!((_options = options) !== null && _options !== void 0 && _options.subscribe && !unsubscribed)) {
+                            _context2.next = 8;
                             break;
                           }
                           if (!requestInstance.unsubscribe) {
-                            _context3.next = 5;
+                            _context2.next = 5;
                             break;
                           }
-                          return _context3.abrupt("return", next());
+                          return _context2.abrupt("return", next());
                         case 5:
-                          _context3.next = 7;
+                          _context2.next = 7;
                           return new Promise(function (resolve) {
                             return setTimeout(function () {
                               return resolve();
                             }, _this.pollInterval * 1000);
                           });
                         case 7:
-                          return _context3.abrupt("return", next());
+                          return _context2.abrupt("return", next());
                         case 8:
-                          return _context3.abrupt("return", null);
+                          return _context2.abrupt("return", null);
                         case 9:
                         case "end":
-                          return _context3.stop();
+                          return _context2.stop();
                       }
-                    }, _callee3);
+                    }, _callee2);
                   }));
                   return function subscribeNext() {
-                    return _ref4.apply(this, arguments);
+                    return _ref3.apply(this, arguments);
                   };
                 }();
                 continueWait = /*#__PURE__*/function () {
-                  var _ref5 = _asyncToGenerator__default['default'](/*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee4(wait) {
-                    return _regeneratorRuntime__default['default'].wrap(function _callee4$(_context4) {
-                      while (1) switch (_context4.prev = _context4.next) {
+                  var _ref4 = _asyncToGenerator__default['default'](/*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee3() {
+                    var wait,
+                      _args3 = arguments;
+                    return _regeneratorRuntime__default['default'].wrap(function _callee3$(_context3) {
+                      while (1) switch (_context3.prev = _context3.next) {
                         case 0:
+                          wait = _args3.length > 0 && _args3[0] !== undefined ? _args3[0] : false;
                           if (unsubscribed) {
-                            _context4.next = 5;
+                            _context3.next = 6;
                             break;
                           }
                           if (!wait) {
-                            _context4.next = 4;
+                            _context3.next = 5;
                             break;
                           }
-                          _context4.next = 4;
+                          _context3.next = 5;
                           return new Promise(function (resolve) {
                             return setTimeout(function () {
                               return resolve();
                             }, _this.pollInterval * 1000);
                           });
-                        case 4:
-                          return _context4.abrupt("return", next());
                         case 5:
-                          return _context4.abrupt("return", null);
+                          return _context3.abrupt("return", next());
                         case 6:
+                          return _context3.abrupt("return", null);
+                        case 7:
                         case "end":
-                          return _context4.stop();
+                          return _context3.stop();
                       }
-                    }, _callee4);
+                    }, _callee3);
                   }));
-                  return function continueWait(_x5) {
-                    return _ref5.apply(this, arguments);
+                  return function continueWait() {
+                    return _ref4.apply(this, arguments);
                   };
                 }();
-                if (!(options.subscribe && !skipAuthorizationUpdate)) {
-                  _context5.next = 8;
+                if (!((_options2 = options) !== null && _options2 !== void 0 && _options2.subscribe && !skipAuthorizationUpdate)) {
+                  _context4.next = 8;
                   break;
                 }
-                _context5.next = 8;
+                _context4.next = 8;
                 return _this.updateTransportAuthorization();
               case 8:
                 skipAuthorizationUpdate = false;
-                if (!(response.status === 502 || response.error && response.error.toLowerCase() === 'network error' && --networkRetries >= 0)) {
-                  _context5.next = 13;
+                if (!('status' in response && response.status === 502 || 'error' in response && ((_response$error = response.error) === null || _response$error === void 0 ? void 0 : _response$error.toLowerCase()) === 'network error' && --networkRetries >= 0)) {
+                  _context4.next = 13;
                   break;
                 }
-                _context5.next = 12;
+                _context4.next = 12;
                 return checkMutex();
               case 12:
-                return _context5.abrupt("return", continueWait(true));
+                return _context4.abrupt("return", continueWait(true));
               case 13:
+                // From here we're sure that response is only fetch Response
+                response = response;
                 body = {};
                 text = '';
-                _context5.prev = 15;
-                _context5.next = 18;
+                _context4.prev = 16;
+                _context4.next = 19;
                 return response.text();
-              case 18:
-                text = _context5.sent;
+              case 19:
+                text = _context4.sent;
                 body = JSON.parse(text);
-                _context5.next = 25;
+                _context4.next = 26;
                 break;
-              case 22:
-                _context5.prev = 22;
-                _context5.t0 = _context5["catch"](15);
+              case 23:
+                _context4.prev = 23;
+                _context4.t0 = _context4["catch"](16);
                 body.error = text;
-              case 25:
+              case 26:
                 if (!(body.error === 'Continue wait')) {
-                  _context5.next = 30;
+                  _context4.next = 31;
                   break;
                 }
-                _context5.next = 28;
+                _context4.next = 29;
                 return checkMutex();
-              case 28:
-                if (options.progressCallback) {
+              case 29:
+                if ((_options3 = options) !== null && _options3 !== void 0 && _options3.progressCallback) {
                   options.progressCallback(new ProgressResult(body));
                 }
-                return _context5.abrupt("return", continueWait());
-              case 30:
+                return _context4.abrupt("return", continueWait());
+              case 31:
                 if (!(response.status !== 200)) {
-                  _context5.next = 43;
+                  _context4.next = 44;
                   break;
                 }
-                _context5.next = 33;
+                _context4.next = 34;
                 return checkMutex();
-              case 33:
-                if (!(!options.subscribe && requestInstance.unsubscribe)) {
-                  _context5.next = 36;
+              case 34:
+                if (!(!((_options4 = options) !== null && _options4 !== void 0 && _options4.subscribe) && requestInstance.unsubscribe)) {
+                  _context4.next = 37;
                   break;
                 }
-                _context5.next = 36;
+                _context4.next = 37;
                 return requestInstance.unsubscribe();
-              case 36:
-                error = new RequestError(body.error, body, response.status); // TODO error class
+              case 37:
+                _error = new RequestError(body.error || '', body, response.status);
                 if (!callback) {
-                  _context5.next = 41;
+                  _context4.next = 42;
                   break;
                 }
-                callback(error);
-                _context5.next = 42;
+                callback(_error);
+                _context4.next = 43;
                 break;
-              case 41:
-                throw error;
               case 42:
-                return _context5.abrupt("return", subscribeNext());
+                throw _error;
               case 43:
-                _context5.next = 45;
+                return _context4.abrupt("return", subscribeNext());
+              case 44:
+                _context4.next = 46;
                 return checkMutex();
-              case 45:
-                if (!(!options.subscribe && requestInstance.unsubscribe)) {
-                  _context5.next = 48;
+              case 46:
+                if (!(!((_options5 = options) !== null && _options5 !== void 0 && _options5.subscribe) && requestInstance.unsubscribe)) {
+                  _context4.next = 49;
                   break;
                 }
-                _context5.next = 48;
+                _context4.next = 49;
                 return requestInstance.unsubscribe();
-              case 48:
+              case 49:
                 result = toResult(body);
                 if (!callback) {
-                  _context5.next = 53;
+                  _context4.next = 54;
                   break;
                 }
                 callback(null, result);
-                _context5.next = 54;
+                _context4.next = 55;
                 break;
-              case 53:
-                return _context5.abrupt("return", result);
               case 54:
-                return _context5.abrupt("return", subscribeNext());
+                return _context4.abrupt("return", result);
               case 55:
+                return _context4.abrupt("return", subscribeNext());
+              case 56:
               case "end":
-                return _context5.stop();
+                return _context4.stop();
             }
-          }, _callee5, null, [[15, 22]]);
+          }, _callee4, null, [[16, 23]]);
         }));
-        return function loadImpl(_x3, _x4) {
-          return _ref3.apply(this, arguments);
+        return function loadImpl(_x, _x2) {
+          return _ref2.apply(this, arguments);
         };
       }();
       var promise = requestPromise.then(function (requestInstance) {
@@ -2056,28 +2590,28 @@ var CubeApi = /*#__PURE__*/function () {
       if (callback) {
         return {
           unsubscribe: function () {
-            var _unsubscribe = _asyncToGenerator__default['default'](/*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee6() {
+            var _unsubscribe = _asyncToGenerator__default['default'](/*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee5() {
               var requestInstance;
-              return _regeneratorRuntime__default['default'].wrap(function _callee6$(_context6) {
-                while (1) switch (_context6.prev = _context6.next) {
+              return _regeneratorRuntime__default['default'].wrap(function _callee5$(_context5) {
+                while (1) switch (_context5.prev = _context5.next) {
                   case 0:
-                    _context6.next = 2;
+                    _context5.next = 2;
                     return requestPromise;
                   case 2:
-                    requestInstance = _context6.sent;
+                    requestInstance = _context5.sent;
                     unsubscribed = true;
                     if (!requestInstance.unsubscribe) {
-                      _context6.next = 6;
+                      _context5.next = 6;
                       break;
                     }
-                    return _context6.abrupt("return", requestInstance.unsubscribe());
+                    return _context5.abrupt("return", requestInstance.unsubscribe());
                   case 6:
-                    return _context6.abrupt("return", null);
+                    return _context5.abrupt("return", null);
                   case 7:
                   case "end":
-                    return _context6.stop();
+                    return _context5.stop();
                 }
-              }, _callee6);
+              }, _callee5);
             }));
             function unsubscribe() {
               return _unsubscribe.apply(this, arguments);
@@ -2092,66 +2626,57 @@ var CubeApi = /*#__PURE__*/function () {
   }, {
     key: "updateTransportAuthorization",
     value: function () {
-      var _updateTransportAuthorization = _asyncToGenerator__default['default'](/*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee8() {
+      var _updateTransportAuthorization = _asyncToGenerator__default['default'](/*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee7() {
         var _this2 = this;
-        return _regeneratorRuntime__default['default'].wrap(function _callee8$(_context8) {
-          while (1) switch (_context8.prev = _context8.next) {
+        var tokenFetcher, promise;
+        return _regeneratorRuntime__default['default'].wrap(function _callee7$(_context7) {
+          while (1) switch (_context7.prev = _context7.next) {
             case 0:
               if (!this.updateAuthorizationPromise) {
-                _context8.next = 4;
+                _context7.next = 4;
                 break;
               }
-              _context8.next = 3;
+              _context7.next = 3;
               return this.updateAuthorizationPromise;
             case 3:
-              return _context8.abrupt("return");
+              return _context7.abrupt("return");
             case 4:
-              if (!(typeof this.apiToken === 'function')) {
-                _context8.next = 8;
+              tokenFetcher = this.apiToken;
+              if (!(typeof tokenFetcher === 'function')) {
+                _context7.next = 10;
                 break;
               }
-              this.updateAuthorizationPromise = new Promise(/*#__PURE__*/function () {
-                var _ref6 = _asyncToGenerator__default['default'](/*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee7(resolve, reject) {
-                  var token;
-                  return _regeneratorRuntime__default['default'].wrap(function _callee7$(_context7) {
-                    while (1) switch (_context7.prev = _context7.next) {
-                      case 0:
-                        _context7.prev = 0;
-                        _context7.next = 3;
-                        return _this2.apiToken();
-                      case 3:
-                        token = _context7.sent;
-                        if (_this2.transport.authorization !== token) {
-                          _this2.transport.authorization = token;
-                        }
-                        resolve();
-                        _context7.next = 11;
-                        break;
-                      case 8:
-                        _context7.prev = 8;
-                        _context7.t0 = _context7["catch"](0);
-                        reject(_context7.t0);
-                      case 11:
-                        _context7.prev = 11;
-                        _this2.updateAuthorizationPromise = null;
-                        return _context7.finish(11);
-                      case 14:
-                      case "end":
-                        return _context7.stop();
-                    }
-                  }, _callee7, null, [[0, 8, 11, 14]]);
-                }));
-                return function (_x6, _x7) {
-                  return _ref6.apply(this, arguments);
-                };
-              }());
-              _context8.next = 8;
-              return this.updateAuthorizationPromise;
-            case 8:
+              promise = _asyncToGenerator__default['default'](/*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee6() {
+                var token;
+                return _regeneratorRuntime__default['default'].wrap(function _callee6$(_context6) {
+                  while (1) switch (_context6.prev = _context6.next) {
+                    case 0:
+                      _context6.prev = 0;
+                      _context6.next = 3;
+                      return tokenFetcher();
+                    case 3:
+                      token = _context6.sent;
+                      if (_this2.transport.authorization !== token) {
+                        _this2.transport.authorization = token;
+                      }
+                    case 5:
+                      _context6.prev = 5;
+                      _this2.updateAuthorizationPromise = null;
+                      return _context6.finish(5);
+                    case 8:
+                    case "end":
+                      return _context6.stop();
+                  }
+                }, _callee6, null, [[0,, 5, 8]]);
+              }))();
+              this.updateAuthorizationPromise = promise;
+              _context7.next = 10;
+              return promise;
+            case 10:
             case "end":
-              return _context8.stop();
+              return _context7.stop();
           }
-        }, _callee8, this);
+        }, _callee7, this);
       }));
       function updateTransportAuthorization() {
         return _updateTransportAuthorization.apply(this, arguments);
@@ -2160,17 +2685,13 @@ var CubeApi = /*#__PURE__*/function () {
     }()
     /**
      * Add system properties to a query object.
-     * @param {Query} query
-     * @param {string} responseFormat
-     * @returns {void}
-     * @private
      */
   }, {
     key: "patchQueryInternal",
     value: function patchQueryInternal(query, responseFormat) {
-      if (responseFormat === ResultType.COMPACT && query.responseFormat !== ResultType.COMPACT) {
+      if (responseFormat === 'compact' && query.responseFormat !== 'compact') {
         return _objectSpread(_objectSpread({}, query), {}, {
-          responseFormat: ResultType.COMPACT
+          responseFormat: 'compact'
         });
       } else {
         return query;
@@ -2180,26 +2701,23 @@ var CubeApi = /*#__PURE__*/function () {
     /**
      * Process result fetched from the gateway#load method according
      * to the network protocol.
-     * @param {*} response
-     * @returns ResultSet
-     * @private
      */
   }, {
     key: "loadResponseInternal",
     value: function loadResponseInternal(response) {
       var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
       if (response.results.length) {
-        if (options.castNumerics) {
+        if (options !== null && options !== void 0 && options.castNumerics) {
           response.results.forEach(function (result) {
-            var numericMembers = Object.entries(_objectSpread(_objectSpread({}, result.annotation.measures), result.annotation.dimensions)).map(function (_ref7) {
-              var _ref8 = _slicedToArray__default['default'](_ref7, 2),
-                k = _ref8[0],
-                v = _ref8[1];
+            var numericMembers = Object.entries(_objectSpread(_objectSpread({}, result.annotation.measures), result.annotation.dimensions)).reduce(function (acc, _ref6) {
+              var _ref7 = _slicedToArray__default['default'](_ref6, 2),
+                k = _ref7[0],
+                v = _ref7[1];
               if (v.type === 'number') {
-                return k;
+                acc.push(k);
               }
-              return undefined;
-            }).filter(Boolean);
+              return acc;
+            }, []);
             result.data = result.data.map(function (row) {
               numericMembers.forEach(function (key) {
                 if (row[key] != null) {
@@ -2210,12 +2728,15 @@ var CubeApi = /*#__PURE__*/function () {
             });
           });
         }
-        if (response.results[0].query.responseFormat && response.results[0].query.responseFormat === ResultType.COMPACT) {
+        if (response.results[0].query.responseFormat && response.results[0].query.responseFormat === 'compact') {
           response.results.forEach(function (result, j) {
             var data = [];
-            result.data.dataset.forEach(function (r) {
+            var _ref8 = result.data,
+              dataset = _ref8.dataset,
+              members = _ref8.members;
+            dataset.forEach(function (r) {
               var row = {};
-              result.data.members.forEach(function (m, i) {
+              members.forEach(function (m, i) {
                 row[m] = r[i];
               });
               data.push(row);
@@ -2230,65 +2751,136 @@ var CubeApi = /*#__PURE__*/function () {
     }
   }, {
     key: "load",
-    value: function load(query, options, callback) {
+    value:
+    /**
+     * Fetch data for the passed `query`.
+     *
+     * ```js
+     * import cube from '@cubejs-client/core';
+     * import Chart from 'chart.js';
+     * import chartjsConfig from './toChartjsData';
+     *
+     * const cubeApi = cube('CUBEJS_TOKEN');
+     *
+     * const resultSet = await cubeApi.load({
+     *  measures: ['Stories.count'],
+     *  timeDimensions: [{
+     *    dimension: 'Stories.time',
+     *    dateRange: ['2015-01-01', '2015-12-31'],
+     *    granularity: 'month'
+     *   }]
+     * });
+     *
+     * const context = document.getElementById('myChart');
+     * new Chart(context, chartjsConfig(resultSet));
+     * ```
+     * @param query - [Query object](/product/apis-integrations/rest-api/query-format)
+     * @param options
+     * @param callback
+     * @param responseFormat
+     */
+    function load(query, options, callback) {
       var _this3 = this;
-      var responseFormat = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : ResultType.DEFAULT;
-      options = _objectSpread({
-        castNumerics: this.castNumerics
-      }, options);
-      if (responseFormat === ResultType.COMPACT) {
-        if (Array.isArray(query)) {
-          query = query.map(function (q) {
-            return _this3.patchQueryInternal(q, ResultType.COMPACT);
-          });
-        } else {
-          query = this.patchQueryInternal(query, ResultType.COMPACT);
-        }
-      }
+      var responseFormat = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'default';
+      var _this$prepareQueryOpt = this.prepareQueryOptions(query, options, responseFormat);
+      var _this$prepareQueryOpt2 = _slicedToArray__default['default'](_this$prepareQueryOpt, 2);
+      query = _this$prepareQueryOpt2[0];
+      options = _this$prepareQueryOpt2[1];
       return this.loadMethod(function () {
+        var _options6;
         return _this3.request('load', {
           query: query,
-          queryType: 'multi'
+          queryType: 'multi',
+          signal: (_options6 = options) === null || _options6 === void 0 ? void 0 : _options6.signal
         });
       }, function (response) {
         return _this3.loadResponseInternal(response, options);
       }, options, callback);
     }
   }, {
-    key: "subscribe",
-    value: function subscribe(query, options, callback) {
+    key: "prepareQueryOptions",
+    value: function prepareQueryOptions(query, options) {
       var _this4 = this;
-      var responseFormat = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : ResultType.DEFAULT;
+      var responseFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'default';
       options = _objectSpread({
         castNumerics: this.castNumerics
       }, options);
-      if (responseFormat === ResultType.COMPACT) {
+      if (responseFormat === 'compact') {
         if (Array.isArray(query)) {
-          query = query.map(function (q) {
-            return _this4.patchQueryInternal(q, ResultType.COMPACT);
+          var patched = query.map(function (q) {
+            return _this4.patchQueryInternal(q, 'compact');
           });
+          return [patched, options];
         } else {
-          query = this.patchQueryInternal(query, ResultType.COMPACT);
+          var _patched = this.patchQueryInternal(query, 'compact');
+          return [_patched, options];
         }
       }
+      return [query, options];
+    }
+
+    /**
+     * Allows you to fetch data and receive updates over time. See [Real-Time Data Fetch](/product/apis-integrations/rest-api/real-time-data-fetch)
+     *
+     * ```js
+     * // Subscribe to a query's updates
+     * const subscription = await cubeApi.subscribe(
+     *   {
+     *     measures: ['Logs.count'],
+     *     timeDimensions: [
+     *       {
+     *         dimension: 'Logs.time',
+     *         granularity: 'hour',
+     *         dateRange: 'last 1440 minutes',
+     *       },
+     *     ],
+     *   },
+     *   options,
+     *   (error, resultSet) => {
+     *     if (!error) {
+     *       // handle the update
+     *     }
+     *   }
+     * );
+     *
+     * // Unsubscribe from a query's updates
+     * subscription.unsubscribe();
+     * ```
+     */
+  }, {
+    key: "subscribe",
+    value: function subscribe(query, options, callback) {
+      var _this5 = this;
+      var responseFormat = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'default';
+      var _this$prepareQueryOpt3 = this.prepareQueryOptions(query, options, responseFormat);
+      var _this$prepareQueryOpt4 = _slicedToArray__default['default'](_this$prepareQueryOpt3, 2);
+      query = _this$prepareQueryOpt4[0];
+      options = _this$prepareQueryOpt4[1];
       return this.loadMethod(function () {
-        return _this4.request('subscribe', {
+        var _options7;
+        return _this5.request('subscribe', {
           query: query,
-          queryType: 'multi'
+          queryType: 'multi',
+          signal: (_options7 = options) === null || _options7 === void 0 ? void 0 : _options7.signal
         });
       }, function (response) {
-        return _this4.loadResponseInternal(response, options);
+        return _this5.loadResponseInternal(response, options);
       }, _objectSpread(_objectSpread({}, options), {}, {
         subscribe: true
       }), callback);
     }
   }, {
     key: "sql",
-    value: function sql(query, options, callback) {
-      var _this5 = this;
+    value:
+    /**
+     * Get generated SQL string for the given `query`.
+     */
+    function sql(query, options, callback) {
+      var _this6 = this;
       return this.loadMethod(function () {
-        return _this5.request('sql', {
-          query: query
+        return _this6.request('sql', {
+          query: query,
+          signal: options === null || options === void 0 ? void 0 : options.signal
         });
       }, function (response) {
         return Array.isArray(response) ? response.map(function (body) {
@@ -2298,21 +2890,32 @@ var CubeApi = /*#__PURE__*/function () {
     }
   }, {
     key: "meta",
-    value: function meta(options, callback) {
-      var _this6 = this;
+    value:
+    /**
+     * Get meta description of cubes available for querying.
+     */
+    function meta(options, callback) {
+      var _this7 = this;
       return this.loadMethod(function () {
-        return _this6.request('meta');
+        return _this7.request('meta', {
+          signal: options === null || options === void 0 ? void 0 : options.signal
+        });
       }, function (body) {
         return new Meta(body);
       }, options, callback);
     }
   }, {
     key: "dryRun",
-    value: function dryRun(query, options, callback) {
-      var _this7 = this;
+    value:
+    /**
+     * Get query related meta without query execution
+     */
+    function dryRun(query, options, callback) {
+      var _this8 = this;
       return this.loadMethod(function () {
-        return _this7.request('dry-run', {
-          query: query
+        return _this8.request('dry-run', {
+          query: query,
+          signal: options === null || options === void 0 ? void 0 : options.signal
         });
       }, function (response) {
         return response;
@@ -2331,8 +2934,10 @@ exports.GRANULARITIES = GRANULARITIES;
 exports.HttpTransport = HttpTransport;
 exports.LocalDateRegex = LocalDateRegex;
 exports.Meta = Meta;
+exports.ProgressResult = ProgressResult;
 exports.RequestError = RequestError;
 exports.ResultSet = ResultSet;
+exports.SqlQuery = SqlQuery;
 exports.TIME_SERIES = TIME_SERIES;
 exports.addInterval = addInterval;
 exports.aliasSeries = aliasSeries;
@@ -2357,4 +2962,4 @@ exports.removeEmptyQueryFields = removeEmptyQueryFields;
 exports.subtractInterval = subtractInterval;
 exports.timeSeriesFromCustomInterval = timeSeriesFromCustomInterval;
 exports.validateQuery = validateQuery;
-//# sourceMappingURL=cubejs-client-core.js.map
+//# sourceMappingURL=cubejs-client-core.cjs.js.map