@podium/podlet 5.0.0 → 5.0.2

package/types/podlet.d.ts

@@ -0,0 +1,663 @@
+/**
+ * @typedef {(...args: any) => void} LogFunction
+ * @typedef {{ trace: LogFunction, debug: LogFunction, info: LogFunction, warn: LogFunction, error: LogFunction, fatal: LogFunction }} AbsLogger
+ *
+ * @typedef {Object} PodletOptions
+ * @property {string} name - (required) podlet name
+ * @property {string} version - (required) podlet version
+ * @property {string} pathname - (required) podlet pathname
+ * @property {string} [manifest] - path where the podlet manifest file is served from (default '/manifest.json')
+ * @property {string} [content] - path where the podlet content HTML markup is served from (default '/')
+ * @property {string} [fallback] - path where the podlet fallback HTML markup is served from (default '/fallback')
+ * @property {boolean} [development] - a boolean flag that, when true, enables additional development setup (default false)
+ * @property {Console | AbsLogger} [logger] - a logger to use when provided. Can be the console object if console logging is desired but can also be any Log4j compatible logging object as well. Nothing is logged if no logger is provided. (default null)
+ * @property {import("@podium/proxy").default.PodiumProxyOptions} proxy - options that can be provided to configure the @podium/proxy instance used by the podlet. See that module for details.
+ *
+ * @typedef {{ debug: 'true' | 'false', locale: string, deviceType: string, requestedBy: string, mountOrigin: string, mountPathname: string, publicPathname: string }} PodletContext
+ * @typedef {{ as?: string | false | null, crossorigin?: string | null | boolean, disabled?: boolean | '' | null, hreflang?: string | false | null, title?: string | false | null, media?: string | false | null, rel?: string | false | null, type?: string | false | null, value: string | false | null, data?: Array<{ key: string; value: string }>, strategy?: "beforeInteractive" | "afterInteractive" | "lazy", scope?: "content" | "fallback" | "all", [key: string]: any }} AssetCssLike
+ * @typedef {{ value: string | null, crossorigin?: string | null | boolean, type?: string | null | false, integrity?: string | null | false, referrerpolicy?: string | null | false, nomodule?: boolean | null | '', async?: boolean | null | '', defer?: boolean | null | '', data?: Array<{ key: string; value: string }>, strategy?: "beforeInteractive" | "afterInteractive" | "lazy", scope?: "content" | "fallback" | "all", [key: string]: any }} AssetJsLike
+ */
+export default class PodiumPodlet {
+    /**
+     * Creates a new instance of a Podium podlet which can be used in conjunction with your framework of choice to build podlet server apps.
+     * `name`, `version` and `pathname` constructor arguments are required. All other options are optional.
+     *
+     * * `name` - podlet name (**required**)
+     * * `version` - podlet version (**required**)
+     * * `pathname` - podlet pathname (**required**)
+     * * `manifest` - path where the podlet manifest file is served from (**default** `'/manifest.json'`)
+     * * `content` - path where the podlet content HTML markup is served from (**default** `'/'`)
+     * * `fallback` - path where the podlet fallback HTML markup is served from (**default** `'/fallback'`)
+     * * `development` - a boolean flag that, when true, enables additional development setup (**default** `false`)
+     * * `logger` - a logger to use when provided. Can be the console object if console logging is desired but can also be any Log4j compatible logging object as well. Nothing is logged if no logger is provided. (**default** `null`)
+     * * `proxy` - options that can be provided to configure the @podium/proxy instance used by the podlet. See that module for details. (**default**: `{}`)
+     *
+     * @see https://podium-lib.io/docs/api/podlet/#constructor
+     * @see https://podium-lib.io/docs/podlet/getting_started
+     *
+     * @param {PodletOptions} options
+     *
+     * @example
+     * ```
+     * const podlet = new Podlet({ name: 'foo', version: '1.0.0', pathname: '/' });
+     * ```
+     */
+    constructor({ name, version, pathname, manifest, fallback, content, logger, development, proxy, }: PodletOptions);
+    /**
+     * The name that the podlet identifies itself by. (set in the constructor) This is used internally for things like metrics but can also be used by a layout server.
+     * This value must be in camelCase.
+     *
+     * @see https://podium-lib.io/docs/api/podlet/#name
+     *
+     * @example ```js
+     * const podlet = new Podlet({ name: 'foo', ... });
+     * podlet.name // foo
+     * ```
+     */
+    name: string;
+    /**
+     * The current version of the podlet. (set in the constructor)
+     * It is important that this value be updated when a new version of the podlet is deployed since the page (layout)
+     * that the podlet is displayed in uses this value to know whether to refresh the podlet's manifest and fallback content or not.
+     *
+     * @see https://podium-lib.io/docs/api/podlet/#version
+     *
+     * @example ```js
+     * const podlet = new Podlet({ version: '1.0.0', ... });
+     * podlet.version // 1.0.0
+     * ```
+     */
+    version: string;
+    /**
+     * The podlet development property (set in the constructor)
+     * Used to make podlet development simple without the need to run a layout server locally
+     * Do not run a podlet in development mode when deploying to production.
+     *
+     * @see https://podium-lib.io/docs/api/podlet/#development
+     * @see https://podium-lib.io/docs/api/podlet/#development-mode
+     *
+     * @example ```js
+     * const podlet = new Podlet({ development: true, ... });
+     * podlet.development // true
+     * ```
+     */
+    development: boolean;
+    /**
+     * A logger. The abstract logger "Abslog" is used to make it possible to provide different kinds of loggers.
+     * The logger can be provided via the 'logger' constructor argument.
+     *
+     * @see https://www.npmjs.com/package/abslog
+     *
+     * @example ```js
+     * const podlet = new Podlet({ logger: console, ... });
+     * podlet.log.trace('trace log to the console')
+     * podlet.log.debug('debug log to the console')
+     * podlet.log.info('info log to the console')
+     * podlet.log.warn('warn log to the console')
+     * podlet.log.error('error log to the console')
+     * podlet.log.fatal('fatal log to the console')
+     * ```
+     *
+     * @type {AbsLogger}
+     */
+    log: AbsLogger;
+    /**
+     * An instance of the `@podium/proxy` module
+     * @see https://github.com/podium-lib/proxy
+     */
+    httpProxy: Proxy;
+    /**
+     * The pathname for the manifest of the podlet. Defaults to /manifest.json. (set in the constructor)
+     * The value should be relative to the value set on the pathname argument.
+     * In other words if a podlet is mounted into an HTTP server at /foo and the manifest is at /foo/component.json, pathname will be /foo and manifestRoute will be /component.json
+     *
+     * @see https://podium-lib.io/docs/api/podlet/#manifest
+     *
+     * @example ```js
+     * const podlet = new Podlet({ manifest: '/manifest.json', ... });
+     * podlet.manifestRoute // /manifest.json
+     * ```
+     */
+    manifestRoute: string;
+    /**
+     * The pathname for the content route of the podlet. Defaults to /. (set in the constructor)
+     * The value should be relative to the value set on the pathname argument.
+     * In other words if a podlet is mounted into an HTTP server at /foo and the content is at /foo/content, pathname will be /foo and contentRoute will be /content
+     *
+     * @see https://podium-lib.io/docs/api/podlet/#content
+     *
+     * @example ```js
+     * const podlet = new Podlet({ content: '/foo', ... });
+     * podlet.contentRoute // /foo
+     * ```
+     */
+    contentRoute: string;
+    /**
+     * The pathname for the fallback route of the podlet. Defaults to /fallback. (set in the constructor)
+     * The value should be relative to the value set on the pathname argument.
+     * In other words if a podlet is mounted into an HTTP server at /foo and the fallback is at /foo/fallback, pathname will be /foo and fallbackRoute will be /fallback
+     *
+     * @see https://podium-lib.io/docs/api/podlet/#fallback
+     *
+     * @example ```js
+     * const podlet = new Podlet({ fallback: '/fallback', ... });
+     * podlet.fallbackRoute // /fallback
+     * ```
+     */
+    fallbackRoute: string;
+    /**
+     * An object that holds information about defined proxy routes. Proxy routes are defined using the podlet.proxy(...) method and up to 4 proxy routes
+     * may be defined per podlet.
+     *
+     * @see https://podium-lib.io/docs/api/podlet#proxy-target-name-
+     * @see https://podium-lib.io/docs/podlet/proxying
+     *
+     * @example ```js
+     * const podlet = new Podlet({ ... });
+     * podlet.proxy({ target: '/api', name: 'api' })
+     * podlet.proxyRoutes // { api: '/api' }
+     * ```
+     *
+     * @type {Record<string, string>}
+     */
+    proxyRoutes: Record<string, string>;
+    /**
+     * An object containing a set of Podium context values configured for podlet development.
+     * This is necessary when the podlet is in development mode because requests do not come from a layout (which is what normally sends the context information)
+     * These base context values can be overridden by providing a default context using the podlet.defaults() method
+     * in which case the baseContext and the defaultContext will be merged together to provide the development context object.
+     * This is not used at all when the podlet is not in development mode or when it is in development mode but the request to the podlet comes from a Podium layout.
+     *
+     * @see https://podium-lib.io/docs/podlet/context
+     * @see https://podium-lib.io/docs/api/podlet#development-mode
+     * @see https://podium-lib.io/docs/api/podlet#defaultscontext
+     *
+     * @example ```js
+     * const podlet = new Podlet({ name: 'foo', pathname: '/bar', ... });
+     * podlet.baseContext; // { debug: 'false', locale: 'en-US', deviceType: 'desktop', requestedBy: this.name, mountOrigin: '', mountPathname: '/bar', publicPathname: '/bar/podium-resource/foo' }
+     * ```
+     *
+     * @type {PodletContext}
+     */
+    baseContext: PodletContext;
+    /**
+     * An object containing a set of Podium context values configured for podlet development.
+     * This is necessary when the podlet is in development mode because requests do not come from a layout (which is what normally sends the context information)
+     * These default context values override the `baseContext` values set by the package and can be set using the podlet.defaults() method
+     * in which case the baseContext and the defaultContext will be merged together to provide the development context object.
+     * This is not used at all when the podlet is not in development mode or when it is in development mode but the request to the podlet comes from a Podium layout.
+     *
+     * @see https://podium-lib.io/docs/podlet/context
+     * @see https://podium-lib.io/docs/api/podlet#development-mode
+     * @see https://podium-lib.io/docs/api/podlet#defaultscontext
+     *
+     * @example ```js
+     * const podlet = new Podlet({ name: 'foo', pathname: '/bar', ... });
+     * podlet.defaults({ debug: 'true', locale: 'nb' });
+     * podlet.baseContext; // { debug: 'true', locale: 'nb', deviceType: 'desktop', requestedBy: this.name, mountOrigin: '', mountPathname: '/bar', publicPathname: '/bar/podium-resource/foo' }
+     * ```
+     *
+     * @type {PodletContext}
+     */
+    defaultContext: PodletContext;
+    /**
+     * Property that holds the podlet's CSS asset references. Objects in the array are AssetCss instances. Asset references can be added using the podlet.css() method.
+     *
+     * @see https://podium-lib.io/docs/api/podlet/#cssoptionsoptions
+     * @see https://podium-lib.io/docs/api/assets#assetcss
+     * @see https://podium-lib.io/docs/api/assets
+     *
+     * @example ```js
+     * const podlet = new Podlet({ ... });
+     * podlet.css({ value: 'https://my.assets.com/styles.css' });
+     * podlet.cssRoute // [ AssetCss{ value: 'https://my.assets.com/styles.css' } ]
+     * ```
+     *
+     * @type {AssetCss[]}
+     */
+    cssRoute: AssetCss[];
+    /**
+     * Property that holds the podlet's JS asset references. Objects in the array are AssetJs instances. Asset references can be added using the podlet.js() method.
+     *
+     * @see https://podium-lib.io/docs/api/podlet/#jsoptionsoptions
+     * @see https://podium-lib.io/docs/api/assets#assetjs
+     * @see https://podium-lib.io/docs/api/assets
+     *
+     * @example ```js
+     * const podlet = new Podlet({ ... });
+     * podlet.js({ value: 'https://my.assets.com/scripts.js' });
+     * podlet.jsRoute // [ AssetJs{ value: 'https://my.assets.com/scripts.js' } ]
+     * ```
+     *
+     * @type {AssetJs[]}
+     */
+    jsRoute: AssetJs[];
+    /**
+     * Metrics client stream object that can be used to consume metrics out of a Podium podlet.
+     * @see https://www.npmjs.com/package/@metrics/client for detailed documentation
+     *
+     * @example
+     * ```js
+     * const podlet = new Podlet(...);
+     * podlet.metrics.pipe(...);
+     * // or
+     * podlet.metrics.on('data', chunk => { ... });
+     * ```
+     */
+    metrics: Metrics;
+    /**
+     * Method that returns the pathname for where a podlet is mounted in an HTTP server.
+     * It is important that this value matches where the entry point of a route is in an HTTP server since
+     * this value is used to define where the manifest is for the podlet.
+     * (set in the constructor)
+     *
+     * @see https://podium-lib.io/docs/api/podlet/#pathname
+     *
+     * @example
+     * The method returns the value of `pathname` as defined in the podlet constructor
+     * ```js
+     * const podlet = new Podlet({ pathname: '/foo', ... });
+     * podlet.pathname() // /foo
+     * ```
+     *
+     * @example
+     * This method is typically used when defining routes to ensure the pathname is prepended to any routes
+     * ```js
+     * const podlet = new Podlet({ pathname: '/foo', content: '/bar', ... });
+     * app.get(podlet.pathname() + '/bar', (req, res) => res.podiumSend(...));
+     * ```
+     */
+    pathname(): string;
+    /**
+     * Method that returns the pathname for where a podlet's manifest route is to be mounted.
+     * By default the podlet's pathname value is prepended to the manifest value.
+     *
+     * @example
+     * Prefix is true by default which will prepend the pathname (/foo) in this example
+     * ```js
+     * const podlet = new Podlet({ pathname: '/foo', manifest: '/manifest.json', ... });
+     * podlet.manifest() // /foo/manifest.json
+     * podlet.manifest({ prefix: false }) // /manifest.json
+     * ```
+     *
+     * @example
+     * This method is typically used when defining the manifest route
+     * ```js
+     * const podlet = new Podlet({ ... });
+     * app.get(podlet.manifest(), (req, res) => res.send(podlet));
+     * ```
+     *
+     * @param {{ prefix?: boolean }} [options]
+     * @returns {string}
+     */
+    manifest({ prefix }?: {
+        prefix?: boolean;
+    }): string;
+    /**
+     * Method that returns the pathname for where a podlet's content route is to be mounted.
+     * By default the podlet's pathname value is prepended to the content value.
+     *
+     * @example
+     * Prefix is true by default which will prepend the pathname (/foo) in this example
+     * ```js
+     * const podlet = new Podlet({ pathname: '/foo', content: '/', ... });
+     * podlet.content() // /foo
+     * podlet.content({ prefix: false }) // /
+     * ```
+     *
+     * @example
+     * This method is typically used when defining the content route
+     * ```js
+     * const podlet = new Podlet({ ... });
+     * app.get(podlet.content(), (req, res) => res.podiumSend(...));
+     * ```
+     *
+     * @param {{ prefix?: boolean }} [options]
+     * @returns {string}
+     */
+    content({ prefix }?: {
+        prefix?: boolean;
+    }): string;
+    /**
+     * Method that returns the pathname for where a podlet's fallback route is to be mounted.
+     * By default the podlet's pathname value is prepended to the fallback value.
+     *
+     * @example
+     * Prefix is true by default which will prepend the pathname (/foo) in this example
+     * ```js
+     * const podlet = new Podlet({ pathname: '/foo', fallback: '/fallback', ... });
+     * podlet.fallback() // /foo/fallback
+     * podlet.fallback({ prefix: false }) // /fallback
+     * ```
+     *
+     * @example
+     * This method is typically used when defining the fallback route
+     * ```js
+     * const podlet = new Podlet({ ... });
+     * app.get(podlet.fallback(), (req, res) => res.podiumSend(...));
+     * ```
+     *
+     * @param {{ prefix?: boolean }} [options]
+     * @returns {string}
+     */
+    fallback({ prefix }?: {
+        prefix?: boolean;
+    }): string;
+    /**
+     * Method used to set CSS asset references for a podlet. Accepts an AssetCss object, a plain JS object with the same properties as an AssetCss object or
+     * an array containing AssetCss or plain JS objects. Asset references set in this way can be accessed via `podlet.cssRoute` and
+     * will be added to the podlet manifest file for sending to the layout
+     *
+     * @see https://podium-lib.io/docs/api/podlet/#cssoptionsoptions
+     * @see https://podium-lib.io/docs/api/assets#assetcss
+     * @see https://podium-lib.io/docs/api/assets
+     *
+     * @example ```js
+     * const podlet = new Podlet({ ... });
+     * podlet.css(new AssetCss{ value: 'https://my.assets.com/styles.css' });
+     * podlet.css({ value: 'https://my.assets.com/styles.css' });
+     * podlet.css([new AssetCss{ value: 'https://my.assets.com/styles.css' }, { value: 'https://my.assets.com/styles.css' }]);
+     * ```
+     *
+     * @param { AssetCss | AssetCss[] | AssetCssLike | AssetCssLike[] } options
+     * @returns {void}
+     */
+    css(options: AssetCss | AssetCss[] | AssetCssLike | AssetCssLike[]): void;
+    /**
+     * Method used to set JS asset references for a podlet. Accepts an AssetJs object, a plain JS object with the same properties as an AssetJs object or
+     * an array containing AssetJs or plain JS objects. Asset references set in this way can be accessed via `podlet.jsRoute` and
+     * will be added to the podlet manifest file for sending to the layout
+     *
+     * @see https://podium-lib.io/docs/api/podlet/#jsoptionsoptions
+     * @see https://podium-lib.io/docs/api/assets#assetjs
+     * @see https://podium-lib.io/docs/api/assets
+     *
+     * @example ```js
+     * const podlet = new Podlet({ ... });
+     * podlet.js(new AssetJs{ value: 'https://my.assets.com/scripts.js' });
+     * podlet.js({ value: 'https://my.assets.com/scripts.js' });
+     * podlet.js([new AssetJs{ value: 'https://my.assets.com/scripts.js' }, { value: 'https://my.assets.com/scripts.js' }]);
+     * ```
+     *
+     * @param {AssetJs | AssetJs[] | AssetJsLike | AssetJsLike[] } [options]
+     * @returns {void}
+     */
+    js(options?: AssetJs | AssetJs[] | AssetJsLike | AssetJsLike[]): void;
+    /**
+     * Method for defining proxy targets to be mounted in a layout server.
+     * Accepts an object with `target` and `name` keys where target is the relative or absolute path to proxy requests to and name is an identifier
+     * to distinguish it from other proxy endpoints. It's common to define a target of "/api" and a name of just "api". The method returns the target so that
+     * it's possible to both define the proxy and the route at the same time.
+     *
+     * For a detailed overview of how proxying works, please see the proxying guide for further details.
+     *
+     * @see https://podium-lib.io/docs/podlet/proxying
+     * @see https://podium-lib.io/docs/api/podlet#proxy-target-name-
+     *
+     * @example
+     * ```js
+     * podlet.proxy({ name: 'api', target: '/api' }); // returns /api
+     * ```
+     *
+     * @example
+     * Define the proxy and route at the same time
+     * ```js
+     * // proxy mounted at /api in the app
+     * app.get(podlet.proxy({ name: 'api', target: '/api' }), (req, res) => res.sendStatus(200));
+     * ```
+     *
+     * @param {{ target: string; name: string }} options
+     * @returns {string}
+     */
+    proxy({ target, name }: {
+        target: string;
+        name: string;
+    }): string;
+    /**
+     * Method to alter the default context set when in development mode.
+     * In a production setup, this is not necessary since the context values are sent to the podlet from the layout.
+     * By default, the context will contain the following context values, all of which can be overridden.
+     *
+     * * `debug:` 'false',
+     * * `locale:` 'en-EN',
+     * * `deviceType:` 'desktop',
+     * * `requestedBy:` '<podlet name>',
+     * * `mountOrigin:` 'http://localhost:port',
+     * * `mountPathname:` '/<podlet pathname>',
+     * * `publicPathname:` '/:pathname/podium_resource/:manifestname',
+     *
+     * @see https://podium-lib.io/docs/api/podlet#defaultscontext
+     *
+     * @example
+     * Example of overriding deviceType
+     * ```js
+     * const podlet = new Podlet({ ... });
+     * podlet.defaults({ deviceType: 'mobile' });
+     * ```
+     *
+     * @param {any} context
+     * @returns {any}
+     */
+    defaults(context?: any): any;
+    /**
+     * Method to set a Podium document template to be used when the podlet is in development mode.
+     * Must be used in conjunction with with the `.podiumSend()` method or the `podlet.render()` in the content/fallback route to have any effect.
+     * Has no effect when the podlet is not in development mode or if a request to the podlet comes from a Podium layout.
+     *
+     * @see https://podium-lib.io/docs/api/document
+     *
+     * @example
+     * A document template can be provided using the podlet.view method
+     * ```js
+     * const podlet = new Podlet({ ... });
+     * podlet.view(myDocumentTemplate);
+     * ```
+     *
+     * @example
+     * You need to call podiumSend or podlet.render to make use of the template you provided with podlet.view
+     * ```js
+     * app.get(podlet.content(), (req, res) => {
+     *  res.podiumSend(`...podlet markup here...`);
+     *  // or
+     *  podlet.render(res.locals.podium, `...podlet markup here...`)
+     * });
+     * ```
+     *
+     * @template {{ [key: string]: unknown }} T
+     * @param {( incoming: HttpIncoming<T>, fragment: string, ...args: unknown[]) => string} fn
+     * @returns {void}
+     */
+    view<T extends {
+        [key: string]: unknown;
+    }>(fn: (incoming: HttpIncoming<T>, fragment: string, ...args: unknown[]) => string): void;
+    /**
+     * Method for serialising the podlet instance into a plain JS object. Called automatically when stringifying the podlet with JSON.stringify(podlet).
+     * Doing so will result in a correct Podium manifest file string and so is suitable for usage in a manifest route hook.
+     *
+     * @see https://podium-lib.io/docs/podlet/getting_started#step-7-create-a-manifest-route
+     *
+     * @example
+     * ```js
+     * app.get(podlet.manifest(), (req, res) => res.send(JSON.stringify(podlet)));
+     * ```
+     *
+     * @example
+     * In frameworks that automatically serialise JS objects, such as Express, you can omit JSON.stringify
+     * ```js
+     * app.get(podlet.manifest(), (req, res) => res.send(podlet));
+     * ```
+     */
+    toJSON(): {
+        name: string;
+        version: string;
+        content: string;
+        fallback: string;
+        css: AssetCss[];
+        js: AssetJs[];
+        proxy: Record<string, string>;
+    };
+    /**
+     * Method to render the document template. Will, by default, render the document template provided by Podium unless a custom document template is set using the .view method.
+     * In most HTTP frameworks this method can be ignored in favour of res.podiumSend().
+     * If present, res.podiumSend() has the advantage that it's not necessary to pass in an HttpIncoming object as the first argument.
+     *
+     * @see https://podium-lib.io/docs/api/podlet#renderhttpincoming-fragment-args
+     *
+     * @example
+     * ```js
+     * app.get(podlet.content(), (req, res) => {
+     *     const incoming = res.locals.podium;
+     *     const document = podlet.render(incoming, '<div>content to render</div>');
+     *     res.send(document);
+     * });
+     * ```
+     *
+     * @template {{ [key: string]: unknown }} T
+     * @param {HttpIncoming<T>} incoming - Instance of Podium HttpIncoming object
+     * @param {string} data - the podlet content as an HTML markup string
+     * @param  {...any} args - additional args depending on the template and what values it accepts
+     * @returns {string}
+     */
+    render<T_1 extends {
+        [key: string]: unknown;
+    }>(incoming: HttpIncoming<T_1>, data: string, ...args: any[]): string;
+    /**
+     * Method for processing an incoming HTTP request. This method is intended to be used to implement support for multiple HTTP frameworks and in most cases will not need to be used directly by podlet developers when creating podlet servers.
+     *
+     * What it does:
+     * * Handles detection of development mode and sets the appropriate defaults
+     * * Runs context deserializing on the incoming request and sets a context object at HttpIncoming.context.
+     * * Returns an HttpIncoming object.
+     *
+     * @see https://podium-lib.io/docs/api/podlet#processhttpincoming
+     *
+     * @param {HttpIncoming} incoming
+     * @param {{ proxy?: boolean }} [options]
+     * @returns {Promise<HttpIncoming>}
+     */
+    process(incoming: HttpIncoming, { proxy }?: {
+        proxy?: boolean;
+    }): Promise<HttpIncoming>;
+    /**
+     * A Connect/Express compatible middleware function which takes care of the multiple operations needed for a podlet to operate correctly. This function is more or less a wrapper for the .process() method.
+     * Returns an array of middleware that will create an HttpIncoming object and store it at res.locals.podium.
+     *
+     * **Important:** *This middleware must be mounted before defining any routes.*
+     *
+     * @see https://podium-lib.io/docs/api/podlet#middleware
+     *
+     * @example
+     * ```js
+     * const app = express();
+     * app.use(podlet.middleware());
+     * ```
+     *
+     * @returns {(req: any, res: any, next: function) => Promise<void>}
+     */
+    middleware(): (req: any, res: any, next: Function) => Promise<void>;
+    get [Symbol.toStringTag](): string;
+    #private;
+}
+export type LogFunction = (...args: any) => void;
+export type AbsLogger = {
+    trace: LogFunction;
+    debug: LogFunction;
+    info: LogFunction;
+    warn: LogFunction;
+    error: LogFunction;
+    fatal: LogFunction;
+};
+export type PodletOptions = {
+    /**
+     * - (required) podlet name
+     */
+    name: string;
+    /**
+     * - (required) podlet version
+     */
+    version: string;
+    /**
+     * - (required) podlet pathname
+     */
+    pathname: string;
+    /**
+     * - path where the podlet manifest file is served from (default '/manifest.json')
+     */
+    manifest?: string;
+    /**
+     * - path where the podlet content HTML markup is served from (default '/')
+     */
+    content?: string;
+    /**
+     * - path where the podlet fallback HTML markup is served from (default '/fallback')
+     */
+    fallback?: string;
+    /**
+     * - a boolean flag that, when true, enables additional development setup (default false)
+     */
+    development?: boolean;
+    /**
+     * - a logger to use when provided. Can be the console object if console logging is desired but can also be any Log4j compatible logging object as well. Nothing is logged if no logger is provided. (default null)
+     */
+    logger?: Console | AbsLogger;
+    /**
+     * - options that can be provided to configure the
+     */
+    proxy: import("@podium/proxy").default.PodiumProxyOptions;
+};
+export type PodletContext = {
+    debug: 'true' | 'false';
+    locale: string;
+    deviceType: string;
+    requestedBy: string;
+    mountOrigin: string;
+    mountPathname: string;
+    publicPathname: string;
+};
+export type AssetCssLike = {
+    [key: string]: any;
+    as?: string | false | null;
+    crossorigin?: string | null | boolean;
+    disabled?: boolean | '' | null;
+    hreflang?: string | false | null;
+    title?: string | false | null;
+    media?: string | false | null;
+    rel?: string | false | null;
+    type?: string | false | null;
+    value: string | false | null;
+    data?: Array<{
+        key: string;
+        value: string;
+    }>;
+    strategy?: "beforeInteractive" | "afterInteractive" | "lazy";
+    scope?: "content" | "fallback" | "all";
+};
+export type AssetJsLike = {
+    [key: string]: any;
+    value: string | null;
+    crossorigin?: string | null | boolean;
+    type?: string | null | false;
+    integrity?: string | null | false;
+    referrerpolicy?: string | null | false;
+    nomodule?: boolean | null | '';
+    async?: boolean | null | '';
+    defer?: boolean | null | '';
+    data?: Array<{
+        key: string;
+        value: string;
+    }>;
+    strategy?: "beforeInteractive" | "afterInteractive" | "lazy";
+    scope?: "content" | "fallback" | "all";
+};
+import Proxy from '@podium/proxy';
+import { AssetCss } from '@podium/utils';
+import { AssetJs } from '@podium/utils';
+import Metrics from '@metrics/client';
+import { HttpIncoming } from '@podium/utils';
+declare global {
+  namespace Express {
+    interface Response {
+      podiumSend(fragment: string, ...args: unknown[]): Response;
+    }
+  }
+}