aws-delivlib 15.0.16 → 15.0.18

package/lib/publishing/github/node_modules/@types/jsonwebtoken/node_modules/@types/node/v8.d.ts

@@ -4,7 +4,7 @@
  * ```js
  * import v8 from 'node:v8';
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/v8.js)
+ * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/v8.js)
  */
 declare module "v8" {
     import { Readable } from "node:stream";
@@ -547,8 +547,7 @@ declare module "v8" {
     function stopCoverage(): void;
     /**
      * The API is a no-op if `--heapsnapshot-near-heap-limit` is already set from the command line or the API is called more than once.
-     * `limit` must be a positive integer. See [`--heapsnapshot-near-heap-limit`](https://nodejs.org/docs/latest-v22.x/api/cli.html#--heapsnapshot-near-heap-limitmax_count) for more information.
-     * @experimental
+     * `limit` must be a positive integer. See [`--heapsnapshot-near-heap-limit`](https://nodejs.org/docs/latest-v24.x/api/cli.html#--heapsnapshot-near-heap-limitmax_count) for more information.
      * @since v18.10.0, v16.18.0
      */
     function setHeapSnapshotNearHeapLimit(limit: number): void;
@@ -774,33 +773,6 @@ declare module "v8" {
      */
     const promiseHooks: PromiseHooks;
     type StartupSnapshotCallbackFn = (args: any) => any;
-    interface StartupSnapshot {
-        /**
-         * Add a callback that will be called when the Node.js instance is about to get serialized into a snapshot and exit.
-         * This can be used to release resources that should not or cannot be serialized or to convert user data into a form more suitable for serialization.
-         * @since v18.6.0, v16.17.0
-         */
-        addSerializeCallback(callback: StartupSnapshotCallbackFn, data?: any): void;
-        /**
-         * Add a callback that will be called when the Node.js instance is deserialized from a snapshot.
-         * The `callback` and the `data` (if provided) will be serialized into the snapshot, they can be used to re-initialize the state of the application or
-         * to re-acquire resources that the application needs when the application is restarted from the snapshot.
-         * @since v18.6.0, v16.17.0
-         */
-        addDeserializeCallback(callback: StartupSnapshotCallbackFn, data?: any): void;
-        /**
-         * This sets the entry point of the Node.js application when it is deserialized from a snapshot. This can be called only once in the snapshot building script.
-         * If called, the deserialized application no longer needs an additional entry point script to start up and will simply invoke the callback along with the deserialized
-         * data (if provided), otherwise an entry point script still needs to be provided to the deserialized application.
-         * @since v18.6.0, v16.17.0
-         */
-        setDeserializeMainFunction(callback: StartupSnapshotCallbackFn, data?: any): void;
-        /**
-         * Returns true if the Node.js instance is run to build a snapshot.
-         * @since v18.6.0, v16.17.0
-         */
-        isBuildingSnapshot(): boolean;
-    }
     /**
      * The `v8.startupSnapshot` interface can be used to add serialization and deserialization hooks for custom startup snapshots.
      *
@@ -879,10 +851,35 @@ declare module "v8" {
      *
      * Currently the application deserialized from a user-land snapshot cannot be snapshotted again, so these APIs are only available to applications that are not deserialized from a user-land snapshot.
      *
-     * @experimental
      * @since v18.6.0, v16.17.0
      */
-    const startupSnapshot: StartupSnapshot;
+    namespace startupSnapshot {
+        /**
+         * Add a callback that will be called when the Node.js instance is about to get serialized into a snapshot and exit.
+         * This can be used to release resources that should not or cannot be serialized or to convert user data into a form more suitable for serialization.
+         * @since v18.6.0, v16.17.0
+         */
+        function addSerializeCallback(callback: StartupSnapshotCallbackFn, data?: any): void;
+        /**
+         * Add a callback that will be called when the Node.js instance is deserialized from a snapshot.
+         * The `callback` and the `data` (if provided) will be serialized into the snapshot, they can be used to re-initialize the state of the application or
+         * to re-acquire resources that the application needs when the application is restarted from the snapshot.
+         * @since v18.6.0, v16.17.0
+         */
+        function addDeserializeCallback(callback: StartupSnapshotCallbackFn, data?: any): void;
+        /**
+         * This sets the entry point of the Node.js application when it is deserialized from a snapshot. This can be called only once in the snapshot building script.
+         * If called, the deserialized application no longer needs an additional entry point script to start up and will simply invoke the callback along with the deserialized
+         * data (if provided), otherwise an entry point script still needs to be provided to the deserialized application.
+         * @since v18.6.0, v16.17.0
+         */
+        function setDeserializeMainFunction(callback: StartupSnapshotCallbackFn, data?: any): void;
+        /**
+         * Returns true if the Node.js instance is run to build a snapshot.
+         * @since v18.6.0, v16.17.0
+         */
+        function isBuildingSnapshot(): boolean;
+    }
 }
 declare module "node:v8" {
     export * from "v8";

package/lib/publishing/github/node_modules/@types/jsonwebtoken/node_modules/@types/node/vm.d.ts

@@ -34,7 +34,7 @@
  *
  * console.log(x); // 1; y is not defined.
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/vm.js)
+ * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/vm.js)
  */
 declare module "vm" {
     import { ImportAttributes } from "node:module";
@@ -60,6 +60,7 @@ declare module "vm" {
         specifier: string,
         referrer: T,
         importAttributes: ImportAttributes,
+        phase: "source" | "evaluation",
     ) => Module | Promise<Module>;
     interface ScriptOptions extends BaseOptions {
         /**
@@ -71,7 +72,8 @@ declare module "vm" {
         /**
          * Used to specify how the modules should be loaded during the evaluation of this script when `import()` is called. This option is
          * part of the experimental modules API. We do not recommend using it in a production environment. For detailed information, see
-         * [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v22.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
+         * [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v24.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
+         * @experimental
          */
         importModuleDynamically?:
             | DynamicModuleLoader<Script>
@@ -122,7 +124,8 @@ declare module "vm" {
         /**
          * Used to specify how the modules should be loaded during the evaluation of this script when `import()` is called. This option is
          * part of the experimental modules API. We do not recommend using it in a production environment. For detailed information, see
-         * [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v22.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
+         * [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v24.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
+         * @experimental
          */
         importModuleDynamically?:
             | DynamicModuleLoader<Script>
@@ -137,7 +140,8 @@ declare module "vm" {
         /**
          * Used to specify how the modules should be loaded during the evaluation of this script when `import()` is called. This option is
          * part of the experimental modules API. We do not recommend using it in a production environment. For detailed information, see
-         * [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v22.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
+         * [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v24.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
+         * @experimental
          */
         importModuleDynamically?:
             | DynamicModuleLoader<Script>
@@ -165,7 +169,8 @@ declare module "vm" {
         /**
          * Used to specify how the modules should be loaded during the evaluation of this script when `import()` is called. This option is
          * part of the experimental modules API. We do not recommend using it in a production environment. For detailed information, see
-         * [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v22.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
+         * [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v24.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
+         * @experimental
          */
         importModuleDynamically?:
             | DynamicModuleLoader<ReturnType<typeof compileFunction>>
@@ -208,7 +213,8 @@ declare module "vm" {
         /**
          * Used to specify how the modules should be loaded during the evaluation of this script when `import()` is called. This option is
          * part of the experimental modules API. We do not recommend using it in a production environment. For detailed information, see
-         * [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v22.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
+         * [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v24.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
+         * @experimental
          */
         importModuleDynamically?:
             | DynamicModuleLoader<Context>
@@ -410,9 +416,9 @@ declare module "vm" {
     }
     /**
      * If the given `contextObject` is an object, the `vm.createContext()` method will
-     * [prepare that object](https://nodejs.org/docs/latest-v22.x/api/vm.html#what-does-it-mean-to-contextify-an-object)
+     * [prepare that object](https://nodejs.org/docs/latest-v24.x/api/vm.html#what-does-it-mean-to-contextify-an-object)
      * and return a reference to it so that it can be used in calls to {@link runInContext} or
-     * [`script.runInContext()`](https://nodejs.org/docs/latest-v22.x/api/vm.html#scriptrunincontextcontextifiedobject-options).
+     * [`script.runInContext()`](https://nodejs.org/docs/latest-v24.x/api/vm.html#scriptrunincontextcontextifiedobject-options).
      * Inside such scripts, the global object will be wrapped by the `contextObject`, retaining all of its
      * existing properties but also having the built-in objects and functions any standard
      * [global object](https://es5.github.io/#x15.1) has. Outside of scripts run by the vm module, global
@@ -907,7 +913,8 @@ declare module "vm" {
         /**
          * Used to specify how the modules should be loaded during the evaluation of this script when `import()` is called. This option is
          * part of the experimental modules API. We do not recommend using it in a production environment. For detailed information, see
-         * [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v22.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
+         * [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v24.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
+         * @experimental
          */
         importModuleDynamically?: DynamicModuleLoader<SourceTextModule> | undefined;
     }
@@ -1005,7 +1012,7 @@ declare module "vm" {
          * and `vm.compileFunction()` so that Node.js uses the default ESM loader from the main
          * context to load the requested module.
          *
-         * For detailed information, see [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v22.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
+         * For detailed information, see [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v24.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
          * @since v21.7.0, v20.12.0
          */
         const USE_MAIN_CONTEXT_DEFAULT_LOADER: number;

package/lib/publishing/github/node_modules/@types/jsonwebtoken/node_modules/@types/node/wasi.d.ts

@@ -67,7 +67,7 @@
  * wat2wasm demo.wat
  * ```
  * @experimental
- * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/wasi.js)
+ * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/wasi.js)
  */
 declare module "wasi" {
     interface WASIOptions {

package/lib/publishing/github/node_modules/@types/jsonwebtoken/node_modules/@types/node/worker_threads.d.ts

@@ -15,28 +15,31 @@
  *
  * ```js
  * import {
- *   Worker, isMainThread, parentPort, workerData,
+ *   Worker,
+ *   isMainThread,
+ *   parentPort,
+ *   workerData,
  * } from 'node:worker_threads';
- * import { parse } from 'some-js-parsing-library';
  *
- * if (isMainThread) {
- *   module.exports = function parseJSAsync(script) {
- *     return new Promise((resolve, reject) => {
- *       const worker = new Worker(__filename, {
- *         workerData: script,
- *       });
- *       worker.on('message', resolve);
- *       worker.on('error', reject);
- *       worker.on('exit', (code) => {
- *         if (code !== 0)
- *           reject(new Error(`Worker stopped with exit code ${code}`));
- *       });
- *     });
- *   };
- * } else {
+ * if (!isMainThread) {
+ *   const { parse } = await import('some-js-parsing-library');
  *   const script = workerData;
  *   parentPort.postMessage(parse(script));
  * }
+ *
+ * export default function parseJSAsync(script) {
+ *   return new Promise((resolve, reject) => {
+ *     const worker = new Worker(new URL(import.meta.url), {
+ *       workerData: script,
+ *     });
+ *     worker.on('message', resolve);
+ *     worker.on('error', reject);
+ *     worker.on('exit', (code) => {
+ *       if (code !== 0)
+ *         reject(new Error(`Worker stopped with exit code ${code}`));
+ *     });
+ *   });
+ * };
  * ```
  *
  * The above example spawns a Worker thread for each `parseJSAsync()` call. In
@@ -49,7 +52,7 @@
  *
  * Worker threads inherit non-process-specific options by default. Refer to `Worker constructor options` to know how to customize worker thread options,
  * specifically `argv` and `execArgv` options.
- * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/worker_threads.js)
+ * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/worker_threads.js)
  */
 declare module "worker_threads" {
     import { Context } from "node:vm";
@@ -59,6 +62,7 @@ declare module "worker_threads" {
     import { Readable, Writable } from "node:stream";
     import { ReadableStream, TransformStream, WritableStream } from "node:stream/web";
     import { URL } from "node:url";
+    import { HeapInfo } from "node:v8";
     const isInternalThread: boolean;
     const isMainThread: boolean;
     const parentPort: null | MessagePort;
@@ -184,6 +188,11 @@ declare module "worker_threads" {
          * @since v10.5.0
          */
         postMessage(value: any, transferList?: readonly Transferable[]): void;
+        /**
+         * If true, the `MessagePort` object will keep the Node.js event loop active.
+         * @since v18.1.0, v16.17.0
+         */
+        hasRef(): boolean;
         /**
          * Opposite of `unref()`. Calling `ref()` on a previously `unref()`ed port does _not_ let the program exit if it's the only active handle left (the default
          * behavior). If the port is `ref()`ed, calling `ref()` again has no effect.
@@ -466,6 +475,13 @@ declare module "worker_threads" {
          * @return A promise for a Readable Stream containing a V8 heap snapshot
          */
         getHeapSnapshot(): Promise<Readable>;
+        /**
+         * This method returns a `Promise` that will resolve to an object identical to `v8.getHeapStatistics()`,
+         * or reject with an `ERR_WORKER_NOT_RUNNING` error if the worker is no longer running.
+         * This methods allows the statistics to be observed from outside the actual thread.
+         * @since v24.0.0
+         */
+        getHeapStatistics(): Promise<HeapInfo>;
         addListener(event: "error", listener: (err: Error) => void): this;
         addListener(event: "exit", listener: (exitCode: number) => void): this;
         addListener(event: "message", listener: (value: any) => void): this;

package/lib/publishing/github/node_modules/@types/jsonwebtoken/node_modules/@types/node/zlib.d.ts

@@ -9,7 +9,7 @@
  * ```
  *
  * Compression and decompression are built around the Node.js
- * [Streams API](https://nodejs.org/docs/latest-v22.x/api/stream.html).
+ * [Streams API](https://nodejs.org/docs/latest-v24.x/api/stream.html).
  *
  * Compressing or decompressing a stream (such as a file) can be accomplished by
  * piping the source stream through a `zlib` `Transform` stream into a destination
@@ -89,7 +89,7 @@
  *   });
  * ```
  * @since v0.5.8
- * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/zlib.js)
+ * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/zlib.js)
  */
 declare module "zlib" {
     import * as stream from "node:stream";
@@ -143,7 +143,7 @@ declare module "zlib" {
             }
             | undefined;
         /**
-         * Limits output size when using [convenience methods](https://nodejs.org/docs/latest-v22.x/api/zlib.html#convenience-methods).
+         * Limits output size when using [convenience methods](https://nodejs.org/docs/latest-v24.x/api/zlib.html#convenience-methods).
          * @default buffer.kMaxLength
          */
         maxOutputLength?: number | undefined;
@@ -163,19 +163,17 @@ declare module "zlib" {
         chunkSize?: number | undefined;
         /**
          * Key-value object containing indexed
-         * [Zstd parameters](https://nodejs.org/docs/latest-v22.x/api/zlib.html#zstd-constants).
+         * [Zstd parameters](https://nodejs.org/docs/latest-v24.x/api/zlib.html#zstd-constants).
          */
         params?: { [key: number]: number | boolean } | undefined;
         /**
          * Limits output size when using
-         * [convenience methods](https://nodejs.org/docs/latest-v22.x/api/zlib.html#convenience-methods).
+         * [convenience methods](https://nodejs.org/docs/latest-v24.x/api/zlib.html#convenience-methods).
          * @default buffer.kMaxLength
          */
         maxOutputLength?: number | undefined;
     }
     interface Zlib {
-        /** @deprecated Use bytesWritten instead. */
-        readonly bytesRead: number;
         readonly bytesWritten: number;
         shell?: boolean | string | undefined;
         close(callback?: () => void): void;

package/lib/publishing/github/node_modules/undici-types/agent.d.ts

@@ -1,17 +1,17 @@
 import { URL } from 'url'
 import Pool from './pool'
-import Dispatcher from "./dispatcher";
+import Dispatcher from './dispatcher'
 
 export default Agent
 
-declare class Agent extends Dispatcher{
-  constructor(opts?: Agent.Options)
+declare class Agent extends Dispatcher {
+  constructor (opts?: Agent.Options)
   /** `true` after `dispatcher.close()` has been called. */
-  closed: boolean;
+  closed: boolean
   /** `true` after `dispatcher.destroyed()` has been called or `dispatcher.close()` has been called and the dispatcher shutdown has completed. */
-  destroyed: boolean;
+  destroyed: boolean
   /** Dispatches a request. */
-  dispatch(options: Agent.DispatchOptions, handler: Dispatcher.DispatchHandlers): boolean;
+  dispatch (options: Agent.DispatchOptions, handler: Dispatcher.DispatchHandler): boolean
 }
 
 declare namespace Agent {
@@ -21,7 +21,7 @@ declare namespace Agent {
     /** Integer. Default: `0` */
     maxRedirections?: number;
 
-    interceptors?: { Agent?: readonly Dispatcher.DispatchInterceptor[] } & Pool.Options["interceptors"]
+    interceptors?: { Agent?: readonly Dispatcher.DispatchInterceptor[] } & Pool.Options['interceptors']
   }
 
   export interface DispatchOptions extends Dispatcher.DispatchOptions {

package/lib/publishing/github/node_modules/undici-types/api.d.ts

@@ -2,42 +2,42 @@ import { URL, UrlObject } from 'url'
 import { Duplex } from 'stream'
 import Dispatcher from './dispatcher'
 
-export {
-  request,
-  stream,
-  pipeline,
-  connect,
-  upgrade,
-}
-
 /** Performs an HTTP request. */
-declare function request(
+declare function request<TOpaque = null> (
   url: string | URL | UrlObject,
-  options?: { dispatcher?: Dispatcher } & Omit<Dispatcher.RequestOptions, 'origin' | 'path' | 'method'> & Partial<Pick<Dispatcher.RequestOptions, 'method'>>,
-): Promise<Dispatcher.ResponseData>;
+  options?: { dispatcher?: Dispatcher } & Omit<Dispatcher.RequestOptions<TOpaque>, 'origin' | 'path' | 'method'> & Partial<Pick<Dispatcher.RequestOptions, 'method'>>,
+): Promise<Dispatcher.ResponseData<TOpaque>>
 
 /** A faster version of `request`. */
-declare function stream(
+declare function stream<TOpaque = null> (
   url: string | URL | UrlObject,
-  options: { dispatcher?: Dispatcher } & Omit<Dispatcher.RequestOptions, 'origin' | 'path'>,
-  factory: Dispatcher.StreamFactory
-): Promise<Dispatcher.StreamData>;
+  options: { dispatcher?: Dispatcher } & Omit<Dispatcher.RequestOptions<TOpaque>, 'origin' | 'path'>,
+  factory: Dispatcher.StreamFactory<TOpaque>
+): Promise<Dispatcher.StreamData<TOpaque>>
 
 /** For easy use with `stream.pipeline`. */
-declare function pipeline(
+declare function pipeline<TOpaque = null> (
   url: string | URL | UrlObject,
-  options: { dispatcher?: Dispatcher } & Omit<Dispatcher.PipelineOptions, 'origin' | 'path'>,
-  handler: Dispatcher.PipelineHandler
-): Duplex;
+  options: { dispatcher?: Dispatcher } & Omit<Dispatcher.PipelineOptions<TOpaque>, 'origin' | 'path'>,
+  handler: Dispatcher.PipelineHandler<TOpaque>
+): Duplex
 
 /** Starts two-way communications with the requested resource. */
-declare function connect(
+declare function connect<TOpaque = null> (
   url: string | URL | UrlObject,
-  options?: { dispatcher?: Dispatcher } & Omit<Dispatcher.ConnectOptions, 'origin' | 'path'>
-): Promise<Dispatcher.ConnectData>;
+  options?: { dispatcher?: Dispatcher } & Omit<Dispatcher.ConnectOptions<TOpaque>, 'origin' | 'path'>
+): Promise<Dispatcher.ConnectData<TOpaque>>
 
 /** Upgrade to a different protocol. */
-declare function upgrade(
+declare function upgrade (
   url: string | URL | UrlObject,
   options?: { dispatcher?: Dispatcher } & Omit<Dispatcher.UpgradeOptions, 'origin' | 'path'>
-): Promise<Dispatcher.UpgradeData>;
+): Promise<Dispatcher.UpgradeData>
+
+export {
+  request,
+  stream,
+  pipeline,
+  connect,
+  upgrade
+}

package/lib/publishing/github/node_modules/undici-types/balanced-pool.d.ts

@@ -4,26 +4,26 @@ import { URL } from 'url'
 
 export default BalancedPool
 
-type BalancedPoolConnectOptions = Omit<Dispatcher.ConnectOptions, "origin">;
+type BalancedPoolConnectOptions = Omit<Dispatcher.ConnectOptions, 'origin'>
 
 declare class BalancedPool extends Dispatcher {
-  constructor(url: string | string[] | URL | URL[], options?: Pool.Options);
+  constructor (url: string | string[] | URL | URL[], options?: Pool.Options)
 
-  addUpstream(upstream: string | URL): BalancedPool;
-  removeUpstream(upstream: string | URL): BalancedPool;
-  upstreams: Array<string>;
+  addUpstream (upstream: string | URL): BalancedPool
+  removeUpstream (upstream: string | URL): BalancedPool
+  upstreams: Array<string>
 
   /** `true` after `pool.close()` has been called. */
-  closed: boolean;
+  closed: boolean
   /** `true` after `pool.destroyed()` has been called or `pool.close()` has been called and the pool shutdown has completed. */
-  destroyed: boolean;
+  destroyed: boolean
 
   // Override dispatcher APIs.
-  override connect(
+  override connect (
     options: BalancedPoolConnectOptions
-  ): Promise<Dispatcher.ConnectData>;
-  override connect(
+  ): Promise<Dispatcher.ConnectData>
+  override connect (
     options: BalancedPoolConnectOptions,
     callback: (err: Error | null, data: Dispatcher.ConnectData) => void
-  ): void;
+  ): void
 }

package/lib/publishing/github/node_modules/undici-types/cache-interceptor.d.ts

@@ -0,0 +1,172 @@
+import { Readable, Writable } from 'node:stream'
+
+export default CacheHandler
+
+declare namespace CacheHandler {
+  export type CacheMethods = 'GET' | 'HEAD' | 'OPTIONS' | 'TRACE'
+
+  export interface CacheHandlerOptions {
+    store: CacheStore
+
+    cacheByDefault?: number
+
+    type?: CacheOptions['type']
+  }
+
+  export interface CacheOptions {
+    store?: CacheStore
+
+    /**
+     * The methods to cache
+     * Note we can only cache safe methods. Unsafe methods (i.e. PUT, POST)
+     *  invalidate the cache for a origin.
+     * @see https://www.rfc-editor.org/rfc/rfc9111.html#name-invalidating-stored-respons
+     * @see https://www.rfc-editor.org/rfc/rfc9110#section-9.2.1
+     */
+    methods?: CacheMethods[]
+
+    /**
+     * RFC9111 allows for caching responses that we aren't explicitly told to
+     *  cache or to not cache.
+     * @see https://www.rfc-editor.org/rfc/rfc9111.html#section-3-5
+     * @default undefined
+     */
+    cacheByDefault?: number
+
+    /**
+     * TODO docs
+     * @default 'shared'
+     */
+    type?: 'shared' | 'private'
+  }
+
+  export interface CacheControlDirectives {
+    'max-stale'?: number;
+    'min-fresh'?: number;
+    'max-age'?: number;
+    's-maxage'?: number;
+    'stale-while-revalidate'?: number;
+    'stale-if-error'?: number;
+    public?: true;
+    private?: true | string[];
+    'no-store'?: true;
+    'no-cache'?: true | string[];
+    'must-revalidate'?: true;
+    'proxy-revalidate'?: true;
+    immutable?: true;
+    'no-transform'?: true;
+    'must-understand'?: true;
+    'only-if-cached'?: true;
+  }
+
+  export interface CacheKey {
+    origin: string
+    method: string
+    path: string
+    headers?: Record<string, string | string[]>
+  }
+
+  export interface CacheValue {
+    statusCode: number
+    statusMessage: string
+    headers: Record<string, string | string[]>
+    vary?: Record<string, string | string[] | null>
+    etag?: string
+    cacheControlDirectives?: CacheControlDirectives
+    cachedAt: number
+    staleAt: number
+    deleteAt: number
+  }
+
+  export interface DeleteByUri {
+    origin: string
+    method: string
+    path: string
+  }
+
+  type GetResult = {
+    statusCode: number
+    statusMessage: string
+    headers: Record<string, string | string[]>
+    vary?: Record<string, string | string[] | null>
+    etag?: string
+    body?: Readable | Iterable<Buffer> | AsyncIterable<Buffer> | Buffer | Iterable<string> | AsyncIterable<string> | string
+    cacheControlDirectives: CacheControlDirectives,
+    cachedAt: number
+    staleAt: number
+    deleteAt: number
+  }
+
+  /**
+   * Underlying storage provider for cached responses
+   */
+  export interface CacheStore {
+    get(key: CacheKey): GetResult | Promise<GetResult | undefined> | undefined
+
+    createWriteStream(key: CacheKey, val: CacheValue): Writable | undefined
+
+    delete(key: CacheKey): void | Promise<void>
+  }
+
+  export interface MemoryCacheStoreOpts {
+    /**
+       * @default Infinity
+       */
+    maxCount?: number
+
+    /**
+     * @default Infinity
+     */
+    maxSize?: number
+
+    /**
+     * @default Infinity
+     */
+    maxEntrySize?: number
+
+    errorCallback?: (err: Error) => void
+  }
+
+  export class MemoryCacheStore implements CacheStore {
+    constructor (opts?: MemoryCacheStoreOpts)
+
+    get (key: CacheKey): GetResult | Promise<GetResult | undefined> | undefined
+
+    createWriteStream (key: CacheKey, value: CacheValue): Writable | undefined
+
+    delete (key: CacheKey): void | Promise<void>
+  }
+
+  export interface SqliteCacheStoreOpts {
+    /**
+     * Location of the database
+     * @default ':memory:'
+     */
+    location?: string
+
+    /**
+     * @default Infinity
+     */
+    maxCount?: number
+
+    /**
+     * @default Infinity
+     */
+    maxEntrySize?: number
+  }
+
+  export class SqliteCacheStore implements CacheStore {
+    constructor (opts?: SqliteCacheStoreOpts)
+
+    /**
+     * Closes the connection to the database
+     */
+    close (): void
+
+    get (key: CacheKey): GetResult | Promise<GetResult | undefined> | undefined
+
+    createWriteStream (key: CacheKey, value: CacheValue): Writable | undefined
+
+    delete (key: CacheKey): void | Promise<void>
+  }
+}