@etainabl/nodejs-sdk 1.2.42 → 1.2.44

package/dist/cjs/types/reading.d.ts

@@ -0,0 +1,17 @@
+export interface Reading {
+    _id: string;
+    submittedAt: Date;
+    value: number;
+    type?: string;
+    invoiceStartRead?: number;
+    source: string;
+    invoiceId?: string;
+    rateId?: string;
+    contractRateType?: string;
+    invoiceBatchId?: string;
+    batchId?: string;
+    accountId: string;
+    entityId: string;
+    companyId: string;
+    userSub?: string;
+}

package/dist/cjs/types/reading.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/types/report.d.ts

@@ -0,0 +1,21 @@
+export interface Report {
+    _id: string;
+    type: 'dynamic' | 'spreadsheet' | 'table' | 'pdf';
+    subType?: string;
+    fileFormat: 'pdf' | 'xlsx' | 'csv' | 'png' | 'jpg' | 'chart';
+    fileName?: string;
+    status: 'preparing' | 'ready';
+    scheduled?: boolean;
+    version?: number;
+    metadata?: Record<string, any>;
+    data?: Record<string, any>;
+    requestedAt: Date;
+    availableAt?: Date;
+    s3Key: string | null;
+    batchId?: string;
+    scheduledReportId?: string;
+    reportTemplateId?: string;
+    entityId: string;
+    companyId: string;
+    userSub?: string;
+}

package/dist/cjs/types/report.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/types/scraperRun.d.ts

@@ -0,0 +1,15 @@
+export interface CreateScraperRunParams {
+    supplierId: string;
+    accountId: string;
+    companyId: string;
+}
+export interface ScraperRun {
+    _id: string;
+    logs?: {}[];
+    supplierId: string;
+    accountId: string;
+    companyId: string;
+    invoiceData?: [];
+    status: string[];
+    error?: string;
+}

package/dist/cjs/types/scraperRun.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/types/statusHistory.d.ts

@@ -0,0 +1,5 @@
+export interface StatusHistory {
+    date: Date;
+    value: 'active' | 'inactive';
+    notes?: string;
+}

package/dist/cjs/types/statusHistory.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/types/supplier.d.ts

@@ -0,0 +1,28 @@
+import { Portal } from './portal.js';
+interface PortalSupplierSchema extends Portal {
+    concurrent: boolean;
+    checkInvoiceFilenames: boolean;
+    supplierRefRequired: boolean;
+}
+interface InvoiceOptionsSchema {
+    stampPositionX?: number;
+    stampPositionY?: number;
+}
+export interface Supplier {
+    _id: string;
+    name: string;
+    logoUrl?: string;
+    websiteUrl?: string;
+    portalUrl?: string;
+    identifier?: string;
+    type: 'supplier' | 'distributor';
+    region?: string;
+    countryCode: string;
+    defaultScraper?: string;
+    active: boolean;
+    transferSupplier: boolean;
+    transferSupplierId?: string;
+    portal: PortalSupplierSchema;
+    invoiceOptions?: InvoiceOptionsSchema;
+}
+export {};

package/dist/cjs/types/supplier.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+;

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' | 'oil' | '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' | 'l';
+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,94 @@
+"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',
+    oil: 'l'
+};
+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'],
+    oil: ['l']
+};
+// 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

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

package/dist/mjs/api.js

@@ -0,0 +1,308 @@
+import axios from 'axios';
+import https from 'https';
+import logger from './logger.js';
+const log = logger('etainablApi');
+function _handleResponse(req, res, isPaged = false) {
+    if (!res) {
+        throw new Error(`No response from API (${req.method} ${req.url})`);
+    }
+    if (res.status !== 200) {
+        throw new Error(`${res.status} ${res.statusText} response from API (${req.method} ${req.url})`);
+    }
+    if (!res.data) {
+        throw new Error(`No data from API (${req.method} ${req.url})`);
+    }
+    if (isPaged && !res.data.data) {
+        throw new Error(`No data from API (${req.method} ${req.url})`);
+    }
+    return res;
+}
+const factory = {
+    getWithId: (etainablApi, endpoint, postEndpoint) => async (id, options = {}) => {
+        const req = {
+            method: 'GET',
+            url: `${endpoint}/${id}${postEndpoint ? `/${postEndpoint}` : ''}`
+        };
+        log.info(`API Request: ${req.method} ${process.env.ETAsINABL_API_URL}/${req.url}`);
+        let res;
+        try {
+            res = await etainablApi.get(req.url, options);
+        }
+        catch (e) {
+            if (e.response?.data)
+                throw new Error(`API error response: ${JSON.stringify(e.response.data)}`);
+            throw e;
+        }
+        console.log(`API Response: ${req.method} ${process.env.ETAINABL_API_URL}/${req.url}`);
+        _handleResponse(req, res);
+        return res.data;
+    },
+    get: (etainablApi, endpoint, postEndpoint) => async (options = {}) => {
+        const req = {
+            method: 'GET',
+            url: `${endpoint}${postEndpoint ? `/${postEndpoint}` : ''}`
+        };
+        log.info(`API Request: ${req.method} ${process.env.ETAINABL_API_URL}/${req.url}`);
+        let res;
+        try {
+            res = await etainablApi.get(req.url, options);
+        }
+        catch (e) {
+            if (e.response?.data)
+                throw new Error(`API error response: ${JSON.stringify(e.response.data)}`);
+            throw e;
+        }
+        console.log(`API Response: ${req.method} ${process.env.ETAINABL_API_URL}/${req.url}`);
+        _handleResponse(req, res);
+        return res.data;
+    },
+    list: (etainablApi, endpoint, postEndpoint) => async (options = {}) => {
+        const req = {
+            method: 'GET',
+            url: `${endpoint}${postEndpoint ? `/${postEndpoint}` : ''}`
+        };
+        log.info(`API Request: ${req.method} ${process.env.ETAINABL_API_URL}/${req.url}`);
+        let res;
+        try {
+            res = await etainablApi.get(req.url, options);
+        }
+        catch (e) {
+            if (e.response?.data)
+                throw new Error(`API error response: ${JSON.stringify(e.response.data)}`);
+            throw e;
+        }
+        console.log(`API Response: ${req.method} ${process.env.ETAINABL_API_URL}/${req.url}`);
+        _handleResponse(req, res, true);
+        return res.data;
+    },
+    update: (etainablApi, endpoint, postEndpoint) => async (id, data, options = {}) => {
+        const req = {
+            method: 'PATCH',
+            url: `${endpoint}/${id}${postEndpoint ? `/${postEndpoint}` : ''}`
+        };
+        log.info(`API Request: ${req.method} ${process.env.ETAINABL_API_URL}/${req.url}`);
+        let res;
+        try {
+            res = await etainablApi.patch(req.url, data, options);
+        }
+        catch (e) {
+            if (e.response?.data)
+                throw new Error(`API error response: ${JSON.stringify(e.response.data)}`);
+            throw e;
+        }
+        _handleResponse(req, res);
+        return res.data;
+    },
+    create: (etainablApi, endpoint, postEndpoint) => async (data, options = {}) => {
+        const req = {
+            method: 'POST',
+            url: `${endpoint}${postEndpoint ? `/${postEndpoint}` : ''}`
+        };
+        log.info(`API Request: ${req.method} ${process.env.ETAINABL_API_URL}/${req.url}`);
+        let res;
+        try {
+            res = await etainablApi.post(req.url, data, options);
+        }
+        catch (e) {
+            if (e.response?.data)
+                throw new Error(`API error response: ${JSON.stringify(e.response.data)}`);
+            throw e;
+        }
+        _handleResponse(req, res);
+        return res.data;
+    },
+    remove: (etainablApi, endpoint, postEndpoint) => async (id, options = {}) => {
+        const req = {
+            method: 'DELETE',
+            url: `${endpoint}/${id}${postEndpoint ? `/${postEndpoint}` : ''}`
+        };
+        let res;
+        log.info(`API Request: ${req.method} ${process.env.ETAINABL_API_URL}/${req.url}`);
+        try {
+            res = await etainablApi.delete(req.url, options);
+        }
+        catch (e) {
+            if (e.response?.data)
+                throw new Error(`API error response: ${JSON.stringify(e.response.data)}`);
+            throw e;
+        }
+        _handleResponse(req, res);
+        return res.data;
+    },
+    customWithId: (etainablApi, method, endpoint, postEndpoint) => async (id, data, options = {}) => {
+        const req = {
+            method: method,
+            url: `${endpoint}/${id}${postEndpoint ? `/${postEndpoint}` : ''}`,
+            data,
+            ...options
+        };
+        log.info(`API Request (Custom): ${req.method} ${process.env.ETAINABL_API_URL}/${req.url}`);
+        let res;
+        try {
+            res = await etainablApi.request(req);
+        }
+        catch (e) {
+            if (e.response?.data)
+                throw new Error(`API error response: ${JSON.stringify(e.response.data)}`);
+            throw e;
+        }
+        _handleResponse(req, res);
+        return res.data;
+    }
+};
+// ETN Sub Endpoints
+// e.g. /assets/:id/documents/:documentId
+const subFactory = {
+    // e.g. POST /assets/:id/documents
+    create: (etainablApi, endpoint, subEndpoint) => async (id, data, options = {}) => {
+        const subUrl = `${id}/${subEndpoint}`;
+        return factory.create(etainablApi, endpoint, subUrl)(data, options);
+    },
+    // e.g. PATCH /assets/:id/documents/:documentId
+    update: (etainablApi, endpoint, subEndpoint) => async (id, subId, data, options = {}) => {
+        const subUrl = `${subEndpoint}/${subId}`;
+        return factory.update(etainablApi, endpoint, subUrl)(id, data, options);
+    },
+    // e.g. DELETE /assets/:id/documents/:documentId
+    remove: (etainablApi, endpoint, subEndpoint) => async (id, subId, options = {}) => {
+        const subUrl = `${subEndpoint}/${subId}`;
+        return factory.remove(etainablApi, endpoint, subUrl)(id, options);
+    }
+};
+export default (auth, instanceOptions = {}) => {
+    try {
+        const headers = {};
+        if (auth.key) {
+            headers['x-key'] = auth.key;
+        }
+        else if (auth.token) {
+            headers['Authorization'] = auth.token;
+        }
+        else {
+            headers['x-key'] = process.env.ETAINABL_API_KEY;
+        }
+        const etainablApi = axios.create({
+            baseURL: process.env.ETAINABL_API_URL,
+            timeout: 300000,
+            httpsAgent: new https.Agent({ keepAlive: true }),
+            headers,
+            ...instanceOptions
+        });
+        return {
+            instance: etainablApi,
+            // accounts
+            getAccount: factory.getWithId(etainablApi, 'accounts'),
+            listAccounts: factory.list(etainablApi, 'accounts'),
+            updateAccount: factory.update(etainablApi, 'accounts'),
+            createAccount: factory.create(etainablApi, 'accounts'),
+            removeAccount: factory.remove(etainablApi, 'accounts'),
+            getAccountSchema: factory.get(etainablApi, 'accounts', 'schema'),
+            invalidateAccountCache: factory.customWithId(etainablApi, 'put', 'accounts', 'invalidate-cache'),
+            // assets
+            getAsset: factory.getWithId(etainablApi, 'assets'),
+            listAssets: factory.list(etainablApi, 'assets'),
+            updateAsset: factory.update(etainablApi, 'assets'),
+            createAsset: factory.create(etainablApi, 'assets'),
+            removeAsset: factory.remove(etainablApi, 'assets'),
+            getAssetSchema: factory.get(etainablApi, 'assets', 'schema'),
+            // assetGroups
+            getAssetGroup: factory.getWithId(etainablApi, 'asset-groups'),
+            listAssetGroups: factory.list(etainablApi, 'asset-groups'),
+            updateAssetGroup: factory.update(etainablApi, 'asset-groups'),
+            createAssetGroup: factory.create(etainablApi, 'asset-groups'),
+            removeAssetGroup: factory.remove(etainablApi, 'asset-groups'),
+            getAssetGroupAssets: factory.getWithId(etainablApi, 'asset-groups', 'assets'),
+            getAssetGroupSchema: factory.get(etainablApi, 'asset-groups', 'schema'),
+            // automation
+            getAutomation: factory.getWithId(etainablApi, 'automation'),
+            listAutomations: factory.list(etainablApi, 'automation'),
+            updateAutomation: factory.update(etainablApi, 'automation'),
+            createAutomation: factory.create(etainablApi, 'automation'),
+            removeAutomation: factory.remove(etainablApi, 'automation'),
+            createAutomationLog: subFactory.create(etainablApi, 'automation', 'logs'),
+            updateAutomationLog: subFactory.update(etainablApi, 'automation', 'logs'),
+            removeAutomationLog: subFactory.remove(etainablApi, 'automation', 'logs'),
+            // company
+            getCompany: factory.getWithId(etainablApi, 'companies'),
+            // consumption
+            getConsumption: factory.getWithId(etainablApi, 'consumptions'),
+            listConsumptions: factory.list(etainablApi, 'consumptions'),
+            updateConsumption: factory.update(etainablApi, 'consumptions'),
+            createConsumption: factory.create(etainablApi, 'consumptions'),
+            removeConsumption: factory.remove(etainablApi, 'consumptions'),
+            getConsumptionSchema: factory.get(etainablApi, 'consumptions', 'schema'),
+            // emails
+            getEmail: factory.getWithId(etainablApi, 'emails'),
+            listEmails: factory.list(etainablApi, 'emails'),
+            updateEmail: factory.update(etainablApi, 'emails'),
+            createEmail: factory.create(etainablApi, 'emails'),
+            removeEmail: factory.remove(etainablApi, 'emails'),
+            // emission factors
+            getEmissionFactor: factory.getWithId(etainablApi, 'emission-factors'),
+            listEmissionFactors: factory.list(etainablApi, 'emission-factors'),
+            updateEmissionFactor: factory.update(etainablApi, 'emission-factors'),
+            createEmissionFactor: factory.create(etainablApi, 'emission-factors'),
+            removeEmissionFactor: factory.remove(etainablApi, 'emission-factors'),
+            // entity
+            getEntity: factory.getWithId(etainablApi, 'entities'),
+            listEntities: factory.list(etainablApi, 'entities'),
+            updateEntity: factory.update(etainablApi, 'entities'),
+            createEntity: factory.create(etainablApi, 'entities'),
+            removeEntity: factory.remove(etainablApi, 'entities'),
+            getEntitiesSchema: factory.get(etainablApi, 'entities', 'schema'),
+            // logs
+            getLog: factory.getWithId(etainablApi, 'logs'),
+            listLogs: factory.list(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'),
+            updateReading: factory.update(etainablApi, 'readings'),
+            createReading: factory.create(etainablApi, 'readings'),
+            removeReading: factory.remove(etainablApi, 'readings'),
+            getReadingSchema: factory.get(etainablApi, 'readings', 'schema'),
+            // reports
+            getReport: factory.getWithId(etainablApi, 'reports'),
+            listReports: factory.list(etainablApi, 'reports'),
+            updateReport: factory.update(etainablApi, 'reports'),
+            createReport: factory.create(etainablApi, 'reports'),
+            removeReport: factory.remove(etainablApi, 'reports'),
+            sendReport: factory.customWithId(etainablApi, 'post', 'reports', 'send'),
+            // report templates
+            getReportTemplate: factory.getWithId(etainablApi, 'report-templates'),
+            listReportTemplates: factory.list(etainablApi, 'report-templates'),
+            updateReportTemplate: factory.update(etainablApi, 'report-templates'),
+            createReportTemplate: factory.create(etainablApi, 'report-templates'),
+            removeReportTemplate: factory.remove(etainablApi, 'report-templates'),
+            // scheduled reports
+            getScheduledReport: factory.getWithId(etainablApi, 'scheduled-reports'),
+            listScheduledReports: factory.list(etainablApi, 'scheduled-reports'),
+            updateScheduledReport: factory.update(etainablApi, 'scheduled-reports'),
+            createScheduledReport: factory.create(etainablApi, 'scheduled-reports'),
+            removeScheduledReport: factory.remove(etainablApi, 'scheduled-reports'),
+            sendScheduledReport: factory.customWithId(etainablApi, 'post', 'scheduled-reports', 'send'),
+            // invoices
+            getInvoice: factory.getWithId(etainablApi, 'invoices'),
+            listInvoices: factory.list(etainablApi, 'invoices'),
+            updateInvoice: factory.update(etainablApi, 'invoices'),
+            createInvoice: factory.create(etainablApi, 'invoices'),
+            removeInvoice: factory.remove(etainablApi, 'invoices'),
+            getInvoiceSchema: factory.get(etainablApi, 'invoices', 'schema'),
+            //suppliers
+            listSuppliers: factory.list(etainablApi, 'suppliers'),
+            getSupplierSchema: factory.get(etainablApi, 'suppliers', 'schema'),
+            // import templates
+            getImportTemplate: factory.getWithId(etainablApi, 'import-templates'),
+            //data imports
+            updateDataIngest: factory.update(etainablApi, 'data-ingests'),
+            createDataIngest: factory.create(etainablApi, 'data-ingests'),
+            listDataIngest: factory.list(etainablApi, 'data-ingests'),
+        };
+    }
+    catch (e) {
+        log.error(e);
+        throw e;
+    }
+};

package/dist/mjs/consumption.d.ts

@@ -0,0 +1,14 @@
+import moment from 'moment';
+interface ConsumptionData {
+    date: Date;
+    consumption: number;
+}
+export declare const dayNightConsumption: (data: ConsumptionData[]) => {
+    dayConsumption: number;
+    nightConsumption: number;
+    consumption: number;
+};
+export declare const calcMaxConsumptionValue: (data: ConsumptionData[]) => number;
+export declare const calcMaxDemand: (data: ConsumptionData[]) => number;
+export declare const calcPeakLoad: (consumption: number, maxDemand: number, startDate: string | moment.Moment, endDate: string | moment.Moment) => number;
+export {};