api-def 0.12.1 → 0.14.0-alpha.1

package/cjs/TextDecoding.js

@@ -2,22 +2,22 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.textDecode = void 0;
 // polyfill from https://github.com/anonyco/FastestSmallestTextEncoderDecoder/blob/master/EncoderDecoderTogether.src.js
-var textDecode = function (inputArrayOrBuffer, options) {
+const textDecode = (inputArrayOrBuffer, options) => {
     if (typeof TextDecoder !== "undefined") {
         return new TextDecoder("utf-8").decode(inputArrayOrBuffer);
     }
-    var fromCharCode = String.fromCharCode;
-    var Object_prototype_toString = {}.toString;
-    var sharedArrayBufferString = Object_prototype_toString.call(window.SharedArrayBuffer);
-    var undefinedObjectString = Object_prototype_toString();
-    var NativeUint8Array = window.Uint8Array;
-    var patchedU8Array = NativeUint8Array || Array;
-    var nativeArrayBuffer = NativeUint8Array ? ArrayBuffer : patchedU8Array;
-    var arrayBuffer_isView = nativeArrayBuffer.isView || (function (x) { return x && "length" in x; });
-    var arrayBufferString = Object_prototype_toString.call(nativeArrayBuffer.prototype);
-    var tmpBufferU16 = new (NativeUint8Array ? Uint16Array : patchedU8Array)(32);
-    var inputAs8 = inputArrayOrBuffer;
-    var asObjectString;
+    const fromCharCode = String.fromCharCode;
+    const Object_prototype_toString = {}.toString;
+    const sharedArrayBufferString = Object_prototype_toString.call(window.SharedArrayBuffer);
+    const undefinedObjectString = Object_prototype_toString();
+    const NativeUint8Array = window.Uint8Array;
+    const patchedU8Array = NativeUint8Array || Array;
+    const nativeArrayBuffer = NativeUint8Array ? ArrayBuffer : patchedU8Array;
+    const arrayBuffer_isView = nativeArrayBuffer.isView || ((x) => x && "length" in x);
+    const arrayBufferString = Object_prototype_toString.call(nativeArrayBuffer.prototype);
+    const tmpBufferU16 = new (NativeUint8Array ? Uint16Array : patchedU8Array)(32);
+    let inputAs8 = inputArrayOrBuffer;
+    let asObjectString;
     if (!arrayBuffer_isView(inputAs8)) {
         asObjectString = Object_prototype_toString.call(inputAs8);
         if (asObjectString !== arrayBufferString &&
@@ -26,18 +26,18 @@ var textDecode = function (inputArrayOrBuffer, options) {
             throw TypeError("Failed to execute 'decode' on 'TextDecoder': The provided value is not of type '(ArrayBuffer or ArrayBufferView)'");
         inputAs8 = NativeUint8Array ? new patchedU8Array(inputAs8) : inputAs8 || [];
     }
-    var resultingString = "";
-    var tmpStr = "";
-    var index = 0;
-    var len = inputAs8.length | 0;
-    var lenMinus32 = (len - 32) | 0;
-    var nextEnd = 0;
-    var cp0 = 0;
-    var codePoint = 0;
-    var minBits = 0;
-    var cp1 = 0;
-    var pos = 0;
-    var tmp = -1;
+    let resultingString = "";
+    let tmpStr = "";
+    let index = 0;
+    const len = inputAs8.length | 0;
+    const lenMinus32 = (len - 32) | 0;
+    let nextEnd = 0;
+    let cp0 = 0;
+    let codePoint = 0;
+    let minBits = 0;
+    let cp1 = 0;
+    let pos = 0;
+    let tmp = -1;
     // Note that tmp represents the 2nd half of a surrogate pair incase a surrogate gets divided between blocks
     while (index < len) {
         nextEnd = index <= lenMinus32 ? 32 : (len - index) | 0;
@@ -47,29 +47,29 @@ var textDecode = function (inputArrayOrBuffer, options) {
                 // biome-ignore lint: optimised code
                 case 15:
                     cp1 = inputAs8[(index = (index + 1) | 0)] & 0xff;
-                    if (cp1 >> 6 !== 2 || 247 < cp0) {
+                    if (cp1 >> 6 !== 0b10 || 0b11110111 < cp0) {
                         index = (index - 1) | 0;
                         break;
                     }
-                    codePoint = ((cp0 & 7) << 6) | (cp1 & 63);
+                    codePoint = ((cp0 & 0b111) << 6) | (cp1 & 0b00111111);
                     minBits = 5; // 20 ensures it never passes -> all invalid replacements
                     cp0 = 0x100; //  keep track of th bit size
                 // biome-ignore lint: optimised code
                 case 14:
                     cp1 = inputAs8[(index = (index + 1) | 0)] & 0xff;
                     codePoint <<= 6;
-                    codePoint |= ((cp0 & 15) << 6) | (cp1 & 63);
-                    minBits = cp1 >> 6 === 2 ? (minBits + 4) | 0 : 24; // 24 ensures it never passes -> all invalid replacements
+                    codePoint |= ((cp0 & 0b1111) << 6) | (cp1 & 0b00111111);
+                    minBits = cp1 >> 6 === 0b10 ? (minBits + 4) | 0 : 24; // 24 ensures it never passes -> all invalid replacements
                     cp0 = (cp0 + 0x100) & 0x300; // keep track of th bit size
                 case 13:
                 // biome-ignore lint: optimised code
                 case 12:
                     cp1 = inputAs8[(index = (index + 1) | 0)] & 0xff;
                     codePoint <<= 6;
-                    codePoint |= ((cp0 & 31) << 6) | (cp1 & 63);
+                    codePoint |= ((cp0 & 0b11111) << 6) | (cp1 & 0b00111111);
                     minBits = (minBits + 7) | 0;
                     // Now, process the code point
-                    if (index < len && cp1 >> 6 === 2 && codePoint >> minBits && codePoint < 0x110000) {
+                    if (index < len && cp1 >> 6 === 0b10 && codePoint >> minBits && codePoint < 0x110000) {
                         cp0 = codePoint;
                         codePoint = (codePoint - 0x10000) | 0;
                         if (0 <= codePoint /*0xffff < codePoint*/) {

package/cjs/Utils.d.ts

@@ -14,3 +14,4 @@ export declare const noop: () => void;
 export declare const delayThenReturn: <T>(value: T, delayMs: number) => Promise<T>;
 export declare const randInt: (min: number, max: number) => number;
 export declare const isFormData: (value: any) => value is FormData;
+export declare const toFormData: (body: any) => FormData;

package/cjs/Utils.js

@@ -1,23 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isFormData = exports.randInt = exports.delayThenReturn = exports.noop = exports.getGlobalFetch = exports.getGlobal = exports.padNumber = exports.assign = void 0;
+exports.toFormData = exports.isFormData = exports.randInt = exports.delayThenReturn = exports.noop = exports.getGlobalFetch = exports.getGlobal = exports.padNumber = exports.assign = void 0;
 // polyfill from https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign
+const hasOwn = (object, key) => Object.prototype.hasOwnProperty.call(object, key);
 exports.assign = Object.assign ||
-    (function (target) {
-        var varArgs = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            varArgs[_i - 1] = arguments[_i];
-        }
+    ((target, ...varArgs) => {
         if (target === null || target === undefined) {
             throw new TypeError("Cannot convert undefined or null to object");
         }
-        var to = Object(target);
-        for (var index = 0; index < varArgs.length; index++) {
-            var nextSource = varArgs[index];
+        const to = Object(target);
+        for (let index = 0; index < varArgs.length; index++) {
+            const nextSource = varArgs[index];
             if (nextSource !== null && nextSource !== undefined) {
-                for (var nextKey in nextSource) {
+                for (const nextKey in nextSource) {
                     // Avoid bugs when hasOwnProperty is shadowed
-                    if (Object.prototype.hasOwnProperty.call(nextSource, nextKey)) {
+                    if (hasOwn(nextSource, nextKey)) {
                         to[nextKey] = nextSource[nextKey];
                     }
                 }
@@ -25,12 +22,12 @@ exports.assign = Object.assign ||
         }
         return to;
     });
-var padNumber = function (stringOrNumber, maxLength) {
-    var string = stringOrNumber.toString();
+const padNumber = (stringOrNumber, maxLength) => {
+    const string = stringOrNumber.toString();
     return string.length >= maxLength ? string : "0".repeat(maxLength - string.length) + string;
 };
 exports.padNumber = padNumber;
-var getGlobal = function () {
+const getGlobal = () => {
     if (typeof global !== "undefined") {
         return global;
     }
@@ -40,15 +37,15 @@ var getGlobal = function () {
     return undefined;
 };
 exports.getGlobal = getGlobal;
-var getGlobalFetch = function () {
-    var global = (0, exports.getGlobal)();
+const getGlobalFetch = () => {
+    const global = (0, exports.getGlobal)();
     if (global && typeof global.fetch === "function") {
         return global.fetch.bind(global);
     }
     return undefined;
 };
 exports.getGlobalFetch = getGlobalFetch;
-var noop = function () { };
+const noop = () => { };
 exports.noop = noop;
 /**
  * Just used to simulate lag, or loading times.
@@ -56,10 +53,10 @@ exports.noop = noop;
  * @param delayMs The delay in ms
  * @returns The `value` param as a Promise
  */
-var delayThenReturn = function (value, delayMs) {
-    return new Promise(function (resolve) {
+const delayThenReturn = (value, delayMs) => {
+    return new Promise((resolve) => {
         if (delayMs > 0) {
-            setTimeout(function () {
+            setTimeout(() => {
                 resolve(value);
             }, delayMs);
         }
@@ -69,13 +66,65 @@ var delayThenReturn = function (value, delayMs) {
     });
 };
 exports.delayThenReturn = delayThenReturn;
-var randInt = function (min, max) {
-    var minI = Math.ceil(min);
-    var maxI = Math.floor(max);
+const randInt = (min, max) => {
+    const minI = Math.ceil(min);
+    const maxI = Math.floor(max);
     return Math.floor(Math.random() * (maxI - minI + 1)) + minI;
 };
 exports.randInt = randInt;
-var isFormData = function (value) {
-    return value instanceof FormData;
+const isFormData = (value) => {
+    return typeof FormData !== "undefined" && value instanceof FormData;
 };
 exports.isFormData = isFormData;
+const isPlainObject = (value) => {
+    return Object.prototype.toString.call(value) === "[object Object]";
+};
+const isBlob = (value) => {
+    return typeof Blob !== "undefined" && value instanceof Blob;
+};
+const isArrayBuffer = (value) => {
+    return typeof ArrayBuffer !== "undefined" && value instanceof ArrayBuffer;
+};
+const isArrayBufferView = (value) => {
+    return typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView(value);
+};
+const toFormDataValue = (value) => {
+    if (isBlob(value)) {
+        return value;
+    }
+    if ((isArrayBuffer(value) || isArrayBufferView(value)) && typeof Blob !== "undefined") {
+        return new Blob([value]);
+    }
+    return String(value);
+};
+const toFormData = (body) => {
+    if ((0, exports.isFormData)(body)) {
+        return body;
+    }
+    const formData = new FormData();
+    const appendValue = (key, value) => {
+        if (value === undefined || value === null) {
+            return;
+        }
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                appendValue(key, item);
+            }
+            return;
+        }
+        if (isPlainObject(value) && !isBlob(value)) {
+            for (const nestedKey of Object.keys(value)) {
+                appendValue(`${key}.${nestedKey}`, value[nestedKey]);
+            }
+            return;
+        }
+        formData.append(key, toFormDataValue(value));
+    };
+    if (isPlainObject(body)) {
+        for (const key of Object.keys(body)) {
+            appendValue(key, body[key]);
+        }
+    }
+    return formData;
+};
+exports.toFormData = toFormData;

package/cjs/Validation.d.ts

@@ -1,9 +1,16 @@
 import type * as zod from "zod";
-import type { Body, Params, Query, State } from "./ApiTypes";
+import type { Body, Params, Query, RequestBodyEncoding, State } from "./ApiTypes";
+export interface ValidationOptions<TValue> {
+    schema?: zod.Schema<TValue>;
+}
+export interface BodyValidationOptions<TBody extends Body> extends ValidationOptions<TBody> {
+    encoding?: RequestBodyEncoding;
+}
 export interface Validation<TResponse = any, TParams extends Params | undefined = Params | undefined, TQuery extends Query | undefined = Query | undefined, TBody extends Body | undefined = Body | undefined, TState extends State = State> {
     query?: zod.Schema<TQuery>;
     params?: zod.Schema<TParams>;
     body?: zod.Schema<TBody>;
+    bodyEncoding?: RequestBodyEncoding;
     response?: zod.Schema<TResponse>;
     state?: zod.Schema<TState>;
 }

package/cjs/backend/AxiosRequestBackend.d.ts

@@ -1,8 +1,8 @@
 import type { AxiosError, AxiosResponse } from "axios";
 import type { ApiResponse } from "../ApiTypes";
 import type RequestContext from "../RequestContext";
-import type { ConvertedApiResponse, RequestBackendErrorInfo, RequestOperation } from "./RequestBackend";
 import type RequestBackend from "./RequestBackend";
+import type { ConvertedApiResponse, RequestBackendErrorInfo, RequestOperation } from "./RequestBackend";
 export declare const isAxiosError: (error: Error) => error is AxiosError;
 export default class AxiosRequestBackend implements RequestBackend<AxiosResponse> {
     readonly id = "axios";

package/cjs/backend/AxiosRequestBackend.js

@@ -1,96 +1,13 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-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());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __asyncValues = (this && this.__asyncValues) || function (o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-};
-var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
-var __asyncDelegator = (this && this.__asyncDelegator) || function (o) {
-    var i, p;
-    return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
-    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }
-};
-var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var g = generator.apply(thisArg, _arguments || []), i, q = [];
-    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
-    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
-    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
-    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
-    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
-    function fulfill(value) { resume("next", value); }
-    function reject(value) { resume("throw", value); }
-    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
-};
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isAxiosError = void 0;
-var ApiUtils_1 = require("../ApiUtils");
-var axios;
-var isAxiosError = function (error) {
+const ApiUtils_1 = require("../ApiUtils");
+let axios;
+const isAxiosError = (error) => {
     return "isAxiosError" in error;
 };
 exports.isAxiosError = isAxiosError;
-var getCacheHeaders = function (browserCache) {
+const getCacheHeaders = (browserCache) => {
     switch (browserCache) {
         case "no-store":
             return {
@@ -114,105 +31,81 @@ var getCacheHeaders = function (browserCache) {
             return {};
     }
 };
-var AxiosRequestBackend = /** @class */ (function () {
-    function AxiosRequestBackend(axiosLibrary) {
+class AxiosRequestBackend {
+    constructor(axiosLibrary) {
         this.id = "axios";
         axios = axiosLibrary;
     }
-    AxiosRequestBackend.prototype.extractResponseFromError = function (error) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                if ((0, exports.isAxiosError)(error)) {
-                    return [2 /*return*/, error.response ? error.response : null];
-                }
-                return [2 /*return*/, undefined];
-            });
-        });
-    };
-    AxiosRequestBackend.prototype.convertResponse = function (context, response) {
-        return __awaiter(this, void 0, void 0, function () {
-            var responseType, data;
-            var _a;
-            var _b, _c, _d, _e, _f;
-            return __generator(this, function (_g) {
-                responseType = (_b = context.responseType) !== null && _b !== void 0 ? _b : (0, ApiUtils_1.inferResponseType)(response.headers["content-type"]);
-                if (responseType === "stream") {
-                    // For streaming responses, we create an async iterator from the response data
-                    if (!response.data) {
-                        throw new Error("[api-def] Response data is null for streaming response");
+    async extractResponseFromError(error) {
+        if ((0, exports.isAxiosError)(error)) {
+            return error.response ? error.response : null;
+        }
+        return undefined;
+    }
+    async convertResponse(context, response) {
+        const contentType = response.headers["content-type"];
+        const responseType = context.responseType ?? (0, ApiUtils_1.inferResponseType)(contentType == null ? contentType : String(contentType));
+        let data;
+        if (responseType === "stream") {
+            // For streaming responses, we create an async iterator from the response data
+            if (!response.data) {
+                throw new Error("[api-def] Response data is null for streaming response");
+            }
+            data = {
+                async *[Symbol.asyncIterator]() {
+                    const stream = response.data;
+                    if (stream[Symbol.asyncIterator]) {
+                        yield* stream;
                     }
-                    data = (_a = {},
-                        _a[Symbol.asyncIterator] = function () {
-                            return __asyncGenerator(this, arguments, function _a() {
-                                var stream;
-                                return __generator(this, function (_b) {
-                                    switch (_b.label) {
-                                        case 0:
-                                            stream = response.data;
-                                            if (!stream[Symbol.asyncIterator]) return [3 /*break*/, 3];
-                                            return [5 /*yield**/, __values(__asyncDelegator(__asyncValues(stream)))];
-                                        case 1: return [4 /*yield*/, __await.apply(void 0, [_b.sent()])];
-                                        case 2:
-                                            _b.sent();
-                                            return [3 /*break*/, 7];
-                                        case 3:
-                                            if (!stream.on) return [3 /*break*/, 6];
-                                            // Handle Node.js streams
-                                            return [5 /*yield**/, __values(__asyncDelegator(__asyncValues(stream)))];
-                                        case 4: 
-                                        // Handle Node.js streams
-                                        return [4 /*yield*/, __await.apply(void 0, [_b.sent()])];
-                                        case 5:
-                                            // Handle Node.js streams
-                                            _b.sent();
-                                            return [3 /*break*/, 7];
-                                        case 6: throw new Error("[api-def] Response data is not a valid stream");
-                                        case 7: return [2 /*return*/];
-                                    }
-                                });
-                            });
-                        },
-                        _a);
-                }
-                else {
-                    data = response.data;
-                }
-                return [2 /*return*/, {
-                        method: context.method,
-                        url: (_d = (_c = response.request.res) === null || _c === void 0 ? void 0 : _c.responseUrl) !== null && _d !== void 0 ? _d : (_f = (_e = response.request) === null || _e === void 0 ? void 0 : _e._redirectable) === null || _f === void 0 ? void 0 : _f._currentUrl,
-                        data: data,
-                        headers: response.headers,
-                        status: response.status,
-                        state: context.requestConfig.state,
-                        __lowercaseHeaders: response._lowerCaseResponseHeaders,
-                        stats: context.stats,
-                    }];
-            });
-        });
-    };
-    AxiosRequestBackend.prototype.makeRequest = function (context) {
-        var requestConfig = context.requestConfig;
-        var url = context.requestUrl;
-        var canceler = null;
-        var promise = axios({
+                    else if (stream.on) {
+                        // Handle Node.js streams
+                        yield* stream;
+                    }
+                    else {
+                        throw new Error("[api-def] Response data is not a valid stream");
+                    }
+                },
+            };
+        }
+        else {
+            data = response.data;
+        }
+        return {
+            method: context.method,
+            url: response.request.res?.responseUrl ?? response.request?._redirectable?._currentUrl,
+            data: data,
+            headers: response.headers,
+            status: response.status,
+            state: context.requestConfig.state,
+            __lowercaseHeaders: response._lowerCaseResponseHeaders,
+            stats: context.stats,
+        };
+    }
+    makeRequest(context) {
+        const { requestConfig } = context;
+        const url = context.requestUrl;
+        let canceler = null;
+        const promise = axios({
             method: context.method,
             url: url.href,
             data: context.getParsedBody(),
-            headers: __assign(__assign({}, getCacheHeaders(requestConfig.browserCache)), requestConfig.headers),
+            headers: {
+                ...getCacheHeaders(requestConfig.browserCache),
+                ...requestConfig.headers,
+            },
             responseType: context.responseType,
             withCredentials: requestConfig.credentials === "include" || requestConfig.credentials === "same-origin",
-            cancelToken: new axios.CancelToken(function (cancellerFunc) {
+            cancelToken: new axios.CancelToken((cancellerFunc) => {
                 canceler = cancellerFunc;
             }),
         });
         return {
             promise: promise,
-            canceler: function () { return canceler === null || canceler === void 0 ? void 0 : canceler(); },
+            canceler: () => canceler?.(),
         };
-    };
-    AxiosRequestBackend.prototype.getErrorInfo = function (error, response) {
+    }
+    getErrorInfo(error, response) {
         return undefined;
-    };
-    return AxiosRequestBackend;
-}());
+    }
+}
 exports.default = AxiosRequestBackend;

package/cjs/backend/FetchRequestBackend.d.ts

@@ -1,8 +1,8 @@
 import type { ApiResponse } from "../ApiTypes";
 import type RequestContext from "../RequestContext";
 import { type Fetch } from "../Utils";
-import type { ConvertedApiResponse, RequestBackendErrorInfo, RequestOperation } from "./RequestBackend";
 import type RequestBackend from "./RequestBackend";
+import type { ConvertedApiResponse, RequestBackendErrorInfo, RequestOperation } from "./RequestBackend";
 export default class FetchRequestBackend implements RequestBackend<Response> {
     fetch: (((input: RequestInfo | URL, init?: RequestInit) => Promise<Response>) & typeof fetch) | undefined;
     readonly id = "fetch";