@solidjs/web 2.0.0-beta.2 → 2.0.0-beta.20

package/types-cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/types-cjs/response.d.cts

@@ -0,0 +1,93 @@
+/**
+ * Envelope pairing HTTP metadata (a `Response`) with an in-memory value.
+ * Produced by `respond()` and by server-function `transformResult`
+ * implementations (e.g. single-flight payloads). The HTTP handler forwards
+ * `response`'s headers and (non-redirect) status and encodes `value` as the
+ * body through the codec, while client-only integrations read `value`
+ * directly — no reparse. Mostly consumed by integrations (routers);
+ * application code usually just returns what `respond()` gives it.
+ */
+export class ResponseEnvelope<T = unknown> {
+  constructor(response: Response | undefined, value: T);
+  /** The HTTP metadata: status and headers to forward (body ignored by integrations). */
+  response: Response | undefined;
+  /** The structured value the caller receives. */
+  value: T;
+}
+
+/**
+ * Whether `value` is a `ResponseEnvelope`. Uses a registered-symbol brand
+ * rather than `instanceof`, so it stays correct when separately bundled
+ * entries each carry a copy of the class. Integrations should always use
+ * this over `instanceof`.
+ */
+export function isResponseEnvelope(value: unknown): value is ResponseEnvelope;
+
+/** `ResponseInit` accepted by the response helpers, plus `revalidate`. */
+export interface ResponseHelperInit extends ResponseInit {
+  /**
+   * Cache keys the mutation invalidated, carried in the `X-Revalidate`
+   * header. Opaque to the protocol — the integration's keyed cache (e.g.
+   * the router's `query` cache) assigns them meaning.
+   */
+  revalidate?: string | string[];
+}
+
+/**
+ * Response redirecting to `url` (default status 302). Return (or throw) it
+ * from a server function — the HTTP handler forwards the redirect for the
+ * client integration to follow — or return it from a client-side action,
+ * where the integration interprets it in memory. Same object, same
+ * meaning, both sides.
+ *
+ * @example
+ * ```ts
+ * import { redirect } from "@solidjs/web";
+ *
+ * async function login(form: FormData) {
+ *   "use server";
+ *   // ...
+ *   return redirect("/dashboard", { revalidate: "session" });
+ * }
+ * ```
+ */
+export function redirect(url: string, init?: number | ResponseHelperInit): Response;
+
+/**
+ * Empty response requesting revalidation of the named cache keys — all of
+ * them when omitted. For mutations whose only effect the caller needs is
+ * "refetch your data".
+ *
+ * @example
+ * ```ts
+ * import { reload } from "@solidjs/web";
+ *
+ * async function addTodo(title: string) {
+ *   "use server";
+ *   await db.insert(title);
+ *   return reload({ revalidate: "todos" });
+ * }
+ * ```
+ */
+export function reload(init?: ResponseHelperInit): Response;
+
+/**
+ * A value paired with response metadata (status, headers, `revalidate`) —
+ * for the things a naked return can't express. Scripted callers receive
+ * `value` transparently (the transport unwraps the envelope), and
+ * progressive enhancement stays invisible: the carried response holds a
+ * plain JSON body so consumers without the client runtime (no-JS form
+ * posts, direct HTTP) get real JSON.
+ *
+ * @example
+ * ```ts
+ * import { respond } from "@solidjs/web";
+ *
+ * async function createItem(input: Item) {
+ *   "use server";
+ *   const item = await db.create(input);
+ *   return respond(item, { status: 201, revalidate: "items" });
+ * }
+ * ```
+ */
+export function respond<T>(value: T, init?: ResponseHelperInit): ResponseEnvelope<T>;

package/types-cjs/serializer.d.cts

@@ -0,0 +1,139 @@
+import { Plugin, Serializer, SerovalNode } from "seroval";
+
+/**
+ * Seroval's node shape — the intermediate representation `serializeJSON`
+ * emits and `createJSONDeserializer` consumes. Safe to `JSON.stringify`.
+ */
+export type { SerovalNode };
+
+/**
+ * A Seroval plugin usable with the web serializers — teaches the codec how
+ * to encode/decode a custom value type. Supply matching plugins on both
+ * peers of a transport.
+ */
+export type SerializerPlugin = Plugin<any, any>;
+
+/**
+ * Baseline plugin set for serializing web-platform values (AbortSignal,
+ * Event, FormData, Headers, ReadableStream, Request, Response, URL, ...).
+ * Applied by every serializer in this module; custom plugins compose ahead
+ * of it via `resolveSerializerPlugins`.
+ */
+export const DEFAULT_WEB_PLUGINS: readonly SerializerPlugin[];
+
+/**
+ * Composes custom plugins with `DEFAULT_WEB_PLUGINS`. Custom plugins come
+ * first so they can shadow a default for values both would match. Returns a
+ * fresh array; the defaults are never mutated. Useful when handing a full
+ * plugin list to another serialization layer.
+ */
+export function resolveSerializerPlugins(customPlugins?: SerializerPlugin[]): SerializerPlugin[];
+
+/** Options for `createSerializer`. */
+export interface WebSerializerOptions {
+  /** Name of the global object the emitted scripts write resolved values into. */
+  globalIdentifier: string;
+  /** Cross-reference scope id, for isolating multiple streams on one page. */
+  scopeId?: string;
+  /**
+   * Seroval feature bitflags to exclude from output. Defaults to disabling
+   * post-ES2017 features (AggregateError, BigInt typed arrays).
+   */
+  disabledFeatures?: number;
+  /** Extra plugins, composed ahead of `DEFAULT_WEB_PLUGINS`. */
+  plugins?: SerializerPlugin[];
+  /** Receives each emitted script chunk. */
+  onData: (result: string) => void;
+  onError?: (error: unknown) => void;
+  /** Fires once all async values have settled. */
+  onDone?: () => void;
+}
+
+/**
+ * Creates a streaming Seroval serializer preconfigured with the web plugin
+ * set and the default feature policy. Emits JavaScript chunks (through
+ * `onData`) that reconstruct the values under `globalIdentifier` when
+ * evaluated — the script-injection form of serialization renderers build
+ * on. For a JSON-based wire codec (no eval on the receiving side), use
+ * `serializeJSON` / `createJSONDeserializer` instead.
+ */
+export function createSerializer(options: WebSerializerOptions): Serializer;
+
+/**
+ * Options for `createHydrationSerializer` — `WebSerializerOptions` minus
+ * the knobs hydration pins (`globalIdentifier`, `disabledFeatures`).
+ * @internal
+ */
+export type HydrationSerializerOptions = Omit<
+  WebSerializerOptions,
+  "globalIdentifier" | "disabledFeatures"
+>;
+
+/**
+ * Renderer primitive — the serializer SSR uses for hydration output. Pins
+ * the hydration global (`_$HY.r`) and feature policy; only the wiring
+ * options (callbacks, scope, extra plugins) are configurable. Not meant
+ * for hand-written code — custom serialization should use
+ * `createSerializer` or the JSON codec.
+ * @internal
+ */
+export function createHydrationSerializer(options: HydrationSerializerOptions): Serializer;
+
+/**
+ * Renderer primitive — returns the cross-reference bootstrap script SSR
+ * emits ahead of hydration data for a render scope. Not meant for
+ * hand-written code.
+ * @internal
+ */
+export function getLocalHeaderScript(id?: string): string;
+
+// ---- JSON codec (server function transports) ----
+
+/**
+ * Options shared by both halves of the JSON codec. All of them must match
+ * on the serializing and deserializing peer or payloads will not
+ * round-trip — for server functions, set them once through the
+ * client/server `codec` config option.
+ */
+export interface JSONCodecOptions {
+  /** Extra plugins, composed ahead of `DEFAULT_WEB_PLUGINS`. Must match on both peers. */
+  plugins?: SerializerPlugin[];
+  /**
+   * Seroval feature bitflags to exclude. Defaults to disabling `RegExp`
+   * (payloads may come from an untrusted peer). Must match on both peers.
+   */
+  disabledFeatures?: number;
+  /** Maximum parse/deserialize depth. Defaults to 64. Must match on both peers. */
+  depthLimit?: number;
+}
+
+/** Options for `serializeJSON`. */
+export interface JSONSerializeOptions extends JSONCodecOptions {
+  /**
+   * Receives each serialized node; `initial` is true for the first chunk
+   * (the source value itself). Async values produce additional chunks as
+   * they resolve.
+   */
+  onParse: (node: SerovalNode, initial: boolean) => void;
+  onError?: (error: unknown) => void;
+  /** Fires once all async values have settled. */
+  onDone?: () => void;
+}
+
+/**
+ * Serializes `value` as SerovalNode chunks delivered through `onParse` —
+ * the encoding half of the eval-free JSON codec (RPC-style transports;
+ * the deserializing peer needs no script evaluation, so CSP-safe). Wire
+ * framing of the nodes is the transport's concern. Returns a cancel
+ * function that aborts pending async serialization.
+ */
+export function serializeJSON(value: unknown, options: JSONSerializeOptions): () => void;
+
+/**
+ * Creates the decoding counterpart of `serializeJSON`. Cross-references
+ * between chunks resolve through state shared across calls, so all chunks
+ * from one stream must go through the same deserializer instance. The first
+ * chunk's return value is the decoded source value; feeding later chunks
+ * settles the async values referenced inside it.
+ */
+export function createJSONDeserializer(options?: JSONCodecOptions): <T>(node: SerovalNode) => T;

package/types-cjs/server-functions/client.d.cts

@@ -0,0 +1,63 @@
+import { JSONCodecOptions } from "../serializer.cjs";
+
+export { FUNCTION_HEADER, INSTANCE_HEADER, decodeResponse } from "./shared.cjs";
+
+/** Options for `configureServerFunctionsClient`. */
+export interface ServerFunctionsClientConfig {
+  /**
+   * Endpoint the server's HTTP handler is mounted on. Must match the
+   * server configuration — SSR'd reference `url`s (e.g. form actions) and
+   * client fetches both derive from it. Prefix it when the app serves from
+   * a base path (e.g. `` `${BASE_URL}_server` ``).
+   * @default "/_server"
+   */
+  endpoint?: string;
+  /**
+   * Codec options (extra plugins etc.) for encoding arguments and decoding
+   * results — must match the server's. Stored in the shared layer, so
+   * `decodeResponse` sees them too.
+   */
+  codec?: JSONCodecOptions;
+}
+
+/**
+ * Configures the client transport. Call once, before any server function is
+ * invoked — typically in the client entry, next to `hydrate()`. Only needed
+ * when deviating from the defaults (custom endpoint or codec plugins).
+ */
+export function configureServerFunctionsClient(config?: ServerFunctionsClientConfig): void;
+
+/**
+ * What a server function import is at runtime on the client: an async
+ * callable that fetches the server, plus escape hatches for forms and
+ * custom requests.
+ */
+export interface ServerFunctionCallable {
+  (...args: any[]): Promise<any>;
+  /** URL invoking this function directly over HTTP (e.g. form `action`s). */
+  url: string;
+  /**
+   * Variant issuing GET requests with the arguments encoded in the query
+   * string — cacheable by HTTP infrastructure.
+   */
+  GET: ServerFunctionCallable;
+  /** Variant applying a custom RequestInit to every call (headers etc.). */
+  withOptions(options: RequestInit): ServerFunctionCallable;
+}
+
+/**
+ * Compiler ABI — emitted by compiled `"use server"` client output where a
+ * server function was referenced; produces the fetch-backed callable for
+ * the function's build-stable id. Not meant for hand-written code.
+ * @internal
+ */
+export function createServerReference(id: string): ServerFunctionCallable;
+
+/**
+ * Compiler ABI — only ever referenced by server-mode compiler output;
+ * throws so a misconfigured build (server transform feeding a client
+ * bundle) fails loudly instead of with a missing-export error. Not meant
+ * for hand-written code.
+ * @internal
+ */
+export function registerServerReference(): never;

package/types-cjs/server-functions/server.d.cts

@@ -0,0 +1,188 @@
+import { ResponseEnvelope } from "../response.cjs";
+import { JSONCodecOptions } from "../serializer.cjs";
+import { RequestEvent } from "../server.cjs";
+
+export { FUNCTION_HEADER, INSTANCE_HEADER, decodeResponse } from "./shared.cjs";
+
+/**
+ * The request event a server function call runs under: the base
+ * `RequestEvent` (request + locals) plus `serverOnly`, set when the call is
+ * an in-process SSR invocation whose result never serializes to a client.
+ */
+export interface ServerFunctionEvent extends RequestEvent {
+  serverOnly?: boolean;
+}
+
+/** Options for `configureServerFunctionsServer`. */
+export interface ServerFunctionsServerConfig {
+  /**
+   * Establishes the request-event scope for a call — the function passed
+   * runs with `event` visible to `getRequestEvent()`. Wire it to
+   * `provideRequestEvent` from `@solidjs/web/storage` (or the framework's
+   * equivalent). When omitted, falls back to the AsyncLocalStorage instance
+   * an established request scope parks on the global.
+   */
+  provideEvent?: <T>(event: ServerFunctionEvent, fn: () => T) => T;
+  /**
+   * Endpoint the HTTP handler is mounted on, used for the `url` of SSR'd
+   * references (e.g. form actions) — must match the client configuration.
+   * Prefix it when the app serves from a base path (e.g.
+   * `` `${BASE_URL}_server` ``).
+   * @default "/_server"
+   */
+  endpoint?: string;
+  /**
+   * Codec options (extra plugins etc.) for decoding arguments and encoding
+   * results — must match the client's. Stored in the shared layer, so
+   * `decodeResponse` sees them too.
+   */
+  codec?: JSONCodecOptions;
+}
+
+/**
+ * Configures the server runtime. Call once at server startup, before
+ * handling requests. Only needed when deviating from the defaults (custom
+ * endpoint, codec plugins, or an explicit event provider).
+ */
+export function configureServerFunctionsServer(config?: ServerFunctionsServerConfig): void;
+
+/**
+ * A registered server function: its build-stable id paired with the
+ * original implementation. Returned by `registerServerReference` and
+ * consumed by the server-side `createServerReference`.
+ *
+ * Compiler ABI shape; hand-written code rarely constructs these.
+ * @internal
+ */
+export interface ServerFunctionReference<T extends any[] = any[], R = any> {
+  id: string;
+  fn: (...args: T) => R;
+}
+
+/**
+ * Adds a function to the dispatch registry under an id and returns it
+ * unchanged. The low-level registry write for integrations registering
+ * functions outside the compiler (e.g. a router registering its own
+ * endpoints); compiled output goes through `registerServerReference`
+ * instead. Ids must be stable across the client and server builds.
+ */
+export function registerServerFunction<T extends any[], R>(
+  id: string,
+  callback: (...args: T) => R
+): (...args: T) => R;
+
+/**
+ * Looks up a registered server function by id; throws for unknown ids.
+ * The HTTP handler uses this for dispatch — integrations building custom
+ * dispatch (or introspection) can too.
+ */
+export function getServerFunction<T extends any[], R>(id: string): (...args: T) => R;
+
+/**
+ * Compiler ABI — emitted by compiled `"use server"` server output for
+ * every server function: registers `fn` for HTTP dispatch under its
+ * build-stable id and returns the reference the server-side
+ * `createServerReference` consumes. Not meant for hand-written code.
+ * @internal
+ */
+export function registerServerReference<T extends any[], R>(
+  id: string,
+  fn: (...args: T) => R
+): ServerFunctionReference<T, R>;
+
+/**
+ * Compiler ABI — emitted by compiled `"use server"` server output where
+ * the function was referenced; produces the server-side callable. Calling
+ * it during SSR runs the original function in-process (no HTTP), under a
+ * request event derived from the current one — marked `serverOnly` and
+ * carrying the function's meta. Not meant for hand-written code.
+ * @internal
+ */
+export function createServerReference<T extends any[], R>(
+  reference: ServerFunctionReference<T, R>
+): (...args: T) => R;
+
+/** Identity of the currently executing server function. */
+export interface ServerFunctionMeta {
+  id: string;
+}
+
+/**
+ * Reads the calling server function's meta (its id) off the current request
+ * event — usable inside a server function body, e.g. to key caches or logs
+ * by function. Returns undefined outside a server function call.
+ */
+export function getServerFunctionMeta(): ServerFunctionMeta | undefined;
+
+/**
+ * Hooks layering framework policy onto `handleServerFunctionRequest`.
+ * All are optional — the bare handler dispatches, scopes events, and
+ * encodes results on its own.
+ */
+export interface HandleServerFunctionOptions {
+  /**
+   * Builds the request event a call runs under (default: bare
+   * `{ request, locals: {} }`). Integrations supply their richer event
+   * (cookies, response helpers, platform handles).
+   */
+  createEvent?(request: Request): ServerFunctionEvent;
+  /**
+   * Overrides the configured event provider for this handler — same
+   * contract as the `provideEvent` config option.
+   */
+  provideEvent?<T>(event: ServerFunctionEvent, fn: () => T): T;
+  /**
+   * Observes or replaces the function's result before encoding — the
+   * extension point for policies like single-flight payloads. Runs for
+   * returned and thrown results alike (`context.thrown` distinguishes);
+   * `context.instance` is null for no-JS calls. Return the result
+   * unchanged to pass through, or a `ResponseEnvelope` (exposed through
+   * the core entry) to send HTTP metadata plus a structured payload.
+   */
+  transformResult?(
+    event: ServerFunctionEvent,
+    result: unknown,
+    context: { instance: string | null; request: Request; thrown?: boolean }
+  ): unknown | ResponseEnvelope | Promise<unknown | ResponseEnvelope>;
+  /**
+   * Builds the response for calls made without the client runtime (no
+   * instance header — no-JS form posts, direct HTTP) — the extension
+   * point for conventions like redirect-with-flash-cookie. Receives the
+   * (transformed) result, the request, and the decoded arguments; `thrown`
+   * is set when the result was thrown rather than returned. Defaults to
+   * the normal serialized response.
+   */
+  handleNoJS?(
+    result: unknown,
+    request: Request,
+    args: unknown[],
+    thrown?: boolean
+  ): Response | Promise<Response>;
+  /** Overrides the configured codec options for this handler. */
+  codec?: JSONCodecOptions;
+}
+
+/**
+ * Web-standard HTTP handler for server function calls: resolves the
+ * function id from the request, decodes arguments, runs the function under
+ * a request-event scope, and encodes the result (forwarding
+ * redirect/revalidation metadata through headers). Mount it on the endpoint
+ * the client transport targets (default `/_server`); platform adapters
+ * (h3, express, ...) convert their request shape to a web `Request` around
+ * it.
+ *
+ * @example
+ * ```ts
+ * import { handleServerFunctionRequest } from "@solidjs/web/server-functions";
+ * import "virtual:solid-server-function-manifest";
+ *
+ * // in the server's request handling:
+ * if (url.pathname.startsWith("/_server")) {
+ *   return handleServerFunctionRequest(request);
+ * }
+ * ```
+ */
+export function handleServerFunctionRequest(
+  request: Request,
+  options?: HandleServerFunctionOptions
+): Promise<Response>;

package/types-cjs/server-functions/shared.d.cts

@@ -0,0 +1,171 @@
+import { JSONCodecOptions } from "../serializer.cjs";
+
+export type { JSONCodecOptions };
+
+/**
+ * Configures the codec options for the server function wire format (extra
+ * Seroval plugins, feature policy, depth limit). Both peers must configure
+ * identical options or payloads will not round-trip. Usually called
+ * indirectly through `configureServerFunctionsClient` /
+ * `configureServerFunctionsServer` (their `codec` option writes through to
+ * here); call it directly only from universal code configuring both sides
+ * at once.
+ */
+export function configureServerFunctionsCodec(codec: JSONCodecOptions | undefined): void;
+
+/**
+ * The currently configured codec options (set through
+ * `configureServerFunctionsCodec` or the client/server `codec` option), or
+ * undefined when running on the defaults. Integrations pass this to
+ * lower-level codec helpers so custom plugins configured by the app apply.
+ */
+export function getServerFunctionsCodec(): JSONCodecOptions | undefined;
+
+/**
+ * Request header carrying the server function id (`"X-Server-Function-Id"`).
+ * Integrations can read it to identify which function a request targets;
+ * the id also arrives as the `id` query parameter for GET calls and no-JS
+ * form posts.
+ */
+export const FUNCTION_HEADER: string;
+
+/**
+ * Request header carrying a per-call instance id
+ * (`"X-Server-Function-Instance"`). Its presence tells the server the call
+ * came through the client runtime — its absence marks a no-JS form post or
+ * direct HTTP call, which receive plain responses instead of codec-encoded
+ * ones.
+ */
+export const INSTANCE_HEADER: string;
+
+/**
+ * Header carrying the body format tag (a `BodyFormat` value) —
+ * `"X-Server-Function-Format"`.
+ *
+ * Transport wire detail; not meant for hand-written code.
+ * @internal
+ */
+export const BODY_FORMAT_HEADER: string;
+
+/**
+ * FormData key used when a lone File is sent as the argument.
+ *
+ * Transport wire detail; not meant for hand-written code.
+ * @internal
+ */
+export const FILE_FORM_KEY: string;
+
+/**
+ * Wire tags naming how a request/response body was encoded, carried in
+ * `BODY_FORMAT_HEADER`.
+ *
+ * Transport wire detail; not meant for hand-written code.
+ * @internal
+ */
+export const BodyFormat: {
+  readonly Serialized: "0";
+  readonly String: "1";
+  readonly FormData: "2";
+  readonly URLSearchParams: "3";
+  readonly Blob: "4";
+  readonly File: "5";
+  readonly ArrayBuffer: "6";
+  readonly Uint8Array: "7";
+};
+
+/**
+ * Transport wire detail; not meant for hand-written code.
+ * @internal
+ */
+export type BodyFormatValue = (typeof BodyFormat)[keyof typeof BodyFormat];
+
+/**
+ * Picks a direct HTTP encoding (headers + BodyInit) for values that have
+ * one — strings, FormData, URLSearchParams, File, Blob, ArrayBuffer,
+ * Uint8Array. Returns undefined when the value needs the serializer.
+ *
+ * Transport building block used by the fetch transport and the HTTP
+ * handler; not meant for hand-written code.
+ * @internal
+ */
+export function getHeadersAndBody(
+  body: unknown
+): { headers?: Record<string, string>; body: BodyInit } | undefined;
+
+/**
+ * Decodes a Request/Response body according to its `BODY_FORMAT_HEADER`
+ * tag (falling back to content-type sniffing for form posts that never saw
+ * the client runtime). The inverse of `getHeadersAndBody` + the serialized
+ * stream. Resolves undefined for bodies without a recognized encoding.
+ *
+ * Transport building block; use `decodeResponse` from integration code.
+ * @internal
+ */
+export function extractBody(
+  source: Request | Response,
+  codecOptions?: JSONCodecOptions
+): Promise<unknown>;
+
+/**
+ * Serializes a value as a stream of length-prefixed SerovalNode chunks.
+ * Async values (promises, streams) keep the stream open until they settle,
+ * so one connection carries incremental results. Codec options must match
+ * the deserializing peer.
+ *
+ * Transport building block; not meant for hand-written code.
+ * @internal
+ */
+export function serializeStream(
+  value: unknown,
+  codecOptions?: JSONCodecOptions
+): ReadableStream<Uint8Array>;
+
+/**
+ * `serializeStream` drained to a string (async values fully awaited).
+ *
+ * Transport building block; not meant for hand-written code.
+ * @internal
+ */
+export function serializeString(value: unknown, codecOptions?: JSONCodecOptions): Promise<string>;
+
+/**
+ * Decodes a framed chunk stream from a Request/Response body. Resolves with
+ * the first chunk's value (the source value); later chunks settle the async
+ * values referenced inside it as they arrive.
+ *
+ * Transport building block; use `decodeResponse` from integration code.
+ * @internal
+ */
+export function deserializeStream<T = unknown>(
+  source: Request | Response,
+  codecOptions?: JSONCodecOptions
+): Promise<T>;
+
+/**
+ * `deserializeStream` for an already-buffered string.
+ *
+ * Transport building block; not meant for hand-written code.
+ * @internal
+ */
+export function deserializeString<T = unknown>(
+  text: string,
+  codecOptions?: JSONCodecOptions
+): Promise<T>;
+
+/**
+ * Decodes a server function response body using the configured codec. This
+ * is the integration-facing decoder: routers call it on responses the
+ * transport hands over whole — redirects, revalidation, single-flight
+ * payloads — to recover the structured value inside. Resolves undefined for
+ * empty bodies and bodies without a recognized encoding (e.g. a raw user
+ * Response). Renderer- and platform-neutral: safe to use from universal
+ * code.
+ *
+ * @param response the transport response; its body is read from a clone,
+ * so the original stays readable
+ * @param codecOptions overrides the configured codec for this call
+ */
+export function decodeResponse<T = unknown>(
+  response: Response,
+  codecOptions?: JSONCodecOptions
+): Promise<T | undefined>;