jimpex 7.0.2 → 9.0.0

package/dist/services/common/index.d.mts

@@ -0,0 +1,47 @@
+import * as _homer0_jimple from '@homer0/jimple';
+import { J as Jimpex } from '../../index-efeb437e.js';
+export { AppError, AppErrorClass, AppErrorContext, CreateAppErrorFn, appErrorProvider, createAppError } from './appError.mjs';
+export { CreateHTTPErrorFn, HTTPError, HTTPErrorClass, createHTTPError, httpErrorProvider } from './httpError.mjs';
+export { SendFile, SendFileGeneratorOptions, SendFileOptions, sendFile, sendFileProvider } from './sendFile.mjs';
+import '../../types/express.mjs';
+import 'express';
+import '../../types/http.mjs';
+import 'https';
+import 'http';
+import 'spdy';
+import 'node-fetch';
+import '../../types/utils.mjs';
+import '@homer0/path-utils';
+import '@homer0/simple-logger';
+import '@homer0/simple-config';
+import '@homer0/events-hub';
+import '../../utils/fns/statuses.mjs';
+import 'statuses';
+
+/**
+ * Registers all the common services on the container.
+ *
+ * - {@link AppError | appError}
+ * - {@link HTTPError | httpError}
+ * - {@link SendFile | sendFile}
+ *
+ * @example
+ *
+ *   // Register the collection on the container
+ *   container.register(commonServicesProvider);
+ *   // Getting access to one the services instance
+ *   const sendFile = container.get<SendFile>('sendFile');
+ *
+ * @group Providers
+ */
+declare const commonServicesProvider: {
+    appErrorProvider: _homer0_jimple.Resource<"provider", "register", _homer0_jimple.ProviderRegisterFn<Jimpex>>;
+    httpErrorProvider: _homer0_jimple.Resource<"provider", "register", _homer0_jimple.ProviderRegisterFn<Jimpex>>;
+    sendFileProvider: _homer0_jimple.Resource<"provider", "register", _homer0_jimple.ProviderRegisterFn<Jimpex>>;
+} & Record<string, _homer0_jimple.Resource<"provider", "register", _homer0_jimple.ProviderRegisterFn<Jimpex>>> & {
+    provider: true;
+} & {
+    register: _homer0_jimple.ProviderRegisterFn<Jimpex>;
+} & Record<string, unknown>;
+
+export { commonServicesProvider };

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

@@ -0,0 +1,47 @@
+import * as _homer0_jimple from '@homer0/jimple';
+import { J as Jimpex } from '../../index-b2a04c78.js';
+export { AppError, AppErrorClass, AppErrorContext, CreateAppErrorFn, appErrorProvider, createAppError } from './appError.js';
+export { CreateHTTPErrorFn, HTTPError, HTTPErrorClass, createHTTPError, httpErrorProvider } from './httpError.js';
+export { SendFile, SendFileGeneratorOptions, SendFileOptions, sendFile, sendFileProvider } from './sendFile.js';
+import '../../types/express.js';
+import 'express';
+import '../../types/http.js';
+import 'https';
+import 'http';
+import 'spdy';
+import 'node-fetch';
+import '../../types/utils.js';
+import '@homer0/path-utils';
+import '@homer0/simple-logger';
+import '@homer0/simple-config';
+import '@homer0/events-hub';
+import '../../utils/fns/statuses.js';
+import 'statuses';
+
+/**
+ * Registers all the common services on the container.
+ *
+ * - {@link AppError | appError}
+ * - {@link HTTPError | httpError}
+ * - {@link SendFile | sendFile}
+ *
+ * @example
+ *
+ *   // Register the collection on the container
+ *   container.register(commonServicesProvider);
+ *   // Getting access to one the services instance
+ *   const sendFile = container.get<SendFile>('sendFile');
+ *
+ * @group Providers
+ */
+declare const commonServicesProvider: {
+    appErrorProvider: _homer0_jimple.Resource<"provider", "register", _homer0_jimple.ProviderRegisterFn<Jimpex>>;
+    httpErrorProvider: _homer0_jimple.Resource<"provider", "register", _homer0_jimple.ProviderRegisterFn<Jimpex>>;
+    sendFileProvider: _homer0_jimple.Resource<"provider", "register", _homer0_jimple.ProviderRegisterFn<Jimpex>>;
+} & Record<string, _homer0_jimple.Resource<"provider", "register", _homer0_jimple.ProviderRegisterFn<Jimpex>>> & {
+    provider: true;
+} & {
+    register: _homer0_jimple.ProviderRegisterFn<Jimpex>;
+} & Record<string, unknown>;
+
+export { commonServicesProvider };

package/dist/services/common/index.js

@@ -0,0 +1,44 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __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 = {};
+__export(common_exports, {
+  commonServicesProvider: () => commonServicesProvider
+});
+module.exports = __toCommonJS(common_exports);
+var import_utils = require("../../utils");
+var import_appError = require("./appError");
+var import_httpError = require("./httpError");
+var import_sendFile = require("./sendFile");
+__reExport(common_exports, require("./appError"), module.exports);
+__reExport(common_exports, require("./httpError"), module.exports);
+__reExport(common_exports, require("./sendFile"), module.exports);
+const commonServicesProvider = (0, import_utils.providers)({
+  appErrorProvider: import_appError.appErrorProvider,
+  httpErrorProvider: import_httpError.httpErrorProvider,
+  sendFileProvider: import_sendFile.sendFileProvider
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  commonServicesProvider,
+  ...require("./appError"),
+  ...require("./httpError"),
+  ...require("./sendFile")
+});
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/services/common/index.ts"],"sourcesContent":["import { providers } from '../../utils';\nimport { appErrorProvider } from './appError';\nimport { httpErrorProvider } from './httpError';\nimport { sendFileProvider } from './sendFile';\n/**\n * Registers all the common services on the container.\n *\n * - {@link AppError | appError}\n * - {@link HTTPError | httpError}\n * - {@link SendFile | sendFile}\n *\n * @example\n *\n *   // Register the collection on the container\n *   container.register(commonServicesProvider);\n *   // Getting access to one the services instance\n *   const sendFile = container.get<SendFile>('sendFile');\n *\n * @group Providers\n */\nexport const commonServicesProvider = providers({\n  appErrorProvider,\n  httpErrorProvider,\n  sendFileProvider,\n});\n\nexport * from './appError';\nexport * from './httpError';\nexport * from './sendFile';\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAA0B;AAC1B,sBAAiC;AACjC,uBAAkC;AAClC,sBAAiC;AAuBjC,2BAAc,uBA1Bd;AA2BA,2BAAc,wBA3Bd;AA4BA,2BAAc,uBA5Bd;AAoBO,MAAM,6BAAyB,wBAAU;AAAA,EAC9C;AAAA,EACA;AAAA,EACA;AACF,CAAC;","names":[]}

package/dist/services/common/sendFile.d.mts

@@ -0,0 +1,102 @@
+import * as _homer0_jimple from '@homer0/jimple';
+import { J as Jimpex } from '../../index-efeb437e.js';
+import { Response, NextFunction } from 'express';
+import { PathUtils } from '@homer0/path-utils';
+import '../../types/express.mjs';
+import '../../types/http.mjs';
+import 'https';
+import 'http';
+import 'spdy';
+import 'node-fetch';
+import '../../types/utils.mjs';
+import '@homer0/simple-logger';
+import '@homer0/simple-config';
+import '@homer0/events-hub';
+
+/**
+ * The options to create a {@link SendFile} function.
+ *
+ * @group Services/SendFile
+ */
+type SendFileGeneratorOptions = {
+    /**
+     * A dictionary with the dependencies to inject.
+     */
+    inject: {
+        pathUtils: PathUtils;
+    };
+};
+/**
+ * The options for the function that actually serves a file.
+ *
+ * @group Services/SendFile
+ */
+type SendFileOptions = {
+    /**
+     * The response object sent by the application. Necessary to write the file.
+     */
+    res: Response;
+    /**
+     * The path of the file to serve. Depending on the `from` option, it will be either
+     * relative to the project root, or the application executable.
+     */
+    filepath: string;
+    /**
+     * The name of a location on the `pathUtils` service from where the `filepath` is
+     * relative to. It can be `app` for the directory containing the application executable,
+     * or `project` for the project root. It could also be any other location that the
+     * implementation may have registered.
+     *
+     * @default 'app'
+     */
+    from?: string;
+    /**
+     * The function to move to the next middleware. It can be used to report an error in
+     * case the file can't be served.
+     *
+     * @default {() => {}}
+     */
+    next?: NextFunction;
+};
+/**
+ * The type of the function that serves a file.
+ * This is exported to make it easy to type the dependency injection.
+ *
+ * @group Services/SendFile
+ */
+type SendFile = (options: SendFileOptions) => void;
+/**
+ * Generates a function to send files on the application response.
+ *
+ * @param options  To inject the required dependencies.
+ * @example
+ *
+ * <caption>Basic usage</caption>
+ *
+ *   // Let's say this is inside an Express middleware.
+ *   // Get the function
+ *   const send = sendFile(pathUtils);
+ *   send({ res, filepath: 'some-file.html', next });
+ *   // If your app is on "/app/index.js", this will send "/app/some-file.html".
+ *
+ * @group Services
+ * @group Services/SendFile
+ */
+declare const sendFile: ({ inject: { pathUtils } }: SendFileGeneratorOptions) => SendFile;
+/**
+ * The service provider that once registered on the container will set the result of
+ * {@link sendFile} as the `sendFile` service.
+ *
+ * @example
+ *
+ *   // Register it on the container
+ *   container.register(sendFileProvider);
+ *   // Getting access to the service instance
+ *   const sendFile = container.get<SendFile>('sendFile');
+ *
+ * @group Providers
+ * @group Services/SendFile
+ */
+declare const sendFileProvider: _homer0_jimple.Resource<"provider", "register", _homer0_jimple.ProviderRegisterFn<Jimpex>>;
+
+export { SendFile, SendFileGeneratorOptions, SendFileOptions, sendFile, sendFileProvider };

package/dist/services/common/sendFile.d.ts

@@ -0,0 +1,102 @@
+import * as _homer0_jimple from '@homer0/jimple';
+import { J as Jimpex } from '../../index-b2a04c78.js';
+import { Response, NextFunction } from 'express';
+import { PathUtils } from '@homer0/path-utils';
+import '../../types/express.js';
+import '../../types/http.js';
+import 'https';
+import 'http';
+import 'spdy';
+import 'node-fetch';
+import '../../types/utils.js';
+import '@homer0/simple-logger';
+import '@homer0/simple-config';
+import '@homer0/events-hub';
+
+/**
+ * The options to create a {@link SendFile} function.
+ *
+ * @group Services/SendFile
+ */
+type SendFileGeneratorOptions = {
+    /**
+     * A dictionary with the dependencies to inject.
+     */
+    inject: {
+        pathUtils: PathUtils;
+    };
+};
+/**
+ * The options for the function that actually serves a file.
+ *
+ * @group Services/SendFile
+ */
+type SendFileOptions = {
+    /**
+     * The response object sent by the application. Necessary to write the file.
+     */
+    res: Response;
+    /**
+     * The path of the file to serve. Depending on the `from` option, it will be either
+     * relative to the project root, or the application executable.
+     */
+    filepath: string;
+    /**
+     * The name of a location on the `pathUtils` service from where the `filepath` is
+     * relative to. It can be `app` for the directory containing the application executable,
+     * or `project` for the project root. It could also be any other location that the
+     * implementation may have registered.
+     *
+     * @default 'app'
+     */
+    from?: string;
+    /**
+     * The function to move to the next middleware. It can be used to report an error in
+     * case the file can't be served.
+     *
+     * @default {() => {}}
+     */
+    next?: NextFunction;
+};
+/**
+ * The type of the function that serves a file.
+ * This is exported to make it easy to type the dependency injection.
+ *
+ * @group Services/SendFile
+ */
+type SendFile = (options: SendFileOptions) => void;
+/**
+ * Generates a function to send files on the application response.
+ *
+ * @param options  To inject the required dependencies.
+ * @example
+ *
+ * <caption>Basic usage</caption>
+ *
+ *   // Let's say this is inside an Express middleware.
+ *   // Get the function
+ *   const send = sendFile(pathUtils);
+ *   send({ res, filepath: 'some-file.html', next });
+ *   // If your app is on "/app/index.js", this will send "/app/some-file.html".
+ *
+ * @group Services
+ * @group Services/SendFile
+ */
+declare const sendFile: ({ inject: { pathUtils } }: SendFileGeneratorOptions) => SendFile;
+/**
+ * The service provider that once registered on the container will set the result of
+ * {@link sendFile} as the `sendFile` service.
+ *
+ * @example
+ *
+ *   // Register it on the container
+ *   container.register(sendFileProvider);
+ *   // Getting access to the service instance
+ *   const sendFile = container.get<SendFile>('sendFile');
+ *
+ * @group Providers
+ * @group Services/SendFile
+ */
+declare const sendFileProvider: _homer0_jimple.Resource<"provider", "register", _homer0_jimple.ProviderRegisterFn<Jimpex>>;
+
+export { SendFile, SendFileGeneratorOptions, SendFileOptions, sendFile, sendFileProvider };

package/dist/services/common/sendFile.js

@@ -0,0 +1,51 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 sendFile_exports = {};
+__export(sendFile_exports, {
+  sendFile: () => sendFile,
+  sendFileProvider: () => sendFileProvider
+});
+module.exports = __toCommonJS(sendFile_exports);
+var import_utils = require("../../utils");
+const sendFile = ({ inject: { pathUtils } }) => ({ res, filepath, from = "app", next = () => {
+} }) => {
+  res.sendFile(pathUtils.joinFrom(from, filepath), (error) => {
+    if (error) {
+      next(error);
+    } else {
+      res.end();
+    }
+  });
+};
+const sendFileProvider = (0, import_utils.provider)((app) => {
+  app.set(
+    "sendFile",
+    () => sendFile({
+      inject: {
+        pathUtils: app.get("pathUtils")
+      }
+    })
+  );
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  sendFile,
+  sendFileProvider
+});
+//# sourceMappingURL=sendFile.js.map

package/dist/services/common/sendFile.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/services/common/sendFile.ts"],"sourcesContent":["import { provider } from '../../utils';\nimport type { Response, NextFunction, PathUtils } from '../../types';\n/**\n * The options to create a {@link SendFile} function.\n *\n * @group Services/SendFile\n */\nexport type SendFileGeneratorOptions = {\n  /**\n   * A dictionary with the dependencies to inject.\n   */\n  inject: {\n    pathUtils: PathUtils;\n  };\n};\n/**\n * The options for the function that actually serves a file.\n *\n * @group Services/SendFile\n */\nexport type SendFileOptions = {\n  /**\n   * The response object sent by the application. Necessary to write the file.\n   */\n  res: Response;\n  /**\n   * The path of the file to serve. Depending on the `from` option, it will be either\n   * relative to the project root, or the application executable.\n   */\n  filepath: string;\n  /**\n   * The name of a location on the `pathUtils` service from where the `filepath` is\n   * relative to. It can be `app` for the directory containing the application executable,\n   * or `project` for the project root. It could also be any other location that the\n   * implementation may have registered.\n   *\n   * @default 'app'\n   */\n  from?: string;\n  /**\n   * The function to move to the next middleware. It can be used to report an error in\n   * case the file can't be served.\n   *\n   * @default {() => {}}\n   */\n  next?: NextFunction;\n};\n/**\n * The type of the function that serves a file.\n * This is exported to make it easy to type the dependency injection.\n *\n * @group Services/SendFile\n */\nexport type SendFile = (options: SendFileOptions) => void;\n/**\n * Generates a function to send files on the application response.\n *\n * @param options  To inject the required dependencies.\n * @example\n *\n * <caption>Basic usage</caption>\n *\n *   // Let's say this is inside an Express middleware.\n *   // Get the function\n *   const send = sendFile(pathUtils);\n *   send({ res, filepath: 'some-file.html', next });\n *   // If your app is on \"/app/index.js\", this will send \"/app/some-file.html\".\n *\n * @group Services\n * @group Services/SendFile\n */\nexport const sendFile =\n  ({ inject: { pathUtils } }: SendFileGeneratorOptions): SendFile =>\n  ({ res, filepath, from = 'app', next = () => {} }) => {\n    res.sendFile(pathUtils.joinFrom(from, filepath), (error) => {\n      if (error) {\n        next(error);\n      } else {\n        res.end();\n      }\n    });\n  };\n\n/**\n * The service provider that once registered on the container will set the result of\n * {@link sendFile} as the `sendFile` service.\n *\n * @example\n *\n *   // Register it on the container\n *   container.register(sendFileProvider);\n *   // Getting access to the service instance\n *   const sendFile = container.get<SendFile>('sendFile');\n *\n * @group Providers\n * @group Services/SendFile\n */\nexport const sendFileProvider = provider((app) => {\n  app.set('sendFile', () =>\n    sendFile({\n      inject: {\n        pathUtils: app.get('pathUtils'),\n      },\n    }),\n  );\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAyB;AAuElB,MAAM,WACX,CAAC,EAAE,QAAQ,EAAE,UAAU,EAAE,MACzB,CAAC,EAAE,KAAK,UAAU,OAAO,OAAO,OAAO,MAAM;AAAC,EAAE,MAAM;AACpD,MAAI,SAAS,UAAU,SAAS,MAAM,QAAQ,GAAG,CAAC,UAAU;AAC1D,QAAI,OAAO;AACT,WAAK,KAAK;AAAA,IACZ,OAAO;AACL,UAAI,IAAI;AAAA,IACV;AAAA,EACF,CAAC;AACH;AAgBK,MAAM,uBAAmB,uBAAS,CAAC,QAAQ;AAChD,MAAI;AAAA,IAAI;AAAA,IAAY,MAClB,SAAS;AAAA,MACP,QAAQ;AAAA,QACN,WAAW,IAAI,IAAI,WAAW;AAAA,MAChC;AAAA,IACF,CAAC;AAAA,EACH;AACF,CAAC;","names":[]}

package/dist/services/frontend/frontendFs.d.mts

@@ -0,0 +1,96 @@
+import * as _homer0_jimple from '@homer0/jimple';
+import { J as Jimpex } from '../../index-efeb437e.js';
+import { PathUtils } from '@homer0/path-utils';
+import fs from 'fs/promises';
+import '../../types/express.mjs';
+import 'express';
+import '../../types/http.mjs';
+import 'https';
+import 'http';
+import 'spdy';
+import 'node-fetch';
+import '../../types/utils.mjs';
+import '@homer0/simple-logger';
+import '@homer0/simple-config';
+import '@homer0/events-hub';
+
+/**
+ * The options to construct a {@link FrontendFs}.
+ *
+ * @group Services/FrontendFs
+ */
+type FrontendFsOptions = {
+    /**
+     * A dictionary with the dependencies to inject.
+     */
+    inject: {
+        pathUtils: PathUtils;
+    };
+};
+/**
+ * This service allows the application to easily work with the filesystem. The idea behind
+ * centralizing this functionalities into a service is that is pretty common to have
+ * bundling tools to generate the frontend, and on that process files can have different
+ * paths or not even be generated all. The service can be extended/overwritten to
+ * accommodate any requirements and avoid having to update or add `if`s to every `fs` call
+ * the application does.
+ * Another _'feature'_ of this service is that all the paths are relative to the directory
+ * where the app executable is located, so you don't have to remember the relative path
+ * from the place you are accessing a file to the place where it's located.
+ *
+ * @group Services
+ * @group Services/FrontendFs
+ */
+declare class FrontendFs {
+    /**
+     * The service that generates the relative paths.
+     */
+    protected readonly _pathUtils: PathUtils;
+    /**
+     * @param options  The options to construct the service.
+     */
+    constructor({ inject: { pathUtils } }: FrontendFsOptions);
+    /**
+     * Deletes a file from the file system.
+     *
+     * @param filepath  The path to the file.
+     */
+    delete(filepath: string): Promise<void>;
+    /**
+     * Reads a file from the file system.
+     *
+     * @param filepath  The path to the file.
+     * @param encoding  The text encoding in which the file should be read.
+     */
+    read(filepath: string, encoding?: BufferEncoding): Promise<string>;
+    /**
+     * Writes a file on the file system.
+     *
+     * @param filepath  The path to the file.
+     * @param content   The contents of the file.
+     */
+    write(filepath: string, content: Parameters<typeof fs.writeFile>[1]): Promise<void>;
+    /**
+     * Utility method to get the path of a file relative to the application executable.
+     *
+     * @param filepath  The path to the file.
+     */
+    protected getAppPath(filepath: string): string;
+}
+/**
+ * The service provider that once registered on the container will set an instance of
+ * {@link FrontendFs} as the `frontendFs` service.
+ *
+ * @example
+ *
+ *   // Register it on the container
+ *   container.register(frontendFsProvider);
+ *   // Getting access to the service instance
+ *   const frontendFs = container.get<FrontendFs>('frontendFs');
+ *
+ * @group Providers
+ * @group Services/FrontendFs
+ */
+declare const frontendFsProvider: _homer0_jimple.Resource<"provider", "register", _homer0_jimple.ProviderRegisterFn<Jimpex>>;
+
+export { FrontendFs, FrontendFsOptions, frontendFsProvider };

package/dist/services/frontend/frontendFs.d.ts

@@ -0,0 +1,96 @@
+import * as _homer0_jimple from '@homer0/jimple';
+import { J as Jimpex } from '../../index-b2a04c78.js';
+import { PathUtils } from '@homer0/path-utils';
+import fs from 'fs/promises';
+import '../../types/express.js';
+import 'express';
+import '../../types/http.js';
+import 'https';
+import 'http';
+import 'spdy';
+import 'node-fetch';
+import '../../types/utils.js';
+import '@homer0/simple-logger';
+import '@homer0/simple-config';
+import '@homer0/events-hub';
+
+/**
+ * The options to construct a {@link FrontendFs}.
+ *
+ * @group Services/FrontendFs
+ */
+type FrontendFsOptions = {
+    /**
+     * A dictionary with the dependencies to inject.
+     */
+    inject: {
+        pathUtils: PathUtils;
+    };
+};
+/**
+ * This service allows the application to easily work with the filesystem. The idea behind
+ * centralizing this functionalities into a service is that is pretty common to have
+ * bundling tools to generate the frontend, and on that process files can have different
+ * paths or not even be generated all. The service can be extended/overwritten to
+ * accommodate any requirements and avoid having to update or add `if`s to every `fs` call
+ * the application does.
+ * Another _'feature'_ of this service is that all the paths are relative to the directory
+ * where the app executable is located, so you don't have to remember the relative path
+ * from the place you are accessing a file to the place where it's located.
+ *
+ * @group Services
+ * @group Services/FrontendFs
+ */
+declare class FrontendFs {
+    /**
+     * The service that generates the relative paths.
+     */
+    protected readonly _pathUtils: PathUtils;
+    /**
+     * @param options  The options to construct the service.
+     */
+    constructor({ inject: { pathUtils } }: FrontendFsOptions);
+    /**
+     * Deletes a file from the file system.
+     *
+     * @param filepath  The path to the file.
+     */
+    delete(filepath: string): Promise<void>;
+    /**
+     * Reads a file from the file system.
+     *
+     * @param filepath  The path to the file.
+     * @param encoding  The text encoding in which the file should be read.
+     */
+    read(filepath: string, encoding?: BufferEncoding): Promise<string>;
+    /**
+     * Writes a file on the file system.
+     *
+     * @param filepath  The path to the file.
+     * @param content   The contents of the file.
+     */
+    write(filepath: string, content: Parameters<typeof fs.writeFile>[1]): Promise<void>;
+    /**
+     * Utility method to get the path of a file relative to the application executable.
+     *
+     * @param filepath  The path to the file.
+     */
+    protected getAppPath(filepath: string): string;
+}
+/**
+ * The service provider that once registered on the container will set an instance of
+ * {@link FrontendFs} as the `frontendFs` service.
+ *
+ * @example
+ *
+ *   // Register it on the container
+ *   container.register(frontendFsProvider);
+ *   // Getting access to the service instance
+ *   const frontendFs = container.get<FrontendFs>('frontendFs');
+ *
+ * @group Providers
+ * @group Services/FrontendFs
+ */
+declare const frontendFsProvider: _homer0_jimple.Resource<"provider", "register", _homer0_jimple.ProviderRegisterFn<Jimpex>>;
+
+export { FrontendFs, FrontendFsOptions, frontendFsProvider };