jimpex 7.0.1 → 8.0.0

package/dist/controllers/common/config.js

@@ -0,0 +1,89 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var config_exports = {};
+__export(config_exports, {
+  ConfigController: () => ConfigController,
+  configController: () => configController
+});
+module.exports = __toCommonJS(config_exports);
+var import_utils = require("../../utils");
+class ConfigController {
+  constructor({ inject }) {
+    __publicField(this, "_responsesBuilder");
+    __publicField(this, "_config");
+    this._responsesBuilder = inject.responsesBuilder;
+    this._config = inject.config;
+  }
+  showConfig() {
+    return (_, res) => {
+      this.respondWithConfig(res);
+    };
+  }
+  switchConfig() {
+    return async (req, res, next) => {
+      const { name } = req.params;
+      if (!name || !this._config.canSwitchConfigs()) {
+        next();
+        return;
+      }
+      try {
+        await this._config.switch(name);
+        this.respondWithConfig(res);
+      } catch (error) {
+        next(error);
+      }
+    };
+  }
+  respondWithConfig(res) {
+    const name = this._config.get("name");
+    const data = {
+      name,
+      ...this._config.getConfig()
+    };
+    this._responsesBuilder.json({
+      res,
+      data
+    });
+  }
+}
+const configController = (0, import_utils.controller)((app) => {
+  const config = app.getConfig();
+  const router = app.getRouter();
+  if (config.get("debug.configController") !== true) {
+    return router;
+  }
+  const ctrl = new ConfigController({
+    inject: {
+      config,
+      responsesBuilder: app.get("responsesBuilder")
+    }
+  });
+  return router.get("/", ctrl.showConfig()).get("/switch/:name", ctrl.switchConfig());
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConfigController,
+  configController
+});
+//# sourceMappingURL=config.js.map

package/dist/controllers/common/config.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/controllers/common/config.ts"],"sourcesContent":["import { controller } from '../../utils';\nimport type { ResponsesBuilder } from '../../services';\nimport type {\n  Config,\n  Response,\n  AsyncExpressMiddleware,\n  ExpressMiddleware,\n} from '../../types';\n/**\n * The options to contruct a {@link ConfigController}.\n *\n * @group Controllers/Config\n */\nexport type ConfigControllerOptions = {\n  /**\n   * A dictionary with the dependencies to inject.\n   */\n  inject: {\n    responsesBuilder: ResponsesBuilder;\n    config: Config;\n  };\n};\n/**\n * The controller class that allows to show and switch the application configuration.\n *\n * @group Controller Classes\n * @group Controllers/Config\n * @prettierignore\n */\nexport class ConfigController {\n  /**\n   * The service in charge or building the responses.\n   */\n  protected readonly _responsesBuilder: ResponsesBuilder;\n  /**\n   * The service in charge of the configuration.\n   */\n  protected readonly _config: Config;\n  /**\n   * @param options  The options to construct the controller.\n   */\n  constructor({ inject }: ConfigControllerOptions) {\n    this._responsesBuilder = inject.responsesBuilder;\n    this._config = inject.config;\n  }\n  /**\n   * Creates the middleware the shows the current configuration.\n   */\n  showConfig(): ExpressMiddleware {\n    return (_, res) => {\n      this.respondWithConfig(res);\n    };\n  }\n  /**\n   * Creates the middleware the allows to switch the configuration.\n   */\n  switchConfig(): AsyncExpressMiddleware {\n    return async (req, res, next) => {\n      const { name } = req.params;\n      if (!name || !this._config.canSwitchConfigs()) {\n        next();\n        return;\n      }\n\n      try {\n        await this._config.switch(name);\n        this.respondWithConfig(res);\n      } catch (error) {\n        next(error);\n      }\n    };\n  }\n  /**\n   * Utility to respond with the current configuration.\n   */\n  protected respondWithConfig(res: Response): void {\n    const name = this._config.get<string>('name');\n    const data = {\n      name,\n      ...this._config.getConfig<Record<string, unknown>>(),\n    };\n\n    this._responsesBuilder.json({\n      res,\n      data,\n    });\n  }\n}\n/**\n * This controller is kind of special as it will only mount the routes if the\n * `debug.configController` setting of the app configuration is set to `true`.\n *\n * It provides routes for:\n * - `/`: Showing the current configuration.\n * - `/switch/:name`: Switching the configuration, but only if the service allows it.\n *\n * @group Controllers\n * @group Controllers/Config\n */\nexport const configController = controller((app) => {\n  const config = app.getConfig();\n  const router = app.getRouter();\n  if (config.get<boolean | undefined>('debug.configController') !== true) {\n    return router;\n  }\n\n  const ctrl = new ConfigController({\n    inject: {\n      config,\n      responsesBuilder: app.get('responsesBuilder'),\n    },\n  });\n\n  return router.get('/', ctrl.showConfig()).get('/switch/:name', ctrl.switchConfig());\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAA2B;AA6BpB,MAAM,iBAAiB;AAAA,EAY5B,YAAY,EAAE,OAAO,GAA4B;AARjD,wBAAmB;AAInB,wBAAmB;AAKjB,SAAK,oBAAoB,OAAO;AAChC,SAAK,UAAU,OAAO;AAAA,EACxB;AAAA,EAIA,aAAgC;AAC9B,WAAO,CAAC,GAAG,QAAQ;AACjB,WAAK,kBAAkB,GAAG;AAAA,IAC5B;AAAA,EACF;AAAA,EAIA,eAAuC;AACrC,WAAO,OAAO,KAAK,KAAK,SAAS;AAC/B,YAAM,EAAE,KAAK,IAAI,IAAI;AACrB,UAAI,CAAC,QAAQ,CAAC,KAAK,QAAQ,iBAAiB,GAAG;AAC7C,aAAK;AACL;AAAA,MACF;AAEA,UAAI;AACF,cAAM,KAAK,QAAQ,OAAO,IAAI;AAC9B,aAAK,kBAAkB,GAAG;AAAA,MAC5B,SAAS,OAAP;AACA,aAAK,KAAK;AAAA,MACZ;AAAA,IACF;AAAA,EACF;AAAA,EAIU,kBAAkB,KAAqB;AAC/C,UAAM,OAAO,KAAK,QAAQ,IAAY,MAAM;AAC5C,UAAM,OAAO;AAAA,MACX;AAAA,MACA,GAAG,KAAK,QAAQ,UAAmC;AAAA,IACrD;AAEA,SAAK,kBAAkB,KAAK;AAAA,MAC1B;AAAA,MACA;AAAA,IACF,CAAC;AAAA,EACH;AACF;AAYO,MAAM,uBAAmB,yBAAW,CAAC,QAAQ;AAClD,QAAM,SAAS,IAAI,UAAU;AAC7B,QAAM,SAAS,IAAI,UAAU;AAC7B,MAAI,OAAO,IAAyB,wBAAwB,MAAM,MAAM;AACtE,WAAO;AAAA,EACT;AAEA,QAAM,OAAO,IAAI,iBAAiB;AAAA,IAChC,QAAQ;AAAA,MACN;AAAA,MACA,kBAAkB,IAAI,IAAI,kBAAkB;AAAA,IAC9C;AAAA,EACF,CAAC;AAED,SAAO,OAAO,IAAI,KAAK,KAAK,WAAW,CAAC,EAAE,IAAI,iBAAiB,KAAK,aAAa,CAAC;AACpF,CAAC;","names":[]}

package/dist/controllers/common/health.d.ts

@@ -0,0 +1,82 @@
+import * as _homer0_jimple from '@homer0/jimple';
+import { Statuses } from '../../utils/fns/statuses.js';
+import { r as JimpexHealthStatus, C as ControllerConnectFn } from '../../jimpex-7eaee271.js';
+import { AsyncExpressMiddleware } from '../../types/express.js';
+import { SimpleConfig } from '@homer0/simple-config';
+import { ResponsesBuilder } from '../../services/http/responsesBuilder.js';
+import 'statuses';
+import '@homer0/events-hub';
+import 'express';
+import '../../types/http.js';
+import 'https';
+import 'http';
+import 'spdy';
+import 'node-fetch';
+import '../../types/utils.js';
+import '@homer0/simple-logger';
+
+/**
+ * A function that will return the health status of the application.
+ *
+ * @group Controllers/Health
+ */
+type GetHealthStatus = () => Promise<JimpexHealthStatus>;
+/**
+ * The options to contruct a {@link HealthController}.
+ *
+ * @group Controllers/Health
+ */
+type HealthControllerOptions = {
+    /**
+     * A dictionary with the dependencies to inject.
+     */
+    inject: {
+        getHealthStatus: GetHealthStatus;
+        responsesBuilder: ResponsesBuilder;
+        config: SimpleConfig;
+        statuses: Statuses;
+    };
+};
+/**
+ * The controller class that shows the application health status.
+ *
+ * @group Controller Classes
+ * @group Controllers/Health
+ * @prettierignore
+ */
+declare class HealthController {
+    /**
+     * The function that returns the health status of the application.
+     */
+    protected readonly _getHealthStatus: GetHealthStatus;
+    /**
+     * The service in charge or building the responses.
+     */
+    protected readonly _responsesBuilder: ResponsesBuilder;
+    /**
+     * The service in charge of the configuration.
+     */
+    protected readonly _config: SimpleConfig;
+    /**
+     * The uility service to get HTTP status codes.
+     */
+    protected readonly _statuses: Statuses;
+    /**
+     * @param options  The options to construct the controller.
+     */
+    constructor({ inject }: HealthControllerOptions);
+    /**
+     * Creates the middleware the shows the application health status.
+     */
+    showHealth(): AsyncExpressMiddleware;
+}
+/**
+ * The controller that once mounted, it will add an endpoint to show the application
+ * health status.
+ *
+ * @group Controllers
+ * @group Controllers/Health
+ */
+declare const healthController: _homer0_jimple.Resource<"controller", "connect", ControllerConnectFn>;
+
+export { GetHealthStatus, HealthController, HealthControllerOptions, healthController };

package/dist/controllers/common/health.js

@@ -0,0 +1,97 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var health_exports = {};
+__export(health_exports, {
+  HealthController: () => HealthController,
+  healthController: () => healthController
+});
+module.exports = __toCommonJS(health_exports);
+var import_utils = require("../../utils");
+class HealthController {
+  constructor({ inject }) {
+    __publicField(this, "_getHealthStatus");
+    __publicField(this, "_responsesBuilder");
+    __publicField(this, "_config");
+    __publicField(this, "_statuses");
+    this._getHealthStatus = inject.getHealthStatus;
+    this._responsesBuilder = inject.responsesBuilder;
+    this._config = inject.config;
+    this._statuses = inject.statuses;
+  }
+  showHealth() {
+    return async (_, res) => {
+      const healthStatus = await this._getHealthStatus();
+      let isHealthy;
+      let extras;
+      if (typeof healthStatus === "boolean") {
+        isHealthy = healthStatus;
+        extras = {};
+      } else {
+        if (typeof healthStatus.isHealthy === "boolean") {
+          isHealthy = healthStatus.isHealthy;
+        } else if (healthStatus.services) {
+          isHealthy = Object.values(healthStatus.services).every(
+            (value) => value === true
+          );
+        } else {
+          isHealthy = true;
+        }
+        extras = {
+          ...healthStatus.services
+        };
+      }
+      const { name: config, version } = this._config.get(["name", "version"]);
+      const status = isHealthy ? this._statuses("ok") : this._statuses("service unavailable");
+      this._responsesBuilder.json({
+        res,
+        status,
+        data: {
+          isHealthy,
+          status,
+          config,
+          version,
+          ...extras
+        }
+      });
+    };
+  }
+}
+const healthController = (0, import_utils.controller)((app) => {
+  const router = app.getRouter();
+  const ctrl = new HealthController({
+    inject: {
+      getHealthStatus: app.isHealthy.bind(app),
+      responsesBuilder: app.get("responsesBuilder"),
+      config: app.get("config"),
+      statuses: app.get("statuses")
+    }
+  });
+  return router.get("/", ctrl.showHealth());
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HealthController,
+  healthController
+});
+//# sourceMappingURL=health.js.map

package/dist/controllers/common/health.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/controllers/common/health.ts"],"sourcesContent":["import { controller, type Statuses } from '../../utils';\nimport type { ResponsesBuilder } from '../../services';\nimport type { JimpexHealthStatus, Config, AsyncExpressMiddleware } from '../../types';\n/**\n * A function that will return the health status of the application.\n *\n * @group Controllers/Health\n */\nexport type GetHealthStatus = () => Promise<JimpexHealthStatus>;\n/**\n * The options to contruct a {@link HealthController}.\n *\n * @group Controllers/Health\n */\nexport type HealthControllerOptions = {\n  /**\n   * A dictionary with the dependencies to inject.\n   */\n  inject: {\n    getHealthStatus: GetHealthStatus;\n    responsesBuilder: ResponsesBuilder;\n    config: Config;\n    statuses: Statuses;\n  };\n};\n/**\n * The controller class that shows the application health status.\n *\n * @group Controller Classes\n * @group Controllers/Health\n * @prettierignore\n */\nexport class HealthController {\n  /**\n   * The function that returns the health status of the application.\n   */\n  protected readonly _getHealthStatus: GetHealthStatus;\n  /**\n   * The service in charge or building the responses.\n   */\n  protected readonly _responsesBuilder: ResponsesBuilder;\n  /**\n   * The service in charge of the configuration.\n   */\n  protected readonly _config: Config;\n  /**\n   * The uility service to get HTTP status codes.\n   */\n  protected readonly _statuses: Statuses;\n  /**\n   * @param options  The options to construct the controller.\n   */\n  constructor({ inject }: HealthControllerOptions) {\n    this._getHealthStatus = inject.getHealthStatus;\n    this._responsesBuilder = inject.responsesBuilder;\n    this._config = inject.config;\n    this._statuses = inject.statuses;\n  }\n  /**\n   * Creates the middleware the shows the application health status.\n   */\n  showHealth(): AsyncExpressMiddleware {\n    return async (_, res) => {\n      const healthStatus = await this._getHealthStatus();\n      let isHealthy: boolean;\n      let extras: Record<string, unknown>;\n      if (typeof healthStatus === 'boolean') {\n        isHealthy = healthStatus;\n        extras = {};\n      } else {\n        if (typeof healthStatus.isHealthy === 'boolean') {\n          isHealthy = healthStatus.isHealthy;\n        } else if (healthStatus.services) {\n          isHealthy = Object.values(healthStatus.services).every(\n            (value) => value === true,\n          );\n        } else {\n          isHealthy = true;\n        }\n\n        extras = {\n          ...healthStatus.services,\n        };\n      }\n\n      const { name: config, version } = this._config.get<{\n        name: string;\n        version: string;\n      }>(['name', 'version']);\n\n      const status = isHealthy\n        ? this._statuses('ok')\n        : this._statuses('service unavailable');\n\n      this._responsesBuilder.json({\n        res,\n        status,\n        data: {\n          isHealthy,\n          status,\n          config,\n          version,\n          ...extras,\n        },\n      });\n    };\n  }\n}\n/**\n * The controller that once mounted, it will add an endpoint to show the application\n * health status.\n *\n * @group Controllers\n * @group Controllers/Health\n */\nexport const healthController = controller((app) => {\n  const router = app.getRouter();\n  const ctrl = new HealthController({\n    inject: {\n      getHealthStatus: app.isHealthy.bind(app),\n      responsesBuilder: app.get('responsesBuilder'),\n      config: app.get('config'),\n      statuses: app.get('statuses'),\n    },\n  });\n\n  return router.get('/', ctrl.showHealth());\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAA0C;AAgCnC,MAAM,iBAAiB;AAAA,EAoB5B,YAAY,EAAE,OAAO,GAA4B;AAhBjD,wBAAmB;AAInB,wBAAmB;AAInB,wBAAmB;AAInB,wBAAmB;AAKjB,SAAK,mBAAmB,OAAO;AAC/B,SAAK,oBAAoB,OAAO;AAChC,SAAK,UAAU,OAAO;AACtB,SAAK,YAAY,OAAO;AAAA,EAC1B;AAAA,EAIA,aAAqC;AACnC,WAAO,OAAO,GAAG,QAAQ;AACvB,YAAM,eAAe,MAAM,KAAK,iBAAiB;AACjD,UAAI;AACJ,UAAI;AACJ,UAAI,OAAO,iBAAiB,WAAW;AACrC,oBAAY;AACZ,iBAAS,CAAC;AAAA,MACZ,OAAO;AACL,YAAI,OAAO,aAAa,cAAc,WAAW;AAC/C,sBAAY,aAAa;AAAA,QAC3B,WAAW,aAAa,UAAU;AAChC,sBAAY,OAAO,OAAO,aAAa,QAAQ,EAAE;AAAA,YAC/C,CAAC,UAAU,UAAU;AAAA,UACvB;AAAA,QACF,OAAO;AACL,sBAAY;AAAA,QACd;AAEA,iBAAS;AAAA,UACP,GAAG,aAAa;AAAA,QAClB;AAAA,MACF;AAEA,YAAM,EAAE,MAAM,QAAQ,QAAQ,IAAI,KAAK,QAAQ,IAG5C,CAAC,QAAQ,SAAS,CAAC;AAEtB,YAAM,SAAS,YACX,KAAK,UAAU,IAAI,IACnB,KAAK,UAAU,qBAAqB;AAExC,WAAK,kBAAkB,KAAK;AAAA,QAC1B;AAAA,QACA;AAAA,QACA,MAAM;AAAA,UACJ;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA,GAAG;AAAA,QACL;AAAA,MACF,CAAC;AAAA,IACH;AAAA,EACF;AACF;AAQO,MAAM,uBAAmB,yBAAW,CAAC,QAAQ;AAClD,QAAM,SAAS,IAAI,UAAU;AAC7B,QAAM,OAAO,IAAI,iBAAiB;AAAA,IAChC,QAAQ;AAAA,MACN,iBAAiB,IAAI,UAAU,KAAK,GAAG;AAAA,MACvC,kBAAkB,IAAI,IAAI,kBAAkB;AAAA,MAC5C,QAAQ,IAAI,IAAI,QAAQ;AAAA,MACxB,UAAU,IAAI,IAAI,UAAU;AAAA,IAC9B;AAAA,EACF,CAAC;AAED,SAAO,OAAO,IAAI,KAAK,KAAK,WAAW,CAAC;AAC1C,CAAC;","names":[]}

package/dist/controllers/common/index.d.ts

@@ -0,0 +1,21 @@
+export { ConfigController, ConfigControllerOptions, configController } from './config.js';
+export { GetHealthStatus, HealthController, HealthControllerOptions, healthController } from './health.js';
+export { AddStaticRouteOptions, StaticsController, StaticsControllerConstructorOptions, StaticsControllerCreatorOptions, StaticsControllerFile, StaticsControllerGetMiddlewaresFn, StaticsControllerOptions, StaticsControllerPathsOptions, staticsController } from './statics.js';
+import '@homer0/jimple';
+import '../../jimpex-7eaee271.js';
+import '@homer0/events-hub';
+import '../../types/express.js';
+import 'express';
+import '../../types/http.js';
+import 'https';
+import 'http';
+import 'spdy';
+import 'node-fetch';
+import '@homer0/simple-config';
+import '../../types/utils.js';
+import '@homer0/simple-logger';
+import '../../services/http/responsesBuilder.js';
+import '../../utils/fns/statuses.js';
+import 'statuses';
+import '../../services/common/sendFile.js';
+import '@homer0/path-utils';

package/dist/controllers/common/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var common_exports = {};
+module.exports = __toCommonJS(common_exports);
+__reExport(common_exports, require("./config"), module.exports);
+__reExport(common_exports, require("./health"), module.exports);
+__reExport(common_exports, require("./statics"), module.exports);
+//# sourceMappingURL=index.js.map

package/dist/controllers/common/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/controllers/common/index.ts"],"sourcesContent":["export * from './config';\nexport * from './health';\nexport * from './statics';\n"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;AAAA,2BAAc,qBAAd;AACA,2BAAc,qBADd;AAEA,2BAAc,sBAFd;","names":[]}

package/dist/controllers/common/statics.d.ts

@@ -0,0 +1,215 @@
+import * as _homer0_jimple from '@homer0/jimple';
+import { J as Jimpex, a1 as MiddlewareLike, C as ControllerConnectFn } from '../../jimpex-7eaee271.js';
+import { RouterMethod, ExpressMiddleware } from '../../types/express.js';
+import { DeepPartial } from '../../types/utils.js';
+import { SendFile } from '../../services/common/sendFile.js';
+import { Router } from 'express';
+import '@homer0/events-hub';
+import '../../types/http.js';
+import 'https';
+import 'http';
+import 'spdy';
+import 'node-fetch';
+import '@homer0/simple-config';
+import '@homer0/simple-logger';
+import '@homer0/path-utils';
+
+/**
+ * The definition for each file the controller handles.
+ *
+ * @group Controllers/Statics
+ */
+type StaticsControllerFile = {
+    /**
+     * The route, relative to the controller root, to the file.
+     */
+    route: string;
+    /**
+     * The path to the file in the filesystem. Since the file is served using the
+     * {@link SendFile} service, whether the file is relative to the project root or the
+     * application executable depends on how the service is configured (relative to the
+     * executable by default).
+     */
+    path: string;
+    /**
+     * A dictionary of headers for the response.
+     */
+    headers?: Record<string, string>;
+};
+/**
+ * These are like "master paths" that get prepended to all the file paths and routes the
+ * controller use.
+ *
+ * @group Controllers/Statics
+ */
+type StaticsControllerPathsOptions = {
+    /**
+     * A custom route to prefix all the file routes with.
+     */
+    route: string;
+    /**
+     * A custom path to prefix all the file paths with.
+     */
+    source: string;
+};
+/**
+ * The options to customize the controller.
+ *
+ * @group Controllers/Statics
+ */
+type StaticsControllerOptions = {
+    /**
+     * A list of filenames, or definitions for the files to handle.
+     */
+    files: Array<string | StaticsControllerFile>;
+    /**
+     * A dictionary with the allowed router (HTTP) methods the controller can use to serve
+     * the files. If `all` is set to `true`, the rest of the values will be ignored.
+     *
+     * @default {get: true, all: false}
+     */
+    methods: Partial<Record<RouterMethod, boolean>>;
+    /**
+     * The "master paths" the controller can use to prefix the file paths and routes.
+     *
+     * @default {route: '', source: './',}
+     */
+    paths: StaticsControllerPathsOptions;
+};
+/**
+ * The options to construct a {@link StaticsController}.
+ *
+ * @group Controllers/Statics
+ */
+type StaticsControllerConstructorOptions = DeepPartial<StaticsControllerOptions> & {
+    /**
+     * A dictionary with the dependencies to inject.
+     */
+    inject: {
+        sendFile: SendFile;
+    };
+};
+/**
+ * A function to generate a list of middlewares that can be executed before the tontroller
+ * main middleware.
+ *
+ * @group Controllers/Statics
+ */
+type StaticsControllerGetMiddlewaresFn = (app: Jimpex) => MiddlewareLike[];
+/**
+ * The options for the controller creator that mounts {@link StaticsController}.
+ *
+ * @group Controllers/Statics
+ */
+type StaticsControllerCreatorOptions = DeepPartial<StaticsControllerOptions> & {
+    /**
+     * A function to generate a list of middlewares that can be executed before the
+     * tontroller main middleware.
+     */
+    getMiddlewares?: StaticsControllerGetMiddlewaresFn;
+};
+/**
+ * The options for {@link StaticsController._addRoute}.
+ *
+ * @access protected
+ * @group Controllers/Statics
+ */
+type AddStaticRouteOptions = {
+    /**
+     * The reference for the router in which the middlewares will be added.
+     */
+    router: Router;
+    /**
+     * The router method in which the middlewares will be added.
+     */
+    method: RouterMethod;
+    /**
+     * The definition of the file to serve.
+     */
+    file: StaticsControllerFile;
+    /**
+     * The middleware created by {@link StaticsController}, that will serve the file.
+     */
+    fileMiddleware: ExpressMiddleware;
+    /**
+     * A list of extra middlewares to execute before the file middleware.
+     */
+    middlewares: ExpressMiddleware[];
+};
+/**
+ * The controller class that allows the application to serve specific files from any
+ * folder to any route without the need of mounting directories as "static".
+ *
+ * @group Controller Classes
+ * @group Controllers/Statics
+ * @prettierignore
+ */
+declare class StaticsController {
+    /**
+     * The service that serves static files.
+     */
+    protected readonly _sendFile: SendFile;
+    /**
+     * The controller customization options.
+     */
+    protected _options: StaticsControllerOptions;
+    /**
+     * A dictionary with the formatted definitions of the files that will be served.
+     * It uses the files' routes as keys, for easy access in the middleware.
+     */
+    protected files: Record<string, StaticsControllerFile>;
+    /**
+     * @param options  The options to construct the controller.
+     */
+    constructor({ inject, ...options }: StaticsControllerConstructorOptions);
+    /**
+     * Mounts the middlewares in the router in order to serve the files.
+     *
+     * @param router       A reference to the application router.
+     * @param middlewares  A list of extra middlewares to execute before the file
+     *                     middleware.
+     */
+    addRoutes(router: Router, middlewares?: ExpressMiddleware[]): Router;
+    /**
+     * The controller options.
+     */
+    get options(): Readonly<StaticsControllerOptions>;
+    /**
+     * Generates the middleware that will serve the file.
+     *
+     * @param file  The definition of the file to serve.
+     */
+    protected _getMiddleware(file: StaticsControllerFile): ExpressMiddleware;
+    /**
+     * Mounts the middleware(s) for a file in the router.
+     *
+     * @param options  The information of the file and how it needs to be added.
+     */
+    protected _addRoute({ router, method, file, fileMiddleware, middlewares, }: AddStaticRouteOptions): void;
+    /**
+     * Validates and formats the options sent to the constructor in order to get the final
+     * set that will be stored in the controller.
+     *
+     * @param options  The options to validate.
+     * @throws If no files are specified.
+     * @throws If methods is not defined.
+     * @throws If no methods are enabled.
+     * @throws If there's an invalid HTTP method.
+     */
+    protected _validateOptions(options: StaticsControllerOptions): StaticsControllerOptions;
+    /**
+     * Parses the files received from the constructor's options, and formats them into
+     * proper definitions the controller can use.
+     */
+    protected _createFiles(): Record<string, StaticsControllerFile>;
+}
+/**
+ * A controller that allows the application to server specific files from any folder to
+ * any route without the need of mounting directories as "static" folders.
+ *
+ * @group Controllers
+ * @group Controllers/Statics
+ */
+declare const staticsController: _homer0_jimple.ResourceCreator<"controller", "connect", ({ getMiddlewares, ...options }?: StaticsControllerCreatorOptions) => <ContainerType extends Jimpex = Jimpex>(app: ContainerType) => Router, ControllerConnectFn>;
+
+export { AddStaticRouteOptions, StaticsController, StaticsControllerConstructorOptions, StaticsControllerCreatorOptions, StaticsControllerFile, StaticsControllerGetMiddlewaresFn, StaticsControllerOptions, StaticsControllerPathsOptions, staticsController };