webflow-api 3.2.0 → 3.3.0-beta

package/dist/core/fetcher/BinaryResponse.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBinaryResponse = getBinaryResponse;
+function getBinaryResponse(response) {
+    const binaryResponse = {
+        get bodyUsed() {
+            return response.bodyUsed;
+        },
+        stream: () => response.body,
+        arrayBuffer: response.arrayBuffer.bind(response),
+        blob: response.blob.bind(response),
+    };
+    if ("bytes" in response && typeof response.bytes === "function") {
+        binaryResponse.bytes = response.bytes.bind(response);
+    }
+    return binaryResponse;
+}

package/dist/core/fetcher/EndpointMetadata.d.ts

@@ -0,0 +1,13 @@
+export type SecuritySchemeKey = string;
+/**
+ * A collection of security schemes, where the key is the name of the security scheme and the value is the list of scopes required for that scheme.
+ * All schemes in the collection must be satisfied for authentication to be successful.
+ */
+export type SecuritySchemeCollection = Record<SecuritySchemeKey, AuthScope[]>;
+export type AuthScope = string;
+export type EndpointMetadata = {
+    /**
+     * An array of security scheme collections. Each collection represents an alternative way to authenticate.
+     */
+    security?: SecuritySchemeCollection[];
+};

package/dist/core/fetcher/EndpointMetadata.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/fetcher/EndpointSupplier.d.ts

@@ -0,0 +1,12 @@
+import type { EndpointMetadata } from "./EndpointMetadata";
+import type { Supplier } from "./Supplier";
+type EndpointSupplierFn<T> = (arg: {
+    endpointMetadata: EndpointMetadata;
+}) => T | Promise<T>;
+export type EndpointSupplier<T> = Supplier<T> | EndpointSupplierFn<T>;
+export declare const EndpointSupplier: {
+    get: <T>(supplier: EndpointSupplier<T>, arg: {
+        endpointMetadata: EndpointMetadata;
+    }) => Promise<T>;
+};
+export {};

package/dist/core/fetcher/EndpointSupplier.js

@@ -0,0 +1,22 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EndpointSupplier = void 0;
+exports.EndpointSupplier = {
+    get: (supplier, arg) => __awaiter(void 0, void 0, void 0, function* () {
+        if (typeof supplier === "function") {
+            return supplier(arg);
+        }
+        else {
+            return supplier;
+        }
+    }),
+};

package/dist/core/fetcher/Fetcher.d.ts

@@ -1,21 +1,23 @@
-import { APIResponse } from "./APIResponse";
-import { Supplier } from "./Supplier";
+import type { APIResponse } from "./APIResponse";
+import type { EndpointMetadata } from "./EndpointMetadata";
+import { EndpointSupplier } from "./EndpointSupplier";
 export type FetchFunction = <R = unknown>(args: Fetcher.Args) => Promise<APIResponse<R, Fetcher.Error>>;
 export declare namespace Fetcher {
     interface Args {
         url: string;
         method: string;
         contentType?: string;
-        headers?: Record<string, string | Supplier<string | undefined> | undefined>;
-        queryParameters?: Record<string, string | string[] | object | object[] | null>;
+        headers?: Record<string, string | EndpointSupplier<string | null | undefined> | null | undefined>;
+        queryParameters?: Record<string, unknown>;
         body?: unknown;
         timeoutMs?: number;
         maxRetries?: number;
         withCredentials?: boolean;
         abortSignal?: AbortSignal;
         requestType?: "json" | "file" | "bytes";
-        responseType?: "json" | "blob" | "sse" | "streaming" | "text" | "arrayBuffer";
+        responseType?: "json" | "blob" | "sse" | "streaming" | "text" | "arrayBuffer" | "binary-response";
         duplex?: "half";
+        endpointMetadata?: EndpointMetadata;
     }
     type Error = FailedStatusCodeError | NonJsonError | TimeoutError | UnknownError;
     interface FailedStatusCodeError {

package/dist/core/fetcher/Fetcher.js

@@ -12,16 +12,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetcher = void 0;
 exports.fetcherImpl = fetcherImpl;
 const json_1 = require("../json");
-const RawResponse_1 = require("./RawResponse");
-const Supplier_1 = require("./Supplier");
 const createRequestUrl_1 = require("./createRequestUrl");
+const EndpointSupplier_1 = require("./EndpointSupplier");
+const getErrorResponseBody_1 = require("./getErrorResponseBody");
 const getFetchFn_1 = require("./getFetchFn");
 const getRequestBody_1 = require("./getRequestBody");
 const getResponseBody_1 = require("./getResponseBody");
 const makeRequest_1 = require("./makeRequest");
+const RawResponse_1 = require("./RawResponse");
 const requestWithRetries_1 = require("./requestWithRetries");
 function getHeaders(args) {
     return __awaiter(this, void 0, void 0, function* () {
+        var _a;
         const newHeaders = {};
         if (args.body !== undefined && args.contentType != null) {
             newHeaders["Content-Type"] = args.contentType;
@@ -30,7 +32,7 @@ function getHeaders(args) {
             return newHeaders;
         }
         for (const [key, value] of Object.entries(args.headers)) {
-            const result = yield Supplier_1.Supplier.get(value);
+            const result = yield EndpointSupplier_1.EndpointSupplier.get(value, { endpointMetadata: (_a = args.endpointMetadata) !== null && _a !== void 0 ? _a : {} });
             if (typeof result === "string") {
                 newHeaders[key] = result;
                 continue;
@@ -45,6 +47,7 @@ function getHeaders(args) {
 }
 function fetcherImpl(args) {
     return __awaiter(this, void 0, void 0, function* () {
+        var _a;
         const url = (0, createRequestUrl_1.createRequestUrl)(args.url, args.queryParameters);
         const requestBody = yield (0, getRequestBody_1.getRequestBody)({
             body: args.body,
@@ -55,11 +58,10 @@ function fetcherImpl(args) {
             const response = yield (0, requestWithRetries_1.requestWithRetries)(() => __awaiter(this, void 0, void 0, function* () {
                 return (0, makeRequest_1.makeRequest)(fetchFn, url, args.method, yield getHeaders(args), requestBody, args.timeoutMs, args.abortSignal, args.withCredentials, args.duplex);
             }), args.maxRetries);
-            const responseBody = yield (0, getResponseBody_1.getResponseBody)(response, args.responseType);
             if (response.status >= 200 && response.status < 400) {
                 return {
                     ok: true,
-                    body: responseBody,
+                    body: (yield (0, getResponseBody_1.getResponseBody)(response, args.responseType)),
                     headers: response.headers,
                     rawResponse: (0, RawResponse_1.toRawResponse)(response),
                 };
@@ -70,14 +72,14 @@ function fetcherImpl(args) {
                     error: {
                         reason: "status-code",
                         statusCode: response.status,
-                        body: responseBody,
+                        body: yield (0, getErrorResponseBody_1.getErrorResponseBody)(response),
                     },
                     rawResponse: (0, RawResponse_1.toRawResponse)(response),
                 };
             }
         }
         catch (error) {
-            if (args.abortSignal != null && args.abortSignal.aborted) {
+            if ((_a = args.abortSignal) === null || _a === void 0 ? void 0 : _a.aborted) {
                 return {
                     ok: false,
                     error: {

package/dist/core/fetcher/HttpResponsePromise.d.ts

@@ -1,4 +1,4 @@
-import { WithRawResponse } from "./RawResponse";
+import type { WithRawResponse } from "./RawResponse";
 /**
  * A promise that returns the parsed response and lets you retrieve the raw response too.
  */

package/dist/core/fetcher/ResponseWithBody.d.ts

@@ -0,0 +1,4 @@
+export type ResponseWithBody = Response & {
+    body: ReadableStream<Uint8Array>;
+};
+export declare function isResponseWithBody(response: Response): response is ResponseWithBody;

package/dist/core/fetcher/ResponseWithBody.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isResponseWithBody = isResponseWithBody;
+function isResponseWithBody(response) {
+    return response.body != null;
+}

package/dist/core/fetcher/createRequestUrl.d.ts

@@ -1 +1 @@
-export declare function createRequestUrl(baseUrl: string, queryParameters?: Record<string, string | string[] | object | object[] | null>): string;
+export declare function createRequestUrl(baseUrl: string, queryParameters?: Record<string, unknown>): string;

package/dist/core/fetcher/createRequestUrl.js

@@ -1,12 +1,8 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createRequestUrl = createRequestUrl;
-const qs_1 = __importDefault(require("qs"));
+const qs_1 = require("../url/qs");
 function createRequestUrl(baseUrl, queryParameters) {
-    return Object.keys(queryParameters !== null && queryParameters !== void 0 ? queryParameters : {}).length > 0
-        ? `${baseUrl}?${qs_1.default.stringify(queryParameters, { arrayFormat: "repeat" })}`
-        : baseUrl;
+    const queryString = (0, qs_1.toQueryString)(queryParameters, { arrayFormat: "repeat" });
+    return queryString ? `${baseUrl}?${queryString}` : baseUrl;
 }

package/dist/core/fetcher/getErrorResponseBody.d.ts

@@ -0,0 +1 @@
+export declare function getErrorResponseBody(response: Response): Promise<unknown>;

package/dist/core/fetcher/getErrorResponseBody.js

@@ -0,0 +1,45 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getErrorResponseBody = getErrorResponseBody;
+const json_1 = require("../json");
+const getResponseBody_1 = require("./getResponseBody");
+function getErrorResponseBody(response) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c;
+        let contentType = (_a = response.headers.get("Content-Type")) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+        if (contentType == null || contentType.length === 0) {
+            return (0, getResponseBody_1.getResponseBody)(response);
+        }
+        if (contentType.indexOf(";") !== -1) {
+            contentType = (_c = (_b = contentType.split(";")[0]) === null || _b === void 0 ? void 0 : _b.trim()) !== null && _c !== void 0 ? _c : "";
+        }
+        switch (contentType) {
+            case "application/hal+json":
+            case "application/json":
+            case "application/ld+json":
+            case "application/problem+json":
+            case "application/vnd.api+json":
+            case "text/json": {
+                const text = yield response.text();
+                return text.length > 0 ? (0, json_1.fromJson)(text) : undefined;
+            }
+            default:
+                if (contentType.startsWith("application/vnd.") && contentType.endsWith("+json")) {
+                    const text = yield response.text();
+                    return text.length > 0 ? (0, json_1.fromJson)(text) : undefined;
+                }
+                // Fallback to plain text if content type is not recognized
+                // Even if no body is present, the response will be an empty string
+                return yield response.text();
+        }
+    });
+}

package/dist/core/fetcher/getFetchFn.js

@@ -43,23 +43,23 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getFetchFn = getFetchFn;
-const runtime_1 = require("../runtime");
+const index_1 = require("../runtime/index");
 /**
  * Returns a fetch function based on the runtime
  */
 function getFetchFn() {
     return __awaiter(this, void 0, void 0, function* () {
         // In Node.js 18+ environments, use native fetch
-        if (runtime_1.RUNTIME.type === "node" && runtime_1.RUNTIME.parsedVersion != null && runtime_1.RUNTIME.parsedVersion >= 18) {
+        if (index_1.RUNTIME.type === "node" && index_1.RUNTIME.parsedVersion != null && index_1.RUNTIME.parsedVersion >= 18) {
             return fetch;
         }
         // In Node.js 18 or lower environments, the SDK always uses`node-fetch`.
-        if (runtime_1.RUNTIME.type === "node") {
+        if (index_1.RUNTIME.type === "node") {
             return (yield Promise.resolve().then(() => __importStar(require("node-fetch")))).default;
         }
         // Otherwise the SDK uses global fetch if available,
         // and falls back to node-fetch.
-        if (typeof fetch == "function") {
+        if (typeof fetch === "function") {
             return fetch;
         }
         // Defaults to node `node-fetch` if global fetch isn't available

package/dist/core/fetcher/getResponseBody.js

@@ -10,45 +10,47 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getResponseBody = getResponseBody;
+const json_1 = require("../json");
+const BinaryResponse_1 = require("./BinaryResponse");
+const ResponseWithBody_1 = require("./ResponseWithBody");
 const chooseStreamWrapper_1 = require("./stream-wrappers/chooseStreamWrapper");
 function getResponseBody(response, responseType) {
     return __awaiter(this, void 0, void 0, function* () {
-        if (response.body != null && responseType === "blob") {
-            return yield response.blob();
+        if (!(0, ResponseWithBody_1.isResponseWithBody)(response)) {
+            return undefined;
         }
-        else if (response.body != null && responseType === "arrayBuffer") {
-            return yield response.arrayBuffer();
+        switch (responseType) {
+            case "binary-response":
+                return (0, BinaryResponse_1.getBinaryResponse)(response);
+            case "blob":
+                return yield response.blob();
+            case "arrayBuffer":
+                return yield response.arrayBuffer();
+            case "sse":
+                return response.body;
+            case "streaming":
+                return (0, chooseStreamWrapper_1.chooseStreamWrapper)(response.body);
+            case "text":
+                return yield response.text();
         }
-        else if (response.body != null && responseType === "sse") {
-            return response.body;
-        }
-        else if (response.body != null && responseType === "streaming") {
-            return (0, chooseStreamWrapper_1.chooseStreamWrapper)(response.body);
-        }
-        else if (response.body != null && responseType === "text") {
-            return yield response.text();
-        }
-        else {
-            const text = yield response.text();
-            if (text.length > 0) {
-                try {
-                    let responseBody = JSON.parse(text);
-                    return responseBody;
-                }
-                catch (err) {
-                    return {
-                        ok: false,
-                        error: {
-                            reason: "non-json",
-                            statusCode: response.status,
-                            rawBody: text,
-                        },
-                    };
-                }
+        // if responseType is "json" or not specified, try to parse as JSON
+        const text = yield response.text();
+        if (text.length > 0) {
+            try {
+                const responseBody = (0, json_1.fromJson)(text);
+                return responseBody;
             }
-            else {
-                return undefined;
+            catch (_err) {
+                return {
+                    ok: false,
+                    error: {
+                        reason: "non-json",
+                        statusCode: response.status,
+                        rawBody: text,
+                    },
+                };
             }
         }
+        return undefined;
     });
 }

package/dist/core/fetcher/index.d.ts

@@ -1,8 +1,11 @@
 export type { APIResponse } from "./APIResponse";
-export { fetcher } from "./Fetcher";
+export type { BinaryResponse } from "./BinaryResponse";
+export type { EndpointMetadata } from "./EndpointMetadata";
+export { EndpointSupplier } from "./EndpointSupplier";
 export type { Fetcher, FetchFunction } from "./Fetcher";
+export { fetcher } from "./Fetcher";
 export { getHeader } from "./getHeader";
-export { Supplier } from "./Supplier";
-export { abortRawResponse, toRawResponse, unknownRawResponse } from "./RawResponse";
-export type { RawResponse, WithRawResponse } from "./RawResponse";
 export { HttpResponsePromise } from "./HttpResponsePromise";
+export type { RawResponse, WithRawResponse } from "./RawResponse";
+export { abortRawResponse, toRawResponse, unknownRawResponse } from "./RawResponse";
+export { Supplier } from "./Supplier";

package/dist/core/fetcher/index.js

@@ -1,15 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HttpResponsePromise = exports.unknownRawResponse = exports.toRawResponse = exports.abortRawResponse = exports.Supplier = exports.getHeader = exports.fetcher = void 0;
+exports.Supplier = exports.unknownRawResponse = exports.toRawResponse = exports.abortRawResponse = exports.HttpResponsePromise = exports.getHeader = exports.fetcher = exports.EndpointSupplier = void 0;
+var EndpointSupplier_1 = require("./EndpointSupplier");
+Object.defineProperty(exports, "EndpointSupplier", { enumerable: true, get: function () { return EndpointSupplier_1.EndpointSupplier; } });
 var Fetcher_1 = require("./Fetcher");
 Object.defineProperty(exports, "fetcher", { enumerable: true, get: function () { return Fetcher_1.fetcher; } });
 var getHeader_1 = require("./getHeader");
 Object.defineProperty(exports, "getHeader", { enumerable: true, get: function () { return getHeader_1.getHeader; } });
-var Supplier_1 = require("./Supplier");
-Object.defineProperty(exports, "Supplier", { enumerable: true, get: function () { return Supplier_1.Supplier; } });
+var HttpResponsePromise_1 = require("./HttpResponsePromise");
+Object.defineProperty(exports, "HttpResponsePromise", { enumerable: true, get: function () { return HttpResponsePromise_1.HttpResponsePromise; } });
 var RawResponse_1 = require("./RawResponse");
 Object.defineProperty(exports, "abortRawResponse", { enumerable: true, get: function () { return RawResponse_1.abortRawResponse; } });
 Object.defineProperty(exports, "toRawResponse", { enumerable: true, get: function () { return RawResponse_1.toRawResponse; } });
 Object.defineProperty(exports, "unknownRawResponse", { enumerable: true, get: function () { return RawResponse_1.unknownRawResponse; } });
-var HttpResponsePromise_1 = require("./HttpResponsePromise");
-Object.defineProperty(exports, "HttpResponsePromise", { enumerable: true, get: function () { return HttpResponsePromise_1.HttpResponsePromise; } });
+var Supplier_1 = require("./Supplier");
+Object.defineProperty(exports, "Supplier", { enumerable: true, get: function () { return Supplier_1.Supplier; } });

package/dist/core/fetcher/makeRequest.js

@@ -14,7 +14,7 @@ const signals_1 = require("./signals");
 const makeRequest = (fetchFn, url, method, headers, requestBody, timeoutMs, abortSignal, withCredentials, duplex) => __awaiter(void 0, void 0, void 0, function* () {
     const signals = [];
     // Add timeout signal
-    let timeoutAbortId = undefined;
+    let timeoutAbortId;
     if (timeoutMs != null) {
         const { signal, abortId } = (0, signals_1.getTimeoutSignal)(timeoutMs);
         timeoutAbortId = abortId;
@@ -24,7 +24,7 @@ const makeRequest = (fetchFn, url, method, headers, requestBody, timeoutMs, abor
     if (abortSignal != null) {
         signals.push(abortSignal);
     }
-    let newSignals = (0, signals_1.anySignal)(signals);
+    const newSignals = (0, signals_1.anySignal)(signals);
     const response = yield fetchFn(url, {
         method: method,
         headers,

package/dist/core/fetcher/requestWithRetries.js

@@ -14,21 +14,57 @@ const INITIAL_RETRY_DELAY = 1000; // in milliseconds
 const MAX_RETRY_DELAY = 60000; // in milliseconds
 const DEFAULT_MAX_RETRIES = 2;
 const JITTER_FACTOR = 0.2; // 20% random jitter
-function addJitter(delay) {
-    // Generate a random value between -JITTER_FACTOR and +JITTER_FACTOR
-    const jitterMultiplier = 1 + (Math.random() * 2 - 1) * JITTER_FACTOR;
+function addPositiveJitter(delay) {
+    // Generate a random value between 0 and +JITTER_FACTOR
+    const jitterMultiplier = 1 + Math.random() * JITTER_FACTOR;
     return delay * jitterMultiplier;
 }
+function addSymmetricJitter(delay) {
+    // Generate a random value in a JITTER_FACTOR-sized percentage range around delay
+    const jitterMultiplier = 1 + (Math.random() - 0.5) * JITTER_FACTOR;
+    return delay * jitterMultiplier;
+}
+function getRetryDelayFromHeaders(response, retryAttempt) {
+    // Check for Retry-After header first (RFC 7231), with no jitter
+    const retryAfter = response.headers.get("Retry-After");
+    if (retryAfter) {
+        // Parse as number of seconds...
+        const retryAfterSeconds = parseInt(retryAfter, 10);
+        if (!Number.isNaN(retryAfterSeconds) && retryAfterSeconds > 0) {
+            return Math.min(retryAfterSeconds * 1000, MAX_RETRY_DELAY);
+        }
+        // ...or as an HTTP date; both are valid
+        const retryAfterDate = new Date(retryAfter);
+        if (!Number.isNaN(retryAfterDate.getTime())) {
+            const delay = retryAfterDate.getTime() - Date.now();
+            if (delay > 0) {
+                return Math.min(Math.max(delay, 0), MAX_RETRY_DELAY);
+            }
+        }
+    }
+    // Then check for industry-standard X-RateLimit-Reset header, with positive jitter
+    const rateLimitReset = response.headers.get("X-RateLimit-Reset");
+    if (rateLimitReset) {
+        const resetTime = parseInt(rateLimitReset, 10);
+        if (!Number.isNaN(resetTime)) {
+            // Assume Unix timestamp in epoch seconds
+            const delay = resetTime * 1000 - Date.now();
+            if (delay > 0) {
+                return addPositiveJitter(Math.min(delay, MAX_RETRY_DELAY));
+            }
+        }
+    }
+    // Fall back to exponential backoff, with symmetric jitter
+    return addSymmetricJitter(Math.min(INITIAL_RETRY_DELAY * Math.pow(2, retryAttempt), MAX_RETRY_DELAY));
+}
 function requestWithRetries(requestFn_1) {
     return __awaiter(this, arguments, void 0, function* (requestFn, maxRetries = DEFAULT_MAX_RETRIES) {
         let response = yield requestFn();
         for (let i = 0; i < maxRetries; ++i) {
             if ([408, 429].includes(response.status) || response.status >= 500) {
-                // Calculate base delay using exponential backoff (in milliseconds)
-                const baseDelay = Math.min(INITIAL_RETRY_DELAY * Math.pow(2, i), MAX_RETRY_DELAY);
-                // Add jitter to the delay
-                const delayWithJitter = addJitter(baseDelay);
-                yield new Promise((resolve) => setTimeout(resolve, delayWithJitter));
+                // Get delay with appropriate jitter applied
+                const delay = getRetryDelayFromHeaders(response, i);
+                yield new Promise((resolve) => setTimeout(resolve, delay));
                 response = yield requestFn();
             }
             else {

package/dist/core/fetcher/stream-wrappers/Node18UniversalStreamWrapper.d.ts

@@ -1,5 +1,5 @@
 import type { Writable } from "readable-stream";
-import { EventCallback, StreamWrapper } from "./chooseStreamWrapper";
+import type { EventCallback, StreamWrapper } from "./chooseStreamWrapper";
 export declare class Node18UniversalStreamWrapper<ReadFormat extends Uint8Array | Uint16Array | Uint32Array> implements StreamWrapper<Node18UniversalStreamWrapper<ReadFormat> | Writable | WritableStream<ReadFormat>, ReadFormat> {
     private readableStream;
     private reader;

package/dist/core/fetcher/stream-wrappers/NodePre18StreamWrapper.d.ts

@@ -1,5 +1,5 @@
 import type { Readable, Writable } from "readable-stream";
-import { EventCallback, StreamWrapper } from "./chooseStreamWrapper";
+import type { EventCallback, StreamWrapper } from "./chooseStreamWrapper";
 export declare class NodePre18StreamWrapper implements StreamWrapper<Writable, Buffer> {
     private readableStream;
     private encoding;

package/dist/core/fetcher/stream-wrappers/UndiciStreamWrapper.d.ts

@@ -1,4 +1,4 @@
-import { StreamWrapper } from "./chooseStreamWrapper";
+import type { StreamWrapper } from "./chooseStreamWrapper";
 type EventCallback = (data?: any) => void;
 export declare class UndiciStreamWrapper<ReadFormat extends Uint8Array | Uint16Array | Uint32Array> implements StreamWrapper<UndiciStreamWrapper<ReadFormat> | WritableStream<ReadFormat>, ReadFormat> {
     private readableStream;

package/dist/core/headers.d.ts

@@ -1,3 +1,2 @@
-import * as core from "./index.js";
-export declare function mergeHeaders(...headersArray: (Record<string, string | core.Supplier<string | undefined> | undefined> | undefined)[]): Record<string, string | core.Supplier<string | undefined>>;
-export declare function mergeOnlyDefinedHeaders(...headersArray: (Record<string, string | core.Supplier<string | undefined> | undefined> | undefined)[]): Record<string, string | core.Supplier<string | undefined>>;
+export declare function mergeHeaders<THeaderValue>(...headersArray: (Record<string, THeaderValue> | null | undefined)[]): Record<string, string | THeaderValue>;
+export declare function mergeOnlyDefinedHeaders<THeaderValue>(...headersArray: (Record<string, THeaderValue> | null | undefined)[]): Record<string, THeaderValue>;

package/dist/core/index.d.ts

@@ -1,4 +1,6 @@
+export * from "./auth";
+export * from "./base64";
 export * from "./fetcher";
 export * from "./runtime";
-export * from "./auth";
 export * as serialization from "./schemas";
+export * as url from "./url";

package/dist/core/index.js

@@ -36,8 +36,10 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.serialization = void 0;
+exports.url = exports.serialization = void 0;
+__exportStar(require("./auth"), exports);
+__exportStar(require("./base64"), exports);
 __exportStar(require("./fetcher"), exports);
 __exportStar(require("./runtime"), exports);
-__exportStar(require("./auth"), exports);
 exports.serialization = __importStar(require("./schemas"));
+exports.url = __importStar(require("./url"));

package/dist/core/schemas/Schema.d.ts

@@ -1,4 +1,4 @@
-import { SchemaUtils } from "./builders";
+import type { SchemaUtils } from "./builders/index";
 export type Schema<Raw = unknown, Parsed = unknown> = BaseSchema<Raw, Parsed> & SchemaUtils<Raw, Parsed>;
 export type inferRaw<S extends Schema> = S extends Schema<infer Raw, any> ? Raw : never;
 export type inferParsed<S extends Schema> = S extends Schema<any, infer Parsed> ? Parsed : never;

package/dist/core/schemas/builders/bigint/bigint.d.ts

@@ -1,2 +1,2 @@
-import { Schema } from "../../Schema";
+import { type Schema } from "../../Schema";
 export declare function bigint(): Schema<bigint | number, bigint>;

package/dist/core/schemas/builders/bigint/bigint.js

@@ -4,7 +4,7 @@ exports.bigint = bigint;
 const Schema_1 = require("../../Schema");
 const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
 const maybeSkipValidation_1 = require("../../utils/maybeSkipValidation");
-const schema_utils_1 = require("../schema-utils");
+const index_1 = require("../schema-utils/index");
 function bigint() {
     const baseSchema = {
         parse: (raw, { breadcrumbsPrefix = [] } = {}) => {
@@ -49,5 +49,5 @@ function bigint() {
         },
         getType: () => Schema_1.SchemaType.BIGINT,
     };
-    return Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, schema_utils_1.getSchemaUtils)(baseSchema));
+    return Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, index_1.getSchemaUtils)(baseSchema));
 }

package/dist/core/schemas/builders/date/date.d.ts

@@ -1,2 +1,2 @@
-import { Schema } from "../../Schema";
+import { type Schema } from "../../Schema";
 export declare function date(): Schema<string, Date>;

package/dist/core/schemas/builders/date/date.js

@@ -4,7 +4,7 @@ exports.date = date;
 const Schema_1 = require("../../Schema");
 const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
 const maybeSkipValidation_1 = require("../../utils/maybeSkipValidation");
-const schema_utils_1 = require("../schema-utils");
+const index_1 = require("../schema-utils/index");
 // https://stackoverflow.com/questions/12756159/regex-and-iso8601-formatted-datetime
 const ISO_8601_REGEX = /^([+-]?\d{4}(?!\d{2}\b))((-?)((0[1-9]|1[0-2])(\3([12]\d|0[1-9]|3[01]))?|W([0-4]\d|5[0-2])(-?[1-7])?|(00[1-9]|0[1-9]\d|[12]\d{2}|3([0-5]\d|6[1-6])))([T\s]((([01]\d|2[0-3])((:?)[0-5]\d)?|24:?00)([.,]\d+(?!:))?)?(\17[0-5]\d([.,]\d+)?)?([zZ]|([+-])([01]\d|2[0-3]):?([0-5]\d)?)?)?)?$/;
 function date() {
@@ -58,5 +58,5 @@ function date() {
         },
         getType: () => Schema_1.SchemaType.DATE,
     };
-    return Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, schema_utils_1.getSchemaUtils)(baseSchema));
+    return Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, index_1.getSchemaUtils)(baseSchema));
 }

package/dist/core/schemas/builders/enum/enum.d.ts

@@ -1,2 +1,2 @@
-import { Schema } from "../../Schema";
+import { type Schema } from "../../Schema";
 export declare function enum_<U extends string, E extends U[]>(values: E): Schema<E[number], E[number]>;