@etainabl/nodejs-sdk 1.2.43 → 1.2.45

package/dist/index.mjs

@@ -0,0 +1,588 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/api.ts
+import axios from "axios";
+import https from "https";
+
+// src/logger.ts
+import winston from "winston";
+var logger_default = (namespace) => winston.createLogger({
+  level: "debug",
+  format: winston.format.combine(
+    winston.format.timestamp(),
+    winston.format.json()
+  ),
+  defaultMeta: { service: process.env.AWS_LAMBDA_FUNCTION_NAME, script: namespace },
+  transports: [
+    new winston.transports.Console()
+  ]
+});
+
+// src/api.ts
+var log = logger_default("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;
+}
+var 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,
+      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;
+  }
+};
+var 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);
+  }
+};
+var api_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: 3e5,
+      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;
+  }
+};
+
+// src/db.ts
+import { MongoClient } from "mongodb";
+var log2 = logger_default("dbHelpers");
+var cachedDb;
+async function connectToDatabase(retryAttempt = 1) {
+  if (!process.env.ETAINABL_DB_URL) throw new Error("ETAINABL_DB_URL is not set");
+  if (!process.env.AWS_ACCESS_KEY_ID) throw new Error("AWS_ACCESS_KEY_ID is not set");
+  if (!process.env.AWS_SECRET_ACCESS_KEY) throw new Error("AWS_SECRET_ACCESS_KEY is not set");
+  if (cachedDb) {
+    log2.debug("Using cached MongoDB connection.");
+    return Promise.resolve(cachedDb);
+  }
+  const uri = `mongodb+srv://${process.env.ETAINABL_DB_URL}`;
+  try {
+    if (process.env.DB_BASIC_AUTH === "true") {
+      log2.debug("Connecting to MongoDB server... (Auth: Basic)");
+      const client2 = new MongoClient(uri);
+      await client2.connect();
+      log2.debug("Connected successfully to MongoDB server! (Auth: Basic)");
+      cachedDb = client2.db("etainabl");
+      return cachedDb;
+    }
+    log2.debug("Connecting to MongoDB server... (Auth: AWS)");
+    const client = new MongoClient(uri, {
+      auth: {
+        username: process.env.AWS_ACCESS_KEY_ID,
+        password: process.env.AWS_SECRET_ACCESS_KEY
+      },
+      authSource: "$external",
+      authMechanism: "MONGODB-AWS"
+    });
+    await client.connect();
+    log2.debug("Connected successfully to MongoDB server! (Auth: AWS)");
+    cachedDb = client.db("etainabl");
+    return cachedDb;
+  } catch (e) {
+    if (retryAttempt > 5) {
+      console.log(`Error connecting to MongoDB server after 5 attempts...`);
+      throw e;
+    }
+    console.log(`MongoDB Connection error: ${e.message}`);
+    console.log(`Error connecting to MongoDB server... Retrying in 3 seconds... (Attempt ${retryAttempt})`);
+    return connectToDatabase(retryAttempt + 1);
+  }
+}
+var db_default = {
+  connectToDatabase
+};
+
+// src/slack.ts
+import axios2 from "axios";
+var postMessage = async (message) => {
+  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 axios2.post(url, data, { headers });
+};
+var slack_default = {
+  postMessage
+};
+
+// src/units.ts
+var units_exports = {};
+__export(units_exports, {
+  accountTypeMap: () => accountTypeMap,
+  accountTypeUnitMap: () => accountTypeUnitMap,
+  checkAccountTypeVsUnits: () => checkAccountTypeVsUnits,
+  convertItems: () => convertItems
+});
+var accountTypeMap = {
+  electricity: "kwh",
+  gas: "kwh",
+  water: "m3",
+  waste: "kg",
+  solar: "kwh",
+  heating: "kwh",
+  flow: "m3/h",
+  cooling: "kwh",
+  temperature: "C",
+  oil: "l"
+};
+var unitConversionFactors = {
+  kwh: {
+    kwh: 1,
+    mwh: 1e3,
+    wh: 1e-3,
+    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: 1e-3
+  },
+  C: {
+    C: 1
+  },
+  kg: {
+    kg: 1,
+    lbs: 0.45359237,
+    tonnes: 1e3
+  },
+  "m3/h": {
+    "m3/h": 1
+  }
+};
+var 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"]
+};
+var convertItems = (items, type, defaultUnits, accountFactor) => {
+  if (!type) throw new Error("Account type is required");
+  const baseUnit = 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 { ...item, value: convertedValue, units: baseUnit };
+  });
+  return convertedItems;
+};
+var _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];
+};
+var 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 = 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 };
+};
+
+// src/consumption.ts
+var consumption_exports = {};
+__export(consumption_exports, {
+  calcMaxConsumptionValue: () => calcMaxConsumptionValue,
+  calcMaxDemand: () => calcMaxDemand,
+  calcPeakLoad: () => calcPeakLoad,
+  dayNightConsumption: () => dayNightConsumption
+});
+import moment from "moment";
+var dayNightConsumption = (data) => data.reduce((acc, item) => {
+  const hour = moment.utc(item.date).hour();
+  if (hour >= 0 && hour < 7) {
+    acc.nightConsumption += item.consumption;
+  } else {
+    acc.dayConsumption += item.consumption;
+  }
+  acc.consumption += item.consumption;
+  return acc;
+}, {
+  dayConsumption: 0,
+  nightConsumption: 0,
+  consumption: 0
+});
+var calcMaxConsumptionValue = (data) => Math.max(...data.map((item) => item.consumption));
+var calcMaxDemand = (data) => calcMaxConsumptionValue(data) * 2;
+var calcPeakLoad = (consumption, maxDemand, startDate, endDate) => {
+  const days = Math.ceil(moment(endDate).diff(moment(startDate), "days", true));
+  return maxDemand === 0 ? 0 : consumption / (maxDemand * 24 * days) * 100;
+};
+
+// src/monitoring.ts
+var monitoring_exports = {};
+__export(monitoring_exports, {
+  sendHeartbeat: () => sendHeartbeat
+});
+import axios3 from "axios";
+var log3 = logger_default("monitoring");
+var sendHeartbeat = async () => {
+  if (!process.env.HEARTBEAT_URL || process.env.HEARTBEAT_URL.endsWith("/")) return false;
+  try {
+    await axios3.post(process.env.HEARTBEAT_URL);
+    return true;
+  } catch (e) {
+    log3.warn(`Failed to send heartbeat: ${e.message || e}`);
+    return false;
+  }
+};
+
+// src/reporting.ts
+var reporting_exports = {};
+__export(reporting_exports, {
+  getScheduledReportRunTimes: () => getScheduledReportRunTimes
+});
+import moment2 from "moment";
+moment2.locale("en", {
+  week: {
+    dow: 1
+  }
+});
+var getNextRunTime = (startDate, schedule, taskTime) => {
+  const [num, freq] = schedule.frequency.split("|");
+  const targetDate = moment2(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;
+  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;
+};
+var getScheduledReportRunTimes = (schedule, limit = 1, taskTime = moment2()) => {
+  if (!schedule.startDate || !schedule.enabled) return [];
+  const originalStartDate = moment2.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];
+    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];
+};
+export {
+  api_default as api,
+  consumption_exports as consumption,
+  db_default as db,
+  logger_default as logger,
+  monitoring_exports as monitoring,
+  reporting_exports as reporting,
+  slack_default as slack,
+  units_exports as units
+};
+//# sourceMappingURL=index.mjs.map