@counterfact/generator 0.1.1

package/dist/templates/counterfact-types/counterfact-response.ts

@@ -0,0 +1,15 @@
+/**
+ * A unique symbol used as a brand for the `COUNTERFACT_RESPONSE` type.
+ * This prevents arbitrary objects from being accidentally treated as a
+ * completed response value.
+ */
+const counterfactResponse = Symbol("Counterfact Response");
+
+/**
+ * The terminal value type returned by the fluent response builder once all
+ * required fields (body, headers, etc.) have been provided. When a route
+ * handler returns this type, Counterfact treats the response as complete.
+ */
+export type COUNTERFACT_RESPONSE = {
+  [counterfactResponse]: typeof counterfactResponse;
+};

package/dist/templates/counterfact-types/example-names.ts

@@ -0,0 +1,13 @@
+import type { OpenApiResponse } from "./open-api-response.js";
+
+/**
+ * Extracts the union of named example keys defined on an OpenAPI response.
+ * Resolves to `never` when the response has no named examples.
+ * Used to constrain the argument to the `.example(name)` method on the
+ * response builder.
+ */
+export type ExampleNames<Response extends OpenApiResponse> = Response extends {
+  examples: infer E;
+}
+  ? keyof E & string
+  : never;

package/dist/templates/counterfact-types/example.ts

@@ -0,0 +1,14 @@
+/**
+ * Represents a named example defined in an OpenAPI document.
+ * Examples can be referenced by route handlers via the `.example(name)` method
+ * on the response builder.
+ *
+ * OpenAPI 3.2 adds `dataValue` as a structured alternative to `value`.
+ * When present, `dataValue` is preferred over `value`.
+ */
+export interface Example {
+  dataValue?: unknown;
+  description: string;
+  summary: string;
+  value?: unknown;
+}

package/dist/templates/counterfact-types/generic-response-builder.ts

@@ -0,0 +1,167 @@
+import type { COUNTERFACT_RESPONSE } from "./counterfact-response.js";
+import type { CookieOptions } from "./cookie-options.js";
+import type { ExampleNames } from "./example-names.js";
+import type { IfHasKey } from "./if-has-key.js";
+import type { MediaType } from "./media-type.js";
+import type { OmitAll } from "./omit-all.js";
+import type { OmitValueWhenNever } from "./omit-value-when-never.js";
+import type { OpenApiResponse } from "./open-api-response.js";
+import type { RandomFunction } from "./random-function.js";
+
+/**
+ * Returns `never` when `Record` is an empty object type (`{}`), signalling
+ * that there are no remaining choices available on the response builder.
+ */
+type NeverIfEmpty<Record> = object extends Record ? never : Record;
+
+/**
+ * Extracts the union of schema types from a map of media-type content entries.
+ * Used to type the body argument of shortcut methods like `.json()` or `.html()`.
+ */
+type SchemasOf<T extends { [key: string]: { schema: unknown } }> = {
+  [K in keyof T]: T[K]["schema"];
+}[keyof T];
+
+/**
+ * Produces a builder method for a shortcut (e.g. `.json()`, `.html()`) when
+ * the response contains at least one of the given `ContentTypes`, and `never`
+ * otherwise. Calling the method narrows the builder by removing those content
+ * types from the remaining options.
+ */
+type MaybeShortcut<
+  ContentTypes extends MediaType[],
+  Response extends OpenApiResponse,
+> = IfHasKey<
+  Response["content"],
+  ContentTypes,
+  (body: SchemasOf<Response["content"]>) => GenericResponseBuilder<{
+    content: NeverIfEmpty<OmitAll<Response["content"], ContentTypes>>;
+    headers: Response["headers"];
+    requiredHeaders: Response["requiredHeaders"];
+  }>,
+  never
+>;
+
+/**
+ * The type of the `.match(contentType, body)` method on the generic response
+ * builder. Calling it narrows the builder by removing the chosen content type
+ * from the remaining options.
+ */
+type MatchFunction<Response extends OpenApiResponse> = <
+  ContentType extends MediaType & keyof Response["content"],
+>(
+  contentType: ContentType,
+  body: Response["content"][ContentType]["schema"],
+) => GenericResponseBuilder<{
+  content: NeverIfEmpty<Omit<Response["content"], ContentType>>;
+  headers: Response["headers"];
+  requiredHeaders: Response["requiredHeaders"];
+}>;
+
+/**
+ * The type of the `.header(name, value)` method on the generic response
+ * builder. Calling it narrows the builder by removing the satisfied header
+ * from the set of required headers.
+ */
+type HeaderFunction<Response extends OpenApiResponse> = <
+  Header extends string & keyof Response["headers"],
+>(
+  header: Header,
+  value: Response["headers"][Header]["schema"],
+) => GenericResponseBuilder<{
+  content: NeverIfEmpty<Response["content"]>;
+  headers: NeverIfEmpty<Omit<Response["headers"], Header>>;
+  requiredHeaders: Exclude<Response["requiredHeaders"], Header>;
+}>;
+
+/**
+ * The inner shape of the generic response builder, listing all methods that
+ * are currently available given the remaining response constraints.
+ * Methods whose type resolves to `never` are stripped by `OmitValueWhenNever`.
+ *
+ * Note: `[T] extends [never]` (non-distributive tuple wrapping) is used
+ * alongside `[keyof T] extends [never]` to correctly handle both `T = never`
+ * (spec-generated no-body) and `T = {}` (all content types consumed) cases.
+ * TypeScript evaluates `keyof never` as `string | number | symbol`, so a
+ * direct `[keyof never] extends [never]` check would incorrectly return false.
+ */
+export type GenericResponseBuilderInner<
+  Response extends OpenApiResponse = OpenApiResponse,
+> = OmitValueWhenNever<{
+  binary: MaybeShortcut<["application/octet-stream"], Response>;
+  cookie: (
+    name: string,
+    value: string,
+    options?: CookieOptions,
+  ) => GenericResponseBuilder<Response>;
+  empty: [Response["content"]] extends [never]
+    ? () => COUNTERFACT_RESPONSE
+    : [keyof Response["content"]] extends [never]
+      ? () => COUNTERFACT_RESPONSE
+      : never;
+  header: [Response["headers"]] extends [never]
+    ? never
+    : [keyof Response["headers"]] extends [never]
+      ? never
+      : HeaderFunction<Response>;
+  html: MaybeShortcut<["text/html"], Response>;
+  json: MaybeShortcut<
+    [
+      "application/json",
+      "text/json",
+      "text/x-json",
+      "application/xml",
+      "text/xml",
+    ],
+    Response
+  >;
+  match: [Response["content"]] extends [never]
+    ? never
+    : [keyof Response["content"]] extends [never]
+      ? never
+      : MatchFunction<Response>;
+  random: [Response["content"]] extends [never]
+    ? never
+    : [keyof Response["content"]] extends [never]
+      ? never
+      : RandomFunction;
+  example: [ExampleNames<Response>] extends [never]
+    ? never
+    : (name: ExampleNames<Response>) => COUNTERFACT_RESPONSE;
+  text: MaybeShortcut<["text/plain"], Response>;
+  xml: MaybeShortcut<["application/xml", "text/xml"], Response>;
+  stream: MaybeShortcut<
+    ["text/event-stream", "application/jsonl", "application/json-seq"],
+    Response
+  >;
+}>;
+
+/**
+ * The strongly-typed, fluent response builder generated for each operation in
+ * a route handler. Its available methods are derived from the OpenAPI response
+ * schema: as methods are called, the builder type narrows until all required
+ * content and headers have been provided, at which point it resolves to
+ * `COUNTERFACT_RESPONSE`.
+ *
+ * When a Response type carries an `examples` key it is a spec-generated
+ * response (either the initial no-body builder or a builder that still has
+ * content/headers to satisfy). Those always go through
+ * `GenericResponseBuilderInner`, which exposes `empty()` when `content` is
+ * `never`.
+ *
+ * When a Response type has no `examples` key it is a narrowed type produced
+ * by a method call (e.g. `.json()` sets the body and returns a type without
+ * `examples`). Those go through the existing collapse logic so that
+ * fully-satisfied responses resolve directly to `COUNTERFACT_RESPONSE`.
+ */
+export type GenericResponseBuilder<
+  Response extends OpenApiResponse = OpenApiResponse,
+> = "examples" extends keyof Response
+  ? GenericResponseBuilderInner<Response>
+  : object extends OmitValueWhenNever<Omit<Response, "examples">>
+    ? COUNTERFACT_RESPONSE
+    : keyof OmitValueWhenNever<Omit<Response, "examples">> extends "headers"
+      ? COUNTERFACT_RESPONSE & {
+          header: HeaderFunction<Response>;
+        }
+      : GenericResponseBuilderInner<Response>;

package/dist/templates/counterfact-types/http-status-code.ts

@@ -0,0 +1,62 @@
+/**
+ * A union of all standard HTTP status codes.
+ * Used to constrain the status code argument in response builder calls and
+ * generated route handler types.
+ */
+export type HttpStatusCode =
+  | 100
+  | 101
+  | 102
+  | 200
+  | 201
+  | 202
+  | 203
+  | 204
+  | 205
+  | 206
+  | 207
+  | 226
+  | 300
+  | 301
+  | 302
+  | 303
+  | 304
+  | 305
+  | 307
+  | 308
+  | 400
+  | 401
+  | 402
+  | 403
+  | 404
+  | 405
+  | 406
+  | 407
+  | 408
+  | 409
+  | 410
+  | 411
+  | 412
+  | 413
+  | 414
+  | 415
+  | 416
+  | 417
+  | 418
+  | 422
+  | 423
+  | 424
+  | 426
+  | 428
+  | 429
+  | 431
+  | 451
+  | 500
+  | 501
+  | 502
+  | 503
+  | 504
+  | 505
+  | 506
+  | 507
+  | 511;

package/dist/templates/counterfact-types/if-has-key.ts

@@ -0,0 +1,19 @@
+/**
+ * Conditional type that resolves to `Yes` when `SomeObject` has at least one
+ * key that contains any string from `Keys` as a substring, and `No` otherwise.
+ * Used to determine whether a shortcut method (e.g. `.json()`, `.html()`)
+ * should be present on the response builder for a given response type.
+ */
+export type IfHasKey<
+  SomeObject,
+  Keys extends readonly string[],
+  Yes,
+  No,
+> = Keys extends [
+  infer FirstKey extends string,
+  ...infer RestKeys extends string[],
+]
+  ? Extract<keyof SomeObject, `${string}${FirstKey}${string}`> extends never
+    ? IfHasKey<SomeObject, RestKeys, Yes, No>
+    : Yes
+  : No;

package/dist/templates/counterfact-types/index.ts

@@ -0,0 +1,30 @@
+export type { CookieOptions } from "./cookie-options.js";
+export type { COUNTERFACT_RESPONSE } from "./counterfact-response.js";
+export type { ExampleNames } from "./example-names.js";
+export type {
+  GenericResponseBuilder,
+  GenericResponseBuilderInner,
+} from "./generic-response-builder.js";
+export type { HttpStatusCode } from "./http-status-code.js";
+export type { IfHasKey } from "./if-has-key.js";
+export type { MaybePromise } from "./maybe-promise.js";
+export type { MediaType } from "./media-type.js";
+export type {
+  Middleware,
+  MiddlewareRequest,
+  MiddlewareResponse,
+  MiddlewareResponseBuilderFactory,
+  MiddlewareResponseObject,
+  MiddlewareTools,
+  RespondTo,
+} from "./middleware.js";
+export type { OmitAll } from "./omit-all.js";
+export type { OmitValueWhenNever } from "./omit-value-when-never.js";
+export type { OpenApiHeader } from "./open-api-header.js";
+export type { OpenApiOperation } from "./open-api-operation.js";
+export type { OpenApiParameters } from "./open-api-parameters.js";
+export type { OpenApiResponse } from "./open-api-response.js";
+export type { ResponseBuilder } from "./response-builder.js";
+export type { ResponseBuilderFactory } from "./response-builder-factory.js";
+export type { WideOperationArgument } from "./wide-operation-argument.js";
+export type { WideResponseBuilder } from "./wide-response-builder.js";

package/dist/templates/counterfact-types/maybe-promise.ts

@@ -0,0 +1,6 @@
+/**
+ * A value that is either `T` directly or a `Promise<T>`.
+ * Route handlers may return either synchronous values or promises, and
+ * Counterfact will await them transparently.
+ */
+export type MaybePromise<T> = T | Promise<T>;

package/dist/templates/counterfact-types/media-type.ts

@@ -0,0 +1,6 @@
+/**
+ * Represents an IANA media type string in the format `type/subtype`
+ * (e.g. `"application/json"`, `"text/plain"`, `"image/png"`).
+ * Used to identify the content type of an HTTP request or response body.
+ */
+export type MediaType = `${string}/${string}`;

package/dist/templates/counterfact-types/middleware.ts

@@ -0,0 +1,87 @@
+import type { COUNTERFACT_RESPONSE } from "./counterfact-response.js";
+import type { HttpStatusCode } from "./http-status-code.js";
+import type { MaybePromise } from "./maybe-promise.js";
+import type { MediaType } from "./media-type.js";
+import type { ResponseBuilder } from "./response-builder.js";
+
+/**
+ * The untyped response object that Counterfact passes between middleware and
+ * route handlers.
+ */
+export interface MiddlewareResponseObject {
+  appendedHeaders?: [string, string][];
+  body?: AsyncIterable<unknown> | Uint8Array | string;
+  content?: { body: unknown; type: MediaType }[];
+  contentType?: string;
+  headers?: { [key: string]: number | string | string[] };
+  status?: number;
+}
+
+/** Utilities available to middleware through `$.tools`. */
+export interface MiddlewareTools {
+  accepts: (contentType: string) => boolean;
+  oneOf: <Item>(array: Item[]) => Item;
+  randomFromSchema: (schema: object) => Promise<unknown>;
+}
+
+/** A response-builder factory with every standard status code available. */
+export type MiddlewareResponseBuilderFactory = {
+  [StatusCode in HttpStatusCode]: ResponseBuilder;
+} & { [key: number | `${number} ${string}`]: ResponseBuilder };
+
+/**
+ * The request argument passed to a custom middleware function.
+ *
+ * Supply the context type from the nearest `_.context.ts` file to retain
+ * autocomplete and checking for `$.context`.
+ */
+export interface MiddlewareRequest<Context = unknown> {
+  auth?: { apiKey?: string; password?: string; username?: string };
+  body?: unknown;
+  context: Context;
+  cookie: { [name: string]: string | undefined };
+  delay: (milliseconds: number, maxMilliseconds?: number) => Promise<void>;
+  headers: { [key: string]: boolean | number | string };
+  matchedPath?: string;
+  path?: { [key: string]: boolean | number | string };
+  proxy: (url: string) => Promise<{
+    body: string;
+    contentType: string;
+    headers: { [key: string]: string };
+    status: number;
+  }>;
+  query: { [key: string]: unknown };
+  response: MiddlewareResponseBuilderFactory;
+  tools: MiddlewareTools;
+}
+
+/** A response value that middleware may return or receive from `respondTo`. */
+export type MiddlewareResponse =
+  COUNTERFACT_RESPONSE | MiddlewareResponseObject | ResponseBuilder;
+
+/** Passes a request to the next matching middleware or route handler. */
+export type RespondTo<Context = unknown> = (
+  request: MiddlewareRequest<Context>,
+) => Promise<MiddlewareResponse>;
+
+/**
+ * A custom Counterfact middleware function.
+ *
+ * @example
+ * ```ts
+ * import type { Middleware } from "../counterfact-types/index.js";
+ * import type { Context } from "./_.context.js";
+ *
+ * export const middleware: Middleware<Context> = async ($, respondTo) => {
+ *   if (!$.context.isAuthorized($.auth?.apiKey)) {
+ *     return $.response[401].json({ error: "Unauthorized" });
+ *   }
+ *
+ *   return respondTo($);
+ * };
+ * ```
+ */
+export type Middleware<Context = unknown> = (
+  request: MiddlewareRequest<Context>,
+  respondTo: RespondTo<Context>,
+) => MaybePromise<MiddlewareResponse>;

package/dist/templates/counterfact-types/omit-all.ts

@@ -0,0 +1,11 @@
+/**
+ * Removes all keys from `T` whose names contain any of the strings in `K`
+ * as a substring (prefix, suffix, or exact match).
+ * Used internally to narrow the set of available content-type methods on the
+ * response builder after one has already been called.
+ */
+export type OmitAll<T, K extends readonly string[]> = {
+  [
+    P in keyof T as P extends `${string}${K[number]}${string}` ? never : P
+  ]: T[P];
+};

package/dist/templates/counterfact-types/omit-value-when-never.ts

@@ -0,0 +1,11 @@
+/**
+ * Creates a new type from `Base` that omits any keys whose value type is
+ * `never`. This is used to strip unavailable builder methods (those that
+ * don't apply to the current response shape) from the fluent response builder.
+ */
+export type OmitValueWhenNever<Base> = Pick<
+  Base,
+  {
+    [Key in keyof Base]: [Base[Key]] extends [never] ? never : Key;
+  }[keyof Base]
+>;

package/dist/templates/counterfact-types/open-api-content.ts

@@ -0,0 +1,8 @@
+/**
+ * Represents a single content entry in an OpenAPI response object.
+ * The `schema` property holds the JSON Schema definition for the body of
+ * a response with this media type.
+ */
+export interface OpenApiContent {
+  schema: unknown;
+}

package/dist/templates/counterfact-types/open-api-header.ts

@@ -0,0 +1,4 @@
+export interface OpenApiHeader {
+  required?: boolean;
+  schema: { [key: string]: unknown };
+}

package/dist/templates/counterfact-types/open-api-operation.ts

@@ -0,0 +1,36 @@
+import type { Example } from "./example.js";
+import type { OpenApiHeader } from "./open-api-header.js";
+import type { OpenApiParameters } from "./open-api-parameters.js";
+
+/**
+ * Describes a single HTTP operation (e.g. `GET /pets`) as defined in an
+ * OpenAPI document. Used internally to derive the strongly-typed argument
+ * and response builder types for generated route handler functions.
+ */
+export interface OpenApiOperation {
+  parameters?: OpenApiParameters[];
+  produces?: string[];
+  requestBody?: {
+    content?: {
+      [mediaType: string]: {
+        schema: { [key: string]: unknown };
+      };
+    };
+    required?: boolean;
+  };
+  responses: {
+    [status: string]: {
+      content?: {
+        [type: number | string]: {
+          examples?: { [key: string]: Example };
+          schema: { [key: string]: unknown };
+        };
+      };
+      examples?: { [key: string]: unknown };
+      headers?: {
+        [name: string]: OpenApiHeader;
+      };
+      schema?: { [key: string]: unknown };
+    };
+  };
+}

package/dist/templates/counterfact-types/open-api-parameters.ts

@@ -0,0 +1,26 @@
+/**
+ * Describes a single parameter (path, query, header, cookie, body, or
+ * formData) as defined in an OpenAPI document. Used internally to type the
+ * `path`, `query`, `headers`, and `body` properties of a route handler's
+ * argument object.
+ */
+export interface OpenApiParameters {
+  explode?: boolean;
+  in:
+    | "body"
+    | "cookie"
+    | "formData"
+    | "header"
+    | "path"
+    | "query"
+    | "querystring";
+  name: string;
+  required?: boolean;
+  schema?: {
+    [key: string]: unknown;
+    properties?: Record<string, unknown>;
+    type?: string;
+  };
+  style?: string;
+  type?: "string" | "number" | "integer" | "boolean";
+}

package/dist/templates/counterfact-types/open-api-response.ts

@@ -0,0 +1,22 @@
+import type { MediaType } from "./media-type.js";
+import type { OpenApiContent } from "./open-api-content.js";
+
+/**
+ * Describes a single HTTP response as modelled in an OpenAPI document.
+ * Contains the allowed content types, optional named examples, and the
+ * required/optional response headers for that response.
+ */
+export interface OpenApiResponse {
+  content: { [key: MediaType]: OpenApiContent };
+  examples?: { [key: string]: unknown };
+  headers: { [key: string]: { schema: unknown } };
+  requiredHeaders: string;
+}
+
+/**
+ * A map of HTTP status codes (or `"default"`) to their corresponding
+ * `OpenApiResponse` definitions for a given operation.
+ */
+export interface OpenApiResponses {
+  [key: string]: OpenApiResponse;
+}

package/dist/templates/counterfact-types/random-function.ts

@@ -0,0 +1,9 @@
+import type { COUNTERFACT_RESPONSE } from "./counterfact-response.js";
+import type { MaybePromise } from "./maybe-promise.js";
+
+/**
+ * The type of the `.random()` method on the response builder.
+ * When called, it randomly selects one of the available content-type examples
+ * and returns a completed `COUNTERFACT_RESPONSE`.
+ */
+export type RandomFunction = () => MaybePromise<COUNTERFACT_RESPONSE>;

package/dist/templates/counterfact-types/response-builder-factory.ts

@@ -0,0 +1,16 @@
+import type { GenericResponseBuilder } from "./generic-response-builder.js";
+import type { OpenApiResponses } from "./open-api-response.js";
+
+/**
+ * Maps each HTTP status code (or `"default"`) in an OpenAPI operation's
+ * response definitions to the corresponding `GenericResponseBuilder`.
+ * This is the type of the `response` property in a generated route handler's
+ * argument object, allowing handlers to call e.g. `response[200].json(body)`.
+ */
+export type ResponseBuilderFactory<
+  Responses extends OpenApiResponses = OpenApiResponses,
+> = {
+  [StatusCode in keyof Responses]: GenericResponseBuilder<
+    Responses[StatusCode]
+  >;
+} & { [key: string]: GenericResponseBuilder<Responses["default"]> };

package/dist/templates/counterfact-types/response-builder.ts

@@ -0,0 +1,36 @@
+import type { CookieOptions } from "./cookie-options.js";
+import type { MaybePromise } from "./maybe-promise.js";
+
+/**
+ * A loosely-typed, chainable response builder used in non-generated contexts
+ * (e.g. middleware or wide/catch-all route handlers) where the exact response
+ * shape is not statically known. For generated route handlers, prefer the
+ * strongly-typed `GenericResponseBuilder`.
+ */
+export interface ResponseBuilder {
+  [status: number | `${number} ${string}`]: ResponseBuilder;
+  binary: (body: Uint8Array | string) => ResponseBuilder;
+  content?: { body: unknown; type: string }[];
+  cookie: (
+    name: string,
+    value: string,
+    options?: CookieOptions,
+  ) => ResponseBuilder;
+  empty: () => ResponseBuilder;
+  example: (name: string) => ResponseBuilder;
+  header: (name: string, value: string) => ResponseBuilder;
+  headers: { [name: string]: string | string[] };
+  html: (body: unknown) => ResponseBuilder;
+  json: (body: unknown) => ResponseBuilder;
+  match: (contentType: string, body: unknown) => ResponseBuilder;
+  random: () => MaybePromise<ResponseBuilder>;
+  randomLegacy: () => MaybePromise<ResponseBuilder>;
+  status?: number;
+  stream: (iterable: AsyncIterable<unknown>) => {
+    body: AsyncIterable<unknown>;
+    contentType: string;
+    status?: number;
+  };
+  text: (body: unknown) => ResponseBuilder;
+  xml: (body: unknown) => ResponseBuilder;
+}

package/dist/templates/counterfact-types/wide-operation-argument.ts

@@ -0,0 +1,20 @@
+import type { HttpStatusCode } from "./http-status-code.js";
+import type { WideResponseBuilder } from "./wide-response-builder.js";
+
+/**
+ * The loosely-typed argument object passed to wide (catch-all) route handlers.
+ * Unlike the generated operation argument types, all fields are typed as
+ * `unknown` or broad index signatures. Use this when writing handlers that
+ * should accept any request without compile-time schema enforcement.
+ */
+export interface WideOperationArgument {
+  body: unknown;
+  context: unknown;
+  headers: { [key: string]: string };
+  path: { [key: string]: string };
+  proxy: (url: string) => { proxyUrl: string };
+  query: { [key: string]: string };
+  response: { [StatusCode in HttpStatusCode]: WideResponseBuilder } & {
+    [key: number]: WideResponseBuilder;
+  };
+}

package/dist/templates/counterfact-types/wide-response-builder.ts

@@ -0,0 +1,28 @@
+import type { COUNTERFACT_RESPONSE } from "./counterfact-response.js";
+import type { CookieOptions } from "./cookie-options.js";
+import type { MaybePromise } from "./maybe-promise.js";
+
+/**
+ * A loosely-typed response builder used in wide (catch-all) route handlers
+ * where the response shape is not known at compile time. Unlike the generated
+ * `GenericResponseBuilder`, this interface accepts `unknown` for all body
+ * arguments and does not enforce content-type constraints.
+ */
+export type WideResponseBuilder = COUNTERFACT_RESPONSE & {
+  binary: (body: Uint8Array | string) => WideResponseBuilder;
+  empty: () => WideResponseBuilder;
+  example: (name: string) => WideResponseBuilder;
+  cookie: (
+    name: string,
+    value: string,
+    options?: CookieOptions,
+  ) => WideResponseBuilder;
+  header: (name: string, value: string) => WideResponseBuilder;
+  html: (body: unknown) => WideResponseBuilder;
+  json: (body: unknown) => WideResponseBuilder;
+  match: (contentType: string, body: unknown) => WideResponseBuilder;
+  random: () => MaybePromise<WideResponseBuilder>;
+  text: (body: unknown) => WideResponseBuilder;
+  xml: (body: unknown) => WideResponseBuilder;
+  stream: (body: AsyncIterable<unknown>) => COUNTERFACT_RESPONSE;
+};