@tahanabavi/typefetch 1.2.1 → 1.3.0

package/README.md

@@ -1,80 +1,86 @@
 # TypeFetch
 
-TypeFetch is a strongly-typed HTTP client built on TypeScript and Zod.
+TypeFetch is a strongly-typed HTTP client built on **TypeScript** and **Zod**.
 
 You define your API once using Zod schemas, and TypeFetch generates a fully type-safe client with:
 
 - End-to-end type safety
-- Automatic URL handling (path, query, body)
-- Middleware pipeline (logging, retry, cache, auth)
+- Structured request support: `{ path, query, body, headers }`
+- Automatic URL handling (path parameters, query string, JSON body)
+- Middleware pipeline (logging, retry, cache, auth, custom)
 - Mock mode for development
 - Dynamic token providers
 - Response wrappers for consistent API envelopes
-- Unified error system (RichError)
+- Unified error system (`RichError`)
+- Optional `form-data` body support for file uploads
+
+---
 
 ## Installation
 
+```bash
 npm install @tahanabavi/typefetch
-
 # or
-
 yarn add @tahanabavi/typefetch
+```
+
+---
 
-## Key Features
+## Core Concepts
 
-1. Type-Safe API Client  
-   Define your API with Zod schemas and get full type safety for request and response types.
+### 1. Type-Safe API Client
 
-2. Structured Request Support  
-   Each request may contain:
+Define your API with Zod schemas and get full type safety for request and response types.
 
-   - path: URL parameters (fills /users/:id)
-   - query: URL query string ?page=1&limit=10
-   - body: JSON payload for POST/PUT/PATCH
+Each endpoint has:
 
-   The client automatically builds URLs and bodies correctly.
+- `method`: HTTP verb (`GET | POST | PUT | PATCH | DELETE`)
+- `path`: path template (e.g. `/users/:id`)
+- `auth?`: whether a token is required
+- `request`: Zod schema for the request
+- `response`: Zod schema for the response
+- `mockData?`: static or dynamic mock response
+- `headers?`: static or function-based default headers
+- `bodyType?`: `"json"` (default) or `"form-data"`
 
-3. Backward Compatibility  
-   If your request schema is flat (z.object({ name: z.string() })), TypeFetch automatically treats it as a simple body payload—no breaking changes.
+### 2. Structured Request Shape
 
-4. Middlewares  
-   Middlewares allow modifying requests and responses.
-   Built-in middlewares include:
+The recommended request shape is:
 
-   - loggingMiddleware
-   - retryMiddleware
-   - authMiddleware
-   - cacheMiddleware
+```ts
+z.object({
+  path: z.object({ ... }).optional(),    // URL params → /users/:id
+  query: z.object({ ... }).optional(),   // query string → ?page=1
+  body: z.object({ ... }).optional(),    // JSON body
+  headers: z.record(z.string()).optional(), // per-call extra headers
+})
+```
 
-5. Token Provider System  
-   Provide tokens dynamically using:
+TypeFetch will:
 
-   - token: static auth token
-   - tokenProvider: function or async function returning a token
+- Replace `:param` segments in the path using `path`
+- Build query string from `query`
+- Serialize `body` as JSON (or `FormData` if `bodyType: "form-data"`)
+- Merge headers from:
+  - auth (Authorization)
+  - endpoint-level `headers`
+  - per-call `headers` in the request (highest priority)
 
-6. Mock Mode  
-   Provides mock responses based on endpoint.mockData, with configurable fake delays.
+### 3. Backward Compatibility
 
-7. Response Wrapper  
-   For APIs that wrap responses:
+If your `request` schema is **flat** (e.g. `z.object({ name: z.string() })`) and does **not** contain `path`, `query`, `body`, or `headers`, TypeFetch treats the entire object as the request body for non-GET methods.
 
-   ```
-   {
-     "success": true,
-     "data": {...},
-     "timestamp": "...",
-     "requestId": "..."
-   }
-   ```
+This makes migration to the structured format incremental and safe.
 
-   TypeFetch unwraps the response automatically.
+---
 
 ## Defining API Contracts
 
 Example contract definition:
 
-```
+```ts
 import { z } from "zod";
+import { Contracts, EndpointDef } from "@tahanabavi/typefetch";
 
 const contracts = {
   user: {
@@ -86,12 +92,13 @@ const contracts = {
         path: z.object({ id: z.string() }).optional(),
         query: z.object({}).optional(),
         body: z.never().optional(),
+        headers: z.record(z.string()).optional(),
       }),
       response: z.object({
         id: z.string(),
         name: z.string(),
       }),
-      mockData: { id: "1", name: "John Doe" }
+      mockData: { id: "1", name: "John Doe" },
     },
 
     createUser: {
@@ -101,7 +108,12 @@ const contracts = {
       request: z.object({
         path: z.object({}).optional(),
         query: z.object({}).optional(),
-        body: z.object({ name: z.string() }).optional(),
+        body: z
+          .object({
+            name: z.string(),
+          })
+          .optional(),
+        headers: z.record(z.string()).optional(),
       }),
       response: z.object({
         id: z.string(),
@@ -111,21 +123,26 @@ const contracts = {
         id: Math.random().toString(36).slice(2),
         name: "Mock User",
       }),
-    }
-  }
-};
+    },
+  },
+} as const;
 ```
 
-## Using ApiClient
+You **do not** have to use these explicit generic annotations if you don’t want to – they are shown here only for clarity. In most cases, simple `as const` + inference is enough.
 
-```
+---
+
+## Using `ApiClient`
+
+```ts
 import { ApiClient } from "@tahanabavi/typefetch";
+import { contracts } from "./contracts";
 
 const client = new ApiClient(
   {
     baseUrl: "https://api.example.com",
-    tokenProvider: () => "dynamic-token",
-    useMockData: false
+    tokenProvider: () => "dynamic-token", // or undefined for public endpoints
+    useMockData: false,
   },
   contracts
 );
@@ -138,11 +155,18 @@ const user = await api.user.getUser({ path: { id: "123" } });
 const created = await api.user.createUser({ body: { name: "Alice" } });
 ```
 
+- `client.init()` builds the typed `modules` API using your contracts.
+- `api.user.getUser` and `api.user.createUser` are fully typed from the Zod schemas.
+
+---
+
 ## Middlewares
 
-Example custom middleware:
+Middlewares allow you to hook into the request/response lifecycle.
 
-```
+### Custom Middleware Example
+
+```ts
 client.use(async (ctx, next) => {
   console.log("Request to:", ctx.url);
   const res = await next();
@@ -151,72 +175,189 @@ client.use(async (ctx, next) => {
 });
 ```
 
-Built-in middlewares:
+### Built-in Middlewares
 
-```
+```ts
 import {
   loggingMiddleware,
   retryMiddleware,
   cacheMiddleware,
-  authMiddleware
+  authMiddleware,
 } from "@tahanabavi/typefetch/middlewares";
 
-  client.use(loggingMiddleware, { logRequest: true });
-  client.use(retryMiddleware, { maxRetries: 3, delay: 100 });
-  client.use(cacheMiddleware, { ttl: 60000 });
-  client.use(authMiddleware, {
-  refreshToken: async () => "refreshed-token"
+client.use(loggingMiddleware, {
+  logRequest: true,
+  logResponse: true,
+  debug: true,
+});
+client.use(retryMiddleware, { maxRetries: 3, delay: 100 });
+client.use(cacheMiddleware, { ttl: 60000 });
+client.use(authMiddleware, {
+  refreshToken: async () => "refreshed-token",
 });
 ```
 
+- **`loggingMiddleware`** – logs requests and responses (controlled by `debug`, `logRequest`, `logResponse`).
+- **`retryMiddleware`** – retries failed requests with configurable `maxRetries` and `delay`.
+- **`cacheMiddleware`** – caches GET responses in-memory per URL with `ttl` (ms).
+- **`authMiddleware`** – can refresh tokens and inject `Authorization` headers before the request.
+
+---
+
 ## Mock Mode
-```
-client.setMockMode(true, { min: 200, max: 1000 });
+
+Enable or disable mock mode globally:
+
+```ts
+client.setMockMode(true, { min: 200, max: 1000 }); // simulate network delay
+// ...
 client.setMockMode(false);
 ```
+
+When mock mode is enabled and `endpoint.mockData` is defined, requests will return mock data instead of hitting the network. The response wrapper and response transform still apply.
+
+---
+
 ## Response Transformation
-```
+
+You can apply a global transformation to all successful responses:
+
+```ts
 client.useResponseTransform((data) => {
   return {
     ...data,
-    transformedAt: new Date().toISOString()
+    transformedAt: new Date().toISOString(),
   };
 });
 ```
+
+This runs after:
+
+1. The HTTP call succeeds (`res.ok` is true)
+2. Optional response wrapper has been unwrapped
+3. The response has been validated with the endpoint’s Zod schema
+
+---
+
 ## Response Wrapper Example
+
+For APIs that wrap responses like this:
+
+```json
+{
+  "success": true,
+  "data": { ... },
+  "timestamp": "...",
+  "requestId": "..."
+}
 ```
-const wrapper = (successResponse) =>
-z.union([
-  z.object({
-    success: z.literal(true),
-    data: successResponse,
-    timestamp: z.string(),
-    requestId: z.string(),
-  }),
-  z.object({
-    success: z.literal(false),
-    message: z.string(),
-    code: z.number(),
-    timestamp: z.string(),
-    requestId: z.string(),
-  }),
-]);
+
+You can define a single wrapper schema:
+
+```ts
+import { z } from "zod";
+
+const wrapper = (successResponse: z.ZodTypeAny) =>
+  z.union([
+    z.object({
+      success: z.literal(true),
+      data: successResponse,
+      timestamp: z.string(),
+      requestId: z.string(),
+    }),
+    z.object({
+      success: z.literal(false),
+      message: z.string(),
+      code: z.number(),
+      timestamp: z.string(),
+      requestId: z.string(),
+    }),
+  ]);
 
 client.setResponseWrapper(wrapper);
 ```
+
+On `success: true`, `data` is passed to the endpoint’s `response` schema.  
+On `success: false`, a `RichError` is thrown with normalized information.
+
+---
+
 ## Error Handling
-```
+
+```ts
 client.onError((err) => {
   console.error("API Error:", err.message, err.status, err.code);
 });
 ```
+
+Errors are normalized into `RichError` (or your custom type if you change the generic). Zod validation errors are also wrapped into a `VALIDATION_ERROR` with a readable message.
+
+You can still handle errors per-call with `try/catch`:
+
+```ts
+try {
+  const user = await api.user.getUser({ path: { id: "123" } });
+} catch (err) {
+  // err is RichError
+}
+```
+
+---
+
+## File Uploads (`form-data`)
+
+For endpoints that need file upload, set `bodyType: "form-data"` and put file(s) inside `body`:
+
+```ts
+const uploadAvatarRequest = z.object({
+  path: z.object({}).optional(),
+  query: z.object({}).optional(),
+  body: z.object({
+    file: z.any(), // or z.instanceof(File) in browser
+  }),
+  headers: z.record(z.string()).optional(),
+});
+
+const uploadAvatarResponse = z.object({
+  url: z.string(),
+});
+
+const contracts = {
+  user: {
+    uploadAvatar: {
+      method: "POST",
+      path: "/users/avatar",
+      auth: true,
+      bodyType: "form-data",
+      request: uploadAvatarRequest,
+      response: uploadAvatarResponse,
+    },
+  },
+} as const;
+```
+
+Usage:
+
+```ts
+const file = input.files?.[0];
+await api.user.uploadAvatar({
+  body: { file },
+});
+```
+
+The client will build a `FormData` object and let the browser set the `Content-Type` header.
+
+---
+
 ## Notes
 
-- Always call client.init() before using client.modules.
-- Middlewares run in reverse registration order.
-- Endpoints requiring auth must have a token or tokenProvider.
-- All responses are validated via Zod.
-- Backward-compatible request support makes migration safe.
+- Always call `client.init()` before using `client.modules`.
+- Middlewares execute in **reverse registration order** (last registered runs first).
+- Endpoints with `auth: true` require a valid token from `token` or `tokenProvider`.
+- All responses are parsed and validated by Zod using each endpoint’s `response` schema.
+- Structured `{ path, query, body, headers }` shape is the canonical model; flat request schemas are still supported for backwards compatibility.
+
+---
 
 ## License
 

package/dist/index.d.mts

@@ -18,6 +18,8 @@ type EndpointDef<TReq extends RequestSchema, TRes extends ResponseSchema> = {
     request: TReq;
     response: TRes;
     mockData?: (() => z.infer<TRes>) | z.infer<TRes>;
+    headers?: Record<string, string> | ((input: z.infer<TReq>) => Record<string, string>);
+    bodyType?: "json" | "form-data";
 };
 type Contracts = {
     [ModuleName: string]: {
@@ -61,15 +63,6 @@ declare class RichError extends Error implements ErrorLike {
 }
 /**
  * Strongly-typed HTTP client built from Zod contracts.
- *
- * Features:
- * - Type-safe request & response based on Zod schemas
- * - Path/query/body support via { path?, query?, body? } shape
- * - Backwards compatible with flat request bodies
- * - Pluggable middleware pipeline
- * - Token and tokenProvider support
- * - Mock mode with configurable delay
- * - Optional response wrapper for APIs that nest data
  */
 declare class ApiClient<C extends Contracts, E extends ErrorLike = RichError> {
     private config;
@@ -148,20 +141,16 @@ declare class ApiClient<C extends Contracts, E extends ErrorLike = RichError> {
      *     path: z.object({...}).optional(),
      *     query: z.object({...}).optional(),
      *     body: z.any().optional(),
+     *     header: z.object({...}).optional(),
      *   })
      *
-     * If the parsed request does not contain `path`, `query` or `body`,
+     * If the parsed request does not contain `path`, `header`,`query` or `body`,
      * the entire input is treated as the legacy flat request body.
      */
     private request;
     /**
-     * Builds the effective URL and request body for an endpoint.
-     *
-     * - Legacy mode: if the input does not contain `path`, `query` or `body`,
-     *   the entire input is used as the JSON request body for non-GET methods.
-     *
-     * - New mode: uses `path` to interpolate `:param` segments, `query` to
-     *   construct the query string, and `body` as the JSON payload.
+     * Builds final URL and body from endpoint + request input.
+     * Supports both structured `{ path, query, body, headers }` and legacy flat input.
      */
     private buildUrlAndBody;
     /**
@@ -207,4 +196,26 @@ type CacheOptions = {
 };
 declare const cacheMiddleware: (options?: CacheOptions) => (ctx: MiddlewareContext, next: MiddlewareNext) => Promise<Response>;
 
-export { ApiClient, type AuthOptions, type CacheOptions, type Contracts, type EndpointDef, type EndpointDefZ, type EndpointMethods, type ErrorLike, type LoggingOptions, type Middleware, type MiddlewareContext, type MiddlewareNext, type RequestSchema, type ResponseSchema, type RetryOptions, RichError, type TokenProvider, authMiddleware, cacheMiddleware, loggingMiddleware, retryMiddleware };
+declare const makeRequestSchema: <TPath extends z.ZodRawShape = {}, TQuery extends z.ZodRawShape = {}, TBody extends z.ZodTypeAny = z.ZodUndefined>() => (defs: {
+    path?: z.ZodObject<TPath>;
+    query?: z.ZodObject<TQuery>;
+    body?: TBody;
+    headers?: z.ZodTypeAny;
+}) => z.ZodObject<{
+    path: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>> | z.ZodOptional<z.ZodObject<TPath, z.UnknownKeysParam, z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<TPath>, any> extends infer T ? { [k in keyof T]: T[k]; } : never, z.baseObjectInputType<TPath> extends infer T_1 ? { [k_1 in keyof T_1]: T_1[k_1]; } : never>>;
+    query: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>> | z.ZodOptional<z.ZodObject<TQuery, z.UnknownKeysParam, z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<TQuery>, any> extends infer T_2 ? { [k_2 in keyof T_2]: T_2[k_2]; } : never, z.baseObjectInputType<TQuery> extends infer T_3 ? { [k_3 in keyof T_3]: T_3[k_3]; } : never>>;
+    body: TBody | z.ZodUndefined;
+    headers: any;
+}, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+    path: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>> | z.ZodOptional<z.ZodObject<TPath, z.UnknownKeysParam, z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<TPath>, any> extends infer T_5 ? { [k in keyof T_5]: T_5[k]; } : never, z.baseObjectInputType<TPath> extends infer T_6 ? { [k_1 in keyof T_6]: T_6[k_1]; } : never>>;
+    query: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>> | z.ZodOptional<z.ZodObject<TQuery, z.UnknownKeysParam, z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<TQuery>, any> extends infer T_7 ? { [k_2 in keyof T_7]: T_7[k_2]; } : never, z.baseObjectInputType<TQuery> extends infer T_8 ? { [k_3 in keyof T_8]: T_8[k_3]; } : never>>;
+    body: TBody | z.ZodUndefined;
+    headers: any;
+}>, any> extends infer T_4 ? { [k_4 in keyof T_4]: T_4[k_4]; } : never, z.baseObjectInputType<{
+    path: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>> | z.ZodOptional<z.ZodObject<TPath, z.UnknownKeysParam, z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<TPath>, any> extends infer T_10 ? { [k in keyof T_10]: T_10[k]; } : never, z.baseObjectInputType<TPath> extends infer T_11 ? { [k_1 in keyof T_11]: T_11[k_1]; } : never>>;
+    query: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>> | z.ZodOptional<z.ZodObject<TQuery, z.UnknownKeysParam, z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<TQuery>, any> extends infer T_12 ? { [k_2 in keyof T_12]: T_12[k_2]; } : never, z.baseObjectInputType<TQuery> extends infer T_13 ? { [k_3 in keyof T_13]: T_13[k_3]; } : never>>;
+    body: TBody | z.ZodUndefined;
+    headers: any;
+}> extends infer T_9 ? { [k_5 in keyof T_9]: T_9[k_5]; } : never>;
+
+export { ApiClient, type AuthOptions, type CacheOptions, type Contracts, type EndpointDef, type EndpointDefZ, type EndpointMethods, type ErrorLike, type LoggingOptions, type Middleware, type MiddlewareContext, type MiddlewareNext, type RequestSchema, type ResponseSchema, type RetryOptions, RichError, type TokenProvider, authMiddleware, cacheMiddleware, loggingMiddleware, makeRequestSchema, retryMiddleware };

package/dist/index.d.ts

@@ -18,6 +18,8 @@ type EndpointDef<TReq extends RequestSchema, TRes extends ResponseSchema> = {
     request: TReq;
     response: TRes;
     mockData?: (() => z.infer<TRes>) | z.infer<TRes>;
+    headers?: Record<string, string> | ((input: z.infer<TReq>) => Record<string, string>);
+    bodyType?: "json" | "form-data";
 };
 type Contracts = {
     [ModuleName: string]: {
@@ -61,15 +63,6 @@ declare class RichError extends Error implements ErrorLike {
 }
 /**
  * Strongly-typed HTTP client built from Zod contracts.
- *
- * Features:
- * - Type-safe request & response based on Zod schemas
- * - Path/query/body support via { path?, query?, body? } shape
- * - Backwards compatible with flat request bodies
- * - Pluggable middleware pipeline
- * - Token and tokenProvider support
- * - Mock mode with configurable delay
- * - Optional response wrapper for APIs that nest data
  */
 declare class ApiClient<C extends Contracts, E extends ErrorLike = RichError> {
     private config;
@@ -148,20 +141,16 @@ declare class ApiClient<C extends Contracts, E extends ErrorLike = RichError> {
      *     path: z.object({...}).optional(),
      *     query: z.object({...}).optional(),
      *     body: z.any().optional(),
+     *     header: z.object({...}).optional(),
      *   })
      *
-     * If the parsed request does not contain `path`, `query` or `body`,
+     * If the parsed request does not contain `path`, `header`,`query` or `body`,
      * the entire input is treated as the legacy flat request body.
      */
     private request;
     /**
-     * Builds the effective URL and request body for an endpoint.
-     *
-     * - Legacy mode: if the input does not contain `path`, `query` or `body`,
-     *   the entire input is used as the JSON request body for non-GET methods.
-     *
-     * - New mode: uses `path` to interpolate `:param` segments, `query` to
-     *   construct the query string, and `body` as the JSON payload.
+     * Builds final URL and body from endpoint + request input.
+     * Supports both structured `{ path, query, body, headers }` and legacy flat input.
      */
     private buildUrlAndBody;
     /**
@@ -207,4 +196,26 @@ type CacheOptions = {
 };
 declare const cacheMiddleware: (options?: CacheOptions) => (ctx: MiddlewareContext, next: MiddlewareNext) => Promise<Response>;
 
-export { ApiClient, type AuthOptions, type CacheOptions, type Contracts, type EndpointDef, type EndpointDefZ, type EndpointMethods, type ErrorLike, type LoggingOptions, type Middleware, type MiddlewareContext, type MiddlewareNext, type RequestSchema, type ResponseSchema, type RetryOptions, RichError, type TokenProvider, authMiddleware, cacheMiddleware, loggingMiddleware, retryMiddleware };
+declare const makeRequestSchema: <TPath extends z.ZodRawShape = {}, TQuery extends z.ZodRawShape = {}, TBody extends z.ZodTypeAny = z.ZodUndefined>() => (defs: {
+    path?: z.ZodObject<TPath>;
+    query?: z.ZodObject<TQuery>;
+    body?: TBody;
+    headers?: z.ZodTypeAny;
+}) => z.ZodObject<{
+    path: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>> | z.ZodOptional<z.ZodObject<TPath, z.UnknownKeysParam, z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<TPath>, any> extends infer T ? { [k in keyof T]: T[k]; } : never, z.baseObjectInputType<TPath> extends infer T_1 ? { [k_1 in keyof T_1]: T_1[k_1]; } : never>>;
+    query: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>> | z.ZodOptional<z.ZodObject<TQuery, z.UnknownKeysParam, z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<TQuery>, any> extends infer T_2 ? { [k_2 in keyof T_2]: T_2[k_2]; } : never, z.baseObjectInputType<TQuery> extends infer T_3 ? { [k_3 in keyof T_3]: T_3[k_3]; } : never>>;
+    body: TBody | z.ZodUndefined;
+    headers: any;
+}, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+    path: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>> | z.ZodOptional<z.ZodObject<TPath, z.UnknownKeysParam, z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<TPath>, any> extends infer T_5 ? { [k in keyof T_5]: T_5[k]; } : never, z.baseObjectInputType<TPath> extends infer T_6 ? { [k_1 in keyof T_6]: T_6[k_1]; } : never>>;
+    query: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>> | z.ZodOptional<z.ZodObject<TQuery, z.UnknownKeysParam, z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<TQuery>, any> extends infer T_7 ? { [k_2 in keyof T_7]: T_7[k_2]; } : never, z.baseObjectInputType<TQuery> extends infer T_8 ? { [k_3 in keyof T_8]: T_8[k_3]; } : never>>;
+    body: TBody | z.ZodUndefined;
+    headers: any;
+}>, any> extends infer T_4 ? { [k_4 in keyof T_4]: T_4[k_4]; } : never, z.baseObjectInputType<{
+    path: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>> | z.ZodOptional<z.ZodObject<TPath, z.UnknownKeysParam, z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<TPath>, any> extends infer T_10 ? { [k in keyof T_10]: T_10[k]; } : never, z.baseObjectInputType<TPath> extends infer T_11 ? { [k_1 in keyof T_11]: T_11[k_1]; } : never>>;
+    query: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>> | z.ZodOptional<z.ZodObject<TQuery, z.UnknownKeysParam, z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<TQuery>, any> extends infer T_12 ? { [k_2 in keyof T_12]: T_12[k_2]; } : never, z.baseObjectInputType<TQuery> extends infer T_13 ? { [k_3 in keyof T_13]: T_13[k_3]; } : never>>;
+    body: TBody | z.ZodUndefined;
+    headers: any;
+}> extends infer T_9 ? { [k_5 in keyof T_9]: T_9[k_5]; } : never>;
+
+export { ApiClient, type AuthOptions, type CacheOptions, type Contracts, type EndpointDef, type EndpointDefZ, type EndpointMethods, type ErrorLike, type LoggingOptions, type Middleware, type MiddlewareContext, type MiddlewareNext, type RequestSchema, type ResponseSchema, type RetryOptions, RichError, type TokenProvider, authMiddleware, cacheMiddleware, loggingMiddleware, makeRequestSchema, retryMiddleware };