@danceroutine/tango-core 0.1.0 → 1.0.0

package/dist/http/TangoBody.d.ts

@@ -7,9 +7,13 @@ type HeadersLike = {
     get?: (arg: string) => string | null;
 };
 type TangoBodySource = BodyInit | JsonValue | null;
+/** Recursive JSON value contract used by Tango HTTP helpers. */
 export type JsonValue = string | number | boolean | null | JsonValue[] | {
     [key: string]: JsonValue;
 };
+/**
+ * Unified body reader/clone utility for Tango request/response wrappers.
+ */
 export declare class TangoBody {
     static readonly BRAND: "tango.http.body";
     readonly __tangoBrand: typeof TangoBody.BRAND;
@@ -17,14 +21,53 @@ export declare class TangoBody {
     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.
      */
@@ -54,11 +97,6 @@ export declare class TangoBody {
      * Returns the original body value (may be used for streaming or clone).
      */
     getRawBodyInit(): TangoBodySource;
-    /**
-     * 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;
     /**
      * Clone the body instance and stream if possible.
      * If the source is a stream, the stream will be cloned if readable, otherwise throws.
@@ -68,18 +106,5 @@ export declare class TangoBody {
      * Helper for all readers. Only allows reading once.
      */
     private consumeBody;
-    static readStreamToArrayBuffer(stream: ReadableStream<Uint8Array>): Promise<ArrayBuffer>;
-    static readStreamToUint8Array(stream: ReadableStream<Uint8Array>): Promise<Uint8Array<ArrayBuffer>>;
-    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>;
 }
 export {};

package/dist/http/TangoHeaders.d.ts

@@ -15,8 +15,14 @@
 export declare class TangoHeaders extends Headers {
     static readonly BRAND: "tango.http.headers";
     readonly __tangoBrand: typeof TangoHeaders.BRAND;
-    constructor(headers?: HeadersInit);
+    /**
+     * 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;
@@ -35,6 +41,9 @@ export declare class TangoHeaders extends Headers {
      * @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.
@@ -106,10 +115,6 @@ export declare class TangoHeaders extends Headers {
         priority?: 'Low' | 'Medium' | 'High';
         partitioned?: boolean;
     }): void;
-    /**
-     * Serialize a cookie for the Set-Cookie header line.
-     */
-    private static serializeCookie;
     /**
      * Add or override Cache-Control header with helpers for common policies.
      */

package/dist/http/TangoQueryParams.d.ts

@@ -0,0 +1,69 @@
+import type { TangoRequest } from './TangoRequest';
+type QueryParamRecord = Record<string, string | string[] | undefined>;
+/**
+ * Immutable query parameter helper that normalizes framework-specific shapes
+ * into one Tango-owned API.
+ */
+export 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;
+    /**
+     * 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[];
+}
+export {};

package/dist/http/TangoRequest.d.ts

@@ -1,4 +1,5 @@
 import type { JsonValue } from './TangoBody';
+import { TangoQueryParams } from './TangoQueryParams';
 type TangoRequestInit = {
     method?: string;
     headers?: HeadersInit;
@@ -13,35 +14,116 @@ type TangoRequestInit = {
     referrerPolicy?: ReferrerPolicy;
     signal?: AbortSignal;
 };
+/**
+ * Framework request wrapper that normalizes JSON-like bodies and preserves
+ * fetch `Request` compatibility for downstream handlers.
+ */
 export 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;
 }

package/dist/http/TangoResponse.d.ts

@@ -11,10 +11,11 @@ type TangoResponseInit = {
     type?: ResponseType;
     url?: string;
 };
+/**
+ * Framework response wrapper with fetch-compatible surface plus ergonomic helpers.
+ */
 export declare class TangoResponse implements Response {
     static readonly BRAND: "tango.http.response";
-    private tangoBody;
-    private okValue;
     readonly __tangoBrand: typeof TangoResponse.BRAND;
     readonly headers: TangoHeaders;
     readonly redirected: boolean;
@@ -23,107 +24,116 @@ export declare class TangoResponse implements Response {
     readonly type: ResponseType;
     readonly url: string;
     readonly body: Response['body'];
-    static isTangoResponse(value: unknown): value is TangoResponse;
-    get bodySource(): BodyInit | JsonValue | null;
+    private tangoBody;
+    private okValue;
     constructor(init?: TangoResponseInit);
-    get ok(): boolean;
-    get bodyUsed(): boolean;
-    setHeader(name: string, value: string): void;
-    appendHeader(name: string, value: string): void;
-    getHeader(name: string): string | null;
-    hasHeader(name: string): boolean;
-    deleteHeader(name: string): void;
-    vary(...fields: string[]): void;
-    setCookie(name: string, value: string, options?: Parameters<TangoHeaders['setCookie']>[2]): void;
-    appendCookie(name: string, value: string, options?: Parameters<TangoHeaders['appendCookie']>[2]): void;
-    deleteCookie(name: string, options?: Parameters<TangoHeaders['deleteCookie']>[1]): void;
-    cacheControl(control: Parameters<TangoHeaders['cacheControl']>[0]): void;
-    location(url: string): void;
-    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.
+     * Narrow an unknown value to `TangoResponse`.
      */
-    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;
+    static isTangoResponse(value: unknown): value is TangoResponse;
     /**
-     * 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.
+     * Create a JSON response with sensible content headers.
      */
-    propagateTraceHeaders(input: HeadersInit): this;
     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;
-    clone(): TangoResponse;
-    arrayBuffer(): Promise<ArrayBuffer>;
-    blob(): Promise<Blob>;
-    bytes(): Promise<Uint8Array<ArrayBuffer>>;
-    formData(): Promise<FormData>;
-    json<T = unknown>(): Promise<T>;
-    text(): Promise<string>;
     /**
      * Returns a response for serving a file.
      */
@@ -144,6 +154,131 @@ export declare class TangoResponse implements Response {
             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.

package/dist/http/index.d.ts

@@ -3,7 +3,8 @@
  */
 import { TangoBody, type JsonValue } from './TangoBody';
 import { TangoHeaders } from './TangoHeaders';
+import { TangoQueryParams } from './TangoQueryParams';
 import { TangoRequest } from './TangoRequest';
 import { TangoResponse } from './TangoResponse';
-export { TangoBody, TangoHeaders, TangoRequest, TangoResponse };
+export { TangoBody, TangoHeaders, TangoQueryParams, TangoRequest, TangoResponse };
 export type { JsonValue };

package/dist/http/index.js

@@ -1,5 +1,5 @@
-import "../TangoError-NPkVPfuH.js";
-import "../runtime-DPpCYEe_.js";
-import { TangoBody, TangoHeaders, TangoRequest, TangoResponse } from "../http-DOLwwAYt.js";
+import "../TangoError-DdQVQNZU.js";
+import "../runtime-B8KkgD3R.js";
+import { TangoBody, TangoHeaders, TangoQueryParams, TangoRequest, TangoResponse } from "../http-D20MQa6p.js";
 
-export { TangoBody, TangoHeaders, TangoRequest, TangoResponse };
+export { TangoBody, TangoHeaders, TangoQueryParams, TangoRequest, TangoResponse };