@cushin/api-codegen 5.0.0 → 5.0.2

package/dist/cli.js

@@ -174,6 +174,19 @@ var BaseGenerator = class {
       (e) => e.method === "GET"
     );
   }
+  // Helper methods to get named type references
+  getResponseTypeName(name) {
+    return `${this.capitalize(name)}Response`;
+  }
+  getInputTypeName(name) {
+    return `${this.capitalize(name)}Input`;
+  }
+  getQueryTypeName(name) {
+    return `${this.capitalize(name)}Query`;
+  }
+  getParamsTypeName(name) {
+    return `${this.capitalize(name)}Params`;
+  }
 };
 
 // src/generators/hooks.ts
@@ -186,16 +199,12 @@ var HooksGenerator = class extends BaseGenerator {
   }
   generateContent() {
     const useClientDirective = this.context.config.options?.useClientDirective ?? true;
-    const outputPath = path2.join(this.context.config.outputDir, "types.ts");
-    const endpointsPath = path2.join(this.context.config.endpointsPath);
-    const relativePath = path2.relative(path2.dirname(outputPath), endpointsPath).replace(/\\/g, "/").replace(/\.ts$/, "");
     const content = `${useClientDirective ? "'use client';\n" : ""}
 import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
 import { apiClient } from "./client";
 import { queryKeys } from "./query-keys";
 import { apiQueryOptions } from "./query-options";
-import { z } from "zod";
-import { apiConfig } from "${relativePath}";
+import type * as Types from "./types";
 
 ${this.generateQueryHooks()}
 ${this.generateMutationHooks()}
@@ -216,29 +225,23 @@ ${this.generateMutationHooks()}
     const hookName = `use${this.capitalize(name)}`;
     const resource = this.getResourceFromEndpoint(name, endpoint);
     const optionName = this.getEndpointKeyName(name);
-    const inferParams = this.inferNonNull(
-      `typeof apiConfig.endpoints.${name}.params`
-    );
-    const inferQuery = this.inferNonNull(
-      `typeof apiConfig.endpoints.${name}.query`
-    );
-    const inferResponse = this.inferNonNull(
-      `typeof apiConfig.endpoints.${name}.response`
-    );
+    const responseType = `Types.${this.getResponseTypeName(name)}`;
+    const paramsType = endpoint.params ? `Types.${this.getParamsTypeName(name)}` : null;
+    const queryType = endpoint.query ? `Types.${this.getQueryTypeName(name)}` : null;
     const params = [];
     const optionParams = [];
     const queryTags = this.getQueryTags(endpoint);
-    if (endpoint.params) {
-      params.push(`params: ${inferParams}`);
+    if (paramsType) {
+      params.push(`params: ${paramsType}`);
       optionParams.push("params");
     }
-    if (endpoint.query) {
-      params.push(`filters?: ${inferQuery}`);
+    if (queryType) {
+      params.push(`filters?: ${queryType}`);
       optionParams.push("filters");
     }
     params.push(`options?: {
     enabled?: boolean;
-    select?: <TData = ${inferResponse}>(data: ${inferResponse}) => TData;
+    select?: <TData = ${responseType}>(data: ${responseType}) => TData;
   }`);
     return `/**
  * ${endpoint.description || `Query hook for ${name}`}
@@ -264,26 +267,20 @@ export function ${hookName}(${params.join(",\n  ")}) {
   generateMutationHook(name, endpoint) {
     const hookName = `use${this.capitalize(name)}`;
     const resource = this.getResourceFromEndpoint(name, endpoint);
-    const inferParams = this.inferNonNull(
-      `typeof apiConfig.endpoints.${name}.params`
-    );
-    const inferBody = this.inferNonNull(
-      `typeof apiConfig.endpoints.${name}.body`
-    );
-    const inferResponse = this.inferNonNull(
-      `typeof apiConfig.endpoints.${name}.response`
-    );
+    const responseType = `Types.${this.getResponseTypeName(name)}`;
+    const paramsType = endpoint.params ? `Types.${this.getParamsTypeName(name)}` : null;
+    const bodyType = endpoint.body ? `Types.${this.getInputTypeName(name)}` : null;
     const resourceHasQueries = this.resourceHasQueryEndpoints(resource);
     let inputType;
     let fnBody;
-    if (endpoint.params && endpoint.body) {
-      inputType = `{ params: ${inferParams}; body: ${inferBody}; }`;
+    if (paramsType && bodyType) {
+      inputType = `{ params: ${paramsType}; body: ${bodyType}; }`;
       fnBody = `({ params, body }: ${inputType}) => apiClient.${name}(params, body)`;
-    } else if (endpoint.params) {
-      inputType = `${inferParams}`;
+    } else if (paramsType) {
+      inputType = paramsType;
       fnBody = `(params: ${inputType}) => apiClient.${name}(params)`;
-    } else if (endpoint.body) {
-      inputType = `${inferBody}`;
+    } else if (bodyType) {
+      inputType = bodyType;
       fnBody = `(body: ${inputType}) => apiClient.${name}(body)`;
     } else {
       inputType = "void";
@@ -294,24 +291,24 @@ export function ${hookName}(${params.join(",\n  ")}) {
  * ${endpoint.description || `Mutation hook for ${name}`}
  * @tags ${endpoint.tags?.join(", ") || "none"}
  */
-    export function ${hookName}(options?: {
-      onSuccess?: (data: ${inferResponse}, variables: ${inputType}, context: unknown) => void;
-      onError?: (error: Error, variables: ${inputType}, context: unknown) => void;
-      onSettled?: (data: ${inferResponse} | undefined, error: Error | null, variables: ${inputType}, context: unknown) => void;
-      onMutate?: (variables: ${inputType}) => Promise<unknown> | unknown;
-    }) {
-      ${invalidate ? "const queryClient = useQueryClient();" : ""}
-      return useMutation({
-	mutationFn: ${fnBody},
-	onSuccess: (data, variables, context) => {
-	  ${invalidate}
-	  options?.onSuccess?.(data, variables, context);
-	},
-	onError: options?.onError,
-	onSettled: options?.onSettled,
-	onMutate: options?.onMutate,
-      });
-    }`;
+export function ${hookName}(options?: {
+  onSuccess?: (data: ${responseType}, variables: ${inputType}, context: unknown) => void;
+  onError?: (error: Error, variables: ${inputType}, context: unknown) => void;
+  onSettled?: (data: ${responseType} | undefined, error: Error | null, variables: ${inputType}, context: unknown) => void;
+  onMutate?: (variables: ${inputType}) => Promise<unknown> | unknown;
+}) {
+  ${invalidate ? "const queryClient = useQueryClient();" : ""}
+  return useMutation({
+    mutationFn: ${fnBody},
+    onSuccess: (data, variables, context) => {
+      ${invalidate}
+      options?.onSuccess?.(data, variables, context);
+    },
+    onError: options?.onError,
+    onSettled: options?.onSettled,
+    onMutate: options?.onMutate,
+  });
+}`;
   }
 };
 
@@ -326,15 +323,11 @@ var ServerActionsGenerator = class extends BaseGenerator {
     await fs2.writeFile(outputPath, content, "utf-8");
   }
   generateContent() {
-    const outputPath = path3.join(this.context.config.outputDir, "types.ts");
-    const endpointsPath = path3.join(this.context.config.endpointsPath);
-    const relativePath = path3.relative(path3.dirname(outputPath), endpointsPath).replace(/\\/g, "/").replace(/\.ts$/, "");
     const imports = `'use server';
 
 import { revalidateTag, revalidatePath } from 'next/cache';
 import { serverClient } from './server-client';
-import { z } from 'zod';
-import { apiConfig } from '${relativePath}';
+import type * as Types from './types';
 
 export type ActionResult<T> =
   | { success: true; data: T }
@@ -353,18 +346,20 @@ export type ActionResult<T> =
   generateServerAction(name, endpoint) {
     const actionSuffix = this.context.config.options?.actionSuffix || "Action";
     const actionName = `${name}${actionSuffix}`;
-    const signature = this.getEndpointSignature(name, endpoint);
     const invalidationTags = this.getInvalidationTags(endpoint);
+    const responseType = `Types.${this.getResponseTypeName(name)}`;
+    const paramsType = endpoint.params ? `Types.${this.getParamsTypeName(name)}` : null;
+    const bodyType = endpoint.body ? `Types.${this.getInputTypeName(name)}` : null;
     let inputType = "";
     let callArgs = "";
-    if (signature.hasParams && signature.hasBody) {
-      inputType = `input: { params: ${signature.paramType}; body: ${signature.bodyType} }`;
+    if (paramsType && bodyType) {
+      inputType = `input: { params: ${paramsType}; body: ${bodyType} }`;
       callArgs = "input.params, input.body";
-    } else if (signature.hasParams) {
-      inputType = `params: ${signature.paramType}`;
+    } else if (paramsType) {
+      inputType = `params: ${paramsType}`;
       callArgs = "params";
-    } else if (signature.hasBody) {
-      inputType = `body: ${signature.bodyType}`;
+    } else if (bodyType) {
+      inputType = `body: ${bodyType}`;
       callArgs = "body";
     }
     const revalidateStatements = invalidationTags.length > 0 ? invalidationTags.map((tag) => `    revalidateTag('${tag}');`).join("\n") : "    // No automatic revalidations";
@@ -374,7 +369,7 @@ export type ActionResult<T> =
  */
 export async function ${actionName}(
   ${inputType}
-): Promise<ActionResult<${signature.responseType}>> {
+): Promise<ActionResult<${responseType}>> {
   try {
     const result = await (serverClient as any).${name}(${callArgs});
 
@@ -404,14 +399,10 @@ var ServerQueriesGenerator = class extends BaseGenerator {
     await fs3.writeFile(outputPath, content, "utf-8");
   }
   generateContent() {
-    const outputPath = path4.join(this.context.config.outputDir, "types.ts");
-    const endpointsPath = path4.join(this.context.config.endpointsPath);
-    const relativePath = path4.relative(path4.dirname(outputPath), endpointsPath).replace(/\\/g, "/").replace(/\.ts$/, "");
     const imports = `import { cache } from 'react';
 import { unstable_cache } from 'next/cache';
 import { serverClient } from './server-client';
-import { z } from 'zod';
-import { apiConfig } from '${relativePath}';
+import type * as Types from './types';
 `;
     const queries = [];
     Object.entries(this.context.apiConfig.endpoints).forEach(
@@ -425,24 +416,26 @@ import { apiConfig } from '${relativePath}';
   }
   generateServerQuery(name, endpoint) {
     const queryName = `${name}Query`;
-    const signature = this.getEndpointSignature(name, endpoint);
     const queryTags = this.getQueryTags(endpoint);
-    const paramDef = signature.hasParams ? `params: ${signature.paramType}` : "";
-    const queryDef = signature.hasQuery ? `query?: ${signature.queryType}` : "";
+    const responseType = `Types.${this.getResponseTypeName(name)}`;
+    const paramsType = endpoint.params ? `Types.${this.getParamsTypeName(name)}` : null;
+    const queryType = endpoint.query ? `Types.${this.getQueryTypeName(name)}` : null;
+    const paramDef = paramsType ? `params: ${paramsType}` : "";
+    const queryDef = queryType ? `query?: ${queryType}` : "";
     const paramsList = [paramDef, queryDef].filter(Boolean).join(",\n  ");
     let clientCall = "";
-    if (signature.hasParams && signature.hasQuery) {
+    if (paramsType && queryType) {
       clientCall = `(serverClient as any).${name}(params, query)`;
-    } else if (signature.hasParams) {
+    } else if (paramsType) {
       clientCall = `(serverClient as any).${name}(params)`;
-    } else if (signature.hasQuery) {
+    } else if (queryType) {
       clientCall = `(serverClient as any).${name}(query)`;
     } else {
       clientCall = `(serverClient as any).${name}()`;
     }
     const cacheKeyParts = [`'${name}'`];
-    if (signature.hasParams) cacheKeyParts.push("JSON.stringify(params)");
-    if (signature.hasQuery)
+    if (paramsType) cacheKeyParts.push("JSON.stringify(params)");
+    if (queryType)
       cacheKeyParts.push("query ? JSON.stringify(query) : 'no-query'");
     return `/**
  * ${endpoint.description || `Server query for ${name}`}
@@ -450,7 +443,7 @@ import { apiConfig } from '${relativePath}';
  */
 export const ${queryName} = cache(async (
   ${paramsList}
-): Promise<${signature.responseType}> => {
+): Promise<${responseType}> => {
   return unstable_cache(
     async () => ${clientCall},
     [${cacheKeyParts.join(", ")}],
@@ -495,22 +488,24 @@ ${this.generateEndpointTypes()}
     Object.entries(this.context.apiConfig.endpoints).forEach(
       ([name, endpoint]) => {
         const cap = this.capitalize(name);
-        if (endpoint.response)
-          types.push(
-            `export type ${cap}Response = ${this.inferNonNull(`typeof apiConfig.endpoints.${name}.response`)};`
-          );
-        if (endpoint.body)
+        types.push(
+          `export type ${cap}Response = z.infer<typeof apiConfig.endpoints.${name}.response>;`
+        );
+        if (endpoint.body) {
           types.push(
-            `export type ${cap}Input = ${this.inferNonNull(`typeof apiConfig.endpoints.${name}.body`)};`
+            `export type ${cap}Input = z.infer<typeof apiConfig.endpoints.${name}.body>;`
           );
-        if (endpoint.query)
+        }
+        if (endpoint.query) {
           types.push(
-            `export type ${cap}Query = ${this.inferNonNull(`typeof apiConfig.endpoints.${name}.query`)};`
+            `export type ${cap}Query = z.infer<typeof apiConfig.endpoints.${name}.query>;`
           );
-        if (endpoint.params)
+        }
+        if (endpoint.params) {
           types.push(
-            `export type ${cap}Params = ${this.inferNonNull(`typeof apiConfig.endpoints.${name}.params`)};`
+            `export type ${cap}Params = z.infer<typeof apiConfig.endpoints.${name}.params>;`
           );
+        }
       }
     );
     return types.join("\n");
@@ -551,32 +546,13 @@ var ClientGenerator = class extends BaseGenerator {
 import { createAPIClient } from '@cushin/api-runtime';
 import type { AuthCallbacks } from '@cushin/api-runtime';
 import { apiConfig } from '${relativePath}';
-import { z } from 'zod';
+import type * as Types from './types';
 
-// Type the methods based on endpoints
+// Type the methods based on generated types
 type APIClientMethods = {
-  [K in keyof typeof apiConfig.endpoints]: (typeof apiConfig.endpoints)[K] extends infer E
-    ? E extends { method: "GET"; params: infer P; query: infer Q; response: infer R }
-      ? (params: P extends z.ZodType ? z.infer<P> : never, query?: Q extends z.ZodType ? z.infer<Q> : never) => Promise<R extends z.ZodType ? z.infer<R> : never>
-      : E extends { method: "GET"; params: infer P; response: infer R }
-        ? (params: P extends z.ZodType ? z.infer<P> : never) => Promise<R extends z.ZodType ? z.infer<R> : never>
-        : E extends { method: "GET"; query: infer Q; response: infer R }
-          ? (query?: Q extends z.ZodType ? z.infer<Q> : never) => Promise<R extends z.ZodType ? z.infer<R> : never>
-          : E extends { method: "GET"; response: infer R }
-            ? () => Promise<R extends z.ZodType ? z.infer<R> : never>
-            : E extends { method: string; params: infer P; body: infer B; response: infer R }
-              ? (params: P extends z.ZodType ? z.infer<P> : never, body: B extends z.ZodType ? z.infer<B> : never) => Promise<R extends z.ZodType ? z.infer<R> : never>
-              : E extends { method: string; params: infer P; response: infer R }
-                ? (params: P extends z.ZodType ? z.infer<P> : never) => Promise<R extends z.ZodType ? z.infer<R> : never>
-                : E extends { method: string; body: infer B; response: infer R }
-                  ? (body: B extends z.ZodType ? z.infer<B> : never) => Promise<R extends z.ZodType ? z.infer<R> : never>
-                  : E extends { method: string; response: infer R }
-                    ? () => Promise<R extends z.ZodType ? z.infer<R> : never>
-                    : never
-    : never;
+${this.generateAPIClientMethodTypes()}
 };
 
-
 // Export singleton instance (will be initialized later)
 export let baseClient: APIClientMethods & {
   refreshAuth: () => Promise<void>;
@@ -590,7 +566,7 @@ ${this.generateApiClientMethods()}
 /**
  * Initialize API client with auth callbacks
  * Call this function in your auth provider setup
- * 
+ *
  * @example
  * const authCallbacks = {
  *   getTokens: () => getStoredTokens(),
@@ -599,7 +575,7 @@ ${this.generateApiClientMethods()}
  *     await refreshAccessToken();
  *   },
  * };
- * 
+ *
  * initializeAPIClient(authCallbacks);
  */
 export const initializeAPIClient = (authCallbacks: AuthCallbacks) => {
@@ -618,29 +594,11 @@ export type { AuthCallbacks };
     const relativePath = path6.relative(path6.dirname(outputPath), endpointsPath).replace(/\\/g, "/").replace(/\.ts$/, "");
     return `import { createAPIClient } from '@cushin/api-runtime';
 import { apiConfig } from '${relativePath}';
-import { z } from 'zod';
+import type * as Types from './types';
 
-// Type the methods based on endpoints
+// Type the methods based on generated types
 type APIClientMethods = {
-  [K in keyof typeof apiConfig.endpoints]: (typeof apiConfig.endpoints)[K] extends infer E
-    ? E extends { method: "GET"; params: infer P; query: infer Q; response: infer R }
-      ? (params: P extends z.ZodType ? z.infer<P> : never, query?: Q extends z.ZodType ? z.infer<Q> : never) => Promise<R extends z.ZodType ? z.infer<R> : never>
-      : E extends { method: "GET"; params: infer P; response: infer R }
-        ? (params: P extends z.ZodType ? z.infer<P> : never) => Promise<R extends z.ZodType ? z.infer<R> : never>
-        : E extends { method: "GET"; query: infer Q; response: infer R }
-          ? (query?: Q extends z.ZodType ? z.infer<Q> : never) => Promise<R extends z.ZodType ? z.infer<R> : never>
-          : E extends { method: "GET"; response: infer R }
-            ? () => Promise<R extends z.ZodType ? z.infer<R> : never>
-            : E extends { method: string; params: infer P; body: infer B; response: infer R }
-              ? (params: P extends z.ZodType ? z.infer<P> : never, body: B extends z.ZodType ? z.infer<B> : never) => Promise<R extends z.ZodType ? z.infer<R> : never>
-              : E extends { method: string; params: infer P; response: infer R }
-                ? (params: P extends z.ZodType ? z.infer<P> : never) => Promise<R extends z.ZodType ? z.infer<R> : never>
-                : E extends { method: string; body: infer B; response: infer R }
-                  ? (body: B extends z.ZodType ? z.infer<B> : never) => Promise<R extends z.ZodType ? z.infer<R> : never>
-                  : E extends { method: string; response: infer R }
-                    ? () => Promise<R extends z.ZodType ? z.infer<R> : never>
-                    : never
-    : never;
+${this.generateAPIClientMethodTypes()}
 };
 
 /**
@@ -650,48 +608,75 @@ type APIClientMethods = {
 export const serverClient = createAPIClient(apiConfig) as APIClientMethods;
 `;
   }
+  generateAPIClientMethodTypes() {
+    const methods = [];
+    Object.entries(this.context.apiConfig.endpoints).forEach(
+      ([name, endpoint]) => {
+        const responseType = `Types.${this.getResponseTypeName(name)}`;
+        const paramsType = endpoint.params ? `Types.${this.getParamsTypeName(name)}` : null;
+        const queryType = endpoint.query ? `Types.${this.getQueryTypeName(name)}` : null;
+        const bodyType = endpoint.body ? `Types.${this.getInputTypeName(name)}` : null;
+        let signature = "";
+        if (endpoint.method === "GET") {
+          if (paramsType && queryType) {
+            signature = `(params: ${paramsType}, query?: ${queryType}) => Promise<${responseType}>`;
+          } else if (paramsType) {
+            signature = `(params: ${paramsType}) => Promise<${responseType}>`;
+          } else if (queryType) {
+            signature = `(query?: ${queryType}) => Promise<${responseType}>`;
+          } else {
+            signature = `() => Promise<${responseType}>`;
+          }
+        } else {
+          if (paramsType && bodyType) {
+            signature = `(params: ${paramsType}, body: ${bodyType}) => Promise<${responseType}>`;
+          } else if (paramsType) {
+            signature = `(params: ${paramsType}) => Promise<${responseType}>`;
+          } else if (bodyType) {
+            signature = `(body: ${bodyType}) => Promise<${responseType}>`;
+          } else {
+            signature = `() => Promise<${responseType}>`;
+          }
+        }
+        methods.push(`  ${name}: ${signature};`);
+      }
+    );
+    return methods.join("\n");
+  }
   generateApiClientMethods() {
     const methods = [];
     Object.entries(this.context.apiConfig.endpoints).forEach(
       ([name, endpoint]) => {
-        const inferParams = this.inferNonNull(
-          `typeof apiConfig.endpoints.${name}.params`
-        );
-        const inferQuery = this.inferNonNull(
-          `typeof apiConfig.endpoints.${name}.query`
-        );
-        const inferBody = this.inferNonNull(
-          `typeof apiConfig.endpoints.${name}.body`
-        );
-        const inferResponse = this.inferNonNull(
-          `typeof apiConfig.endpoints.${name}.response`
-        );
+        const responseType = `Types.${this.getResponseTypeName(name)}`;
+        const paramsType = endpoint.params ? `Types.${this.getParamsTypeName(name)}` : null;
+        const queryType = endpoint.query ? `Types.${this.getQueryTypeName(name)}` : null;
+        const bodyType = endpoint.body ? `Types.${this.getInputTypeName(name)}` : null;
         if (endpoint.method === "GET") {
-          if (endpoint.params && endpoint.query) {
-            methods.push(`  ${name}: (params: ${inferParams}, query?: ${inferQuery}): Promise<${inferResponse}> => 
+          if (paramsType && queryType) {
+            methods.push(`  ${name}: (params: ${paramsType}, query?: ${queryType}): Promise<${responseType}> =>
     (baseClient as any).${name}(params, query),`);
-          } else if (endpoint.params) {
-            methods.push(`  ${name}: (params: ${inferParams}): Promise<${inferResponse}> => 
+          } else if (paramsType) {
+            methods.push(`  ${name}: (params: ${paramsType}): Promise<${responseType}> =>
     (baseClient as any).${name}(params),`);
-          } else if (endpoint.query) {
-            methods.push(`  ${name}: (query?: ${inferQuery}): Promise<${inferResponse}> => 
+          } else if (queryType) {
+            methods.push(`  ${name}: (query?: ${queryType}): Promise<${responseType}> =>
     (baseClient as any).${name}(query),`);
           } else {
-            methods.push(`  ${name}: (): Promise<${inferResponse}> => 
+            methods.push(`  ${name}: (): Promise<${responseType}> =>
     (baseClient as any).${name}(),`);
           }
         } else {
-          if (endpoint.params && endpoint.body) {
-            methods.push(`  ${name}: (params: ${inferParams}, body: ${inferBody}): Promise<${inferResponse}> => 
+          if (paramsType && bodyType) {
+            methods.push(`  ${name}: (params: ${paramsType}, body: ${bodyType}): Promise<${responseType}> =>
     (baseClient as any).${name}(params, body),`);
-          } else if (endpoint.params) {
-            methods.push(`  ${name}: (params: ${inferParams}): Promise<${inferResponse}> => 
+          } else if (paramsType) {
+            methods.push(`  ${name}: (params: ${paramsType}): Promise<${responseType}> =>
     (baseClient as any).${name}(params),`);
-          } else if (endpoint.body) {
-            methods.push(`  ${name}: (body: ${inferBody}): Promise<${inferResponse}> => 
+          } else if (bodyType) {
+            methods.push(`  ${name}: (body: ${bodyType}): Promise<${responseType}> =>
     (baseClient as any).${name}(body),`);
           } else {
-            methods.push(`  ${name}: (): Promise<${inferResponse}> => 
+            methods.push(`  ${name}: (): Promise<${responseType}> =>
     (baseClient as any).${name}(),`);
           }
         }
@@ -719,8 +704,7 @@ var QueryKeysGenerator = class extends BaseGenerator {
     const endpointsPath = path7.join(this.context.config.endpointsPath);
     const relativePath = path7.relative(path7.dirname(outputPath), endpointsPath).replace(/\\/g, "/").replace(/\.ts$/, "");
     const content = `// Auto-generated query keys
-import { z } from 'zod';
-import { apiConfig } from '${relativePath}';
+import type * as Types from './types';
 
 export const queryKeys = {
 ${this.generateQueryKeysContent()}
@@ -741,16 +725,12 @@ ${this.generateQueryKeysContent()}
       queryEndpoints.forEach(({ name, endpoint }) => {
         const keyName = this.getEndpointKeyName(name);
         if (added.has(keyName)) return;
-        const inferParams = this.inferNonNull(
-          `typeof apiConfig.endpoints.${name}.params`
-        );
-        const inferQuery = this.inferNonNull(
-          `typeof apiConfig.endpoints.${name}.query`
-        );
         if (endpoint.params || endpoint.query) {
           const params = [];
-          if (endpoint.params) params.push(`params?: ${inferParams}`);
-          if (endpoint.query) params.push(`query?: ${inferQuery}`);
+          if (endpoint.params)
+            params.push(`params?: Types.${this.getParamsTypeName(name)}`);
+          if (endpoint.query)
+            params.push(`query?: Types.${this.getQueryTypeName(name)}`);
           resourceKeys.push(`    ${keyName}: (${params.join(", ")}) =>
       ['${resource}', '${keyName}', ${endpoint.params ? "params" : "undefined"}, ${endpoint.query ? "query" : "undefined"}] as const,`);
         } else {
@@ -782,15 +762,11 @@ var QueryOptionsGenerator = class extends BaseGenerator {
     await fs7.writeFile(outputPath, content, "utf-8");
   }
   generateContent() {
-    const outputPath = path8.join(this.context.config.outputDir, "types.ts");
-    const endpointsPath = path8.join(this.context.config.endpointsPath);
-    const relativePath = path8.relative(path8.dirname(outputPath), endpointsPath).replace(/\\/g, "/").replace(/\.ts$/, "");
     const content = `// Auto-generated query options
 import { queryOptions } from '@tanstack/react-query';
 import { apiClient } from './client';
 import { queryKeys } from './query-keys';
-import { z } from 'zod';
-import { apiConfig } from '${relativePath}';
+import type * as Types from './types';
 
 ${this.generateQueryOptionsContent()}
 
@@ -811,25 +787,19 @@ ${this.generateQueryOptionsExports()}
       const resourceOptions = [];
       queries.forEach(({ name, endpoint }) => {
         const optionName = this.getEndpointKeyName(name);
-        const inferParams = this.inferNonNull(
-          `typeof apiConfig.endpoints.${name}.params`
-        );
-        const inferQuery = this.inferNonNull(
-          `typeof apiConfig.endpoints.${name}.query`
-        );
-        const inferResponse = this.inferNonNull(
-          `typeof apiConfig.endpoints.${name}.response`
-        );
+        const responseType = `Types.${this.getResponseTypeName(name)}`;
+        const paramsType = endpoint.params ? `Types.${this.getParamsTypeName(name)}` : null;
+        const queryType = endpoint.query ? `Types.${this.getQueryTypeName(name)}` : null;
         const params = [];
         let apiCall = "";
-        if (endpoint.params && endpoint.query) {
-          params.push(`params: ${inferParams}`, `filters?: ${inferQuery}`);
+        if (paramsType && queryType) {
+          params.push(`params: ${paramsType}`, `filters?: ${queryType}`);
           apiCall = `apiClient.${name}(params, filters)`;
-        } else if (endpoint.params) {
-          params.push(`params: ${inferParams}`);
+        } else if (paramsType) {
+          params.push(`params: ${paramsType}`);
           apiCall = `apiClient.${name}(params)`;
-        } else if (endpoint.query) {
-          params.push(`filters?: ${inferQuery}`);
+        } else if (queryType) {
+          params.push(`filters?: ${queryType}`);
           apiCall = `apiClient.${name}(filters)`;
         } else {
           apiCall = `apiClient.${name}()`;
@@ -838,7 +808,7 @@ ${this.generateQueryOptionsExports()}
         resourceOptions.push(`  ${optionName}: (${params.join(", ")}) =>
     queryOptions({
       queryKey: ${keyCall},
-      queryFn: (): Promise<${inferResponse}> => ${apiCall},
+      queryFn: (): Promise<${responseType}> => ${apiCall},
       staleTime: 1000 * 60 * 5,
     }),`);
       });
@@ -878,8 +848,7 @@ var PrefetchGenerator = class extends BaseGenerator {
     const content = `// Auto-generated prefetch utilities
 import { type QueryClient } from '@tanstack/react-query';
 ${this.hasQueryOptions() ? "import { apiQueryOptions } from './query-options';" : ""}
-import { z } from 'zod';
-import { apiConfig } from '../config/endpoints';
+import type * as Types from './types';
 
 ${this.generatePrefetchFunctions()}
 `;
@@ -899,20 +868,14 @@ ${this.generatePrefetchFunctions()}
     const prefetchName = `prefetch${this.capitalize(name)}`;
     const resource = this.getResourceFromEndpoint(name, endpoint);
     const optionName = this.getEndpointKeyName(name);
-    const inferParams = this.inferNonNull(
-      `typeof apiConfig.endpoints.${name}.params`
-    );
-    const inferQuery = this.inferNonNull(
-      `typeof apiConfig.endpoints.${name}.query`
-    );
     const params = ["queryClient: QueryClient"];
     const optionParams = [];
     if (endpoint.params) {
-      params.push(`params: ${inferParams}`);
+      params.push(`params: Types.${this.getParamsTypeName(name)}`);
       optionParams.push("params");
     }
     if (endpoint.query) {
-      params.push(`filters?: ${inferQuery}`);
+      params.push(`filters?: Types.${this.getQueryTypeName(name)}`);
       optionParams.push("filters");
     }
     return `export const ${prefetchName} = async (${params.join(",\n  ")}) => {
@@ -1012,6 +975,9 @@ var CodegenCore = class {
           'Invalid API config: must export an object with "endpoints" property'
         );
       }
+      if (this.config.acceptEncoding) {
+        apiConfig.acceptEncoding = this.config.acceptEncoding;
+      }
       return apiConfig;
     } catch (error) {
       throw new Error(