@ykdz/template 0.0.37 → 0.0.40

package/node_modules/@ykdz/template-builtin-presets/templates/ts-cli/test/integration/command.test.ts

@@ -5,79 +5,138 @@ import { describe, expect, it } from "vitest";
 import { cliCommandIdentity } from "../../src/cli-command-identity.ts";
 import { runCli, type CliRuntime } from "../../src/main.ts";
 
-const require = createRequire(import.meta.url);
-const packageManifest = require("../../package.json") as unknown;
-const identity = cliCommandIdentity(packageManifest);
+const identity = cliCommandIdentity(
+  createRequire(import.meta.url)("../../package.json"),
+);
 
-function testRuntime(args: readonly string[]): {
-  readonly runtime: CliRuntime;
-  readonly stdout: () => string;
-  readonly stderr: () => string;
-} {
+function testRuntime(args: readonly string[]) {
   let stdout = "";
   let stderr = "";
-  return {
-    runtime: {
-      argv: ["node", identity.commandName, ...args],
-      streams: {
-        stdin: {},
-        stdout: { write: (chunk) => (stdout += chunk) },
-        stderr: { write: (chunk) => (stderr += chunk) },
-      },
-      cwd: "/workspace",
-      env: { MODE: "test" },
-      tty: { stdin: false, stdout: false, stderr: false },
-      identity,
+  const runtime: CliRuntime = {
+    argv: ["node", identity.commandName, ...args],
+    identity,
+    write: ({ destination, chunk }) => {
+      if (destination === "stdout") stdout += chunk;
+      else stderr += chunk;
     },
-    stdout: () => stdout,
-    stderr: () => stderr,
   };
+  return { runtime, stdout: () => stdout, stderr: () => stderr };
 }
 
-describe("CLI command control", () => {
-  it("parses greet and writes business output to the injected stream", async () => {
-    const output = testRuntime(["greet", "  Ada Lovelace  "]);
-
-    await expect(runCli(output.runtime)).resolves.toBe(0);
-    expect(output.stdout()).toBe("Hello, Ada Lovelace\n");
+describe("CLI 契约", () => {
+  it("查询成功默认返回结构化数据，也支持中文文本", async () => {
+    const output = testRuntime(["lookup", "ada"]);
+    expect(await runCli(output.runtime)).toBe(0);
+    expect(JSON.parse(output.stdout())).toEqual({
+      schemaVersion: "1",
+      command: "lookup",
+      kind: "data",
+      variant: "found",
+      data: { name: "ada", title: "Ada Lovelace" },
+    });
     expect(output.stderr()).toBe("");
+    const human = testRuntime(["lookup", "ada", "--output-format", "text"]);
+    expect(await runCli(human.runtime)).toBe(0);
+    expect(human.stdout()).toContain("找到记录");
+    expect(human.stdout()).toContain("Ada Lovelace");
   });
 
-  it("renders the version derived from the package manifest", async () => {
-    const output = testRuntime(["--version"]);
-
-    await expect(runCli(output.runtime)).resolves.toBe(0);
-    expect(output.stdout()).toBe(`${identity.version}\n`);
-    expect(output.stderr()).toBe("");
-  });
-
-  it("renders Commander help without exiting the process", async () => {
-    const output = testRuntime(["--help"]);
-
-    await expect(runCli(output.runtime)).resolves.toBe(0);
-    expect(output.stdout()).toContain(
-      `Usage: ${identity.commandName} [options] [command]`,
-    );
-    expect(output.stdout()).toContain("greet <name>");
-    expect(output.stderr()).toBe("");
+  it("未找到记录是已声明失败，非法名称是用法错误", async () => {
+    const missing = testRuntime(["lookup", "missing"]);
+    expect(await runCli(missing.runtime)).toBe(1);
+    expect(missing.stdout()).toBe("");
+    expect(JSON.parse(missing.stderr())).toMatchObject({
+      kind: "failure",
+      variant: "notFound",
+      data: { name: "missing" },
+    });
+    for (const args of [["lookup"], ["lookup", "   "]]) {
+      const invalid = testRuntime([...args, "--output-format", "text"]);
+      expect(await runCli(invalid.runtime)).toBe(2);
+      expect(invalid.stdout()).toBe("");
+      expect(JSON.parse(invalid.stderr())).toMatchObject({
+        kind: "usageFailure",
+      });
+    }
   });
 
-  it("reports missing arguments as Commander usage errors", async () => {
-    const output = testRuntime(["greet"]);
-
-    await expect(runCli(output.runtime)).resolves.toBe(1);
-    expect(output.stdout()).toBe("");
-    expect(output.stderr()).toContain(
-      "error: missing required argument 'name'",
+  it("帮助和版本使用 manifest 身份，schema 导出完整契约", async () => {
+    const version = testRuntime(["--version"]);
+    expect(await runCli(version.runtime)).toBe(0);
+    expect(version.stdout()).toBe(
+      `${identity.commandName} ${identity.version}\n`,
     );
-    expect(output.stderr()).toContain(`Usage: ${identity.commandName} greet`);
+    const help = testRuntime(["--help"]);
+    expect(await runCli(help.runtime)).toBe(0);
+    expect(help.stdout()).toContain(identity.commandName);
+    expect(help.stdout()).toContain("lookup");
+    expect(help.stdout()).toContain("schema");
+    const schema = testRuntime(["schema"]);
+    expect(await runCli(schema.runtime)).toBe(0);
+    const humanSchema = testRuntime(["schema", "--output-format", "text"]);
+    expect(await runCli(humanSchema.runtime)).toBe(0);
+    expect(humanSchema.stdout()).toContain("CLI 契约");
+    expect(humanSchema.stdout()).toContain('"commands"');
+    const manifest = JSON.parse(schema.stdout()).data.manifest;
+    expect(manifest).toMatchObject({
+      commands: {
+        lookup: {
+          input: {
+            inputSchema: {
+              properties: { name: { pattern: "^[a-z]+$" } },
+              required: ["name"],
+            },
+          },
+          success: { variants: { found: { exitCode: 0 } } },
+          failures: { notFound: { exitCode: 1 } },
+        },
+        schema: { success: { variants: { exported: { exitCode: 0 } } } },
+      },
+      controls: {
+        output: {
+          defaultFormat: "structured",
+          formats: ["structured", "text"],
+        },
+      },
+      usageFailure: { exitCode: 2 },
+    });
   });
 
-  it("adapts business validation into a testable command error", async () => {
-    const output = testRuntime(["greet", "   "]);
-
-    await expect(runCli(output.runtime)).resolves.toBe(1);
-    expect(output.stdout()).toBe("");
-    expect(output.stderr()).toContain("error: Name must not be empty");
+  it("等待输出完成，仅 stdout EPIPE 安静成功", async () => {
+    const output = testRuntime(["lookup", "ada"]);
+    expect(
+      await runCli({
+        ...output.runtime,
+        write: async () => {
+          throw Object.assign(new Error("pipe"), { code: "EPIPE" });
+        },
+      }),
+    ).toBe(0);
+    expect(
+      await runCli({
+        ...output.runtime,
+        write: async () => {
+          throw new Error("disk");
+        },
+      }),
+    ).toBe(70);
+    const failure = testRuntime(["lookup", "missing"]);
+    expect(
+      await runCli({
+        ...failure.runtime,
+        write: async () => {
+          throw Object.assign(new Error("pipe"), { code: "EPIPE" });
+        },
+      }),
+    ).toBe(70);
+    const argv = ["node", identity.commandName];
+    Object.defineProperty(argv, "slice", {
+      value() {
+        throw new Error("内部细节");
+      },
+    });
+    expect(await runCli({ ...output.runtime, argv })).toBe(70);
+    expect(output.stderr()).toContain("命令执行失败");
+    expect(output.stderr()).not.toContain("内部细节");
   });
 });

package/node_modules/@ykdz/template-core/dist/package-contribution.d.ts

@@ -32,7 +32,6 @@ export type FoundationContribution = {
             readonly dockerfile: FoundationTemplateAssetSource;
             readonly dockerIgnore: FoundationTemplateAssetSource;
             readonly shellCheckDockerfile: FoundationTemplateAssetSource;
-            readonly dockerClientToolLayer: FoundationTemplateAssetSource;
         };
     };
     /** Closed publication capability consumed only by coordinated root policy. */

package/node_modules/@ykdz/template-core/dist/pnpm-workspace.yaml

@@ -21,6 +21,8 @@ overrides:
   "vue>typescript": "-"
 
 catalog:
+  "@ykdz/cli-contract": 0.2.1
+  "@valibot/to-json-schema": ^1.8.0
   "@devcontainers/cli": 0.89.0
   "@hono/node-server": ^2.0.12
   "@playwright/test": ^1.62.1
@@ -31,7 +33,6 @@ catalog:
   "@vikejs/hono": ^0.2.1
   "@vue/devtools-api": ^8.1.5
   "@vue/tsconfig": ^0.9.1
-  commander: ^15.0.0
   drizzle-kit: 1.0.0-rc.5-ab785fc
   drizzle-orm: 1.0.0-rc.5-ab785fc
   execa: ^10.0.1

package/node_modules/@ykdz/template-core/dist/project-blueprint.d.ts

@@ -1,3 +1,4 @@
+import * as v from "valibot";
 /**
  * The durable, preset-agnostic topology used by local template follow-up
  * operations. Preset provenance deliberately belongs in Generation Record.
@@ -40,6 +41,20 @@ export type BlueprintValidationResult = {
     readonly ok: false;
     readonly issues: readonly BlueprintValidationIssue[];
 };
+declare function packageDefinitionMessage(issue: v.BaseIssue<unknown>): string;
+export declare const projectBlueprintSchema: v.StrictObjectSchema<{
+    readonly schemaVersion: v.LiteralSchema<3, (issue: v.LiteralIssue) => string>;
+    readonly packages: v.ArraySchema<v.StrictObjectSchema<{
+        readonly name: v.StringSchema<"Package name must be a string">;
+        readonly path: v.StringSchema<"Package Path must be a string">;
+        readonly role: v.PicklistSchema<readonly ["cli-tool", "runtime-service", "shared-library", "native-package"], "Package Role must be cli-tool, runtime-service, shared-library, or native-package">;
+        readonly packageDefinitionId: v.StringSchema<"Package Definition ID must use the package-<sha256> format">;
+    }, typeof packageDefinitionMessage>, "Package Definitions must be an array">;
+    readonly packageLinkIntents: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
+        readonly consumerPackagePath: v.StringSchema<"Package Link Intent consumer Package Path must be a string">;
+        readonly providerPackagePath: v.StringSchema<"Package Link Intent provider Package Path must be a string">;
+    }, (issue: v.StrictObjectIssue) => "Package Link Intent must be an object" | "Unknown Blueprint v3 field">, "Package Link Intents must be an array">, undefined>;
+}, (issue: v.StrictObjectIssue) => "Local Template Metadata must be an object" | "Unknown Blueprint v3 field">;
 /** Canonical npm package-name predicate shared by Blueprint and input preparation. */
 export declare function isValidNewNpmPackageName(value: string): boolean;
 export type NewPackagePathValidation = {

package/node_modules/@ykdz/template-core/dist/project-blueprint.js

@@ -42,7 +42,7 @@ const packageLinkIntentSchema = v.strictObject({
 }, (issue) => issue.path?.at(-1)?.origin === "key" && issue.input !== undefined
     ? unknownBlueprintField
     : "Package Link Intent must be an object");
-const projectBlueprintSchema = v.strictObject({
+export const projectBlueprintSchema = v.strictObject({
     schemaVersion: v.literal(3, (issue) => `Unsupported Local Template Metadata schema version ${String(issue.input)}; expected 3`),
     packages: v.array(packageDefinitionSchema, "Package Definitions must be an array"),
     packageLinkIntents: v.optional(v.array(packageLinkIntentSchema, "Package Link Intents must be an array")),

package/node_modules/@ykdz/template-core/dist/project-github.d.ts

@@ -47,7 +47,7 @@ export type ProjectCheckWorkflowPlan = {
     readonly packagePaths: readonly string[];
     readonly diagnosticArtifacts: readonly CiDiagnosticArtifactDeclaration[];
 };
-export type DependencyEcosystem = "npm" | "cargo" | "github-actions" | "docker" | "rust-toolchain";
+export type DependencyEcosystem = "npm" | "cargo" | "github-actions" | "docker" | "devcontainers" | "rust-toolchain";
 export type DependabotDirectory = `/${string}`;
 export type DependencyMaintenancePolicy = {
     readonly ecosystems: DependencyEcosystem[];

package/node_modules/undici-types/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Matteo Collina and Undici contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/undici-types/README.md

@@ -0,0 +1,6 @@
+# undici-types
+
+This package is a dual-publish of the [undici](https://www.npmjs.com/package/undici) library types. The `undici` package **still contains types**. This package is for users who _only_ need undici types (such as for `@types/node`). It is published alongside every release of `undici`, so you can always use the same version.
+
+- [GitHub nodejs/undici](https://github.com/nodejs/undici)
+- [Undici Documentation](https://undici.nodejs.org/#/)

package/node_modules/undici-types/agent.d.ts

@@ -0,0 +1,32 @@
+import { URL } from 'node:url'
+import Pool from './pool'
+import Dispatcher from './dispatcher'
+import TClientStats from './client-stats'
+import TPoolStats from './pool-stats'
+
+export default Agent
+
+declare class Agent extends Dispatcher {
+  constructor (opts?: Agent.Options)
+  /** `true` after `dispatcher.close()` has been called. */
+  closed: boolean
+  /** `true` after `dispatcher.destroyed()` has been called or `dispatcher.close()` has been called and the dispatcher shutdown has completed. */
+  destroyed: boolean
+  /** Dispatches a request. */
+  dispatch (options: Agent.DispatchOptions, handler: Dispatcher.DispatchHandler): boolean
+  /** Aggregate stats for a Agent by origin. */
+  readonly stats: Record<string, TClientStats | TPoolStats>
+}
+
+declare namespace Agent {
+  export interface Options extends Pool.Options {
+    /** Default: `(origin, opts) => new Pool(origin, opts)`. */
+    factory?(origin: string | URL, opts: Object): Dispatcher;
+
+    interceptors?: { Agent?: readonly Dispatcher.DispatchInterceptor[] } & Pool.Options['interceptors']
+    maxOrigins?: number
+  }
+
+  export interface DispatchOptions extends Dispatcher.DispatchOptions {
+  }
+}

package/node_modules/undici-types/api.d.ts

@@ -0,0 +1,43 @@
+import { URL, UrlObject } from 'node:url'
+import { Duplex } from 'node:stream'
+import Dispatcher from './dispatcher'
+
+/** Performs an HTTP request. */
+declare function request<TOpaque = null> (
+  url: string | URL | UrlObject,
+  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<TOpaque = null> (
+  url: string | URL | UrlObject,
+  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<TOpaque = null> (
+  url: string | URL | UrlObject,
+  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<TOpaque = null> (
+  url: string | URL | UrlObject,
+  options?: { dispatcher?: Dispatcher } & Omit<Dispatcher.ConnectOptions<TOpaque>, 'origin' | 'path'>
+): Promise<Dispatcher.ConnectData<TOpaque>>
+
+/** Upgrade to a different protocol. */
+declare function upgrade (
+  url: string | URL | UrlObject,
+  options?: { dispatcher?: Dispatcher } & Omit<Dispatcher.UpgradeOptions, 'origin' | 'path'>
+): Promise<Dispatcher.UpgradeData>
+
+export {
+  request,
+  stream,
+  pipeline,
+  connect,
+  upgrade
+}

package/node_modules/undici-types/balanced-pool.d.ts

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

package/node_modules/undici-types/cache-interceptor.d.ts

@@ -0,0 +1,179 @@
+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'
+
+    /**
+     * Array of origins to cache. Only requests to these origins will be cached.
+     * Supports strings (case insensitive) and RegExp patterns.
+     * @default undefined (cache all origins)
+     */
+    origins?: (string | RegExp)[]
+  }
+
+  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>
+  }
+}

package/node_modules/undici-types/cache.d.ts

@@ -0,0 +1,36 @@
+import type { RequestInfo, Response, Request } from './fetch'
+
+export interface CacheStorage {
+  match (request: RequestInfo, options?: MultiCacheQueryOptions): Promise<Response | undefined>,
+  has (cacheName: string): Promise<boolean>,
+  open (cacheName: string): Promise<Cache>,
+  delete (cacheName: string): Promise<boolean>,
+  keys (): Promise<string[]>
+}
+
+declare const CacheStorage: {
+  prototype: CacheStorage
+  new(): CacheStorage
+}
+
+export interface Cache {
+  match (request: RequestInfo, options?: CacheQueryOptions): Promise<Response | undefined>,
+  matchAll (request?: RequestInfo, options?: CacheQueryOptions): Promise<readonly Response[]>,
+  add (request: RequestInfo): Promise<undefined>,
+  addAll (requests: RequestInfo[]): Promise<undefined>,
+  put (request: RequestInfo, response: Response): Promise<undefined>,
+  delete (request: RequestInfo, options?: CacheQueryOptions): Promise<boolean>,
+  keys (request?: RequestInfo, options?: CacheQueryOptions): Promise<readonly Request[]>
+}
+
+export interface CacheQueryOptions {
+  ignoreSearch?: boolean,
+  ignoreMethod?: boolean,
+  ignoreVary?: boolean
+}
+
+export interface MultiCacheQueryOptions extends CacheQueryOptions {
+  cacheName?: string
+}
+
+export declare const caches: CacheStorage

package/node_modules/undici-types/client-stats.d.ts

@@ -0,0 +1,15 @@
+import Client from './client'
+
+export default ClientStats
+
+declare class ClientStats {
+  constructor (pool: Client)
+  /** If socket has open connection. */
+  connected: boolean
+  /** Number of open socket connections in this client that do not have an active request. */
+  pending: number
+  /** Number of currently active requests of this client. */
+  running: number
+  /** Number of active, pending, or queued requests of this client. */
+  size: number
+}