@podium/client 5.0.21 → 5.0.23

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [5.0.23](https://github.com/podium-lib/client/compare/v5.0.22...v5.0.23) (2024-05-15)
+
+
+### Bug Fixes
+
+* make response toJSON return type serializable ([026a723](https://github.com/podium-lib/client/commit/026a723b545c6b3b0c622851b7d164be2674e8a2))
+
+## [5.0.22](https://github.com/podium-lib/client/compare/v5.0.21...v5.0.22) (2024-05-15)
+
+
+### Bug Fixes
+
+* generate type definitions before publish ([8189b01](https://github.com/podium-lib/client/commit/8189b01c54c733c760b02f2138803f9b64a6fee5))
+
 ## [5.0.21](https://github.com/podium-lib/client/compare/v5.0.20...v5.0.21) (2024-05-14)
 
 

package/lib/response.js

@@ -59,8 +59,8 @@ export default class PodiumClientResponse {
             redirect: this.redirect,
             content: this.content,
             headers: this.headers,
-            css: this.css,
-            js: this.js,
+            css: this.css.map((a) => a.toJSON()),
+            js: this.js.map((a) => a.toJSON()),
         };
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@podium/client",
-  "version": "5.0.21",
+  "version": "5.0.23",
   "type": "module",
   "license": "MIT",
   "keywords": [

package/types/client.d.ts

@@ -0,0 +1,110 @@
+/// <reference types="node" resolution-mode="require"/>
+/**
+ * @typedef {import('./resource.js').default} PodiumClientResource
+ * @typedef {import('./resource.js').PodiumClientResourceOptions} PodiumClientResourceOptions
+ * @typedef {import('./response.js').default} PodiumClientResponse
+ * @typedef {import('./http-outgoing.js').PodiumRedirect} PodiumRedirect
+ * @typedef {import('@podium/schemas').PodletManifestSchema} PodletManifest
+ */
+/**
+ * @typedef {object} PodiumClientOptions
+ * @property {string} name
+ * @property {import('abslog').AbstractLoggerOptions} [logger]
+ * @property {number} [retries=4]
+ * @property {number} [timeout=1000] In milliseconds
+ * @property {number} [maxAge=Infinity]
+ * @property {boolean} [rejectUnauthorized=true]
+ * @property {number} [resolveThreshold]
+ * @property {number} [resolveMax]
+ * @property {import('http').Agent} [httpAgent]
+ * @property {import('https').Agent} [httpsAgent]
+ */
+/**
+ * @typedef {object} RegisterOptions
+ * @property {string} name A unique name for the podlet
+ * @property {string} uri URL to the podlet's `manifest.json`
+ * @property {number} [retries=4] Number of retries before serving fallback
+ * @property {number} [timeout=1000] In milliseconds, the amount of time to wait before serving fallback.
+ * @property {boolean} [throwable=false] Set to `true` and surround `fetch` in `try/catch` to serve different content in case podlet is unavailable. Will not server fallback content.
+ * @property {boolean} [redirectable=false] Set to `true` to allow podlet to respond with a redirect. You need to look for the redirect response from the podlet and return a redirect response to the browser yourself.
+ */
+export default class PodiumClient extends EventEmitter<[never]> {
+    /**
+     * @constructor
+     * @param {PodiumClientOptions} options
+     */
+    constructor(options?: PodiumClientOptions);
+    get registry(): any;
+    get metrics(): Metrics;
+    get state(): "instantiated" | "stable" | "initializing" | "unhealthy" | "unstable";
+    /**
+     * Register a podlet so you can fetch its contents later with {@link PodiumClientResource.fetch}.
+     *
+     * @param {RegisterOptions} options
+     * @returns {PodiumClientResource}
+     *
+     * @example
+     * ```js
+     * const headerPodlet = layout.client.register({
+     *   name: 'header',
+     *   uri: 'http://header/manifest.json',
+     * });
+     * ```
+     */
+    register(options: RegisterOptions): PodiumClientResource;
+    dump(): any;
+    load(dump: any): any;
+    /**
+     * Refreshes the cached podlet manifest for all {@link register}ed podlets.
+     */
+    refreshManifests(): Promise<void>;
+    #private;
+}
+export type PodiumClientResource = import('./resource.js').default;
+export type PodiumClientResourceOptions = import('./resource.js').PodiumClientResourceOptions;
+export type PodiumClientResponse = import('./response.js').default;
+export type PodiumRedirect = import('./http-outgoing.js').PodiumRedirect;
+export type PodletManifest = import('@podium/schemas').PodletManifestSchema;
+export type PodiumClientOptions = {
+    name: string;
+    logger?: import('abslog').AbstractLoggerOptions;
+    retries?: number;
+    /**
+     * In milliseconds
+     */
+    timeout?: number;
+    maxAge?: number;
+    rejectUnauthorized?: boolean;
+    resolveThreshold?: number;
+    resolveMax?: number;
+    httpAgent?: import('http').Agent;
+    httpsAgent?: import('https').Agent;
+};
+export type RegisterOptions = {
+    /**
+     * A unique name for the podlet
+     */
+    name: string;
+    /**
+     * URL to the podlet's `manifest.json`
+     */
+    uri: string;
+    /**
+     * Number of retries before serving fallback
+     */
+    retries?: number;
+    /**
+     * In milliseconds, the amount of time to wait before serving fallback.
+     */
+    timeout?: number;
+    /**
+     * Set to `true` and surround `fetch` in `try/catch` to serve different content in case podlet is unavailable. Will not server fallback content.
+     */
+    throwable?: boolean;
+    /**
+     * Set to `true` to allow podlet to respond with a redirect. You need to look for the redirect response from the podlet and return a redirect response to the browser yourself.
+     */
+    redirectable?: boolean;
+};
+import EventEmitter from 'events';
+import Metrics from '@metrics/client';

package/types/http-outgoing.d.ts

@@ -0,0 +1,177 @@
+/**
+ * @typedef {object} PodiumClientHttpOutgoingOptions
+ * @property {string} name
+ * @property {string} uri To the podlet's `manifest.json`
+ * @property {number} timeout In milliseconds
+ * @property {number} maxAge
+ * @property {number} [retries=4]
+ * @property {boolean} [throwable=false]
+ * @property {boolean} [redirectable=false]
+ * @property {boolean} [rejectUnauthorized=true]
+ * @property {import('http').Agent} [httpAgent]
+ * @property {import('https').Agent} [httpsAgent]
+ */
+/**
+ * @typedef {object} PodiumClientResourceOptions
+ * @property {string} [pathname]
+ * @property {import('http').IncomingHttpHeaders} [headers]
+ * @property {object} [query]
+ */
+/**
+ * @typedef {object} PodiumRedirect
+ * @property {number} statusCode;
+ * @property {string} location;
+ */
+/**
+ * @typedef {object} PodletProxySchema
+ * @property {string} target
+ * @property {string} name
+ */
+/**
+ * @typedef {object} PodletManifest Similar to the schema's manifest, but with instances of AssetCss and AssetJs from `@podium/utils` and default values.
+ * @property {string} name
+ * @property {string} version
+ * @property {string} content
+ * @property {string} fallback
+ * @property {Array<import('@podium/utils').AssetJs>} js
+ * @property {Array<import('@podium/utils').AssetCss>} css
+ * @property {Record<string, string> | Array<PodletProxySchema>} proxy
+ * @property {string} team
+ */
+export default class PodletClientHttpOutgoing extends PassThrough {
+    /**
+     * @constructor
+     * @param {PodiumClientHttpOutgoingOptions} options
+     * @param {PodiumClientResourceOptions} [reqOptions]
+     * @param {import('@podium/utils').HttpIncoming} [incoming]
+     */
+    constructor(options?: PodiumClientHttpOutgoingOptions, reqOptions?: PodiumClientResourceOptions, incoming?: import('@podium/utils').HttpIncoming);
+    get rejectUnauthorized(): boolean;
+    get reqOptions(): {
+        pathname: string;
+        headers: import('http').IncomingHttpHeaders;
+        query: object;
+    };
+    get throwable(): boolean;
+    set manifest(obj: PodletManifest);
+    get manifest(): PodletManifest;
+    set fallback(value: any);
+    get fallback(): any;
+    get timeout(): number;
+    set success(value: boolean);
+    get success(): boolean;
+    get context(): {};
+    set headers(value: {});
+    get headers(): {};
+    set maxAge(value: number);
+    get maxAge(): number;
+    set status(value: "empty" | "fresh" | "cached" | "stale");
+    /**
+     * What status the manifest is in. This is used to tell what actions need to
+     * be performed throughout the resolving process to complete a request.
+     *
+     * The different statuses can be:
+     *  - `"empty"` - there is no manifest available - we are in process of fetching it
+     *  - `"fresh"` - the manifest has been fetched but is not stored in cache yet
+     *  - `"cached"` - the manifest was retrieved from cache
+     *  - `"stale"` - the manifest is outdated, a new manifest needs to be fetched
+     */
+    get status(): "empty" | "fresh" | "cached" | "stale";
+    get name(): string;
+    get manifestUri(): string;
+    get fallbackUri(): string;
+    get contentUri(): string;
+    /**
+     * Kill switch for breaking the recursive promise chain in case it is never able to completely resolve.
+     * This is true if the number of recursions matches the threshold.
+     */
+    get kill(): boolean;
+    /**
+     * Set the number of recursions before the request should be {@link kill}ed
+     */
+    set recursions(value: number);
+    /**
+     * The number of recursions before the request should be {@link kill}ed
+     */
+    get recursions(): number;
+    set redirect(value: PodiumRedirect);
+    /**
+     * When {@link redirectable} is `true` this is populated with redirect information so you can send a redirect response to the browser from your layout.
+     *
+     * @see https://podium-lib.io/docs/layout/handling_redirects
+     */
+    get redirect(): PodiumRedirect;
+    set redirectable(value: boolean);
+    /**
+     * Whether the podlet can signal redirects to the layout.
+     *
+     * @see https://podium-lib.io/docs/layout/handling_redirects
+     */
+    get redirectable(): boolean;
+    /**
+     * True if the client has returned the podlet's fallback.
+     *
+     * @example
+     *
+     * ```js
+     * if (outgoing.isFallback) console.log("Fallback!");
+     * ```
+     *
+     * @see https://podium-lib.io/docs/podlet/fallbacks
+     */
+    get isFallback(): boolean;
+    pushFallback(): void;
+    get [Symbol.toStringTag](): string;
+    #private;
+}
+export type PodiumClientHttpOutgoingOptions = {
+    name: string;
+    /**
+     * To the podlet's `manifest.json`
+     */
+    uri: string;
+    /**
+     * In milliseconds
+     */
+    timeout: number;
+    maxAge: number;
+    retries?: number;
+    throwable?: boolean;
+    redirectable?: boolean;
+    rejectUnauthorized?: boolean;
+    httpAgent?: import('http').Agent;
+    httpsAgent?: import('https').Agent;
+};
+export type PodiumClientResourceOptions = {
+    pathname?: string;
+    headers?: import('http').IncomingHttpHeaders;
+    query?: object;
+};
+export type PodiumRedirect = {
+    /**
+     * ;
+     */
+    statusCode: number;
+    /**
+     * ;
+     */
+    location: string;
+};
+export type PodletProxySchema = {
+    target: string;
+    name: string;
+};
+/**
+ * Similar to the schema's manifest, but with instances of AssetCss and AssetJs from `@podium/utils` and default values.
+ */
+export type PodletManifest = {
+    name: string;
+    version: string;
+    content: string;
+    fallback: string;
+    js: Array<import('@podium/utils').AssetJs>;
+    css: Array<import('@podium/utils').AssetCss>;
+    proxy: Record<string, string> | Array<PodletProxySchema>;
+    team: string;
+};
+import { PassThrough } from 'stream';

package/types/http.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @typedef {object} PodiumHttpClientRequestOptions
+ * @property {'GET' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'CONNECT' | 'OPTIONS' | 'TRACE' | 'PATCH'} method
+ * @property {boolean} [json]
+ * @property {boolean} [rejectUnauthorized]
+ * @property {boolean} [follow]
+ * @property {number} [timeout]
+ * @property {number} [bodyTimeout]
+ * @property {object} [query]
+ * @property {import('http').IncomingHttpHeaders} [headers]
+ */
+export default class HTTP {
+    /**
+     * @param {string} url
+     * @param {PodiumHttpClientRequestOptions} options
+     * @returns {Promise<Pick<import('undici').Dispatcher.ResponseData, 'statusCode' | 'headers' | 'body'>>}
+     */
+    request(url: string, options: PodiumHttpClientRequestOptions): Promise<Pick<import('undici').Dispatcher.ResponseData, 'statusCode' | 'headers' | 'body'>>;
+}
+export type PodiumHttpClientRequestOptions = {
+    method: 'GET' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'CONNECT' | 'OPTIONS' | 'TRACE' | 'PATCH';
+    json?: boolean;
+    rejectUnauthorized?: boolean;
+    follow?: boolean;
+    timeout?: number;
+    bodyTimeout?: number;
+    query?: object;
+    headers?: import('http').IncomingHttpHeaders;
+};

package/types/resolver.cache.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @typedef {object} PodletClientCacheResolverOptions
+ * @property {import('abslog').AbstractLoggerOptions} [logger]
+ */
+export default class PodletClientCacheResolver {
+    /**
+     * @constructor
+     * @param {import('ttl-mem-cache').default} registry
+     * @param {PodletClientCacheResolverOptions} options
+     */
+    constructor(registry: any, options?: PodletClientCacheResolverOptions);
+    /**
+     * Loads the podlet's manifest from cache if not stale
+     *
+     * @param {import('./http-outgoing.js').default} outgoing
+     * @returns {Promise<import('./http-outgoing.js').default>}
+     */
+    load(outgoing: import('./http-outgoing.js').default): Promise<import('./http-outgoing.js').default>;
+    /**
+     * Saves the podlet's manifest to the cache
+     *
+     * @param {import('./http-outgoing.js').default} outgoing
+     * @returns {Promise<import('./http-outgoing.js').default>}
+     */
+    save(outgoing: import('./http-outgoing.js').default): Promise<import('./http-outgoing.js').default>;
+    get [Symbol.toStringTag](): string;
+    #private;
+}
+export type PodletClientCacheResolverOptions = {
+    logger?: import('abslog').AbstractLoggerOptions;
+};

package/types/resolver.content.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @typedef {object} PodletClientContentResolverOptions
+ * @property {string} clientName
+ * @property {import('./http.js').default} [http]
+ * @property {import('abslog').AbstractLoggerOptions} [logger]
+ */
+export default class PodletClientContentResolver {
+    /**
+     * @constructor
+     * @param {PodletClientContentResolverOptions} options
+     */
+    constructor(options?: PodletClientContentResolverOptions);
+    get metrics(): Metrics;
+    /**
+     * Resolves/fetches the podlet's content.
+     *
+     * @param {import('./http-outgoing.js').default} outgoing
+     * @returns {Promise<import('./http-outgoing.js').default>}
+     */
+    resolve(outgoing: import('./http-outgoing.js').default): Promise<import('./http-outgoing.js').default>;
+    get [Symbol.toStringTag](): string;
+    #private;
+}
+export type PodletClientContentResolverOptions = {
+    clientName: string;
+    http?: import('./http.js').default;
+    logger?: import('abslog').AbstractLoggerOptions;
+};
+import Metrics from '@metrics/client';

package/types/resolver.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @typedef {object} PodletClientResolverOptions
+ * @property {string} clientName
+ * @property {import('abslog').AbstractLoggerOptions} [logger]
+ */
+export default class PodletClientResolver {
+    /**
+     * @constructor
+     * @param {import('ttl-mem-cache').default} registry
+     * @param {PodletClientResolverOptions} options
+     */
+    constructor(registry: any, options?: PodletClientResolverOptions);
+    get metrics(): Metrics;
+    /**
+     * Resolve the podlet's manifest, fallback and content
+     *
+     * @param {import('./http-outgoing.js').default} outgoing
+     * @returns {Promise<import('./http-outgoing.js').default>}
+     */
+    resolve(outgoing: import('./http-outgoing.js').default): Promise<import('./http-outgoing.js').default>;
+    /**
+     * Refresh the podlet's cached manifest and fallback
+     *
+     * @param {import('./http-outgoing.js').default} outgoing
+     * @returns {Promise<boolean>} `true` if successful
+     */
+    refresh(outgoing: import('./http-outgoing.js').default): Promise<boolean>;
+    get [Symbol.toStringTag](): string;
+    #private;
+}
+export type PodletClientResolverOptions = {
+    clientName: string;
+    logger?: import('abslog').AbstractLoggerOptions;
+};
+import Metrics from '@metrics/client';

package/types/resolver.fallback.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @typedef {object} PodletClientFallbackResolverOptions
+ * @property {string} clientName
+ * @property {import('./http.js').default} [http]
+ * @property {import('abslog').AbstractLoggerOptions} [logger]
+ */
+export default class PodletClientFallbackResolver {
+    /**
+     * @constructor
+     * @param {PodletClientFallbackResolverOptions} options
+     */
+    constructor(options?: PodletClientFallbackResolverOptions);
+    get metrics(): Metrics;
+    /**
+     * Resolves/fetches the podlet's fallback.
+     *
+     * @param {import('./http-outgoing.js').default} outgoing
+     * @returns {Promise<import('./http-outgoing.js').default>}
+     */
+    resolve(outgoing: import('./http-outgoing.js').default): Promise<import('./http-outgoing.js').default>;
+    get [Symbol.toStringTag](): string;
+    #private;
+}
+export type PodletClientFallbackResolverOptions = {
+    clientName: string;
+    http?: import('./http.js').default;
+    logger?: import('abslog').AbstractLoggerOptions;
+};
+import Metrics from '@metrics/client';

package/types/resolver.manifest.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @typedef {object} PodletClientManifestResolverOptions
+ * @property {string} clientName
+ * @property {import('abslog').AbstractLoggerOptions} [logger]
+ * @property {import('./http.js').default} [http]
+ */
+export default class PodletClientManifestResolver {
+    /**
+     * @constructor
+     * @param {PodletClientManifestResolverOptions} options
+     */
+    constructor(options?: PodletClientManifestResolverOptions);
+    get metrics(): Metrics;
+    /**
+     * @param {import('./http-outgoing.js').default} outgoing
+     * @returns {Promise<import('./http-outgoing.js').default>}
+     */
+    resolve(outgoing: import('./http-outgoing.js').default): Promise<import('./http-outgoing.js').default>;
+    get [Symbol.toStringTag](): string;
+    #private;
+}
+export type PodletClientManifestResolverOptions = {
+    clientName: string;
+    logger?: import('abslog').AbstractLoggerOptions;
+    http?: import('./http.js').default;
+};
+import Metrics from '@metrics/client';

package/types/resource.d.ts

@@ -0,0 +1,89 @@
+/**
+ * @typedef {object} PodiumClientResourceOptions
+ * @property {import('abslog').AbstractLoggerOptions} [logger]
+ * @property {string} clientName
+ * @property {string} name
+ * @property {string} uri To the podlet's `manifest.json`
+ * @property {number} timeout In milliseconds
+ * @property {number} maxAge
+ * @property {number} [retries]
+ * @property {boolean} [throwable]
+ * @property {boolean} [redirectable]
+ * @property {boolean} [rejectUnauthorized]
+ * @property {import('http').Agent} [httpAgent]
+ * @property {import('https').Agent} [httpsAgent]
+ */
+export default class PodiumClientResource {
+    /**
+     * @constructor
+     * @param {import('ttl-mem-cache').default} registry
+     * @param {import('./state.js').default} state
+     * @param {PodiumClientResourceOptions} options
+     */
+    constructor(registry: any, state: import('./state.js').default, options?: PodiumClientResourceOptions);
+    get metrics(): Metrics;
+    get name(): string;
+    get uri(): string;
+    /**
+     * Fetch the podlet's content, or fallback if the podlet is unavailable.
+     * The podlet response includes references to its CSS and JS assets which should be included in the final HTML document.
+     *
+     * @param {import('@podium/utils').HttpIncoming} incoming Instance of HttpIncoming
+     * @param {import('./http-outgoing.js').PodiumClientResourceOptions} [reqOptions={}] Optional parameters to the HTTP request, such as query parameters or HTTP request headers.
+     * @returns {Promise<import('./response.js').default>}
+     *
+     * @example
+     * ```js
+     * const incoming = res.locals.podium; // Express server example
+     * const header = await headerPodlet.fetch(incoming);
+     * incoming.podlets = [header]; // Register the podlet's JS and CSS assets with the layout's HTML template
+     * ```
+     */
+    fetch(incoming: import('@podium/utils').HttpIncoming, reqOptions?: import('./http-outgoing.js').PodiumClientResourceOptions): Promise<import('./response.js').default>;
+    /**
+     * Stream the podlet's content, or fallback if the podlet is unavailable.
+     *
+     * @param {import('@podium/utils').HttpIncoming} incoming
+     * @param {import('./http-outgoing.js').PodiumClientResourceOptions} [reqOptions={}]
+     * @returns {import('./http-outgoing.js').default}
+     */
+    stream(incoming: import('@podium/utils').HttpIncoming, reqOptions?: import('./http-outgoing.js').PodiumClientResourceOptions): import('./http-outgoing.js').default;
+    /**
+     * Refresh the podlet's manifest and fallback in the cache.
+     *
+     * @param {import('@podium/utils').HttpIncoming} [incoming]
+     * @param {import('./http-outgoing.js').PodiumClientResourceOptions} [reqOptions={}]
+     * @returns {Promise<boolean>} `true` if succesful
+     */
+    refresh(incoming?: import('@podium/utils').HttpIncoming, reqOptions?: import('./http-outgoing.js').PodiumClientResourceOptions): Promise<boolean>;
+    [inspect](): {
+        metrics: Metrics;
+        name: string;
+        uri: string;
+    };
+    get [Symbol.toStringTag](): string;
+    #private;
+}
+export type PodiumClientResourceOptions = {
+    logger?: import('abslog').AbstractLoggerOptions;
+    clientName: string;
+    name: string;
+    /**
+     * To the podlet's `manifest.json`
+     */
+    uri: string;
+    /**
+     * In milliseconds
+     */
+    timeout: number;
+    maxAge: number;
+    retries?: number;
+    throwable?: boolean;
+    redirectable?: boolean;
+    rejectUnauthorized?: boolean;
+    httpAgent?: import('http').Agent;
+    httpsAgent?: import('https').Agent;
+};
+import Metrics from '@metrics/client';
+declare const inspect: unique symbol;
+export {};

package/types/response.d.ts

@@ -0,0 +1,47 @@
+/**
+ * @typedef {object} PodiumClientResponseOptions
+ * @property {string} [content]
+ * @property {object} [headers]
+ * @property {Array<import('@podium/utils').AssetJs>} [js]
+ * @property {Array<import('@podium/utils').AssetCss>} [css]
+ * @property {import('./http-outgoing.js').PodiumRedirect | null} [redirect]
+ */
+export default class PodiumClientResponse {
+    /**
+     * @constructor
+     * @param {PodiumClientResponseOptions} options
+     */
+    constructor({ content, headers, css, js, redirect, }?: PodiumClientResponseOptions);
+    get content(): string;
+    get headers(): any;
+    get css(): import("@podium/utils").AssetCss[];
+    get js(): import("@podium/utils").AssetJs[];
+    get redirect(): import("./http-outgoing.js").PodiumRedirect;
+    toJSON(): {
+        redirect: import("./http-outgoing.js").PodiumRedirect;
+        content: string;
+        headers: any;
+        css: import("@podium/utils/types/asset-css.js").CssAsset[];
+        js: import("@podium/utils/types/asset-js.js").JavaScriptAsset[];
+    };
+    toString(): string;
+    [Symbol.toPrimitive](): string;
+    [inspect](): {
+        redirect: import("./http-outgoing.js").PodiumRedirect;
+        content: string;
+        headers: any;
+        css: import("@podium/utils").AssetCss[];
+        js: import("@podium/utils").AssetJs[];
+    };
+    get [Symbol.toStringTag](): string;
+    #private;
+}
+export type PodiumClientResponseOptions = {
+    content?: string;
+    headers?: object;
+    js?: Array<import('@podium/utils').AssetJs>;
+    css?: Array<import('@podium/utils').AssetCss>;
+    redirect?: import('./http-outgoing.js').PodiumRedirect | null;
+};
+declare const inspect: unique symbol;
+export {};

package/types/state.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="node" resolution-mode="require"/>
+/**
+ * @typedef {object} PodiumClientStateOptions
+ * @property {number} [resolveThreshold=10000]
+ * @property {number} [resolveMax=240000]
+ */
+export default class PodiumClientState extends EventEmitter<[never]> {
+    /**
+     * @param {PodiumClientStateOptions} [options]
+     */
+    constructor({ resolveThreshold, resolveMax, }?: PodiumClientStateOptions);
+    get status(): "instantiated" | "stable" | "initializing" | "unhealthy" | "unstable";
+    setInitializingState(): void;
+    setStableState(): void;
+    setUnhealthyState(): void;
+    setUnstableState(): void;
+    reset(): void;
+    toJSON(): {
+        status: "instantiated" | "stable" | "initializing" | "unhealthy" | "unstable";
+    };
+    [inspect](): {
+        status: "instantiated" | "stable" | "initializing" | "unhealthy" | "unstable";
+    };
+    get [Symbol.toStringTag](): string;
+    #private;
+}
+export type PodiumClientStateOptions = {
+    resolveThreshold?: number;
+    resolveMax?: number;
+};
+import EventEmitter from 'events';
+declare const inspect: unique symbol;
+export {};

package/types/utils.d.ts

@@ -0,0 +1,4 @@
+export function isHeaderDefined(headers: object, header: string): boolean;
+export function hasManifestChange(item: object): boolean;
+export function validateIncoming(incoming?: object): boolean;
+export function filterAssets<T extends import("@podium/utils").AssetJs | import("@podium/utils").AssetCss>(scope: "content" | "fallback" | "all", assets: T[]): T[];