@iiasa/ixmp4-ts 0.6.0 → 0.8.0

package/dist/cjs/core/exceptions.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InvalidCredentials = exports.BadFilterArguments = exports.InvalidRunMeta = exports.NoDefaultRunVersion = exports.SchemaError = exports.OperationNotSupported = exports.DeletionPrevented = exports.NotUnique = exports.NotFound = exports.Forbidden = exports.InvalidToken = exports.MissingToken = exports.PlatformNotUnique = exports.PlatformNotFound = exports.UnknownApiError = exports.ManagerApiError = exports.ImproperlyConfigured = exports.BadRequest = exports.InconsistentIamcType = exports.ProgrammingError = exports.IxmpError = exports.createError = void 0;
+exports.InvalidCredentials = exports.BadFilterArguments = exports.InvalidRunMeta = exports.NoDefaultRunVersion = exports.SchemaError = exports.OperationNotSupported = exports.DeletionPrevented = exports.NotUnique = exports.NotFound = exports.Forbidden = exports.InvalidToken = exports.MissingToken = exports.PlatformNotUnique = exports.PlatformNotFound = exports.UnknownApiError = exports.ManagerApiError = exports.ImproperlyConfigured = exports.BadRequest = exports.InconsistentIamcType = exports.ProgrammingError = exports.IxmpError = void 0;
+exports.createError = createError;
 class ProgrammingError extends Error {
 }
 exports.ProgrammingError = ProgrammingError;
@@ -210,7 +211,6 @@ function createError(options) {
         return new ImproperlyConfigured(Object.assign({ message: 'Could not find remote exception in registry. Are you sure client and server ixmp versions are compatible?' }, options));
     }
 }
-exports.createError = createError;
 // Register all error classes
 registerError(InconsistentIamcType);
 registerError(BadRequest);

package/dist/cjs/core/iamc/data.js

@@ -23,6 +23,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PlatformIamcData = exports.RunIamcData = void 0;
 const dataframe_1 = require("../../dataframe");
 const base_1 = require("../base");
+const datapoint_1 = require("../../data/iamc/datapoint");
 const utils_1 = require("../utils");
 const variable_1 = require("./variable");
 /**
@@ -70,18 +71,12 @@ class RunIamcData extends base_1.BaseFacade {
             yield this.backend.iamc.datapoints.bulkDelete(df);
         });
     }
-    /**
-     * Tabulates IAMC format timeseries data with optional filtering.
-     * @param filter Optional. Filter for tabulating IAMC format timeseries data.
-     * @param wide Optional. Whether to return the data in IAMC wide format or not, defaults to false.
-     * @returns A DataFrame representing the tabulated data.
-     * @throws An error if illegal filters are applied.
-     */
-    tabulate(_a = {
-        wide: false,
-    }) {
-        var { wide = false } = _a, filter = __rest(_a, ["wide"]);
-        return __awaiter(this, void 0, void 0, function* () {
+    tabulate() {
+        return __awaiter(this, arguments, void 0, function* (_a = {
+            wide: false,
+            splitByType: false,
+        }) {
+            var { wide = false, splitByType = false } = _a, filter = __rest(_a, ["wide", "splitByType"]);
             if (filter !== undefined && filter !== null) {
                 // these filters do not make sense when applied from a Run
                 const illegalFilter = Object.keys(filter).filter((key) => {
@@ -91,7 +86,9 @@ class RunIamcData extends base_1.BaseFacade {
                     throw new Error(`Illegal filter for 'iamc.tabulate()': ${illegalFilter}`);
                 }
             }
-            return yield this.repository.tabulate(Object.assign({ run: { id: this.run.id, defaultOnly: false }, joinRuns: false, wide }, filter));
+            const df = yield this.repository.tabulate(Object.assign(Object.assign({}, filter), { run: { id: this.run.id, defaultOnly: false }, joinRuns: false, wide,
+                splitByType }));
+            return df;
         });
     }
     contractParameters(df) {
@@ -135,19 +132,9 @@ class PlatformIamcData extends base_1.BaseFacade {
         super(backend);
         this.variables = new variable_1.VariableRepository(this.backend);
     }
-    /**
-     * Tabulates IAMC data with optional filtering.
-     * @param filter Optional. Filter for retrieving IAMC data.
-     * @param joinRuns Optional. Whether to join runs or not, defaults to true.
-     * @param wide Optional. Whether to return the data in IAMC wide format or not, defaults to false.
-     * @returns A Promise that resolves to a DataFrame containing the tabulated data.
-     */
-    tabulate(_a = {
-        joinRuns: true,
-        wide: false,
-    }) {
-        var { joinRuns = true, wide = false } = _a, filter = __rest(_a, ["joinRuns", "wide"]);
-        return __awaiter(this, void 0, void 0, function* () {
+    tabulate() {
+        return __awaiter(this, arguments, void 0, function* (_a = { joinRuns: true, wide: false, splitByType: false }) {
+            var { joinRuns = true, joinRunId = false, wide = false, splitByType = false } = _a, filter = __rest(_a, ["joinRuns", "joinRunId", "wide", "splitByType"]);
             if (filter === undefined) {
                 filter = {};
             }
@@ -156,19 +143,55 @@ class PlatformIamcData extends base_1.BaseFacade {
                 filter['run'] = { defaultOnly: true };
             }
             const joinParameters = true;
-            let df = yield this.backend.iamc.datapoints.tabulate({
+            let df = (yield this.backend.iamc.datapoints.tabulate({
                 joinRuns,
+                joinRunId,
                 joinParameters,
                 filter,
-            });
-            // df = df.dropNa({ axis: 1 });
-            if (df.columns.includes('time_series__id')) {
-                df = df.dropColumns(['time_series__id']);
+            }));
+            if (splitByType) {
+                const splitDfs = (0, utils_1.splitDataFrameByType)(df);
+                const typeMapping = {
+                    annual: datapoint_1.DataPointType.ANNUAL,
+                    categorical: datapoint_1.DataPointType.CATEGORICAL,
+                    datetime: datapoint_1.DataPointType.DATETIME,
+                };
+                const presentTypes = [];
+                Object.entries(typeMapping).forEach(([key, type]) => {
+                    const typedKey = key;
+                    if (splitDfs[typedKey]) {
+                        presentTypes.push(type);
+                        if (wide) {
+                            splitDfs[typedKey] = (0, utils_1.toIamcWide)(splitDfs[typedKey]);
+                        }
+                        splitDfs[typedKey] = (0, utils_1.standardizeIamcDf)(splitDfs[typedKey]);
+                    }
+                });
+                return Object.assign({ presentTypes }, splitDfs);
             }
-            if (df.columns.includes('unit')) {
-                df = df.replaceValue('dimensionless', ' ', 'unit');
+            else {
+                if (wide) {
+                    df = (0, utils_1.toIamcWide)(df);
+                }
+                return (0, utils_1.standardizeIamcDf)(df);
+            }
+        });
+    }
+    /**
+     * Counts IAMC datapoints with optional filtering.
+     * @param filter Optional. Filter for counting IAMC datapoints.
+     * @returns A promise that resolves to the count of datapoints.
+     */
+    count(filter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (filter === undefined) {
+                filter = {};
+            }
+            // return only default runs unless a run-filter is provided
+            if (!Object.hasOwn(filter, 'run')) {
+                filter['run'] = { defaultOnly: true };
             }
-            return wide ? (0, utils_1.toIamcWide)(df) : df;
+            return this.backend.iamc.datapoints.count(filter);
         });
     }
 }

package/dist/cjs/core/iamc/variable.js

@@ -136,5 +136,15 @@ class VariableRepository extends base_1.BaseFacade {
             return this.backend.iamc.variables.tabulate(filter);
         });
     }
+    /**
+     * Counts Variables with optional filtering.
+     * @param filter Optional. Filter for counting Variables.
+     * @returns A Promise that resolves to the count of Variables.
+     */
+    count(filter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.backend.iamc.variables.count(filter);
+        });
+    }
 }
 exports.VariableRepository = VariableRepository;

package/dist/cjs/core/meta.js

@@ -33,17 +33,27 @@ class MetaIndicatorRepository extends base_1.BaseFacade {
      * @param joinRunIndex Optional. Whether to join the run index to the tabulated data, defaults to true.
      * @returns A promise that resolves to a DataFrame containing the tabulated meta indicators.
      */
-    tabulate(_a = {
-        joinRunIndex: true,
-    }) {
-        var { joinRunIndex = true } = _a, filter = __rest(_a, ["joinRunIndex"]);
-        return __awaiter(this, void 0, void 0, function* () {
+    tabulate() {
+        return __awaiter(this, arguments, void 0, function* (_a = {
+            joinRunIndex: true,
+        }) {
+            var { joinRunIndex = true } = _a, filter = __rest(_a, ["joinRunIndex"]);
             if (filter === undefined) {
                 filter = {};
             }
             return yield this.backend.meta.tabulate(filter, joinRunIndex);
         });
     }
+    /**
+     * Counts meta indicators with optional filtering.
+     * @param filter Optional. Filter for counting meta indicators.
+     * @returns A promise that resolves to the count of meta indicators.
+     */
+    count(filter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.backend.meta.count(filter || {});
+        });
+    }
 }
 exports.MetaIndicatorRepository = MetaIndicatorRepository;
 /**

package/dist/cjs/core/model.js

@@ -137,5 +137,15 @@ class ModelRepository extends base_1.BaseFacade {
             return this.backend.models.tabulate((0, utils_1.withIamcDefault)(filter));
         });
     }
+    /**
+     * Counts models with optional filtering.
+     * @param filter Optional. Filter for counting models.
+     * @returns A promise that resolves to the count of models.
+     */
+    count(filter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.backend.models.count((0, utils_1.withIamcDefault)(filter));
+        });
+    }
 }
 exports.ModelRepository = ModelRepository;

package/dist/cjs/core/region.js

@@ -168,5 +168,15 @@ class RegionRepository extends base_1.BaseFacade {
             return this.backend.regions.tabulate((0, utils_1.withIamcDefault)(filter));
         });
     }
+    /**
+     * Counts regions with optional filtering.
+     * @param filter Optional. Filter for counting regions.
+     * @returns A promise that resolves to the count of regions.
+     */
+    count(filter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.backend.regions.count((0, utils_1.withIamcDefault)(filter));
+        });
+    }
 }
 exports.RegionRepository = RegionRepository;

package/dist/cjs/core/run.js

@@ -151,8 +151,8 @@ class RunRepository extends base_1.BaseFacade {
      * @param filter Optional. Filter for retriving runs.
      * @returns A promise that resolves to an array of Run instances.
      */
-    list(filter = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
+    list() {
+        return __awaiter(this, arguments, void 0, function* (filter = {}) {
             if (filter.defaultOnly === undefined) {
                 filter.defaultOnly = true;
             }
@@ -168,8 +168,8 @@ class RunRepository extends base_1.BaseFacade {
      * @param filter Optional. Filter for tabulating runs.
      * @returns A promise that resolves to a DataFrame containing the tabulated runs.
      */
-    tabulate(filter = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
+    tabulate() {
+        return __awaiter(this, arguments, void 0, function* (filter = {}) {
             if (filter.defaultOnly === undefined) {
                 filter.defaultOnly = true;
             }
@@ -190,5 +190,15 @@ class RunRepository extends base_1.BaseFacade {
             });
         });
     }
+    /**
+     * Counts runs with optional filtering.
+     * @param filter Optional. Filter for counting runs.
+     * @returns A promise that resolves to the count of runs.
+     */
+    count() {
+        return __awaiter(this, arguments, void 0, function* (filter = {}) {
+            return this.backend.runs.count((0, utils_1.withIamcDefault)(filter));
+        });
+    }
 }
 exports.RunRepository = RunRepository;

package/dist/cjs/core/scenario.js

@@ -145,5 +145,15 @@ class ScenarioRepository extends base_1.BaseFacade {
             return this.backend.scenarios.tabulate((0, utils_1.withIamcDefault)(filter));
         });
     }
+    /**
+     * Counts scenarios with optional filtering.
+     * @param filter Optional. Filter for counting scenarios.
+     * @returns A promise that resolves to the count of scenarios.
+     */
+    count(filter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.backend.scenarios.count((0, utils_1.withIamcDefault)(filter));
+        });
+    }
 }
 exports.ScenarioRepository = ScenarioRepository;

package/dist/cjs/core/unit.js

@@ -182,5 +182,15 @@ class UnitRepository extends base_1.BaseFacade {
             return this.backend.units.tabulate((0, utils_1.withIamcDefault)(filter));
         });
     }
+    /**
+     * Counts units with optional filtering.
+     * @param filter Optional. Filter for counting units.
+     * @returns A promise that resolves to the count of units.
+     */
+    count(filter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.backend.units.count((0, utils_1.withIamcDefault)(filter));
+        });
+    }
 }
 exports.UnitRepository = UnitRepository;

package/dist/cjs/core/utils.js

@@ -1,6 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.withIamcDefault = exports.toIamcWide = exports.dfToDimensionless = exports.unitToDimensionless = exports.substitudeType = void 0;
+exports.substitudeType = substitudeType;
+exports.unitToDimensionless = unitToDimensionless;
+exports.dfToDimensionless = dfToDimensionless;
+exports.standardizeIamcDf = standardizeIamcDf;
+exports.toIamcWide = toIamcWide;
+exports.withIamcDefault = withIamcDefault;
+exports.getIamcRowIndex = getIamcRowIndex;
+exports.sortTimesWithYearFirst = sortTimesWithYearFirst;
+exports.splitDataFrameByType = splitDataFrameByType;
 const dataframe_1 = require("../dataframe");
 const datapoint_1 = require("../data/iamc/datapoint");
 function substitudeType(df, type) {
@@ -23,91 +31,144 @@ function substitudeType(df, type) {
     }
     return df;
 }
-exports.substitudeType = substitudeType;
 function unitToDimensionless(name) {
     if (name === 'dimensionless') {
         throw new Error("Unit name 'dimensionless' is reserved, use an empty string '' instead.");
     }
     return name === '' ? 'dimensionless' : name;
 }
-exports.unitToDimensionless = unitToDimensionless;
 function dfToDimensionless(df) {
     if (df
         .loc({ columns: ['unit'] })
-        .values.map(toString)
+        .values.map(String)
         .includes('dimensionless')) {
         throw new Error("Unit name 'dimensionless' is reserved, use an empty string '' instead.");
     }
     df.replaceValue('', 'dimensionless', 'unit');
     return df;
 }
-exports.dfToDimensionless = dfToDimensionless;
+/**
+ * Standardizes the columns of a DataFrame in IAMC format.
+ * @param df DataFrame in IAMC format
+ * @returns DataFrame in IAMC format with standardized columns
+ */
+function standardizeIamcDf(df) {
+    if (df.columns.includes('time_series__id')) {
+        df = df.dropColumns(['time_series__id']);
+    }
+    if (df.columns.includes('unit')) {
+        df = df.replaceValue('dimensionless', ' ', 'unit');
+    }
+    // Rename step_category to subannual
+    if (df.columns.includes('step_category')) {
+        df = df.renameColumns({ step_category: 'subannual' });
+    }
+    return df;
+}
+/**
+ * Converts a DataFrame in IAMC long format to wide format.
+ * @param df The DataFrame to convert
+ * @returns A DataFrame in IAMC wide format
+ */
 function toIamcWide(df) {
-    // cannot convert empty dataframe to wide format
+    // empty df: drop long-format columns if present
     if (df.shape[0] === 0) {
-        // drop columns of iamc long format if present
-        if (df.columns.includes('step_year')) {
-            df = df.dropColumns(['step_year']);
-        }
-        if (df.columns.includes('value')) {
-            df = df.dropColumns(['value']);
-        }
-        return df;
-    }
-    // TODO make this work for other types than ANNUAL as well
-    const types = df.columnValues('type');
-    if (types.some((type) => type !== 'ANNUAL')) {
-        throw new Error('Only ANNUAL data is supported for conversion to wide format');
-    }
-    const allYears = [...new Set(df.columnValues('step_year'))];
-    allYears.sort();
-    const stepYearIndex = df.columns.indexOf('step_year');
-    const valueIndex = df.columns.indexOf('value');
-    const newColumnsIndices = df.columns
+        const longCols = [
+            'step_year',
+            'step_datetime',
+            'step_category',
+            'subannual',
+            'value',
+        ];
+        const toDrop = longCols.filter((c) => df.columns.includes(c));
+        return toDrop.length ? df.dropColumns(toDrop) : df;
+    }
+    // column index map
+    const colIdx = Object.fromEntries(df.columns.map((c, i) => [c, i]));
+    // collect unique, non-null times
+    const uniqueNonNull = (arr) => [...new Set(arr.filter((v) => v !== null && v !== undefined))];
+    const years = df.columns.includes('step_year')
+        ? uniqueNonNull(df.columnValues('step_year')).sort((a, b) => a - b)
+        : [];
+    const datetimes = df.columns.includes('step_datetime')
+        ? uniqueNonNull(df.columnValues('step_datetime')).sort()
+        : [];
+    const allTimes = sortTimesWithYearFirst(years, datetimes);
+    // indices to carry over (everything but time and value)
+    const takeOverIdx = df.columns
         .map((_, i) => i)
-        .filter((i) => i !== stepYearIndex && i !== valueIndex);
-    const columns = [];
-    const dtypes = [];
-    for (const index of newColumnsIndices) {
-        columns.push(df.columns[index]);
-        dtypes.push(df.dtypes[index]);
-    }
-    const yearColumnsIndex = new Map();
-    for (const year of allYears) {
-        columns.push(year.toString());
+        .filter((i) => {
+        var _a, _b, _c;
+        return i !== ((_a = colIdx['step_year']) !== null && _a !== void 0 ? _a : -1) &&
+            i !== ((_b = colIdx['step_datetime']) !== null && _b !== void 0 ? _b : -1) &&
+            i !== ((_c = colIdx['value']) !== null && _c !== void 0 ? _c : -1);
+    });
+    // base schema (carry-over columns + dtypes)
+    const columns = takeOverIdx.map((i) => df.columns[i]);
+    const dtypes = takeOverIdx.map((i) => df.dtypes[i]);
+    // add time columns
+    const yearColIdx = new Map();
+    const dtColIdx = new Map();
+    for (const time of allTimes) {
+        columns.push(String(time));
         dtypes.push(dataframe_1.DType.FLOAT32);
-        yearColumnsIndex.set(year, columns.length - 1);
+        const newIdx = columns.length - 1;
+        if (typeof time === 'number')
+            yearColIdx.set(time, newIdx);
+        else
+            dtColIdx.set(time, newIdx);
     }
-    const rowIdentifiers = [
+    // row identifiers: prefer step_category, fall back to subannual if present
+    const stepCategoryCol = df.columns.includes('step_category')
+        ? 'step_category'
+        : df.columns.includes('subannual')
+            ? 'subannual'
+            : undefined;
+    const idCols = [
         'model',
         'scenario',
         'version',
         'region',
         'variable',
         'unit',
-    ].map((col) => df.columns.indexOf(col));
+        'type',
+        stepCategoryCol,
+    ].filter(Boolean);
+    const idIdxs = idCols.map((c) => colIdx[c]);
+    // data mapping
     const dataMap = new Map();
-    for (const row of df.values) {
-        const index = getIamcRowIndex(row, rowIdentifiers);
-        if (dataMap.has(index)) {
-            dataMap.get(index)[yearColumnsIndex.get(row[stepYearIndex])] =
-                row[valueIndex];
+    const yearIdx = colIdx['step_year'];
+    const dtIdx = colIdx['step_datetime'];
+    const valueIdx = colIdx['value'];
+    for (const dfRow of df.values) {
+        const key = getIamcRowIndex(dfRow, idIdxs);
+        let wideRow = dataMap.get(key);
+        if (!wideRow) {
+            wideRow = takeOverIdx
+                .map((i) => dfRow[i])
+                .concat(Array(allTimes.length).fill(null));
+            dataMap.set(key, wideRow);
         }
-        else {
-            const wideRow = row
-                .filter((_, i) => newColumnsIndices.includes(i))
-                .concat(new Array(allYears.length).fill(null));
-            wideRow[yearColumnsIndex.get(row[stepYearIndex])] = row[valueIndex];
-            dataMap.set(index, wideRow);
+        const year = yearIdx !== undefined ? dfRow[yearIdx] : undefined;
+        const dt = dtIdx !== undefined ? dfRow[dtIdx] : undefined;
+        let targetIdx;
+        if (year !== undefined && year !== null)
+            targetIdx = yearColIdx.get(year);
+        else if (dt !== undefined && dt !== null)
+            targetIdx = dtColIdx.get(dt);
+        if (targetIdx !== undefined) {
+            wideRow[targetIdx] = dfRow[valueIdx];
         }
     }
-    const wideIamcData = [];
-    for (const wideRow of dataMap.values()) {
-        wideIamcData.push(wideRow);
-    }
+    const wideIamcData = Array.from(dataMap.values());
     return new dataframe_1.DataFrame(wideIamcData, { columns, dtypes });
 }
-exports.toIamcWide = toIamcWide;
+/**
+ * Generates a unique row index for IAMC data based on the row's identifiers.
+ * @param row The row data as an array
+ * @param rowIdentifiers The indices of the identifiers in the row
+ * @returns A string that uniquely identifies the row
+ */
 function getIamcRowIndex(row, rowIdentifiers) {
     return rowIdentifiers.map((i) => row[i]).join('_');
 }
@@ -131,4 +192,75 @@ function withIamcDefault(filter) {
     }
     return filter;
 }
-exports.withIamcDefault = withIamcDefault;
+function sortTimesWithYearFirst(years, dateTimes) {
+    // Create a combined array with type information
+    const combined = [];
+    // Add years with their metadata
+    for (const year of years) {
+        combined.push({ value: year, isYear: true, year });
+    }
+    // Add datetimes with their extracted year
+    for (const dateTime of dateTimes) {
+        // Extract year from datetime string (format: 2005-03-01T01:00:00)
+        const year = parseInt(dateTime.substring(0, 4), 10);
+        combined.push({ value: dateTime, isYear: false, year });
+    }
+    // Sort by year first, then by type (years before datetimes), then by value
+    combined.sort((a, b) => {
+        // First sort by year
+        if (a.year !== b.year) {
+            return a.year - b.year;
+        }
+        // Within the same year, years come before datetimes
+        if (a.isYear && !b.isYear) {
+            return -1;
+        }
+        if (!a.isYear && b.isYear) {
+            return 1;
+        }
+        // If both are the same type, sort by value
+        if (a.value < b.value) {
+            return -1;
+        }
+        if (a.value > b.value) {
+            return 1;
+        }
+        return 0;
+    });
+    // Return just the values
+    return combined.map((item) => item.value);
+}
+/**
+ * Splits a DataFrame into separate DataFrames based on DataPointType.
+ * @param df The DataFrame to split
+ * @returns An object containing DataFrames for each type present in the data
+ */
+function splitDataFrameByType(df) {
+    const result = {};
+    // If no type column exists, return the original dataframe as annual
+    if (!df.columns.includes('type')) {
+        result.annual = df;
+        return result;
+    }
+    // Get unique types in the dataframe
+    const typeValues = df.columnValues('type');
+    const uniqueTypes = [...new Set(typeValues)];
+    // Filter dataframe for each type present
+    for (const type of uniqueTypes) {
+        const filteredDf = df.query({
+            conditions: { column: 'type', predicate: (value) => value === type },
+        });
+        switch (type) {
+            case datapoint_1.DataPointType.ANNUAL:
+                result.annual = filteredDf;
+                break;
+            case datapoint_1.DataPointType.CATEGORICAL:
+                result.categorical = filteredDf;
+                break;
+            case datapoint_1.DataPointType.DATETIME:
+                result.datetime = filteredDf;
+                break;
+        }
+    }
+    return result;
+}

package/dist/cjs/data/base.js

@@ -26,8 +26,8 @@ class BaseRepository {
         this.enumerationMethod = (_a = this.constructor.enumerationMethod) !== null && _a !== void 0 ? _a : 'PATCH';
     }
     _request(url, method, params, body) {
-        var _a;
         return __awaiter(this, void 0, void 0, function* () {
+            var _a;
             const config = {};
             config.url = url;
             config.method = method;
@@ -80,8 +80,8 @@ class BaseRepository {
     /**
      * Convenience method for requests to the enumeration endpoint.
      */
-    _requestEnumeration(params = {}, body = {}, table = false) {
-        return __awaiter(this, void 0, void 0, function* () {
+    _requestEnumeration() {
+        return __awaiter(this, arguments, void 0, function* (params = {}, body = {}, table = false) {
             params = (0, utils_1.convertToSnakeCase)(params);
             if (body !== undefined && Object.keys(body).length === 0) {
                 body = undefined;
@@ -116,8 +116,8 @@ class BaseRepository {
             }
         });
     }
-    _list({ filter, params, }) {
-        return __awaiter(this, void 0, void 0, function* () {
+    _list(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ filter, params, }) {
             if (this.enumerationMethod === 'GET') {
                 params = Object.assign(Object.assign({}, params), filter);
                 filter = undefined;
@@ -133,8 +133,8 @@ class BaseRepository {
             }
         });
     }
-    _tabulate({ filter, params, }) {
-        return __awaiter(this, void 0, void 0, function* () {
+    _tabulate(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ filter, params, }) {
             // TODO: test what happens if we get a number that cannot be represented as float32 (or int32)
             const data = yield this._requestEnumeration(params, filter, true);
             const pagination = data.pagination;
@@ -156,6 +156,24 @@ class BaseRepository {
             }
         });
     }
+    _count(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ filter, params, }) {
+            if (this.enumerationMethod === 'GET') {
+                params = Object.assign(Object.assign(Object.assign({}, params), filter), { limit: 0 });
+                filter = undefined;
+            }
+            else {
+                params = Object.assign(Object.assign({}, params), { limit: 0 });
+            }
+            const data = yield this._requestEnumeration(params, filter, true);
+            if (data === undefined || data.total === undefined) {
+                throw new exceptions_1.UnknownApiError({
+                    message: 'Count result does not contain total count.',
+                });
+            }
+            return data.total;
+        });
+    }
     _bulkUpsert(df, params) {
         return __awaiter(this, void 0, void 0, function* () {
             return yield this._request(`${this.prefix}bulk/`, 'POST', params, (0, utils_1.dfToJson)(df));