@iiasa/ixmp4-ts 0.6.0 → 0.8.0

package/dist/esm/core/utils.js

@@ -29,78 +29,132 @@ function unitToDimensionless(name) {
 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;
 }
+/**
+ * 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) => i !== (colIdx['step_year'] ?? -1) &&
+        i !== (colIdx['step_datetime'] ?? -1) &&
+        i !== (colIdx['value'] ?? -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(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(wideIamcData, { columns, dtypes });
 }
+/**
+ * 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('_');
 }
@@ -124,4 +178,76 @@ function withIamcDefault(filter) {
     }
     return filter;
 }
-export { substitudeType, unitToDimensionless, dfToDimensionless, toIamcWide, 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 DataPointType.ANNUAL:
+                result.annual = filteredDf;
+                break;
+            case DataPointType.CATEGORICAL:
+                result.categorical = filteredDf;
+                break;
+            case DataPointType.DATETIME:
+                result.datetime = filteredDf;
+                break;
+        }
+    }
+    return result;
+}
+export { substitudeType, unitToDimensionless, dfToDimensionless, standardizeIamcDf, toIamcWide, withIamcDefault, getIamcRowIndex, sortTimesWithYearFirst, splitDataFrameByType, };

package/dist/esm/data/base.js

@@ -126,6 +126,22 @@ class BaseRepository {
             return jsonToDf(data);
         }
     }
+    async _count({ filter, params, }) {
+        if (this.enumerationMethod === 'GET') {
+            params = { ...params, ...filter, limit: 0 };
+            filter = undefined;
+        }
+        else {
+            params = { ...params, limit: 0 };
+        }
+        const data = await this._requestEnumeration(params, filter, true);
+        if (data === undefined || data.total === undefined) {
+            throw new UnknownApiError({
+                message: 'Count result does not contain total count.',
+            });
+        }
+        return data.total;
+    }
     async _bulkUpsert(df, params) {
         return await this._request(`${this.prefix}bulk/`, 'POST', params, dfToJson(df));
     }

package/dist/esm/data/iamc/datapoint.js

@@ -16,9 +16,10 @@ class DataPointRepository extends BaseRepository {
             params: { joinParameters },
         }));
     }
-    async tabulate({ joinParameters = false, joinRuns = false, filter = {}, } = {
+    async tabulate({ joinParameters = false, joinRuns = false, joinRunId = false, filter = {}, } = {
         joinParameters: false,
         joinRuns: false,
+        joinRunId: false,
         filter: {},
     }) {
         return await this._tabulate({
@@ -26,9 +27,15 @@ class DataPointRepository extends BaseRepository {
             params: {
                 joinParameters,
                 joinRuns,
+                joinRunId,
             },
         });
     }
+    async count(filter = {}) {
+        return await this._count({
+            filter,
+        });
+    }
     async bulkUpsert(df) {
         await this._bulkUpsert(df);
     }

package/dist/esm/data/iamc/variable.js

@@ -13,6 +13,9 @@ class VariableRepository extends BaseRepository {
     async tabulate(filter = {}) {
         return await this._tabulate({ filter });
     }
+    async count(filter = {}) {
+        return await this._count({ filter });
+    }
     async create(name) {
         return await this._post({ name });
     }

package/dist/esm/data/meta.js

@@ -14,6 +14,9 @@ class MetaIndicatorRepository extends BaseRepository {
     async tabulate(filter = {}, joinRunIndex) {
         return await this._tabulate({ filter, params: { joinRunIndex } });
     }
+    async count(filter = {}) {
+        return await this._count({ filter });
+    }
     async create(run__id, key, value) {
         const res = await this._post({
             run__id,

package/dist/esm/data/model.js

@@ -13,6 +13,9 @@ class ModelRepository extends BaseRepository {
     async tabulate(filter = {}) {
         return await this._tabulate({ filter });
     }
+    async count(filter = {}) {
+        return await this._count({ filter });
+    }
     async create(name) {
         const res = await this._post({ name });
         return res;

package/dist/esm/data/region.js

@@ -14,6 +14,9 @@ class RegionRepository extends BaseRepository {
     async tabulate(filter = {}) {
         return await this._tabulate({ filter });
     }
+    async count(filter = {}) {
+        return await this._count({ filter });
+    }
     async create(name, hierarchy) {
         const res = await this._post({
             name: name,

package/dist/esm/data/run.js

@@ -8,6 +8,9 @@ class RunRepository extends BaseRepository {
     async tabulate(filter = {}) {
         return await this._tabulate({ filter });
     }
+    async count(filter = {}) {
+        return await this._count({ filter });
+    }
     async create(modelName, scenarioName) {
         const res = await this._post({
             model_name: modelName,

package/dist/esm/data/scenario.js

@@ -13,6 +13,9 @@ class ScenarioRepository extends BaseRepository {
     async tabulate(filter = {}) {
         return await this._tabulate({ filter });
     }
+    async count(filter = {}) {
+        return await this._count({ filter });
+    }
     async create(name) {
         return (await this._post({ name }));
     }

package/dist/esm/data/unit.js

@@ -22,5 +22,8 @@ class UnitRepository extends BaseRepository {
     async tabulate(filter = {}) {
         return await this._tabulate({ filter });
     }
+    async count(filter = {}) {
+        return await this._count({ filter });
+    }
 }
 export { UnitRepository };

package/dist/esm/dataframe/dataframe.js

@@ -191,11 +191,7 @@ class DataFrame {
             values = options.rows.map((i) => values[i]);
             index = options.rows.map((i) => index[i]);
         }
-        return new DataFrame(values, {
-            index,
-            columns,
-            dtypes,
-        });
+        return new DataFrame(values, { index, columns, dtypes });
     }
     /**
      * Returns the value at the specified index and column.

package/dist/esm/index.js

@@ -1,3 +1,4 @@
 export { Platform } from './core/platform';
+export { DataPointType } from './data/iamc/datapoint';
 export { IxmpError, ProgrammingError, InconsistentIamcType, BadRequest, ImproperlyConfigured, ManagerApiError, UnknownApiError, PlatformNotFound, PlatformNotUnique, MissingToken, InvalidToken, Forbidden, NotFound, NotUnique, DeletionPrevented, OperationNotSupported, SchemaError, NoDefaultRunVersion, InvalidRunMeta, BadFilterArguments, InvalidCredentials, } from './core/exceptions';
 export { DataFrame, DType, concat, toJson, toCsv, merge, DataFrameError, InvalidColumn, InvalidIndex, } from './dataframe';

package/dist/esm/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../../src/backend.ts","../../src/index.ts","../../src/core/base.ts","../../src/core/exceptions.ts","../../src/core/meta.ts","../../src/core/model.ts","../../src/core/platform.ts","../../src/core/region.ts","../../src/core/run.ts","../../src/core/scenario.ts","../../src/core/unit.ts","../../src/core/utils.ts","../../src/core/iamc/data.ts","../../src/core/iamc/variable.ts","../../src/data/base.ts","../../src/data/docs.ts","../../src/data/filters.ts","../../src/data/info.ts","../../src/data/meta.ts","../../src/data/model.ts","../../src/data/region.ts","../../src/data/run.ts","../../src/data/scenario.ts","../../src/data/unit.ts","../../src/data/utils.ts","../../src/data/iamc/datapoint.ts","../../src/data/iamc/index.ts","../../src/data/iamc/timeseries.ts","../../src/data/iamc/variable.ts","../../src/dataframe/dataframe.ts","../../src/dataframe/exceptions.ts","../../src/dataframe/index.ts","../../src/dataframe/utils.ts"],"version":"5.9.2"}

package/dist/types/core/iamc/data.d.ts

@@ -11,6 +11,15 @@ import { RunFilter as BaseRunFilter } from '../../data/run';
 import { ScenarioFilter as BaseScenarioFilter } from '../../data/scenario';
 import { IamcDataFilter as BaseIamcDataFilter } from '../../data/iamc/datapoint';
 import { VariableRepository } from './variable';
+/**
+ * Represents the result of tabulating IAMC data with metadata about present types.
+ */
+type IamcDataResult = {
+    presentTypes: DataPointType[];
+    annual?: DataFrame;
+    categorical?: DataFrame;
+    datetime?: DataFrame;
+};
 /**
  * Represents a filter for tabulating IAMC format data.
  */
@@ -56,11 +65,17 @@ declare class RunIamcData extends BaseFacade {
      * 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.
+     * @param splitByType Optional. Whether to return separate DataFrames for different DataPointTypes, defaults to false.
+     * @returns A DataFrame representing the tabulated data, or a IamcDataResult with metadata and separate DataFrames by type if splitByType is true.
      * @throws An error if illegal filters are applied.
      */
-    tabulate({ wide, ...filter }?: {
+    tabulate(params: {
+        wide?: boolean;
+        splitByType: true;
+    } & IamcDataFilter): Promise<IamcDataResult>;
+    tabulate(params?: {
         wide?: boolean;
+        splitByType?: boolean;
     } & IamcDataFilter): Promise<DataFrame>;
     private contractParameters;
 }
@@ -82,12 +97,27 @@ declare class PlatformIamcData extends BaseFacade {
      * @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.
+     * @param splitByType Optional. Whether to return separate DataFrames for different DataPointTypes, defaults to false.
+     * @returns A Promise that resolves to a DataFrame containing the tabulated data, or a IamcDataResult with metadata and separate DataFrames by type if splitByType is true.
      */
-    tabulate({ joinRuns, wide, ...filter }?: {
+    tabulate(params: {
         joinRuns?: boolean;
+        joinRunId?: boolean;
         wide?: boolean;
+        splitByType: true;
+    } & IamcDataFilter): Promise<IamcDataResult>;
+    tabulate(params?: {
+        joinRuns?: boolean;
+        joinRunId?: boolean;
+        wide?: boolean;
+        splitByType?: boolean;
     } & IamcDataFilter): Promise<DataFrame>;
+    /**
+     * 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?: IamcDataFilter): Promise<number>;
 }
 export { RunIamcData, PlatformIamcData };
-export type { IamcDataFilter };
+export type { IamcDataFilter, IamcDataResult };

package/dist/types/core/iamc/variable.d.ts

@@ -93,6 +93,12 @@ declare class VariableRepository extends BaseFacade {
      * @returns A Promise that resolves to the tabulated result.
      */
     tabulate(filter?: VariableFilter): Promise<any>;
+    /**
+     * Counts Variables with optional filtering.
+     * @param filter Optional. Filter for counting Variables.
+     * @returns A Promise that resolves to the count of Variables.
+     */
+    count(filter?: VariableFilter): Promise<number>;
 }
 export { Variable, VariableRepository };
 export type { VariableFilter };

package/dist/types/core/meta.d.ts

@@ -28,6 +28,12 @@ declare class MetaIndicatorRepository extends BaseFacade {
     tabulate({ joinRunIndex, ...filter }?: {
         joinRunIndex?: boolean;
     } & MetaIndicatorFilter): Promise<DataFrame>;
+    /**
+     * 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?: MetaIndicatorFilter): Promise<number>;
 }
 /**
  * Repository for accessing meta indicators of a specific run.

package/dist/types/core/model.d.ts

@@ -96,6 +96,12 @@ declare class ModelRepository extends BaseFacade {
      * @returns A promise that resolves to the tabulated result.
      */
     tabulate(filter?: ModelFilter): Promise<DataFrame>;
+    /**
+     * Counts models with optional filtering.
+     * @param filter Optional. Filter for counting models.
+     * @returns A promise that resolves to the count of models.
+     */
+    count(filter?: ModelFilter): Promise<number>;
 }
 export { Model, ModelRepository };
 export type { ModelFilter };

package/dist/types/core/region.d.ts

@@ -108,6 +108,12 @@ declare class RegionRepository extends BaseFacade {
      * @returns A promise that resolves to a DataFrame containing the tabulated regions.
      */
     tabulate(filter?: RegionFilter): Promise<DataFrame>;
+    /**
+     * Counts regions with optional filtering.
+     * @param filter Optional. Filter for counting regions.
+     * @returns A promise that resolves to the count of regions.
+     */
+    count(filter?: RegionFilter): Promise<number>;
 }
 export { Region as Region, RegionRepository };
 export type { RegionFilter };

package/dist/types/core/run.d.ts

@@ -123,6 +123,12 @@ declare class RunRepository extends BaseFacade {
      * @returns A promise that resolves to a DataFrame containing the tabulated runs.
      */
     tabulate(filter?: RunFilter): Promise<DataFrame>;
+    /**
+     * Counts runs with optional filtering.
+     * @param filter Optional. Filter for counting runs.
+     * @returns A promise that resolves to the count of runs.
+     */
+    count(filter?: RunFilter): Promise<number>;
 }
 export { Run, RunRepository };
 export type { RunFilter };

package/dist/types/core/scenario.d.ts

@@ -101,6 +101,12 @@ declare class ScenarioRepository extends BaseFacade {
      * @returns A Promise that resolves to a DataFrame containing the tabulated data.
      */
     tabulate(filter?: ScenarioFilter): Promise<DataFrame>;
+    /**
+     * Counts scenarios with optional filtering.
+     * @param filter Optional. Filter for counting scenarios.
+     * @returns A promise that resolves to the count of scenarios.
+     */
+    count(filter?: ScenarioFilter): Promise<number>;
 }
 export { Scenario, ScenarioRepository };
 export type { ScenarioFilter };

package/dist/types/core/unit.d.ts

@@ -114,6 +114,12 @@ declare class UnitRepository extends BaseFacade {
      * @returns A promise that resolves with a DataFrame object.
      */
     tabulate(filter?: UnitFilter): Promise<DataFrame>;
+    /**
+     * Counts units with optional filtering.
+     * @param filter Optional. Filter for counting units.
+     * @returns A promise that resolves to the count of units.
+     */
+    count(filter?: UnitFilter): Promise<number>;
 }
 export { Unit, UnitRepository };
 export type { UnitFilter };

package/dist/types/core/utils.d.ts

@@ -9,7 +9,25 @@ import { ModelFilter } from './model';
 declare function substitudeType(df: DataFrame, type?: DataPointType): DataFrame;
 declare function unitToDimensionless(name: string): string;
 declare function dfToDimensionless(df: DataFrame): DataFrame;
+/**
+ * Standardizes the columns of a DataFrame in IAMC format.
+ * @param df DataFrame in IAMC format
+ * @returns DataFrame in IAMC format with standardized columns
+ */
+declare function standardizeIamcDf(df: DataFrame): DataFrame;
+/**
+ * Converts a DataFrame in IAMC long format to wide format.
+ * @param df The DataFrame to convert
+ * @returns A DataFrame in IAMC wide format
+ */
 declare function toIamcWide(df: DataFrame): DataFrame;
+/**
+ * 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
+ */
+declare function getIamcRowIndex(row: any[], rowIdentifiers: number[]): string;
 /**
  * Processes the filter to ensure that IAMC filter is enabled by default unless explicitly disabled.
  * When enabled, only entities with associated datapoints are returned.
@@ -17,4 +35,15 @@ declare function toIamcWide(df: DataFrame): DataFrame;
  * @returns The processed filter with IAMC default settings
  */
 declare function withIamcDefault(filter?: RunFilter | ScenarioFilter | ModelFilter | RegionFilter | UnitFilter): PlainObject;
-export { substitudeType, unitToDimensionless, dfToDimensionless, toIamcWide, withIamcDefault, };
+declare function sortTimesWithYearFirst(years: number[], dateTimes: string[]): (number | string)[];
+/**
+ * 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
+ */
+declare function splitDataFrameByType(df: DataFrame): {
+    annual?: DataFrame;
+    categorical?: DataFrame;
+    datetime?: DataFrame;
+};
+export { substitudeType, unitToDimensionless, dfToDimensionless, standardizeIamcDf, toIamcWide, withIamcDefault, getIamcRowIndex, sortTimesWithYearFirst, splitDataFrameByType, };

package/dist/types/data/base.d.ts

@@ -43,6 +43,10 @@ declare class BaseRepository {
         filter?: object;
         params?: object;
     }): Promise<DataFrame>;
+    _count({ filter, params, }: {
+        filter?: object;
+        params?: object;
+    }): Promise<number>;
     _bulkUpsert(df: DataFrame, params?: object): Promise<void>;
     _bulkDelete(df: DataFrame, params?: object): Promise<void>;
     private static throwRemoteException;

package/dist/types/data/iamc/datapoint.d.ts

@@ -24,11 +24,13 @@ declare class DataPointRepository extends BaseRepository {
         joinParameters?: boolean;
         filter: PlainObject;
     }): Promise<DataPoint[]>;
-    tabulate({ joinParameters, joinRuns, filter, }?: {
+    tabulate({ joinParameters, joinRuns, joinRunId, filter, }?: {
         joinParameters?: boolean;
         joinRuns?: boolean;
+        joinRunId?: boolean;
         filter: PlainObject;
     }): Promise<DataFrame>;
+    count(filter?: PlainObject): Promise<number>;
     bulkUpsert(df: DataFrame): Promise<void>;
     bulkDelete(df: DataFrame): Promise<void>;
 }