api-def 0.12.1 → 0.14.0-alpha.1

package/esm/RequestConfig.js

@@ -1,24 +1,23 @@
-import { COMPUTED_CONFIG_SYMBOL, } from "./ApiTypes";
-import { DEFAULT_QUERY_PARSE, DEFAULT_QUERY_STRINGIFY } from "./QueryHandling";
-import * as Utils from "./Utils";
+import { COMPUTED_CONFIG_SYMBOL, } from "./ApiTypes.js";
+import { DEFAULT_QUERY_PARSE, DEFAULT_QUERY_STRINGIFY } from "./QueryHandling.js";
+import * as Utils from "./Utils.js";
 const MERGED_CONFIG_KEYS = ["headers"];
 export const processRequestConfigs = (configs) => {
-    var _a, _b;
     const computedConfig = Utils.assign({
         [COMPUTED_CONFIG_SYMBOL]: true,
     }, ...configs);
     // merge other values
     for (const key of MERGED_CONFIG_KEYS) {
         computedConfig[key] = Utils.assign({}, ...configs.reduce((acc, config) => {
-            if (config === null || config === void 0 ? void 0 : config[key]) {
+            if (config?.[key]) {
                 acc.push(config[key]);
             }
             return acc;
         }, []));
     }
     computedConfig.queryHandling = {
-        parse: ((_a = computedConfig.queryHandling) === null || _a === void 0 ? void 0 : _a.parse) || DEFAULT_QUERY_PARSE,
-        stringify: ((_b = computedConfig.queryHandling) === null || _b === void 0 ? void 0 : _b.stringify) || computedConfig.queryParser || DEFAULT_QUERY_STRINGIFY,
+        parse: computedConfig.queryHandling?.parse || DEFAULT_QUERY_PARSE,
+        stringify: computedConfig.queryHandling?.stringify || computedConfig.queryParser || DEFAULT_QUERY_STRINGIFY,
     };
     computedConfig.queryParser = undefined;
     const query = computedConfig.query;

package/esm/RequestContext.d.ts

@@ -1,10 +1,10 @@
-import type { Api } from "./Api";
-import type { RequestEvent, RequestMethod, ResponseType } from "./ApiConstants";
-import type { ApiResponse, Body, ComputedRequestConfig, EventResult, Params, Query, RawHeaders, RequestCacheInfo, RequestEventHandlers, RequestHost, RequestStats, State } from "./ApiTypes";
-import type { EndpointMockingConfig } from "./MockingTypes";
-import type { RequestError } from "./RequestError";
-import type { Validation } from "./Validation";
-import type RequestBackend from "./backend/RequestBackend";
+import type { Api } from "./Api.js";
+import type { RequestEvent, RequestMethod, ResponseType } from "./ApiConstants.js";
+import type { ApiResponse, Body, ComputedRequestConfig, EventResult, Params, Query, RawHeaders, RequestCacheInfo, RequestEventHandlers, RequestHost, RequestStats, State } from "./ApiTypes.js";
+import type RequestBackend from "./backend/RequestBackend.js";
+import type { EndpointMockingConfig } from "./MockingTypes.js";
+import type { RequestError } from "./RequestError.js";
+import type { Validation } from "./Validation.js";
 export default class RequestContext<TResponse = any, TParams extends Params | undefined = Params | undefined, TQuery extends Query | undefined = Query | undefined, TBody extends Body | undefined = Body | undefined, TState extends State = State> {
     readonly id: number;
     readonly key: string;
@@ -42,6 +42,7 @@ export default class RequestContext<TResponse = any, TParams extends Params | un
     updateParams(params: Partial<Record<string, string>>): this;
     private parseRequestBody;
     getParsedBody(): any;
+    parseBody(): void;
     updateQuery(newQuery: Partial<TQuery>): this;
     triggerEvent(eventType: RequestEvent): Promise<EventResult<TResponse> | undefined>;
     addCanceller(canceler: () => void): void;

package/esm/RequestContext.js

@@ -1,14 +1,5 @@
-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());
-    });
-};
-import { resolvePathParams, resolveUrl } from "./ApiUtils";
-import * as Utils from "./Utils";
+import { resolvePathParams, resolveUrl } from "./ApiUtils.js";
+import * as Utils from "./Utils.js";
 let contextIdCounter = 0;
 export default class RequestContext {
     constructor(backend, host, config, rawPath, mocking) {
@@ -100,18 +91,32 @@ export default class RequestContext {
         return this;
     }
     parseRequestBody() {
-        var _a;
         if (this.requestConfig.body && this.requestConfig.headers) {
             const contentTypeKey = Object.keys(this.requestConfig.headers).find((key) => key.toLowerCase() === "content-type");
-            const contentType = contentTypeKey && ((_a = this.requestConfig.headers[contentTypeKey]) === null || _a === void 0 ? void 0 : _a.toString().split(";")[0].trim());
+            const contentType = contentTypeKey && this.requestConfig.headers[contentTypeKey]?.toString().split(";")[0].trim();
+            const bodyEncoding = this.validation.bodyEncoding ?? "application/json";
+            if (!contentTypeKey && bodyEncoding === "application/x-www-form-urlencoded") {
+                this.requestConfig.headers["Content-Type"] = "application/x-www-form-urlencoded";
+            }
             if (contentType === "application/x-www-form-urlencoded") {
                 const searchParams = new URLSearchParams();
                 for (const key of Object.keys(this.requestConfig.body)) {
                     const value = this.requestConfig.body[key];
-                    searchParams.append(key, value === null || value === void 0 ? void 0 : value.toString());
+                    searchParams.append(key, value?.toString());
                 }
                 this.parsedBody = searchParams;
             }
+            else if (bodyEncoding === "application/x-www-form-urlencoded") {
+                const searchParams = new URLSearchParams();
+                for (const key of Object.keys(this.requestConfig.body)) {
+                    const value = this.requestConfig.body[key];
+                    searchParams.append(key, value?.toString());
+                }
+                this.parsedBody = searchParams;
+            }
+            else if (bodyEncoding === "multipart/form-data") {
+                this.parsedBody = Utils.toFormData(this.requestConfig.body);
+            }
             else {
                 this.parsedBody = this.requestConfig.body;
             }
@@ -123,25 +128,26 @@ export default class RequestContext {
     getParsedBody() {
         return this.parsedBody;
     }
+    parseBody() {
+        this.parseRequestBody();
+    }
     updateQuery(newQuery) {
         this.requestConfig.queryObject = Utils.assign({}, this.requestConfig.queryObject, newQuery);
         this.computedRequestUrl = this.resolveRequestUrl();
         return this;
     }
-    triggerEvent(eventType) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const eventHandlers = this.eventHandlers[eventType];
-            if (eventHandlers) {
-                for (let i = 0; i < eventHandlers.length; i++) {
-                    const eventHandler = eventHandlers[i];
-                    const eventResult = yield eventHandler(this);
-                    if (eventResult) {
-                        return eventResult;
-                    }
+    async triggerEvent(eventType) {
+        const eventHandlers = this.eventHandlers[eventType];
+        if (eventHandlers) {
+            for (let i = 0; i < eventHandlers.length; i++) {
+                const eventHandler = eventHandlers[i];
+                const eventResult = await eventHandler(this);
+                if (eventResult) {
+                    return eventResult;
                 }
             }
-            return undefined;
-        });
+        }
+        return undefined;
     }
     addCanceller(canceler) {
         this.canceler = canceler;
@@ -170,7 +176,7 @@ export default class RequestContext {
         this.computedMethod = method;
     }
     updateBody(body) {
-        // @ts-ignore
+        // @ts-expect-error
         this.requestConfig.body = body;
         this.parseRequestBody();
     }

package/esm/RequestError.d.ts

@@ -1,6 +1,6 @@
-import type { ApiResponse } from "./ApiTypes";
-import type RequestContext from "./RequestContext";
-import type { EnumOf } from "./Utils";
+import type { ApiResponse } from "./ApiTypes.js";
+import type RequestContext from "./RequestContext.js";
+import type { EnumOf } from "./Utils.js";
 export declare const RequestErrorCode: {
     readonly MISC_UNKNOWN_ERROR: "misc/unknown-error";
     readonly REQUEST_NETWORK_ERROR: "request/network-error";

package/esm/RequestError.js

@@ -46,7 +46,7 @@ export const convertToRequestError = (config) => {
     });
     try {
         Object.defineProperty(resultError, "message", {
-            value: `A ${context.method.toUpperCase()} request to '${context.requestUrl.href}' failed${(response === null || response === void 0 ? void 0 : response.status) ? ` with status code ${response.status}` : ""} [${code}]: ${resultError.message}`,
+            value: `A ${context.method.toUpperCase()} request to '${context.requestUrl.href}' failed${response?.status ? ` with status code ${response.status}` : ""} [${code}]: ${resultError.message}`,
         });
     }
     catch (e) {
@@ -57,9 +57,8 @@ export const convertToRequestError = (config) => {
     return resultError;
 };
 export const getErrorResponse = (error) => {
-    var _a;
     if (isRequestError(error)) {
-        return (_a = error.response) !== null && _a !== void 0 ? _a : undefined;
+        return error.response ?? undefined;
     }
     return undefined;
 };

package/esm/Requester.d.ts

@@ -1,3 +1,3 @@
-import type { ApiResponse, Body, Params, Query, RequestConfig, RequestHost, State } from "./ApiTypes";
-import type { EndpointMockingConfig } from "./MockingTypes";
+import type { ApiResponse, Body, Params, Query, RequestConfig, RequestHost, State } from "./ApiTypes.js";
+import type { EndpointMockingConfig } from "./MockingTypes.js";
 export declare const submit: <TResponse, TParams extends Params | undefined, TQuery extends Query | undefined, TBody extends Body | undefined, TState extends State>(host: RequestHost, config: RequestConfig<TParams, TQuery, TBody, TState>, mocking: EndpointMockingConfig<TResponse, TParams, TQuery, TBody, TState> | null | undefined) => Promise<ApiResponse<TResponse>>;

package/esm/Requester.js

@@ -1,23 +1,14 @@
-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());
-    });
-};
-import { EventResultType, RequestEvent } from "./ApiConstants";
-import { inferResponseType, isAcceptableStatus, isNetworkError } from "./ApiUtils";
-import RequestContext from "./RequestContext";
-import { RequestErrorCode, convertToRequestError, isRequestError } from "./RequestError";
-import { textDecode } from "./TextDecoding";
-import MockRequestBackend from "./backend/MockRequestBackend";
-import retry from "./util/retry";
+import { EventResultType, RequestEvent } from "./ApiConstants.js";
+import { inferResponseType, isAcceptableStatus, isNetworkError } from "./ApiUtils.js";
+import MockRequestBackend from "./backend/MockRequestBackend.js";
+import RequestContext from "./RequestContext.js";
+import { convertToRequestError, isRequestError, RequestErrorCode } from "./RequestError.js";
+import { textDecode } from "./TextDecoding.js";
+import retry from "./util/retry/index.js";
 const locks = {};
 const runningOperations = {};
 const MOCK_REQUEST_BACKEND = new MockRequestBackend();
-export const submit = (host, config, mocking) => __awaiter(void 0, void 0, void 0, function* () {
+export const submit = async (host, config, mocking) => {
     const computedConfig = host.computeConfig(config);
     const backend = mocking ? MOCK_REQUEST_BACKEND : host.getRequestBackend();
     const context = new RequestContext(backend, host, computedConfig, host.path, mocking);
@@ -39,8 +30,8 @@ export const submit = (host, config, mocking) => __awaiter(void 0, void 0, void
         locks[lock] = context;
     }
     try {
-        let response = yield (runningOperations[key] = makeRequest(context));
-        const successEventResult = yield context.triggerEvent(RequestEvent.SUCCESS);
+        let response = await (runningOperations[key] = makeRequest(context));
+        const successEventResult = await context.triggerEvent(RequestEvent.SUCCESS);
         if (successEventResult && successEventResult.type === EventResultType.RESPOND) {
             context.response = response = successEventResult.response;
         }
@@ -56,7 +47,7 @@ export const submit = (host, config, mocking) => __awaiter(void 0, void 0, void
             delete locks[lock];
         }
     }
-});
+};
 const parseRetryOptions = (retryConfig) => {
     if (retryConfig && typeof retryConfig === "object") {
         return retryConfig;
@@ -66,9 +57,8 @@ const parseRetryOptions = (retryConfig) => {
     }
     return { maxAttempts: 0 };
 };
-const makeRequest = (context) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b, _c;
-    const beforeSendEventResult = yield context.triggerEvent(RequestEvent.BEFORE_SEND);
+const makeRequest = async (context) => {
+    const beforeSendEventResult = await context.triggerEvent(RequestEvent.BEFORE_SEND);
     if (beforeSendEventResult && beforeSendEventResult.type === EventResultType.RESPOND) {
         return (context.response = beforeSendEventResult.response);
     }
@@ -98,22 +88,23 @@ const makeRequest = (context) => __awaiter(void 0, void 0, void 0, function* ()
             });
         }
     }
-    const retryOptions = parseRetryOptions((_a = context.requestConfig) === null || _a === void 0 ? void 0 : _a.retry);
+    context.parseBody();
+    const retryOptions = parseRetryOptions(context.requestConfig?.retry);
     const internalRetryOptions = {
         retries: retryOptions.maxAttempts,
         // assume most users won't want to tune the delay between retries
-        minTimeout: (_b = retryOptions.minDelay) !== null && _b !== void 0 ? _b : 200,
-        maxTimeout: (_c = retryOptions.maxDelay) !== null && _c !== void 0 ? _c : 1000,
+        minTimeout: retryOptions.minDelay ?? 200,
+        maxTimeout: retryOptions.maxDelay ?? 1000,
         randomize: true,
     };
     context.stats.attempt = 0;
-    const performRequest = (fnBail, attemptCount) => __awaiter(void 0, void 0, void 0, function* () {
+    const performRequest = async (fnBail, attemptCount) => {
         context.stats.attempt++;
         try {
             const { promise, canceler } = context.backend.makeRequest(context);
             context.addCanceller(canceler);
-            const response = yield promise;
-            const parsedResponse = (yield parseResponse(context, response));
+            const response = await promise;
+            const parsedResponse = (await parseResponse(context, response));
             if (!isAcceptableStatus(parsedResponse.status, context.requestConfig.acceptableStatus)) {
                 throw convertToRequestError({
                     error: new Error(`[api-def] Invalid response status code '${parsedResponse.status}'`),
@@ -130,12 +121,12 @@ const makeRequest = (context) => __awaiter(void 0, void 0, void 0, function* ()
             if (context.cancelled) {
                 rawError.isCancelledRequest = true;
             }
-            const error = yield parseError(context, rawError);
+            const error = await parseError(context, rawError);
             context.error = error;
             context.response = error.response;
             context.stats.endTimestamp = Date.now();
-            const errorEventResult = yield context.triggerEvent(RequestEvent.ERROR);
-            if ((errorEventResult === null || errorEventResult === void 0 ? void 0 : errorEventResult.type) === EventResultType.RESPOND) {
+            const errorEventResult = await context.triggerEvent(RequestEvent.ERROR);
+            if (errorEventResult?.type === EventResultType.RESPOND) {
                 return errorEventResult.response;
             }
             // allow retry logic to handle network errors
@@ -144,7 +135,7 @@ const makeRequest = (context) => __awaiter(void 0, void 0, void 0, function* ()
             //  throw error;
             //}
             // if we have an event that tells us to retry, we must do it
-            const forceRetry = (errorEventResult === null || errorEventResult === void 0 ? void 0 : errorEventResult.type) === EventResultType.RETRY;
+            const forceRetry = errorEventResult?.type === EventResultType.RETRY;
             if (forceRetry) {
                 return performRequest(fnBail, attemptCount);
             }
@@ -153,7 +144,7 @@ const makeRequest = (context) => __awaiter(void 0, void 0, void 0, function* ()
                 throw error;
             }
             // error is unrecoverable, bail
-            const unrecoverableErrorEventResult = yield context.triggerEvent(RequestEvent.UNRECOVERABLE_ERROR);
+            const unrecoverableErrorEventResult = await context.triggerEvent(RequestEvent.UNRECOVERABLE_ERROR);
             if (unrecoverableErrorEventResult) {
                 if (unrecoverableErrorEventResult.type === EventResultType.RESPOND) {
                     return unrecoverableErrorEventResult.response;
@@ -161,8 +152,8 @@ const makeRequest = (context) => __awaiter(void 0, void 0, void 0, function* ()
             }
             fnBail(error);
         }
-    });
-    const response = yield retry(performRequest, internalRetryOptions);
+    };
+    const response = await retry(performRequest, internalRetryOptions);
     if (context.validation.response) {
         try {
             response.data = context.validation.response.parse(response.data);
@@ -176,11 +167,10 @@ const makeRequest = (context) => __awaiter(void 0, void 0, void 0, function* ()
         }
     }
     return response;
-});
-const parseResponse = (context, response, error) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
+};
+const parseResponse = async (context, response, error) => {
     if (response) {
-        const parsedResponse = yield context.backend.convertResponse(context, response);
+        const parsedResponse = await context.backend.convertResponse(context, response);
         const contentType = parsedResponse.headers.get("content-type");
         const inferredResponseType = inferResponseType(contentType);
         if (!error) {
@@ -197,7 +187,7 @@ const parseResponse = (context, response, error) => __awaiter(void 0, void 0, vo
             if (inferredResponseType === "arraybuffer" && context.responseType === "json") {
                 if (parsedResponse.data && typeof parsedResponse.data === "object") {
                     const data = response.data;
-                    if (((_a = data.constructor) === null || _a === void 0 ? void 0 : _a.name) === "ArrayBuffer") {
+                    if (data.constructor?.name === "ArrayBuffer") {
                         try {
                             const decodedData = (response.data = textDecode(data));
                             response.data = JSON.parse(decodedData);
@@ -217,18 +207,17 @@ const parseResponse = (context, response, error) => __awaiter(void 0, void 0, vo
         return parsedResponse;
     }
     return response;
-});
-const parseError = (context, rawError) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
+};
+const parseError = async (context, rawError) => {
     let error;
     if (isRequestError(rawError)) {
         error = rawError;
     }
     else {
-        const extractedResponse = yield context.backend.extractResponseFromError(rawError);
-        let errorResponse = undefined;
+        const extractedResponse = await context.backend.extractResponseFromError(rawError);
+        let errorResponse;
         if (extractedResponse !== undefined) {
-            errorResponse = yield parseResponse(context, extractedResponse, true);
+            errorResponse = await parseResponse(context, extractedResponse, true);
         }
         let code = isNetworkError(rawError)
             ? RequestErrorCode.REQUEST_NETWORK_ERROR
@@ -239,12 +228,18 @@ const parseError = (context, rawError) => __awaiter(void 0, void 0, void 0, func
             }
         }
         else {
-            if (rawError.code === "ENOTFOUND" || ((_a = rawError.cause) === null || _a === void 0 ? void 0 : _a.code) === "ENOTFOUND") {
+            if (rawError.code === "ENOTFOUND" || rawError.cause?.code === "ENOTFOUND") {
                 code = RequestErrorCode.REQUEST_HOST_NAME_NOT_FOUND;
             }
         }
         const errorInfo = context.backend.getErrorInfo(rawError, errorResponse);
-        error = convertToRequestError(Object.assign({ error: rawError, response: errorResponse, code: code, context: context }, errorInfo));
+        error = convertToRequestError({
+            error: rawError,
+            response: errorResponse,
+            code: code,
+            context: context,
+            ...errorInfo,
+        });
     }
     return error;
-});
+};

package/esm/UtilTypes.d.ts

@@ -1,4 +1,4 @@
-import type Endpoint from "./Endpoint";
+import type Endpoint from "./Endpoint.js";
 export type ResponseOf<E extends Endpoint<any, any, any, any>> = E extends Endpoint<infer R, any, any, any> ? R : never;
 export type ParamsOf<E extends Endpoint<any, any, any, any>> = E extends Endpoint<any, infer P, any, any> ? P : never;
 export type QueryOf<E extends Endpoint<any, any, any, any>> = E extends Endpoint<any, any, infer Q, any> ? Q : never;

package/esm/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/esm/Utils.js

@@ -1,4 +1,5 @@
 // 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);
 export const assign = Object.assign ||
     ((target, ...varArgs) => {
         if (target === null || target === undefined) {
@@ -10,7 +11,7 @@ export const assign = Object.assign ||
             if (nextSource !== null && nextSource !== undefined) {
                 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];
                     }
                 }
@@ -63,5 +64,56 @@ export const randInt = (min, max) => {
     return Math.floor(Math.random() * (maxI - minI + 1)) + minI;
 };
 export const isFormData = (value) => {
-    return value instanceof FormData;
+    return typeof FormData !== "undefined" && value instanceof FormData;
+};
+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);
+};
+export const toFormData = (body) => {
+    if (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;
 };

package/esm/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.js";
+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/esm/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 { ApiResponse } from "../ApiTypes.js";
+import type RequestContext from "../RequestContext.js";
+import type RequestBackend from "./RequestBackend.js";
+import type { ConvertedApiResponse, RequestBackendErrorInfo, RequestOperation } from "./RequestBackend.js";
 export declare const isAxiosError: (error: Error) => error is AxiosError;
 export default class AxiosRequestBackend implements RequestBackend<AxiosResponse> {
     readonly id = "axios";