@danceroutine/tango-core 1.11.1 → 1.11.2

package/dist/index-D8o4DOOG.d.ts

@@ -0,0 +1,824 @@
+import { i as TangoError, r as ProblemDetails, t as ErrorDetails } from "./TangoError-ptR2iApz.js";
+
+//#region src/http/TangoBody.d.ts
+/**
+ * The full type of body that TangoResponse/TangoBody supports.
+ * Unlike the fetch spec BodyInit, this can be directly:
+ * - a string, ArrayBuffer, Uint8Array, Blob, FormData, ReadableStream, or JSON-like object, or null/undefined.
+ */
+type HeadersLike = {
+  get?: (arg: string) => string | null;
+};
+type TangoBodySource = BodyInit | JsonValue | null;
+/** Recursive JSON value contract used by Tango HTTP helpers. */
+type JsonValue = string | number | boolean | null | JsonValue[] | {
+  [key: string]: JsonValue;
+};
+/**
+ * Unified body reader/clone utility for Tango request/response wrappers.
+ */
+declare class TangoBody {
+  static readonly BRAND: "tango.http.body";
+  readonly __tangoBrand: typeof TangoBody.BRAND;
+  private bodySourceInternal;
+  private bodyUsedInternal;
+  private headers?;
+  constructor(bodySource: TangoBodySource, headers?: HeadersLike);
+  /**
+   * Narrow an unknown value to `TangoBody`.
+   */
+  static isTangoBody(value: unknown): value is TangoBody;
+  /**
+   * Expose the original body source for cloning and adapter integration.
+   */
+  get bodySource(): TangoBodySource;
+  /**
+   * Report whether a reader method has already consumed this body.
+   */
+  get bodyUsed(): boolean;
+  /**
+   * Describe the current body shape in a way that is useful for diagnostics.
+   */
+  get bodyType(): string;
+  /**
+   * Returns true if value is a valid JSON value (recursively).
+   */
+  static isJsonValue(v: unknown): v is JsonValue;
+  /**
+   * Deep clone utility for body values. Preserves types and values as in the legacy implementation.
+   * If the source is a stream, the stream will be cloned if readable, otherwise throws.
+   */
+  static deepCloneBody(body: TangoBodySource): TangoBodySource;
+  /**
+   * Read a `ReadableStream` into an `ArrayBuffer`.
+   */
+  static readStreamToArrayBuffer(stream: ReadableStream<Uint8Array>): Promise<ArrayBuffer>;
+  /**
+   * Read a `ReadableStream` into a `Uint8Array`.
+   */
+  static readStreamToUint8Array(stream: ReadableStream<Uint8Array>): Promise<Uint8Array<ArrayBuffer>>;
+  /**
+   * Read a `ReadableStream` into UTF-8 text.
+   */
+  static readStreamToText(stream: ReadableStream<Uint8Array>): Promise<string>;
+  /**
+   * Determine the content type for this body, if possible.
+   * Respects an explicitly passed header, otherwise infers from value type.
+   */
+  static detectContentType(body: TangoBodySource, providedType?: string): string | undefined;
+  /**
+   * Attempt to determine the content length, in bytes, for this body.
+   * Only available for certain body types, otherwise returns undefined.
+   */
+  static getContentLength(body: TangoBodySource): Promise<number | undefined>;
+  /**
+   * Reads the body as an ArrayBuffer.
+   */
+  arrayBuffer(): Promise<ArrayBuffer>;
+  /**
+   * Reads the body as a Blob (browser only).
+   */
+  blob(): Promise<Blob>;
+  /**
+   * Reads the body as a Uint8Array.
+   */
+  bytes(): Promise<Uint8Array<ArrayBuffer>>;
+  /**
+   * Reads the body as FormData.
+   * Accepts FormData, or if type is urlencoded or multipart parses a string/bytes.
+   */
+  formData(): Promise<FormData>;
+  /**
+   * Reads and parses the body as JSON (if possible).
+   */
+  json<T = unknown>(): Promise<T>;
+  /**
+   * Reads the body as UTF-8 string.
+   */
+  text(): Promise<string>;
+  /**
+   * Returns the original body value (may be used for streaming or clone).
+   */
+  getRawBodyInit(): TangoBodySource;
+  /**
+   * Clone the body instance and stream if possible.
+   * If the source is a stream, the stream will be cloned if readable, otherwise throws.
+   */
+  clone(): TangoBody;
+  /**
+   * Helper for all readers. Only allows reading once.
+   */
+  private consumeBody;
+}
+//#endregion
+//#region src/http/TangoHeaders.d.ts
+/**
+ * TangoHeaders extends the Web Headers class, adding ergonomic helpers
+ * for common HTTP header patterns, convenience features, and a consistent API for
+ * setting, appending, and deleting headers and cookies. This is designed to be
+ * used by TangoResponse and other Tango HTTP utilities.
+ * Additionally, provides helpers for safely setting Content-Length based on a known body,
+ * and setting Content-Disposition for inline or attachment filenames.
+ *
+ * Includes helpers for request tracing and correlation headers:
+ *   - X-Request-Id
+ *   - traceparent (W3C Trace Context)
+ *   - Server-Timing
+ *   - X-Response-Time
+ */
+declare class TangoHeaders extends Headers {
+  static readonly BRAND: "tango.http.headers";
+  readonly __tangoBrand: typeof TangoHeaders.BRAND;
+  /**
+   * Narrow an unknown value to `TangoHeaders`.
+   */
+  static isTangoHeaders(value: unknown): value is TangoHeaders;
+  /**
+   * Serialize a cookie for the Set-Cookie header line.
+   */
+  private static serializeCookie;
+  private static hasNumberSize;
+  private static hasNumberLength;
+  private static isNodeBuffer;
+  /**
+   * Sets the Content-Disposition header with type "inline" and the specified filename.
+   * This is useful to indicate that the content should be displayed inline in the browser,
+   * but with a suggested filename for saving.
+   *
+   * @param filename The filename to include in the Content-Disposition header.
+   */
+  setContentDispositionInline(filename: string): void;
+  /**
+   * Sets the Content-Disposition header with type "attachment" and the specified filename.
+   * This is useful to indicate that the response should be downloaded as a file.
+   *
+   * @param filename The filename to include in the Content-Disposition header.
+   */
+  setContentDispositionAttachment(filename: string): void;
+  /**
+   * Create a copy that preserves all header names and values.
+   */
+  clone(): TangoHeaders;
+  /**
+   * Set a header, replacing the existing value.
+   */
+  setHeader(name: string, value: string): void;
+  /**
+   * Append a header, adding to existing value(s) for the name.
+   */
+  appendHeader(name: string, value: string): void;
+  /**
+   * Get a header value (first value if header is repeated).
+   */
+  getHeader(name: string): string | null;
+  /**
+   * Check if a header exists.
+   */
+  hasHeader(name: string): boolean;
+  /**
+   * Delete a header.
+   */
+  deleteHeader(name: string): void;
+  /**
+   * Ensure a header is present only once and fully replaces the old value.
+   */
+  ensureUnique(name: string, value: string): void;
+  /**
+   * Add a field (or fields) to the Vary header, merging with existing values.
+   */
+  vary(...fields: string[]): void;
+  /**
+   * Set a cookie header (for Set-Cookie).
+   * @param name
+   * @param value
+   * @param options
+   */
+  setCookie(name: string, value: string, options?: {
+    domain?: string;
+    expires?: Date;
+    httpOnly?: boolean;
+    maxAge?: number;
+    path?: string;
+    sameSite?: 'Strict' | 'Lax' | 'None';
+    secure?: boolean;
+    priority?: 'Low' | 'Medium' | 'High';
+    partitioned?: boolean;
+  }): void;
+  /**
+   * Append (additionally) a new cookie.
+   */
+  appendCookie(name: string, value: string, options?: {
+    domain?: string;
+    expires?: Date;
+    httpOnly?: boolean;
+    maxAge?: number;
+    path?: string;
+    sameSite?: 'Strict' | 'Lax' | 'None';
+    secure?: boolean;
+    priority?: 'Low' | 'Medium' | 'High';
+    partitioned?: boolean;
+  }): void;
+  /**
+   * Delete a cookie ("unset" it via expired date).
+   */
+  deleteCookie(name: string, options?: {
+    domain?: string;
+    path?: string;
+    sameSite?: 'Strict' | 'Lax' | 'None';
+    secure?: boolean;
+    priority?: 'Low' | 'Medium' | 'High';
+    partitioned?: boolean;
+  }): void;
+  /**
+   * Add or override Cache-Control header with helpers for common policies.
+   */
+  cacheControl(control: string | Record<string, string | number | boolean | undefined>): void;
+  /**
+   * Set the Location header.
+   */
+  location(url: string): void;
+  /**
+   * Set the Content-Type header.
+   */
+  contentType(mime: string): void;
+  /**
+   * Attempt to guess and set the Content-Type header from a file (string or Blob) and optional filename.
+   *
+   * @param file File-like input (string or Blob)
+   * @param filename Optional filename to help guess mime type by extension
+   */
+  setContentTypeByFile(file: unknown, filename?: string): void;
+  /**
+   * Sets the Content-Length header, inferring it from the body if not explicitly provided.
+   * If the body is a string, ArrayBuffer, Uint8Array, Blob/Buffer (or has a .size or .length property),
+   * the length is computed. For unsupported types, does nothing.
+   * Mirrors logic from TangoResponse.ts, but generalized for use anywhere.
+   */
+  setContentLengthFromBody(body: unknown): void;
+  /**
+   * Set or update the X-Request-Id header. Used for associating a request/response with a unique id.
+   * @param id The request id value to set.
+   */
+  withRequestId(id: string): this;
+  /**
+   * Set or update the traceparent header. Used for distributed trace context propagation (W3C Trace Context).
+   * @param value The traceparent value (should be a valid traceparent header value).
+   */
+  withTraceParent(value: string): this;
+  /**
+   * Set or append a value to the Server-Timing header.
+   * For a single metric, supply name, and optionally dur and desc.
+   * For advanced usage (many metrics), set the value directly or use appendServerTimingRaw.
+   *
+   * @param name Name of the server-timing metric (e.g., 'total', 'db').
+   * @param dur Optional duration in ms.
+   * @param desc Optional string description.
+   */
+  withServerTiming(name: string, dur?: number, desc?: string): this;
+  /**
+   * Directly append a raw Server-Timing metric value.
+   * This is useful for advanced cases where you have multiple metrics assembled.
+   * @param value The server-timing value chunk to append.
+   */
+  appendServerTimingRaw(value: string): this;
+  /**
+   * Set or update X-Response-Time header.
+   * @param ms Elapsed time in milliseconds (number or string for flexibility).
+   */
+  withResponseTime(ms: number | string): this;
+  /**
+   * Return the current value of X-Request-Id.
+   */
+  getRequestId(): string | null;
+  /**
+   * Return the current value of traceparent header.
+   */
+  getTraceParent(): string | null;
+  /**
+   * Return the current Server-Timing string, if set.
+   */
+  getServerTiming(): string | null;
+  /**
+   * Return the current X-Response-Time string, if set.
+   */
+  getResponseTime(): string | null;
+}
+//#endregion
+//#region src/http/TangoRequest.d.ts
+type TangoRequestInit = {
+  method?: string;
+  headers?: HeadersInit;
+  body?: BodyInit | JsonValue | null;
+  redirect?: RequestRedirect;
+  cache?: RequestCache;
+  credentials?: RequestCredentials;
+  integrity?: string;
+  keepalive?: boolean;
+  mode?: RequestMode;
+  referrer?: string;
+  referrerPolicy?: ReferrerPolicy;
+  signal?: AbortSignal;
+};
+/**
+ * Framework request wrapper that normalizes JSON-like bodies and preserves
+ * fetch `Request` compatibility for downstream handlers.
+ */
+declare class TangoRequest implements Request {
+  static readonly BRAND: "tango.http.request";
+  readonly __tangoBrand: typeof TangoRequest.BRAND;
+  private request;
+  private bodySourceValue;
+  private queryParamsValue?;
+  constructor(input: string | Request, init?: TangoRequestInit);
+  /**
+   * Narrow an unknown value to `TangoRequest`.
+   */
+  static isTangoRequest(value: unknown): value is TangoRequest;
+  /**
+   * Expose the request cache mode from the underlying fetch request.
+   */
+  get cache(): RequestCache;
+  /**
+   * Expose the request credentials mode from the underlying fetch request.
+   */
+  get credentials(): RequestCredentials;
+  /**
+   * Expose the request destination from the underlying fetch request.
+   */
+  get destination(): RequestDestination;
+  /**
+   * Expose the request headers from the underlying fetch request.
+   */
+  get headers(): Headers;
+  /**
+   * Expose the request integrity value from the underlying fetch request.
+   */
+  get integrity(): string;
+  /**
+   * Expose the request keepalive flag from the underlying fetch request.
+   */
+  get keepalive(): boolean;
+  /**
+   * Expose the normalized HTTP method.
+   */
+  get method(): string;
+  /**
+   * Expose the request mode from the underlying fetch request.
+   */
+  get mode(): RequestMode;
+  /**
+   * Expose the redirect policy from the underlying fetch request.
+   */
+  get redirect(): RequestRedirect;
+  /**
+   * Expose the referrer from the underlying fetch request.
+   */
+  get referrer(): string;
+  /**
+   * Expose the referrer policy from the underlying fetch request.
+   */
+  get referrerPolicy(): ReferrerPolicy;
+  /**
+   * Expose the abort signal from the underlying fetch request.
+   */
+  get signal(): AbortSignal;
+  /**
+   * Expose the absolute request URL.
+   */
+  get url(): string;
+  /**
+   * Expose the readable request body stream when one exists.
+   */
+  get body(): Request['body'];
+  /**
+   * Report whether the body has been consumed.
+   */
+  get bodyUsed(): boolean;
+  /**
+   * Expose the pre-normalized body value used to build the request.
+   */
+  get bodySource(): BodyInit | JsonValue | null;
+  /**
+   * Expose normalized query parameters derived from the request URL.
+   */
+  get queryParams(): TangoQueryParams;
+  /**
+   * Read the request body as an array buffer.
+   */
+  arrayBuffer(): Promise<ArrayBuffer>;
+  /**
+   * Read the request body as a blob.
+   */
+  blob(): Promise<Blob>;
+  /**
+   * Read the request body as bytes, including runtimes without `Request.bytes()`.
+   */
+  bytes(): Promise<Uint8Array<ArrayBuffer>>;
+  /**
+   * Read the request body as form data.
+   */
+  formData(): Promise<FormData>;
+  /**
+   * Parse the request body as JSON.
+   */
+  json<T = unknown>(): Promise<T>;
+  /**
+   * Read the request body as text.
+   */
+  text(): Promise<string>;
+  /**
+   * Clone the request so downstream code can consume it independently.
+   */
+  clone(): TangoRequest;
+  private normalizeBody;
+}
+//#endregion
+//#region src/http/TangoQueryParams.d.ts
+type QueryParamRecord = Record<string, string | string[] | undefined>;
+type QueryParamMutationValue = string | number | readonly (string | number)[] | null | undefined;
+type QueryParamMutationRecord = Record<string, QueryParamMutationValue>;
+/**
+ * Immutable query parameter helper that normalizes framework-specific shapes
+ * into one Tango-owned API.
+ */
+declare class TangoQueryParams {
+  static readonly BRAND: "tango.http.query_params";
+  readonly __tangoBrand: typeof TangoQueryParams.BRAND;
+  private readonly values;
+  private constructor();
+  /**
+   * Narrow an unknown value to `TangoQueryParams`.
+   */
+  static isTangoQueryParams(value: unknown): value is TangoQueryParams;
+  /**
+   * Build query params from a `URLSearchParams` instance.
+   */
+  static fromURLSearchParams(params: URLSearchParams): TangoQueryParams;
+  /**
+   * Build query params from framework record-style search params.
+   */
+  static fromRecord(params: QueryParamRecord): TangoQueryParams;
+  /**
+   * Build query params from a full URL string or URL object.
+   */
+  static fromURL(input: string | URL): TangoQueryParams;
+  /**
+   * Build query params from a request-like object with a URL.
+   */
+  static fromRequest(request: Request | TangoRequest): TangoQueryParams;
+  /**
+   * Get the first value for a query param.
+   */
+  get(name: string): string | undefined;
+  /**
+   * Get all values for a query param.
+   */
+  getAll(name: string): string[];
+  /**
+   * Check whether a query param exists.
+   */
+  has(name: string): boolean;
+  /**
+   * Iterate key -> values entries.
+   */
+  entries(): IterableIterator<[string, string[]]>;
+  /**
+   * Iterate keys present in the query params.
+   */
+  keys(): IterableIterator<string>;
+  /**
+   * Convert back to a native `URLSearchParams` object.
+   */
+  toURLSearchParams(): URLSearchParams;
+  /**
+   * Return a new query param set with selected keys replaced or removed.
+   *
+   * `undefined`, `null`, and empty arrays remove the key entirely.
+   */
+  withValues(updates: QueryParamMutationRecord): TangoQueryParams;
+  /**
+   * Convert to a relative query string suitable for links.
+   */
+  toRelativeURL(): string;
+  /**
+   * Get a trimmed value, omitting blank strings.
+   */
+  getTrimmed(name: string): string | undefined;
+  /**
+   * Get the free-text search param using Tango's default key.
+   */
+  getSearch(key?: string): string | undefined;
+  /**
+   * Get the ordering param as trimmed field tokens.
+   */
+  getOrdering(key?: string): string[];
+}
+//#endregion
+//#region src/http/TangoResponse.d.ts
+type TangoResponseInit = {
+  body?: BodyInit | JsonValue | null;
+  headers?: HeadersInit;
+  ok?: boolean;
+  redirected?: boolean;
+  status?: number;
+  statusText?: string;
+  type?: ResponseType;
+  url?: string;
+};
+/**
+ * Framework response wrapper with fetch-compatible surface plus ergonomic helpers.
+ */
+declare class TangoResponse implements Response {
+  static readonly BRAND: "tango.http.response";
+  readonly __tangoBrand: typeof TangoResponse.BRAND;
+  readonly headers: TangoHeaders;
+  readonly redirected: boolean;
+  readonly status: number;
+  readonly statusText: string;
+  readonly type: ResponseType;
+  readonly url: string;
+  readonly body: Response['body'];
+  private tangoBody;
+  private okValue;
+  constructor(init?: TangoResponseInit);
+  /**
+   * Narrow an unknown value to `TangoResponse`.
+   */
+  static isTangoResponse(value: unknown): value is TangoResponse;
+  /**
+   * Create a JSON response with sensible content headers.
+   */
+  static json(data: JsonValue, init?: Omit<TangoResponseInit, 'body' | 'headers'> & {
+    headers?: HeadersInit;
+  }): TangoResponse;
+  /**
+   * Create a plain-text response with sensible content headers.
+   */
+  static text(text: string, init?: Omit<TangoResponseInit, 'body' | 'headers'> & {
+    headers?: HeadersInit;
+  }): TangoResponse;
+  /**
+   * Create an HTML response with sensible content headers.
+   */
+  static html(html: string, init?: Omit<TangoResponseInit, 'body' | 'headers'> & {
+    headers?: HeadersInit;
+  }): TangoResponse;
+  /**
+   * Create a streaming response without buffering the payload in memory.
+   */
+  static stream(stream: ReadableStream<Uint8Array>, init?: Omit<TangoResponseInit, 'body' | 'headers'> & {
+    headers?: HeadersInit;
+  }): TangoResponse;
+  /**
+   * Create a redirect response and set the `Location` header.
+   */
+  static redirect(url: string, status?: number, init?: Omit<TangoResponseInit, 'body' | 'headers' | 'status'> & {
+    headers?: HeadersInit;
+  }): TangoResponse;
+  /**
+   * Create an empty `204 No Content` response.
+   */
+  static noContent(init?: Omit<TangoResponseInit, 'body' | 'status' | 'headers'> & {
+    headers?: HeadersInit;
+  }): TangoResponse;
+  /**
+   * Create a `201 Created` response and optionally attach a location or body.
+   */
+  static created(location?: string, body?: JsonValue, init?: Omit<TangoResponseInit, 'body' | 'status' | 'headers'> & {
+    headers?: HeadersInit;
+  }): TangoResponse;
+  /**
+   * Create a `405 Method Not Allowed` response and optionally populate `Allow`.
+   */
+  static methodNotAllowed(allow?: readonly string[], detail?: string, init?: Omit<TangoResponseInit, 'body' | 'status' | 'headers'> & {
+    headers?: HeadersInit;
+  }): TangoResponse;
+  /**
+   * Normalize a Tango error or problem-details object into an error response.
+   */
+  static error<TDetails extends ErrorDetails = null>(error: TangoError | ProblemDetails<TDetails>, init?: Omit<TangoResponseInit, 'body' | 'headers'> & {
+    headers?: HeadersInit;
+  }): TangoResponse;
+  /**
+   * Create a `400 Bad Request` response from a string or structured error.
+   */
+  static badRequest<TDetails extends ErrorDetails = null>(detail?: string | TangoError | ProblemDetails<TDetails>, init?: Omit<TangoResponseInit, 'body' | 'status' | 'headers'> & {
+    headers?: HeadersInit;
+  }): TangoResponse;
+  /**
+   * Create a `401 Unauthorized` response from a string or structured error.
+   */
+  static unauthorized<TDetails extends ErrorDetails = null>(detail?: string | TangoError | ProblemDetails<TDetails>, init?: Omit<TangoResponseInit, 'body' | 'status' | 'headers'> & {
+    headers?: HeadersInit;
+  }): TangoResponse;
+  /**
+   * Create a `403 Forbidden` response from a string or structured error.
+   */
+  static forbidden<TDetails extends ErrorDetails = null>(detail?: string | TangoError | ProblemDetails<TDetails>, init?: Omit<TangoResponseInit, 'body' | 'status' | 'headers'> & {
+    headers?: HeadersInit;
+  }): TangoResponse;
+  /**
+   * Create a `404 Not Found` response from a string or structured error.
+   */
+  static notFound<TDetails extends ErrorDetails = null>(detail?: string | TangoError | ProblemDetails<TDetails>, init?: Omit<TangoResponseInit, 'body' | 'status' | 'headers'> & {
+    headers?: HeadersInit;
+  }): TangoResponse;
+  /**
+   * Create a `409 Conflict` response from a string or structured error.
+   */
+  static conflict<TDetails extends ErrorDetails = null>(detail?: string | TangoError | ProblemDetails<TDetails>, init?: Omit<TangoResponseInit, 'body' | 'status' | 'headers'> & {
+    headers?: HeadersInit;
+  }): TangoResponse;
+  /**
+   * Create a `422 Unprocessable Entity` response from a string or structured error.
+   */
+  static unprocessableEntity<TDetails extends ErrorDetails = null>(detail?: string | TangoError | ProblemDetails<TDetails>, init?: Omit<TangoResponseInit, 'body' | 'status' | 'headers'> & {
+    headers?: HeadersInit;
+  }): TangoResponse;
+  /**
+   * Create a `429 Too Many Requests` response from a string or structured error.
+   */
+  static tooManyRequests<TDetails extends ErrorDetails = null>(detail?: string | TangoError | ProblemDetails<TDetails>, init?: Omit<TangoResponseInit, 'body' | 'status' | 'headers'> & {
+    headers?: HeadersInit;
+  }): TangoResponse;
+  /**
+   * Create a problem-details style error response with Tango's envelope shape.
+   */
+  static problem<TDetails extends ErrorDetails = null>(problem?: string | TangoError | ProblemDetails<TDetails> | unknown, init?: Omit<TangoResponseInit, 'body' | 'headers'> & {
+    headers?: HeadersInit;
+    status?: number;
+  }): TangoResponse;
+  /**
+   * Returns a response for serving a file.
+   */
+  static file(file: Blob | Uint8Array | ArrayBuffer | ReadableStream<Uint8Array> | string, opts?: {
+    filename?: string;
+    contentType?: string;
+    init?: Omit<TangoResponseInit, 'body' | 'headers'> & {
+      headers?: HeadersInit;
+    };
+  }): TangoResponse;
+  /**
+   * Returns a response that prompts the user to download the file.
+   */
+  static download(file: Blob | Uint8Array | ArrayBuffer | ReadableStream<Uint8Array> | string, opts?: {
+    filename?: string;
+    contentType?: string;
+    init?: Omit<TangoResponseInit, 'body' | 'headers'> & {
+      headers?: HeadersInit;
+    };
+  }): TangoResponse;
+  private static normalizeWebBody;
+  /**
+   * Expose the original body source for cloning and adapter integration.
+   */
+  get bodySource(): BodyInit | JsonValue | null;
+  /**
+   * Report whether the status code falls inside the 2xx range.
+   */
+  get ok(): boolean;
+  /**
+   * Report whether the body has been consumed.
+   */
+  get bodyUsed(): boolean;
+  /**
+   * Replace a header value on the response.
+   */
+  setHeader(name: string, value: string): void;
+  /**
+   * Append another value for a repeated response header.
+   */
+  appendHeader(name: string, value: string): void;
+  /**
+   * Read a response header value.
+   */
+  getHeader(name: string): string | null;
+  /**
+   * Check whether a response header is present.
+   */
+  hasHeader(name: string): boolean;
+  /**
+   * Remove a response header.
+   */
+  deleteHeader(name: string): void;
+  /**
+   * Merge one or more values into the `Vary` header.
+   */
+  vary(...fields: string[]): void;
+  /**
+   * Add a `Set-Cookie` header that replaces prior application intent.
+   */
+  setCookie(name: string, value: string, options?: Parameters<TangoHeaders['setCookie']>[2]): void;
+  /**
+   * Append another `Set-Cookie` header.
+   */
+  appendCookie(name: string, value: string, options?: Parameters<TangoHeaders['appendCookie']>[2]): void;
+  /**
+   * Expire a cookie by issuing a matching deletion cookie header.
+   */
+  deleteCookie(name: string, options?: Parameters<TangoHeaders['deleteCookie']>[1]): void;
+  /**
+   * Set the `Cache-Control` header through Tango's higher-level helper.
+   */
+  cacheControl(control: Parameters<TangoHeaders['cacheControl']>[0]): void;
+  /**
+   * Set the `Location` header on the response.
+   */
+  location(url: string): void;
+  /**
+   * Set the response content type.
+   */
+  contentType(mime: string): void;
+  /**
+   * Set the X-Request-Id header (request correlation).
+   * Returns this for fluent chaining.
+   */
+  withRequestId(requestId: string | undefined | null): this;
+  /**
+   * Set the traceparent header (W3C Trace Context propagation).
+   * Returns this for fluent chaining.
+   */
+  withTraceparent(traceparent: string | undefined | null): this;
+  /**
+   * Set the Server-Timing header.
+   * Accepts a string or array of timing metrics.
+   * Returns this for fluent chaining.
+   */
+  withServerTiming(timing: string | string[]): this;
+  /**
+   * Set the X-Response-Time header (in ms).
+   * Numeric or formatted string (e.g. "76ms").
+   * Returns this for fluent chaining.
+   */
+  withResponseTime(time: number | string): this;
+  /**
+   * Propagate common tracing/correlation headers from provided Headers, TangoHeaders, or plain object.
+   * Known headers: x-request-id, traceparent, server-timing
+   * Returns this for fluent chaining.
+   */
+  propagateTraceHeaders(input: HeadersInit): this;
+  /**
+   * Clone the response so its body can be consumed independently.
+   */
+  clone(): TangoResponse;
+  /**
+   * Convert this Tango-owned response into a native web `Response`.
+   *
+   * Adapters use this at the host-framework boundary so Tango can standardize
+   * on `TangoResponse` internally while Next.js and other hosts still receive
+   * a platform-native response object.
+   */
+  toWebResponse(): Response;
+  /**
+   * Read the response body as an array buffer.
+   */
+  arrayBuffer(): Promise<ArrayBuffer>;
+  /**
+   * Read the response body as a blob.
+   */
+  blob(): Promise<Blob>;
+  /**
+   * Read the response body as bytes.
+   */
+  bytes(): Promise<Uint8Array<ArrayBuffer>>;
+  /**
+   * Read the response body as form data.
+   */
+  formData(): Promise<FormData>;
+  /**
+   * Parse the response body as JSON.
+   */
+  json<T = unknown>(): Promise<T>;
+  /**
+   * Read the response body as text.
+   */
+  text(): Promise<string>;
+  /**
+   * Returns a plain object debug representation of this response: { status, headers: { ... }, bodyType: ... }.
+   * Intended for testing and debug tooling.
+   */
+  toJSON(): {
+    status: number;
+    headers: Record<string, string>;
+    bodyType: string;
+  };
+  /**
+   * Returns the original body for test/debug purposes *without* consuming the stream.
+   *
+   * @throws {Error} if called in a production environment. Provided only for test or debug.
+   * @remarks
+   * This method gives direct access to the original body as provided to the constructor,
+   * before consumption. It is primarily intended for use in test code, introspection, or
+   * advanced debug tools. **Do not rely on this in production.**
+   * In production (`process.env.NODE_ENV === 'production'`), using this method will throw.
+   *
+   * This method is _not_ part of the web Response interface, and is intentionally private/internal.
+   */
+  __peekBodyForTestOnly(): BodyInit | JsonValue | null;
+}
+declare namespace index_d_exports {
+  export { JsonValue, TangoBody, TangoHeaders, TangoQueryParams, TangoRequest, TangoResponse };
+}
+//#endregion
+export { TangoHeaders as a, TangoRequest as i, TangoResponse as n, JsonValue as o, TangoQueryParams as r, TangoBody as s, index_d_exports as t };
+//# sourceMappingURL=index-D8o4DOOG.d.ts.map