@iiasa/ixmp4-ts 0.1.1 → 0.1.2

package/dist/esm/data/unit.js

@@ -2,10 +2,9 @@ import { BaseRepository } from './base';
 import { DocsRepository } from './docs';
 class UnitRepository extends BaseRepository {
     static prefix = 'units/';
-    static enumerationMethod = 'PATCH';
     docs;
     constructor(client) {
-        super(client, UnitRepository.prefix, UnitRepository.enumerationMethod);
+        super(client);
         this.docs = new DocsRepository(client, 'docs/units/');
     }
     async create(name) {
@@ -17,11 +16,11 @@ class UnitRepository extends BaseRepository {
     async get(name) {
         return (await this._get({ name }));
     }
-    async list(f = {}) {
-        return (await this._list(f));
+    async list(filter = {}) {
+        return (await this._list({ filter }));
     }
-    async tabulate(f = {}) {
-        return await this._tabulate(f);
+    async tabulate(filter = {}) {
+        return await this._tabulate({ filter });
     }
 }
 export { UnitRepository };

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

@@ -10,6 +10,7 @@ import { UnitFilter as BaseUnitFilter } from '../../data/unit';
 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 a filter for tabulating IAMC format data.
  */
@@ -25,16 +26,16 @@ type IamcDataFilter = BaseIamcDataFilter & {
     };
 };
 /**
- * Represents a IAMC format data.
+ * Represents IAMC format data for a specific Run.
  */
-declare class IamcData extends BaseFacade {
+declare class RunIamcData extends BaseFacade {
     /**
      * The run associated with the IAMC data.
      */
     run: RunModel;
     private repository;
     /**
-     * Constructs a new instance of the IamcData class.
+     * Constructs a new instance of the RunIamcData class.
      * @param backend The backend instance.
      * @param run The run associated with the IAMC data.
      */
@@ -60,5 +61,28 @@ declare class IamcData extends BaseFacade {
     tabulate(filter?: IamcDataFilter): Promise<dfd.DataFrame>;
     private contractParameters;
 }
-export { IamcData };
+/**
+ * Represents IAMC format data for a specific a modling platform.
+ */
+declare class PlatformIamcData extends BaseFacade {
+    /**
+     * Repository for managing IAMC variables.
+     */
+    variables: VariableRepository;
+    /**
+     * Constructs a new instance of the PlatformIamcData class.
+     * @param backend The backend instance used for data retrieval.
+     */
+    constructor(backend: Backend);
+    /**
+     * Tabulates IAMC data with optional filtering.
+     * @param filter Optional. Filter for retrieving IAMC data.
+     * @param filter.joinRuns Optional. Whether to join runs or not, defaults to true.
+     * @returns A Promise that resolves to a dfd.DataFrame containing the tabulated data.
+     */
+    tabulate({ joinRuns, ...filter }?: {
+        joinRuns?: boolean;
+    } & IamcDataFilter): Promise<dfd.DataFrame>;
+}
+export { RunIamcData, PlatformIamcData };
 export type { IamcDataFilter };

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

@@ -8,7 +8,7 @@ import { UnitFilter as BaseUnitFilter } from '../../data/unit';
 import { RunFilter as BaseRunFilter } from '../../data/run';
 import { ScenarioFilter as BaseScenarioFilter } from '../../data/scenario';
 /**
- * Represents a filter for listing and tabulating units.
+ * Represents a filter for listing and tabulating variables.
  */
 type VariableFilter = BaseVariableFilter & {
     region?: BaseRegionFilter;

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

@@ -14,7 +14,6 @@ type MetaIndicatorFilter = BaseMetaIndicatorFilter & {
         scenario?: BaseScenarioFilter;
         model?: BaseModelFilter;
     };
-    joinRunIndex?: boolean;
 };
 /**
  * Repository for accessing run meta indicators.
@@ -22,10 +21,13 @@ type MetaIndicatorFilter = BaseMetaIndicatorFilter & {
 declare class MetaIndicatorRepository extends BaseFacade {
     /**
      * Tabulates meta indicators based on the provided filter.
-     * @param filter The filter to apply to the meta indicators.
+     * @param filter Optional. The filter to apply to the meta indicators.
+     * @param joinRunIndex Optional. Whether to join the run index to the tabulated data, defaults to true.
      * @returns A promise that resolves to a dfd.DataFrame containing the tabulated meta indicators.
      */
-    tabulate(filter?: MetaIndicatorFilter): Promise<dfd.DataFrame>;
+    tabulate({ joinRunIndex, ...filter }?: {
+        joinRunIndex?: boolean;
+    } & MetaIndicatorFilter): Promise<dfd.DataFrame>;
 }
 /**
  * Repository for accessing meta indicators of a specific run.

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

@@ -3,7 +3,7 @@ import { RunRepository } from './run';
 import { ScenarioRepository } from './scenario';
 import { MetaIndicatorRepository } from './meta';
 import { ModelRepository } from './model';
-import { IamcRepository } from './iamc/repository';
+import { PlatformIamcData } from './iamc/data';
 import { RegionRepository } from './region';
 import { UnitRepository } from './unit';
 /**
@@ -21,7 +21,7 @@ import { UnitRepository } from './unit';
  */
 declare class Platform {
     runs: RunRepository;
-    iamc: IamcRepository;
+    iamc: PlatformIamcData;
     scenarios: ScenarioRepository;
     models: ModelRepository;
     meta: MetaIndicatorRepository;

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

@@ -4,7 +4,7 @@ import { Run as RunModel } from '../data/run';
 import { Model } from '../data/model';
 import { Scenario } from '../data/scenario';
 import { BaseFacade, BaseModelFacade } from './base';
-import { IamcData } from './iamc/data';
+import { RunIamcData } from './iamc/data';
 import { RunMetaIndicatorRepository } from './meta';
 import { ModelFilter as BaseModelFilter } from '../data/model';
 import { RunFilter as BaseRunFilter } from '../data/run';
@@ -27,7 +27,7 @@ declare class Run extends BaseModelFacade<RunModel> {
     /**
      * The IAMC data associated with the run.
      */
-    iamc: IamcData;
+    iamc: RunIamcData;
     /**
      * Creates a new Run instance.
      * @param backend The backend instance.

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

@@ -6,23 +6,45 @@ type BaseModel = {
 type PlainObject = {
     [k: string]: any;
 };
+type Page = {
+    results: any[];
+    pagination: {
+        limit: number;
+        offset: number;
+    };
+    total: number;
+};
 declare class BaseRepository {
     private client;
     prefix: string;
     enumerationMethod: string;
-    constructor(client: AxiosInstance, prefix: string, enumerationMethod?: string);
-    _request(url: string, method: string, params?: object, data?: any): Promise<any>;
+    constructor(client: AxiosInstance, prefix?: string);
+    _request(url: string, method: string, params?: object, body?: any): Promise<any>;
     _get(filter: object): Promise<any>;
     _getById(id: number): Promise<any>;
     _post(data?: any, url?: string): Promise<any>;
     _patch(params?: object, data?: any): Promise<any>;
     _delete(id: number): Promise<void>;
-    _enumerate(filter: object, table?: boolean): Promise<any>;
-    _list(filter: object): Promise<any[]>;
-    _tabulate(filter: object): Promise<dfd.DataFrame>;
+    /**
+     * Convenience method for requests to the enumeration endpoint.
+     */
+    _requestEnumeration(params?: object, body?: object, table?: boolean): Promise<any>;
+    /**
+     * Convenience method for paginated requests to the enumeration endpoint.
+     *
+     * @returns A list of lists of results.
+     */
+    _handlePagination(page: Page, table: boolean, params: object, body: object): Promise<any[]>;
+    _list({ filter, params, }: {
+        filter?: object;
+        params?: object;
+    }): Promise<any[]>;
+    _tabulate({ filter, params, }: {
+        filter?: object;
+        params?: object;
+    }): Promise<dfd.DataFrame>;
     _bulkUpsert(df: dfd.DataFrame, params?: object): Promise<void>;
     _bulkDelete(df: dfd.DataFrame, params?: object): Promise<void>;
-    private static requestInfo;
     private static throwRemoteException;
 }
 export { BaseRepository };

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

@@ -1,4 +1,3 @@
-import { AxiosInstance } from 'axios';
 import { BaseModel, BaseRepository } from './base';
 type Docs = BaseModel & {
     description: string;
@@ -6,7 +5,6 @@ type Docs = BaseModel & {
 };
 declare class DocsRepository extends BaseRepository {
     static enumerationMethod: string;
-    constructor(client: AxiosInstance, prefix: string);
     get(dimensionId: number): Promise<Docs>;
     set(dimensionId: number, description: string): Promise<Docs>;
     list(dimensionId?: number): Promise<Docs[]>;

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

@@ -1,5 +1,4 @@
 import * as dfd from 'danfojs';
-import { AxiosInstance } from 'axios';
 import { BaseModel, BaseRepository, PlainObject } from '../base';
 import { Lookup } from '../filters';
 type DataPoint = BaseModel & {
@@ -21,15 +20,15 @@ type IamcDataFilter = Lookup<{
 }>;
 declare class DataPointRepository extends BaseRepository {
     static prefix: string;
-    static enumerationMethod: string;
-    constructor(client: AxiosInstance);
-    list({ joinParameters, ...filter }?: {
+    list({ joinParameters, filter, }?: {
         joinParameters?: boolean;
-    } & PlainObject): Promise<DataPoint[]>;
-    tabulate({ joinParameters, joinRuns, ...filter }?: {
+        filter: PlainObject;
+    }): Promise<DataPoint[]>;
+    tabulate({ joinParameters, joinRuns, filter, }?: {
         joinParameters?: boolean;
         joinRuns?: boolean;
-    } & PlainObject): Promise<dfd.DataFrame>;
+        filter: PlainObject;
+    }): Promise<dfd.DataFrame>;
     bulkUpsert(df: dfd.DataFrame): Promise<void>;
     bulkDelete(df: dfd.DataFrame): Promise<void>;
 }

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

@@ -1,6 +1,5 @@
 import * as dfd from 'danfojs';
-import { AxiosInstance } from 'axios';
-import { BaseModel, BaseRepository } from '../base';
+import { BaseModel, BaseRepository, PlainObject } from '../base';
 type TimeSeries = BaseModel & {
     id: number;
     run__id: number;
@@ -9,13 +8,18 @@ type TimeSeries = BaseModel & {
 type Mapping<K extends string | number | symbol = any, T = any> = Record<K, T>;
 declare class TimeSeriesRepository extends BaseRepository {
     static prefix: string;
-    constructor(client: AxiosInstance);
     create(runId: number, parameters: Mapping): Promise<TimeSeries>;
     get(runId: number, parameters: Mapping): Promise<TimeSeries>;
     getById(id: number): Promise<TimeSeries>;
     getOrCreate(runId: number, parameters: Mapping): Promise<TimeSeries>;
-    list(runIds?: number[], joinParameters?: boolean): Promise<TimeSeries[]>;
-    tabulate(runIds?: number[] | number, joinParameters?: boolean): Promise<dfd.DataFrame>;
+    list({ joinParameters, filter, }?: {
+        joinParameters?: boolean;
+        filter: PlainObject;
+    }): Promise<TimeSeries[]>;
+    tabulate({ joinParameters, filter, }?: {
+        joinParameters?: boolean;
+        filter: PlainObject;
+    }): Promise<dfd.DataFrame>;
     bulkUpsert(df: dfd.DataFrame, createRelated?: boolean): Promise<void>;
 }
 export { TimeSeriesRepository };

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

@@ -14,11 +14,10 @@ type VariableFilter = Lookup<{
 }>;
 declare class VariableRepository extends BaseRepository {
     static prefix: string;
-    static enumerationMethod: string;
     docs: DocsRepository;
     constructor(client: AxiosInstance);
-    list(f?: PlainObject): Promise<Variable[]>;
-    tabulate(f?: PlainObject): Promise<dfd.DataFrame>;
+    list(filter?: PlainObject): Promise<Variable[]>;
+    tabulate(filter?: PlainObject): Promise<dfd.DataFrame>;
     create(name: string): Promise<Variable>;
     get(name: string): Promise<Variable>;
 }

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

@@ -1,5 +1,4 @@
 import * as dfd from 'danfojs';
-import { AxiosInstance } from 'axios';
 import { BaseModel, BaseRepository, PlainObject } from './base';
 import { RunFilter } from './run';
 import { Lookup } from './filters';
@@ -28,10 +27,8 @@ type MetaIndicatorFilter = Lookup<{
 }>;
 declare class MetaIndicatorRepository extends BaseRepository {
     static prefix: string;
-    static enumerationMethod: string;
-    constructor(client: AxiosInstance);
-    list(f?: PlainObject): Promise<MetaIndicator[]>;
-    tabulate(f?: PlainObject): Promise<dfd.DataFrame>;
+    list(filter?: PlainObject): Promise<MetaIndicator[]>;
+    tabulate(filter?: PlainObject, joinRunIndex?: boolean): Promise<dfd.DataFrame>;
     create(run__id: number, key: string, value: string | number | boolean): Promise<MetaIndicator>;
     get(runId: number, key: string): Promise<MetaIndicator>;
     delete(id: number): Promise<void>;

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

@@ -14,11 +14,10 @@ type ModelFilter = Lookup<{
 }>;
 declare class ModelRepository extends BaseRepository {
     static prefix: string;
-    static enumerationMethod: string;
     docs: DocsRepository;
     constructor(client: AxiosInstance);
-    list(f?: PlainObject): Promise<Model[]>;
-    tabulate(f?: PlainObject): Promise<dfd.DataFrame>;
+    list(filter?: PlainObject): Promise<Model[]>;
+    tabulate(filter?: PlainObject): Promise<dfd.DataFrame>;
     create(name: string): Promise<Model>;
     get(name: string): Promise<Model>;
 }

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

@@ -16,11 +16,10 @@ type RegionFilter = Lookup<{
 }>;
 declare class RegionRepository extends BaseRepository {
     static prefix: string;
-    static enumerationMethod: string;
     docs: DocsRepository;
     constructor(client: AxiosInstance);
-    list(f?: PlainObject): Promise<Region[]>;
-    tabulate(f?: PlainObject): Promise<dfd.DataFrame>;
+    list(filter?: PlainObject): Promise<Region[]>;
+    tabulate(filter?: PlainObject): Promise<dfd.DataFrame>;
     create(name: string, hierarchy: string): Promise<Region>;
     get(name: string): Promise<Region>;
     delete(id: number): Promise<void>;

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

@@ -1,5 +1,4 @@
 import * as dfd from 'danfojs';
-import { AxiosInstance } from 'axios';
 import { BaseModel, BaseRepository, PlainObject } from './base';
 import { Scenario } from './scenario';
 import { Model } from './model';
@@ -20,10 +19,8 @@ type RunFilter = Lookup<{
 }>;
 declare class RunRepository extends BaseRepository {
     static prefix: string;
-    static enumerationMethod: string;
-    constructor(client: AxiosInstance);
-    list(f?: PlainObject): Promise<Run[]>;
-    tabulate(f?: PlainObject): Promise<dfd.DataFrame>;
+    list(filter?: PlainObject): Promise<Run[]>;
+    tabulate(filter?: PlainObject): Promise<dfd.DataFrame>;
     create(modelName: string, scenarioName: string): Promise<Run>;
     get(modelName: string, scenarioName: string, version: number): Promise<Run>;
     getDefaultVersion(modelName: string, scenarioName: string): Promise<Run>;

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

@@ -14,11 +14,10 @@ type ScenarioFilter = Lookup<{
 }>;
 declare class ScenarioRepository extends BaseRepository {
     static prefix: string;
-    static enumerationMethod: string;
     docs: DocsRepository;
     constructor(client: AxiosInstance);
-    list(f?: PlainObject): Promise<Scenario[]>;
-    tabulate(f?: PlainObject): Promise<dfd.DataFrame>;
+    list(filter?: PlainObject): Promise<Scenario[]>;
+    tabulate(filter?: PlainObject): Promise<dfd.DataFrame>;
     create(name: string): Promise<Scenario>;
     get(name: string): Promise<Scenario>;
 }

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

@@ -14,14 +14,13 @@ type UnitFilter = Lookup<{
 }>;
 declare class UnitRepository extends BaseRepository {
     static prefix: string;
-    static enumerationMethod: string;
     docs: DocsRepository;
     constructor(client: AxiosInstance);
     create(name: string): Promise<Unit>;
     delete(id: number): Promise<void>;
     get(name: string): Promise<Unit>;
-    list(f?: PlainObject): Promise<Unit[]>;
-    tabulate(f?: PlainObject): Promise<dfd.DataFrame>;
+    list(filter?: PlainObject): Promise<Unit[]>;
+    tabulate(filter?: PlainObject): Promise<dfd.DataFrame>;
 }
 export { UnitRepository };
 export type { UnitFilter, Unit };

package/dist/types/index.d.ts

@@ -4,8 +4,7 @@ export type { Run, RunRepository, RunFilter } from './core/run';
 export type { Scenario, ScenarioRepository, ScenarioFilter, } from './core/scenario';
 export type { Model, ModelRepository, ModelFilter } from './core/model';
 export type { Region, RegionRepository, RegionFilter } from './core/region';
-export type { IamcData, IamcDataFilter } from './core/iamc/data';
-export type { IamcRepository } from './core/iamc/repository';
+export type { RunIamcData, PlatformIamcData, IamcDataFilter, } from './core/iamc/data';
 export type { Variable, VariableRepository, VariableFilter, } from './core/iamc/variable';
 export type { Unit, UnitRepository, UnitFilter } from './core/unit';
 export type { MetaIndicatorRepository, MetaIndicatorFilter } from './core/meta';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iiasa/ixmp4-ts",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "license": "MIT",
   "description": "typescript client for ixmp4, a data warehouse for scenario analysis",
   "repository": {
@@ -29,12 +29,19 @@
       "email": "wolschlager@iiasa.ac.at"
     }
   ],
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
   "types": "./dist/types/index.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/types/index.d.ts",
-      "import": "./dist/esm/index.js",
-      "require": "./dist/cjs/index.js",
+      "import": {
+        "types": "./dist/types/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/types/index.d.ts",
+        "default": "./dist/cjs/index.js"
+      },
       "default": "./dist/cjs/index.js"
     }
   },

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

@@ -1,73 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IamcRepository = void 0;
-const base_1 = require("../base");
-const variable_1 = require("./variable");
-/**
- * Represents a repository for IAMC (Integrated Assessment Modeling Consortium) data.
- * Provides methods for tabulating IAMC data.
- */
-class IamcRepository extends base_1.BaseFacade {
-    /**
-     * Constructs a new instance of the IamcRepository class.
-     * @param backend The backend instance used for data retrieval.
-     */
-    constructor(backend) {
-        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 filter.joinRuns Optional. Whether to join runs or not, defaults to true.
-     * @returns A Promise that resolves to a dfd.DataFrame containing the tabulated data.
-     */
-    tabulate(_a = {
-        joinRuns: true,
-    }) {
-        var { joinRuns = true } = _a, filter = __rest(_a, ["joinRuns"]);
-        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 };
-            }
-            filter['joinRuns'] = joinRuns;
-            filter['joinParameters'] = true;
-            let df = yield this.backend.iamc.datapoints.tabulate(filter);
-            df = df.dropNa({ axis: 1 });
-            if (df.columns.includes('time_series__id')) {
-                df = df.drop({ columns: ['time_series__id'] });
-            }
-            if (df.columns.includes('unit')) {
-                // TODO report bug to danfojs: df.replace('oldValue', '', { columns: ['column_name'] }) throws: Params Error: Must specify param 'newValue' to replace with (probably newValue is cast to boolean and emty string is falsy)
-                df = df.replace('dimensionless', ' ', { columns: ['unit'] });
-                console.warn(`Unit name "dimensionless" has been replaced with ' ', this will be rejected by ixmp4.`);
-            }
-            return df;
-        });
-    }
-}
-exports.IamcRepository = IamcRepository;

package/dist/esm/core/iamc/repository.js

@@ -1,51 +0,0 @@
-import { BaseFacade } from '../base';
-import { VariableRepository } from './variable';
-/**
- * Represents a repository for IAMC (Integrated Assessment Modeling Consortium) data.
- * Provides methods for tabulating IAMC data.
- */
-class IamcRepository extends BaseFacade {
-    /**
-     * Repository for managing IAMC variables.
-     */
-    variables;
-    /**
-     * Constructs a new instance of the IamcRepository class.
-     * @param backend The backend instance used for data retrieval.
-     */
-    constructor(backend) {
-        super(backend);
-        this.variables = new VariableRepository(this.backend);
-    }
-    /**
-     * Tabulates IAMC data with optional filtering.
-     * @param filter Optional. Filter for retrieving IAMC data.
-     * @param filter.joinRuns Optional. Whether to join runs or not, defaults to true.
-     * @returns A Promise that resolves to a dfd.DataFrame containing the tabulated data.
-     */
-    async tabulate({ joinRuns = true, ...filter } = {
-        joinRuns: true,
-    }) {
-        if (filter === undefined) {
-            filter = {};
-        }
-        // return only default runs unless a run-filter is provided
-        if (!Object.hasOwn(filter, 'run')) {
-            filter['run'] = { defaultOnly: true };
-        }
-        filter['joinRuns'] = joinRuns;
-        filter['joinParameters'] = true;
-        let df = await this.backend.iamc.datapoints.tabulate(filter);
-        df = df.dropNa({ axis: 1 });
-        if (df.columns.includes('time_series__id')) {
-            df = df.drop({ columns: ['time_series__id'] });
-        }
-        if (df.columns.includes('unit')) {
-            // TODO report bug to danfojs: df.replace('oldValue', '', { columns: ['column_name'] }) throws: Params Error: Must specify param 'newValue' to replace with (probably newValue is cast to boolean and emty string is falsy)
-            df = df.replace('dimensionless', ' ', { columns: ['unit'] });
-            console.warn(`Unit name "dimensionless" has been replaced with ' ', this will be rejected by ixmp4.`);
-        }
-        return df;
-    }
-}
-export { IamcRepository };

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

@@ -1,30 +0,0 @@
-import * as dfd from 'danfojs';
-import { Backend } from '../../backend';
-import { BaseFacade } from '../base';
-import { VariableRepository } from './variable';
-import { IamcDataFilter } from './data';
-/**
- * Represents a repository for IAMC (Integrated Assessment Modeling Consortium) data.
- * Provides methods for tabulating IAMC data.
- */
-declare class IamcRepository extends BaseFacade {
-    /**
-     * Repository for managing IAMC variables.
-     */
-    variables: VariableRepository;
-    /**
-     * Constructs a new instance of the IamcRepository class.
-     * @param backend The backend instance used for data retrieval.
-     */
-    constructor(backend: Backend);
-    /**
-     * Tabulates IAMC data with optional filtering.
-     * @param filter Optional. Filter for retrieving IAMC data.
-     * @param filter.joinRuns Optional. Whether to join runs or not, defaults to true.
-     * @returns A Promise that resolves to a dfd.DataFrame containing the tabulated data.
-     */
-    tabulate({ joinRuns, ...filter }?: {
-        joinRuns?: boolean;
-    } & IamcDataFilter): Promise<dfd.DataFrame>;
-}
-export { IamcRepository };