@etainabl/nodejs-sdk 1.2.15 → 1.2.17

package/dist/cjs/reporting.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getScheduledReportRunTimes = void 0;
+const moment_1 = __importDefault(require("moment"));
+moment_1.default.locale('en', {
+    week: {
+        dow: 1
+    }
+});
+const getNextRunTime = (startDate, schedule, taskTime) => {
+    const [num, freq] = schedule.frequency.split('|');
+    const targetDate = (0, moment_1.default)(startDate).add(num, freq);
+    if (schedule.frequencyPeriod === 'first') {
+        targetDate.startOf(freq);
+    }
+    else if (schedule.frequencyPeriod === 'last') {
+        targetDate.endOf(freq);
+    }
+    const isWeekday = targetDate.isoWeekday() > 0 && targetDate.isoWeekday() < 6;
+    const isSaturday = targetDate.isoWeekday() === 6;
+    // The weekday or weekend chosen should be within the same month as the target date
+    if (schedule.frequencyDay === 'weekdays' && !isWeekday) {
+        if ((targetDate.date() / 7) < 2) {
+            targetDate.add(isSaturday ? 2 : 1, 'days');
+        }
+        else {
+            targetDate.subtract(isSaturday ? 1 : 2, 'days');
+        }
+    }
+    else if (schedule.frequencyDay === 'weekends' && isWeekday) {
+        if ((targetDate.date() / 7) < 2) {
+            targetDate.isoWeekday(6);
+        }
+        else {
+            targetDate.isoWeekday(0);
+        }
+    }
+    if (taskTime.isAfter(targetDate, 'minute')) {
+        return getNextRunTime(targetDate, schedule, taskTime);
+    }
+    return targetDate;
+};
+const getScheduledReportRunTimes = (schedule, limit = 1, taskTime = (0, moment_1.default)()) => {
+    if (!schedule.startDate || !schedule.enabled)
+        return [];
+    const originalStartDate = moment_1.default.utc(schedule.startDate);
+    let startDate = originalStartDate;
+    const includeStartDate = taskTime.isSameOrBefore(originalStartDate, 'minute');
+    let runTimes = [];
+    if (includeStartDate) {
+        runTimes = [originalStartDate];
+    }
+    const [, freq] = schedule.frequency.split('|');
+    if (freq === 'once') {
+        const nextRunTime = runTimes[0];
+        // If this is now beyond the start date, return an empty array
+        return taskTime.isAfter(nextRunTime, 'minute') ? [] : runTimes;
+    }
+    const scheduleRunTimes = Array.from(Array(includeStartDate ? limit - 1 : limit).keys()).map(() => {
+        const nextRunTime = getNextRunTime(startDate, schedule, taskTime);
+        startDate = nextRunTime.hour(originalStartDate.hour()).minute(originalStartDate.minute());
+        return nextRunTime;
+    });
+    return [...runTimes, ...scheduleRunTimes];
+};
+exports.getScheduledReportRunTimes = getScheduledReportRunTimes;

package/dist/cjs/slack.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    postMessage: (message: string) => Promise<import("axios").AxiosResponse<any, any>>;
+};
+export default _default;

package/dist/cjs/slack.js

@@ -0,0 +1,28 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios_1 = __importDefault(require("axios"));
+const postMessage = (message) => __awaiter(void 0, void 0, void 0, function* () {
+    const url = 'https://hooks.slack.com/services/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';
+    const data = {
+        text: `[${(process.env.ENV || '').toUpperCase()}][${process.env.AWS_LAMBDA_FUNCTION_NAME}] ${message}`
+    };
+    const headers = {
+        'Content-Type': 'application/json'
+    };
+    return axios_1.default.post(url, data, { headers });
+});
+exports.default = {
+    postMessage
+};

package/dist/cjs/units.d.ts

@@ -0,0 +1,22 @@
+interface Item {
+    units?: string | null;
+    unit?: string | null;
+    factor?: number | null;
+    value: number;
+    [key: string]: any;
+}
+export type AccountType = 'electricity' | 'gas' | 'water' | 'waste' | 'solar' | 'heating' | 'flow' | 'cooling' | 'temperature' | 'other';
+export type ETNUnit = 'kwh' | 'kg' | 'm3' | 'lbs' | 'tonnes' | 'wh' | 'mwh' | 'ft3' | 'hcf' | 'm3/h' | 'qty' | 'l' | 'C' | 'mcuf' | 'hcuf' | 'tcuf' | 'ocuf' | 'hm3' | 'tm3' | 'nm3';
+export type BaseUnit = 'kwh' | 'm3' | 'C' | 'kg' | 'm3/h';
+export declare const accountTypeMap: {
+    [key: string]: BaseUnit;
+};
+export declare const accountTypeUnitMap: {
+    [key: string]: ETNUnit[];
+};
+export declare const convertItems: (items: Item[], type: AccountType, defaultUnits: ETNUnit | undefined, accountFactor: number | undefined) => any;
+export declare const checkAccountTypeVsUnits: (type: string, unit: string, additionalLog?: number | '') => {
+    type: AccountType;
+    unit: ETNUnit;
+};
+export {};

package/dist/cjs/units.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkAccountTypeVsUnits = exports.convertItems = exports.accountTypeUnitMap = exports.accountTypeMap = void 0;
+exports.accountTypeMap = {
+    electricity: 'kwh',
+    gas: 'kwh',
+    water: 'm3',
+    waste: 'kg',
+    solar: 'kwh',
+    heating: 'kwh',
+    flow: 'm3/h',
+    cooling: 'kwh',
+    temperature: 'C'
+};
+const unitConversionFactors = {
+    kwh: {
+        kwh: 1,
+        mwh: 1000,
+        wh: 0.001,
+        m3: (39 * 1.02264) / 3.6,
+        ft3: (0.0283 * 39 * 1.02264) / 3.6,
+        hcf: (2.83 * 39 * 1.02264) / 3.6
+    },
+    m3: {
+        m3: 1,
+        l: 0.001
+    },
+    C: {
+        C: 1
+    },
+    kg: {
+        kg: 1,
+        lbs: 0.45359237,
+        tonnes: 1000
+    },
+    'm3/h': {
+        'm3/h': 1
+    }
+};
+exports.accountTypeUnitMap = {
+    electricity: ['kwh', 'mwh', 'wh'],
+    gas: ['kwh', 'm3', 'ft3', 'hcf'],
+    water: ['m3', 'l'],
+    waste: ['kg', 'lbs', 'tonnes'],
+    solar: ['kwh', 'mwh', 'wh'],
+    heating: ['kwh', 'mwh', 'wh'],
+    flow: ['m3/h'],
+    cooling: ['kwh', 'mwh', 'wh'],
+    temperature: ['C']
+};
+// Convert units to base format
+const convertItems = (items, type, defaultUnits, accountFactor) => {
+    if (!type)
+        throw new Error('Account type is required');
+    const baseUnit = exports.accountTypeMap[type];
+    if (!baseUnit)
+        throw new Error(`Account type ${type} is not supported`);
+    const convertedItems = items.map(item => {
+        const factor = item.factor || accountFactor || 1;
+        const units = item.units || item.unit || defaultUnits || baseUnit;
+        const convertedValue = item.value * _getConversionFactor(units, baseUnit) * factor;
+        return Object.assign(Object.assign({}, item), { value: convertedValue, units: baseUnit });
+    });
+    return convertedItems;
+};
+exports.convertItems = convertItems;
+const _getConversionFactor = (fromUnit = 'kwh', toUnit) => {
+    const conversionFactors = unitConversionFactors[toUnit];
+    if (!conversionFactors) {
+        throw new Error(`Conversion factor base unit ${toUnit} is not defined`);
+    }
+    if (!conversionFactors[fromUnit]) {
+        throw new Error(`Conversion factor from unit ${fromUnit} is not defined`);
+    }
+    return conversionFactors[fromUnit];
+};
+const checkAccountTypeVsUnits = (type, unit, additionalLog = '') => {
+    if (!type)
+        throw new Error('Account type is required');
+    if (!unit)
+        throw new Error('Unit is required');
+    const parsedType = type.toLowerCase().trim();
+    const accountTypeUnits = exports.accountTypeUnitMap[parsedType];
+    if (!accountTypeUnits)
+        throw new Error(`Account type "${parsedType}" is not supported ${additionalLog}`);
+    const parsedUnit = unit.toLowerCase().trim();
+    if (!accountTypeUnits.includes(parsedUnit)) {
+        throw new Error(`Account type "${parsedType}" does not support unit "${parsedUnit}" ${additionalLog}`);
+    }
+    return { type: parsedType, unit: parsedUnit };
+};
+exports.checkAccountTypeVsUnits = checkAccountTypeVsUnits;

package/dist/mjs/api.d.ts

@@ -1,6 +1,7 @@
 import type { AxiosRequestConfig, AxiosInstance, CreateAxiosDefaults } from 'axios';
-export interface ETNPagedResponse {
-    data: any[];
+import type { Account, Asset, Company, Invoice, Log, Reading, Supplier } from '../types/index.js';
+export interface ETNPagedResponse<T = any> {
+    data: T[];
     total: number;
     limit: number;
     skip: number;
@@ -15,84 +16,84 @@ interface AuthOptions {
 }
 declare const _default: (auth: AuthOptions, instanceOptions?: CreateAxiosDefaults) => {
     instance: AxiosInstance;
-    getAccount: (id: string, options?: AxiosRequestConfig<any>) => Promise<any>;
-    listAccounts: (options?: AxiosRequestConfig<any>) => Promise<ETNPagedResponse>;
+    getAccount: (id: string, options?: AxiosRequestConfig<any>) => Promise<Account>;
+    listAccounts: (options?: AxiosRequestConfig<any>) => Promise<ETNPagedResponse<Account>>;
     updateAccount: (id: string, data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
     createAccount: (data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
     removeAccount: (id: string, options?: AxiosRequestConfig<any>) => Promise<any>;
     getAccountSchema: (options?: AxiosRequestConfig<any>) => Promise<any>;
-    getAsset: (id: string, options?: AxiosRequestConfig<any>) => Promise<any>;
-    listAssets: (options?: AxiosRequestConfig<any>) => Promise<ETNPagedResponse>;
+    getAsset: (id: string, options?: AxiosRequestConfig<any>) => Promise<Asset>;
+    listAssets: (options?: AxiosRequestConfig<any>) => Promise<ETNPagedResponse<Asset>>;
     updateAsset: (id: string, data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
     createAsset: (data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
     removeAsset: (id: string, options?: AxiosRequestConfig<any>) => Promise<any>;
     getAssetSchema: (options?: AxiosRequestConfig<any>) => Promise<any>;
     getAssetGroup: (id: string, options?: AxiosRequestConfig<any>) => Promise<any>;
-    listAssetGroups: (options?: AxiosRequestConfig<any>) => Promise<ETNPagedResponse>;
+    listAssetGroups: (options?: AxiosRequestConfig<any>) => Promise<ETNPagedResponse<any>>;
     updateAssetGroup: (id: string, data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
     createAssetGroup: (data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
     removeAssetGroup: (id: string, options?: AxiosRequestConfig<any>) => Promise<any>;
     getAssetGroupAssets: (id: string, options?: AxiosRequestConfig<any>) => Promise<any>;
     getAssetGroupSchema: (options?: AxiosRequestConfig<any>) => Promise<any>;
-    getAutomation: (id: string, options?: AxiosRequestConfig<any>) => Promise<any>;
-    listAutomations: (options?: AxiosRequestConfig<any>) => Promise<ETNPagedResponse>;
+    getAutomation: (id: string, options?: AxiosRequestConfig<any>) => Promise<Automation>;
+    listAutomations: (options?: AxiosRequestConfig<any>) => Promise<ETNPagedResponse<Automation>>;
     updateAutomation: (id: string, data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
     createAutomation: (data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
     removeAutomation: (id: string, options?: AxiosRequestConfig<any>) => Promise<any>;
     createAutomationLog: (id: string, data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
     updateAutomationLog: (id: string, subId: string, data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
     removeAutomationLog: (id: string, subId: string, options?: AxiosRequestConfig<any>) => Promise<any>;
-    getCompany: (id: string, options?: AxiosRequestConfig<any>) => Promise<any>;
+    getCompany: (id: string, options?: AxiosRequestConfig<any>) => Promise<Company>;
     getConsumption: (id: string, options?: AxiosRequestConfig<any>) => Promise<any>;
-    listConsumptions: (options?: AxiosRequestConfig<any>) => Promise<ETNPagedResponse>;
+    listConsumptions: (options?: AxiosRequestConfig<any>) => Promise<ETNPagedResponse<any>>;
     updateConsumption: (id: string, data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
     createConsumption: (data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
     removeConsumption: (id: string, options?: AxiosRequestConfig<any>) => Promise<any>;
     getConsumptionSchema: (options?: AxiosRequestConfig<any>) => Promise<any>;
     getEmail: (id: string, options?: AxiosRequestConfig<any>) => Promise<any>;
-    listEmails: (options?: AxiosRequestConfig<any>) => Promise<ETNPagedResponse>;
+    listEmails: (options?: AxiosRequestConfig<any>) => Promise<ETNPagedResponse<any>>;
     updateEmail: (id: string, data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
     createEmail: (data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
     removeEmail: (id: string, options?: AxiosRequestConfig<any>) => Promise<any>;
     getEmissionFactor: (id: string, options?: AxiosRequestConfig<any>) => Promise<any>;
-    listEmissionFactors: (options?: AxiosRequestConfig<any>) => Promise<ETNPagedResponse>;
+    listEmissionFactors: (options?: AxiosRequestConfig<any>) => Promise<ETNPagedResponse<any>>;
     updateEmissionFactor: (id: string, data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
     createEmissionFactor: (data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
     removeEmissionFactor: (id: string, options?: AxiosRequestConfig<any>) => Promise<any>;
-    getLog: (id: string, options?: AxiosRequestConfig<any>) => Promise<any>;
-    listLogs: (options?: AxiosRequestConfig<any>) => Promise<ETNPagedResponse>;
+    getLog: (id: string, options?: AxiosRequestConfig<any>) => Promise<Log>;
+    listLogs: (options?: AxiosRequestConfig<any>) => Promise<ETNPagedResponse<Log>>;
     updateLog: (id: string, data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
     createLog: (data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
     removeLog: (id: string, options?: AxiosRequestConfig<any>) => Promise<any>;
-    getReading: (id: string, options?: AxiosRequestConfig<any>) => Promise<any>;
-    listReadings: (options?: AxiosRequestConfig<any>) => Promise<ETNPagedResponse>;
+    getReading: (id: string, options?: AxiosRequestConfig<any>) => Promise<Reading>;
+    listReadings: (options?: AxiosRequestConfig<any>) => Promise<ETNPagedResponse<Reading>>;
     updateReading: (id: string, data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
     createReading: (data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
     removeReading: (id: string, options?: AxiosRequestConfig<any>) => Promise<any>;
     getReadingSchema: (options?: AxiosRequestConfig<any>) => Promise<any>;
     getReport: (id: string, options?: AxiosRequestConfig<any>) => Promise<any>;
-    listReports: (options?: AxiosRequestConfig<any>) => Promise<ETNPagedResponse>;
+    listReports: (options?: AxiosRequestConfig<any>) => Promise<ETNPagedResponse<any>>;
     updateReport: (id: string, data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
     createReport: (data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
     removeReport: (id: string, options?: AxiosRequestConfig<any>) => Promise<any>;
     sendReport: (id: string, data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
     getReportTemplate: (id: string, options?: AxiosRequestConfig<any>) => Promise<any>;
-    listReportTemplates: (options?: AxiosRequestConfig<any>) => Promise<ETNPagedResponse>;
+    listReportTemplates: (options?: AxiosRequestConfig<any>) => Promise<ETNPagedResponse<any>>;
     updateReportTemplate: (id: string, data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
     createReportTemplate: (data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
     removeReportTemplate: (id: string, options?: AxiosRequestConfig<any>) => Promise<any>;
     getScheduledReport: (id: string, options?: AxiosRequestConfig<any>) => Promise<any>;
-    listScheduledReports: (options?: AxiosRequestConfig<any>) => Promise<ETNPagedResponse>;
+    listScheduledReports: (options?: AxiosRequestConfig<any>) => Promise<ETNPagedResponse<any>>;
     updateScheduledReport: (id: string, data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
     createScheduledReport: (data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
     removeScheduledReport: (id: string, options?: AxiosRequestConfig<any>) => Promise<any>;
     sendScheduledReport: (id: string, data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
-    getInvoice: (id: string, options?: AxiosRequestConfig<any>) => Promise<any>;
-    listInvoices: (options?: AxiosRequestConfig<any>) => Promise<ETNPagedResponse>;
+    getInvoice: (id: string, options?: AxiosRequestConfig<any>) => Promise<Invoice>;
+    listInvoices: (options?: AxiosRequestConfig<any>) => Promise<ETNPagedResponse<Invoice>>;
     updateInvoice: (id: string, data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
     createInvoice: (data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
     removeInvoice: (id: string, options?: AxiosRequestConfig<any>) => Promise<any>;
     getInvoiceSchema: (options?: AxiosRequestConfig<any>) => Promise<any>;
-    getSupplierSchema: (options?: AxiosRequestConfig<any>) => Promise<any>;
+    getSupplierSchema: (options?: AxiosRequestConfig<any>) => Promise<Supplier>;
 };
 export default _default;

package/dist/mjs/api.js

@@ -23,7 +23,7 @@ const factory = {
             method: 'GET',
             url: `${endpoint}/${id}${postEndpoint ? `/${postEndpoint}` : ''}`
         };
-        log.info(`API Request: ${req.method} ${process.env.ETAINABL_API_URL}/${req.url}`);
+        log.info(`API Request: ${req.method} ${process.env.ETAsINABL_API_URL}/${req.url}`);
         let res;
         try {
             res = await etainablApi.get(req.url, options);

package/dist/mjs/index.d.ts

@@ -6,4 +6,6 @@ import * as units from './units.js';
 import * as consumption from './consumption.js';
 import * as monitoring from './monitoring.js';
 import * as reporting from './reporting.js';
+import type { Account, Asset, Automation, Company, Invoice, Log, Reading, Supplier } from '../types/index.d.js';
 export { api, logger, consumption, monitoring, db, slack, units, reporting };
+export type { Account, Asset, Automation, Company, Invoice, Log, Reading, Supplier };

package/dist/mjs/package.json

@@ -0,0 +1,3 @@
+{
+    "type": "module"
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@etainabl/nodejs-sdk",
-  "version": "1.2.15",
+  "version": "1.2.17",
   "main": "dist/cjs/index.js",
   "module": "dist/mjs/index.js",
   "author": "Jonathan Lambert <jonathan@etainabl.com>",

package/src/api.ts

@@ -4,10 +4,12 @@ import https from 'https';
 
 import logger from './logger.js';
 
+import type { Account, Asset, Automation, Company, Invoice, Log, Reading, Supplier } from '../types/index.js'
+
 const log = logger('etainablApi');
 
-export interface ETNPagedResponse {
-  data: any[];
+export interface ETNPagedResponse<T = any>  {
+  data: T[];
   total: number;
   limit: number;
   skip: number;
@@ -39,13 +41,13 @@ function _handleResponse(req: ETNReq, res: AxiosResponse, isPaged = false) {
 }
 
 const factory = {
-  getWithId: (etainablApi: AxiosInstance, endpoint: string, postEndpoint?: string) => async (id: string, options: AxiosRequestConfig = {}) => {
+  getWithId: <T = any> (etainablApi: AxiosInstance, endpoint: string, postEndpoint?: string) => async (id: string, options: AxiosRequestConfig = {}): Promise<T> => {
     const req = {
       method: 'GET',
       url: `${endpoint}/${id}${postEndpoint ? `/${postEndpoint}` : ''}`
     };
 
-    log.info(`API Request: ${req.method} ${process.env.ETAINABL_API_URL}/${req.url}`);
+    log.info(`API Request: ${req.method} ${process.env.ETAsINABL_API_URL}/${req.url}`);
 
     let res: AxiosResponse;
 
@@ -62,7 +64,7 @@ const factory = {
 
     return res.data;
   },
-  get: (etainablApi: AxiosInstance, endpoint: string, postEndpoint?: string) => async (options: AxiosRequestConfig = {}) => {
+  get: <T = any> (etainablApi: AxiosInstance, endpoint: string, postEndpoint?: string) => async (options: AxiosRequestConfig = {}): Promise<T> => {
     const req = {
       method: 'GET',
       url: `${endpoint}${postEndpoint ? `/${postEndpoint}` : ''}`
@@ -84,7 +86,7 @@ const factory = {
 
     return res.data;
   },
-  list: (etainablApi: AxiosInstance, endpoint: string, postEndpoint?: string) => async (options: AxiosRequestConfig = {}): Promise<ETNPagedResponse> => {
+  list: <T = any> (etainablApi: AxiosInstance, endpoint: string, postEndpoint?: string) => async (options: AxiosRequestConfig = {}): Promise<ETNPagedResponse<T>> => {
     const req = {
       method: 'GET',
       url: `${endpoint}${postEndpoint ? `/${postEndpoint}` : ''}`
@@ -196,7 +198,6 @@ const factory = {
 
 // ETN Sub Endpoints
 // e.g. /assets/:id/documents/:documentId
-
 const subFactory = {
   // e.g. POST /assets/:id/documents
   create: (etainablApi: AxiosInstance, endpoint: string, subEndpoint: string) => async (id: string, data: any, options: AxiosRequestConfig = {}) => {    
@@ -246,20 +247,20 @@ export default (auth: AuthOptions, instanceOptions: CreateAxiosDefaults = {}) =>
       instance: etainablApi,
   
       // accounts
-      getAccount: factory.getWithId(etainablApi, 'accounts'),
-      listAccounts: factory.list(etainablApi, 'accounts'),
+      getAccount: factory.getWithId<Account>(etainablApi, 'accounts'),
+      listAccounts: factory.list<Account>(etainablApi, 'accounts'),
       updateAccount: factory.update(etainablApi, 'accounts'),
       createAccount: factory.create(etainablApi, 'accounts'),
       removeAccount: factory.remove(etainablApi, 'accounts'),
       getAccountSchema: factory.get(etainablApi, 'accounts', 'schema'),
-  
+
       // assets
-      getAsset: factory.getWithId(etainablApi, 'assets'),
-      listAssets: factory.list(etainablApi, 'assets'),
+      getAsset: factory.getWithId<Asset>(etainablApi, 'assets'),
+      listAssets: factory.list<Asset>(etainablApi, 'assets'),
       updateAsset: factory.update(etainablApi, 'assets'),
       createAsset: factory.create(etainablApi, 'assets'),
       removeAsset: factory.remove(etainablApi, 'assets'),
-      getAssetSchema:  factory.get(etainablApi, 'assets', 'schema'),
+      getAssetSchema: factory.get(etainablApi, 'assets', 'schema'),
   
       // assetGroups
       getAssetGroup: factory.getWithId(etainablApi, 'asset-groups'),
@@ -271,8 +272,8 @@ export default (auth: AuthOptions, instanceOptions: CreateAxiosDefaults = {}) =>
       getAssetGroupSchema:  factory.get(etainablApi, 'asset-groups', 'schema'),
   
       // automation
-      getAutomation: factory.getWithId(etainablApi, 'automation'),
-      listAutomations: factory.list(etainablApi, 'automation'),
+      getAutomation: factory.getWithId<Automation>(etainablApi, 'automation'),
+      listAutomations: factory.list<Automation>(etainablApi, 'automation'),
       updateAutomation: factory.update(etainablApi, 'automation'),
       createAutomation: factory.create(etainablApi, 'automation'),
       removeAutomation: factory.remove(etainablApi, 'automation'),
@@ -281,7 +282,7 @@ export default (auth: AuthOptions, instanceOptions: CreateAxiosDefaults = {}) =>
       removeAutomationLog: subFactory.remove(etainablApi, 'automation', 'logs'),
   
       // company
-      getCompany: factory.getWithId(etainablApi, 'companies'),
+      getCompany: factory.getWithId<Company>(etainablApi, 'companies'),
   
       // consumption
       getConsumption: factory.getWithId(etainablApi, 'consumptions'),
@@ -306,15 +307,15 @@ export default (auth: AuthOptions, instanceOptions: CreateAxiosDefaults = {}) =>
       removeEmissionFactor: factory.remove(etainablApi, 'emission-factors'),
   
       // logs
-      getLog: factory.getWithId(etainablApi, 'logs'),
-      listLogs: factory.list(etainablApi, 'logs'),
+      getLog: factory.getWithId<Log>(etainablApi, 'logs'),
+      listLogs: factory.list<Log>(etainablApi, 'logs'),
       updateLog: factory.update(etainablApi, 'logs'),
       createLog: factory.create(etainablApi, 'logs'),
       removeLog: factory.remove(etainablApi, 'logs'),
   
       // readings
-      getReading: factory.getWithId(etainablApi, 'readings'),
-      listReadings: factory.list(etainablApi, 'readings'),
+      getReading: factory.getWithId<Reading>(etainablApi, 'readings'),
+      listReadings: factory.list<Reading>(etainablApi, 'readings'),
       updateReading: factory.update(etainablApi, 'readings'),
       createReading: factory.create(etainablApi, 'readings'),
       removeReading: factory.remove(etainablApi, 'readings'),
@@ -344,15 +345,15 @@ export default (auth: AuthOptions, instanceOptions: CreateAxiosDefaults = {}) =>
       sendScheduledReport: factory.customWithId(etainablApi, 'post',  'scheduled-reports', 'send'),
   
       // invoices
-      getInvoice: factory.getWithId(etainablApi, 'invoices'),
-      listInvoices: factory.list(etainablApi, 'invoices'),
+      getInvoice: factory.getWithId<Invoice>(etainablApi, 'invoices'),
+      listInvoices: factory.list<Invoice>(etainablApi, 'invoices'),
       updateInvoice: factory.update(etainablApi, 'invoices'),
       createInvoice: factory.create(etainablApi, 'invoices'),
       removeInvoice: factory.remove(etainablApi, 'invoices'),
-      getInvoiceSchema:  factory.get(etainablApi, 'invoices', 'schema'),
+      getInvoiceSchema: factory.get(etainablApi, 'invoices', 'schema'),
 
       //suppliers
-      getSupplierSchema:  factory.get(etainablApi, 'suppliers', 'schema')
+      getSupplierSchema:  factory.get<Supplier>(etainablApi, 'suppliers', 'schema')
 
     }
   } catch (e) {

package/src/index.ts

@@ -6,6 +6,7 @@ import * as units from './units.js';
 import * as consumption from './consumption.js';
 import * as monitoring from './monitoring.js';
 import * as reporting from './reporting.js';
+import type { Account, Asset, Automation, Company, Invoice, Log, Reading, Supplier } from '../types/index.d.js';
 
 export {
   api,
@@ -16,4 +17,6 @@ export {
   slack,
   units,
   reporting
-}
+}
+
+export type { Account, Asset, Automation, Company, Invoice, Log, Reading, Supplier };

package/types/account.d.ts

@@ -0,0 +1,116 @@
+import type { Portal } from './portal.ts';
+import type { StatusHistory } from './statusHistory.ts'
+
+interface PortalAccountSchema extends Portal{
+  invoiceFilenames: any[]; 
+}
+
+interface RateSchema {
+  type: string;
+  value: number;
+  description: string;
+}
+
+interface ContractSchema {
+  startDate: Date;
+  endDate: Date;
+  terminationDate?: Date;
+  paymentTerms?: string;
+  duration?: string;
+  tariffName?: string;
+  contractConsumption?: number;
+  volumeTolerance?: any[]; 
+  renewablePercentage?: number;
+  marketBasedEmissionFactor?: number;
+  chargeableCclPercentage?: number;
+  commissionRates?: number;
+  rates: any[];
+  s3Key?: string;
+  rateTypeMapping?: object;
+  batchId?: string;
+  supplierId?: string;
+  status: 'active' | 'inactive';
+  userSub?: string;
+  deletedOn?: Date;
+}
+
+interface CreditNoteSchema {
+  name: string;
+  type: string;
+  amount: number;
+  netAmount: number;
+  taxAmount: number;
+  date: Date;
+  isPaid: boolean;
+  s3Key: string;
+  stampedS3Key: string;
+  fileName: string;
+  invoiceData: object;
+  userSub: string;
+  readingIds: any[];
+  supplierId: string;
+  totalUnits: number;
+  endDate: Date;
+  startDate: Date;
+  stampDate: Date;
+  totalWaterVolume: number;
+  totalWasteVolume: number;
+  totalWaterCost: number;
+  totalWasteCost: number;
+}
+
+export interface Account {
+  _id: string,
+  name: string;
+  modifiedBy?: string;
+  siteCode?: string;
+  type: 'gas' | 'electricity' | 'water' | 'waste' | 'solar';
+  supplierRef?: string;
+  financialCode?: string;
+  propertyCode?: string;
+  meterPointNumber?: string;
+  meterSerialNumber?: string;
+  meterPointNumber2?: string;
+  meterUnits: 'kwh' | 'm3' | 'ft3';
+  automaticMeterRead?: boolean;
+  status?: 'active' | 'inactive';
+  statusHistory?: StatusHistory[]; // Referenced from another file
+  rates?: RateSchema[];
+  capacity?: string;
+  meterOperator?: string;
+  meterLocation?: string;
+  meterOperatorType?: 'lease' | 'purchase';
+  meterOperatorExpiryDate?: Date;
+  dataCollector?: string;
+  parentAccountId?: string;
+  processingInvoices?: object[];
+  contracts?: ContractSchema[];
+  creditNotes?: CreditNoteSchema[];
+  meterUser?: string;
+  isTrc?: boolean;
+  floorArea?: string;
+  floorAreaUnit?: 'metric' | 'imperial';
+  reportingType?: string;
+  solarType?: 'generation' | 'export';
+  consumptionSource?: 'primary' | 'sub' | 'primary-sub';
+  esec?: 'a' | 'b' | 'c' | 'd' | 'e' | 'g' | 'h' | 'j' | 'k' | 'l' | 'm' | 'n' | 'p' | 'q' | 'r' | 's' | 't' | 'u';
+  portal?: PortalAccountSchema;
+  deviceId?: string;
+  gridfetchLoa?: {
+    s3Key?: string;
+    name?: string;
+    uploadedBy?: string;
+    uploadedAt?: Date;
+    expiryDate?: Date;
+    error?: string;
+    uploaded?: boolean;
+  };
+  automationIds?: string[];
+  customIntegrations?: object;
+  supplierId?: string;
+  batchId?: string;
+  assetId: string;
+  entityId: string;
+  companyId: string;
+  userSub: string;
+}

package/types/address.d.ts

@@ -0,0 +1,12 @@
+export interface Address {
+    streetAddress: string;
+    locality?: string;
+    region?: string;
+    postCode: string;
+    province?: string;
+    countryCode?: string;
+    jurisdictionCode?: string;
+    latitude?: string;
+    longitude?: string;
+  }
+