cushin-monorepo 3.0.1

package/test-output/hooks.ts

@@ -0,0 +1,182 @@
+'use client';
+
+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 "../test-real-endpoints.mjs";
+
+/**
+ * List all users
+ * @tags none
+ */
+export function useListUsers(options?: {
+    enabled?: boolean;
+    select?: <TData = z.infer<NonNullable<typeof apiConfig.endpoints.listUsers.response>>>(data: z.infer<NonNullable<typeof apiConfig.endpoints.listUsers.response>>) => TData;
+  }) {
+  return useQuery({
+    ...apiQueryOptions.users.listUsers(),
+    ...options,
+  });
+}
+
+/**
+ * Get user by ID
+ * @tags none
+ */
+export function useGetUser(params: z.infer<NonNullable<typeof apiConfig.endpoints.getUser.params>>,
+  options?: {
+    enabled?: boolean;
+    select?: <TData = z.infer<NonNullable<typeof apiConfig.endpoints.getUser.response>>>(data: z.infer<NonNullable<typeof apiConfig.endpoints.getUser.response>>) => TData;
+  }) {
+  return useQuery({
+    ...apiQueryOptions.users.user(params),
+    ...options,
+  });
+}
+
+/**
+ * Search users
+ * @tags none
+ */
+export function useSearchUsers(filters?: z.infer<NonNullable<typeof apiConfig.endpoints.searchUsers.query>>,
+  options?: {
+    enabled?: boolean;
+    select?: <TData = z.infer<NonNullable<typeof apiConfig.endpoints.searchUsers.response>>>(data: z.infer<NonNullable<typeof apiConfig.endpoints.searchUsers.response>>) => TData;
+  }) {
+  return useQuery({
+    ...apiQueryOptions.users.searchUsers(filters),
+    ...options,
+  });
+}
+
+/**
+ * Get user posts
+ * @tags none
+ */
+export function useGetUserPosts(params: z.infer<NonNullable<typeof apiConfig.endpoints.getUserPosts.params>>,
+  filters?: z.infer<NonNullable<typeof apiConfig.endpoints.getUserPosts.query>>,
+  options?: {
+    enabled?: boolean;
+    select?: <TData = z.infer<NonNullable<typeof apiConfig.endpoints.getUserPosts.response>>>(data: z.infer<NonNullable<typeof apiConfig.endpoints.getUserPosts.response>>) => TData;
+  }) {
+  return useQuery({
+    ...apiQueryOptions.users.userPosts(params, filters),
+    ...options,
+  });
+}
+/**
+ * Create new session
+ * @tags auth
+ */
+    export function useCreateSession(options?: {
+      onSuccess?: (data: z.infer<NonNullable<typeof apiConfig.endpoints.createSession.response>>, variables: void, context: unknown) => void;
+      onError?: (error: Error, variables: void, context: unknown) => void;
+      onSettled?: (data: z.infer<NonNullable<typeof apiConfig.endpoints.createSession.response>> | undefined, error: Error | null, variables: void, context: unknown) => void;
+      onMutate?: (variables: void) => Promise<unknown> | unknown;
+    }) {
+      
+      return useMutation({
+	mutationFn: () => apiClient.createSession(),
+	onSuccess: (data, variables, context) => {
+	  
+	  options?.onSuccess?.(data, variables, context);
+	},
+	onError: options?.onError,
+	onSettled: options?.onSettled,
+	onMutate: options?.onMutate,
+      });
+    }
+
+/**
+ * Create new user
+ * @tags users
+ */
+    export function useCreateUser(options?: {
+      onSuccess?: (data: z.infer<NonNullable<typeof apiConfig.endpoints.createUser.response>>, variables: z.infer<NonNullable<typeof apiConfig.endpoints.createUser.body>>, context: unknown) => void;
+      onError?: (error: Error, variables: z.infer<NonNullable<typeof apiConfig.endpoints.createUser.body>>, context: unknown) => void;
+      onSettled?: (data: z.infer<NonNullable<typeof apiConfig.endpoints.createUser.response>> | undefined, error: Error | null, variables: z.infer<NonNullable<typeof apiConfig.endpoints.createUser.body>>, context: unknown) => void;
+      onMutate?: (variables: z.infer<NonNullable<typeof apiConfig.endpoints.createUser.body>>) => Promise<unknown> | unknown;
+    }) {
+      const queryClient = useQueryClient();
+      return useMutation({
+	mutationFn: (body: z.infer<NonNullable<typeof apiConfig.endpoints.createUser.body>>) => apiClient.createUser(body),
+	onSuccess: (data, variables, context) => {
+	  queryClient.invalidateQueries({ queryKey: queryKeys.users.all });
+	  options?.onSuccess?.(data, variables, context);
+	},
+	onError: options?.onError,
+	onSettled: options?.onSettled,
+	onMutate: options?.onMutate,
+      });
+    }
+
+/**
+ * Update user
+ * @tags users
+ */
+    export function useUpdateUser(options?: {
+      onSuccess?: (data: z.infer<NonNullable<typeof apiConfig.endpoints.updateUser.response>>, variables: { params: z.infer<NonNullable<typeof apiConfig.endpoints.updateUser.params>>; body: z.infer<NonNullable<typeof apiConfig.endpoints.updateUser.body>>; }, context: unknown) => void;
+      onError?: (error: Error, variables: { params: z.infer<NonNullable<typeof apiConfig.endpoints.updateUser.params>>; body: z.infer<NonNullable<typeof apiConfig.endpoints.updateUser.body>>; }, context: unknown) => void;
+      onSettled?: (data: z.infer<NonNullable<typeof apiConfig.endpoints.updateUser.response>> | undefined, error: Error | null, variables: { params: z.infer<NonNullable<typeof apiConfig.endpoints.updateUser.params>>; body: z.infer<NonNullable<typeof apiConfig.endpoints.updateUser.body>>; }, context: unknown) => void;
+      onMutate?: (variables: { params: z.infer<NonNullable<typeof apiConfig.endpoints.updateUser.params>>; body: z.infer<NonNullable<typeof apiConfig.endpoints.updateUser.body>>; }) => Promise<unknown> | unknown;
+    }) {
+      const queryClient = useQueryClient();
+      return useMutation({
+	mutationFn: ({ params, body }: { params: z.infer<NonNullable<typeof apiConfig.endpoints.updateUser.params>>; body: z.infer<NonNullable<typeof apiConfig.endpoints.updateUser.body>>; }) => apiClient.updateUser(params, body),
+	onSuccess: (data, variables, context) => {
+	  queryClient.invalidateQueries({ queryKey: queryKeys.users.all });
+	  options?.onSuccess?.(data, variables, context);
+	},
+	onError: options?.onError,
+	onSettled: options?.onSettled,
+	onMutate: options?.onMutate,
+      });
+    }
+
+/**
+ * Delete user
+ * @tags users
+ */
+    export function useDeleteUser(options?: {
+      onSuccess?: (data: z.infer<NonNullable<typeof apiConfig.endpoints.deleteUser.response>>, variables: z.infer<NonNullable<typeof apiConfig.endpoints.deleteUser.params>>, context: unknown) => void;
+      onError?: (error: Error, variables: z.infer<NonNullable<typeof apiConfig.endpoints.deleteUser.params>>, context: unknown) => void;
+      onSettled?: (data: z.infer<NonNullable<typeof apiConfig.endpoints.deleteUser.response>> | undefined, error: Error | null, variables: z.infer<NonNullable<typeof apiConfig.endpoints.deleteUser.params>>, context: unknown) => void;
+      onMutate?: (variables: z.infer<NonNullable<typeof apiConfig.endpoints.deleteUser.params>>) => Promise<unknown> | unknown;
+    }) {
+      const queryClient = useQueryClient();
+      return useMutation({
+	mutationFn: (params: z.infer<NonNullable<typeof apiConfig.endpoints.deleteUser.params>>) => apiClient.deleteUser(params),
+	onSuccess: (data, variables, context) => {
+	  queryClient.invalidateQueries({ queryKey: queryKeys.users.all });
+	  options?.onSuccess?.(data, variables, context);
+	},
+	onError: options?.onError,
+	onSettled: options?.onSettled,
+	onMutate: options?.onMutate,
+      });
+    }
+
+/**
+ * Refresh access token
+ * @tags auth
+ */
+    export function useRefreshToken(options?: {
+      onSuccess?: (data: z.infer<NonNullable<typeof apiConfig.endpoints.refreshToken.response>>, variables: void, context: unknown) => void;
+      onError?: (error: Error, variables: void, context: unknown) => void;
+      onSettled?: (data: z.infer<NonNullable<typeof apiConfig.endpoints.refreshToken.response>> | undefined, error: Error | null, variables: void, context: unknown) => void;
+      onMutate?: (variables: void) => Promise<unknown> | unknown;
+    }) {
+      
+      return useMutation({
+	mutationFn: () => apiClient.refreshToken(),
+	onSuccess: (data, variables, context) => {
+	  
+	  options?.onSuccess?.(data, variables, context);
+	},
+	onError: options?.onError,
+	onSettled: options?.onSettled,
+	onMutate: options?.onMutate,
+      });
+    }

package/test-output/index.ts

@@ -0,0 +1,9 @@
+// Auto-generated exports
+export * from './types';
+export * from './client';
+export * from './query-keys';
+export * from './query-options';
+export * from './hooks';
+export * from './prefetchs';
+export { z } from 'zod';
+export { apiConfig } from '../test-real-endpoints.mjs';

package/test-output/prefetchs.ts

@@ -0,0 +1,25 @@
+// Auto-generated prefetch utilities
+import { type QueryClient } from '@tanstack/react-query';
+import { apiQueryOptions } from './query-options';
+import { z } from 'zod';
+import { apiConfig } from '../config/endpoints';
+
+export const prefetchListUsers = async (queryClient: QueryClient) => {
+  return await queryClient.ensureQueryData(apiQueryOptions.users.listUsers());
+};
+
+export const prefetchGetUser = async (queryClient: QueryClient,
+  params: z.infer<NonNullable<typeof apiConfig.endpoints.getUser.params>>) => {
+  return await queryClient.ensureQueryData(apiQueryOptions.users.user(params));
+};
+
+export const prefetchSearchUsers = async (queryClient: QueryClient,
+  filters?: z.infer<NonNullable<typeof apiConfig.endpoints.searchUsers.query>>) => {
+  return await queryClient.ensureQueryData(apiQueryOptions.users.searchUsers(filters));
+};
+
+export const prefetchGetUserPosts = async (queryClient: QueryClient,
+  params: z.infer<NonNullable<typeof apiConfig.endpoints.getUserPosts.params>>,
+  filters?: z.infer<NonNullable<typeof apiConfig.endpoints.getUserPosts.query>>) => {
+  return await queryClient.ensureQueryData(apiQueryOptions.users.userPosts(params, filters));
+};

package/test-output/queries.ts

@@ -0,0 +1,78 @@
+import { cache } from 'react';
+import { unstable_cache } from 'next/cache';
+import { serverClient } from './server-client';
+import type { 
+  APIEndpoints, 
+  ExtractParams, 
+  ExtractQuery, 
+  ExtractResponse 
+} from './types';
+
+/**
+ * List all users
+ * @tags none
+ */
+export const listUsersQuery = cache(async (
+  
+): Promise<ExtractResponse<APIEndpoints['listUsers']>> => {
+  return unstable_cache(
+    async () => serverClient.listUsers(),
+    ['listUsers'],
+    {
+      tags: [],
+      revalidate: 3600, // 1 hour default, can be overridden
+    }
+  )();
+});
+
+/**
+ * Get user by ID
+ * @tags none
+ */
+export const getUserQuery = cache(async (
+  params: ExtractParams<APIEndpoints['getUser']>
+): Promise<ExtractResponse<APIEndpoints['getUser']>> => {
+  return unstable_cache(
+    async () => serverClient.getUser(params),
+    ['getUser', JSON.stringify(params)],
+    {
+      tags: [],
+      revalidate: 3600, // 1 hour default, can be overridden
+    }
+  )();
+});
+
+/**
+ * Search users
+ * @tags none
+ */
+export const searchUsersQuery = cache(async (
+  query?: ExtractQuery<APIEndpoints['searchUsers']>
+): Promise<ExtractResponse<APIEndpoints['searchUsers']>> => {
+  return unstable_cache(
+    async () => serverClient.searchUsers(query),
+    ['searchUsers', query ? JSON.stringify(query) : 'no-query'],
+    {
+      tags: [],
+      revalidate: 3600, // 1 hour default, can be overridden
+    }
+  )();
+});
+
+/**
+ * Get user posts
+ * @tags none
+ */
+export const getUserPostsQuery = cache(async (
+  params: ExtractParams<APIEndpoints['getUserPosts']>,
+  query?: ExtractQuery<APIEndpoints['getUserPosts']>
+): Promise<ExtractResponse<APIEndpoints['getUserPosts']>> => {
+  return unstable_cache(
+    async () => serverClient.getUserPosts(params, query),
+    ['getUserPosts', JSON.stringify(params), query ? JSON.stringify(query) : 'no-query'],
+    {
+      tags: [],
+      revalidate: 3600, // 1 hour default, can be overridden
+    }
+  )();
+});

package/test-output/query-keys.ts

@@ -0,0 +1,16 @@
+// Auto-generated query keys
+import { z } from 'zod';
+import { apiConfig } from '../test-real-endpoints.mjs';
+
+export const queryKeys = {
+  users: {
+    all: ['users'] as const,
+    listUsers: () => ['users', 'listUsers'] as const,
+    user: (params?: z.infer<NonNullable<typeof apiConfig.endpoints.getUser.params>>) =>
+      ['users', 'user', params, undefined] as const,
+    searchUsers: (query?: z.infer<NonNullable<typeof apiConfig.endpoints.searchUsers.query>>) =>
+      ['users', 'searchUsers', undefined, query] as const,
+    userPosts: (params?: z.infer<NonNullable<typeof apiConfig.endpoints.getUserPosts.params>>, query?: z.infer<NonNullable<typeof apiConfig.endpoints.getUserPosts.query>>) =>
+      ['users', 'userPosts', params, query] as const,
+  },
+} as const;

package/test-output/query-options.ts

@@ -0,0 +1,38 @@
+// 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 '../test-real-endpoints.mjs';
+
+const usersQueryOptions = {
+  listUsers: () =>
+    queryOptions({
+      queryKey: queryKeys.users.listUsers(),
+      queryFn: (): Promise<z.infer<NonNullable<typeof apiConfig.endpoints.listUsers.response>>> => apiClient.listUsers(),
+      staleTime: 1000 * 60 * 5,
+    }),
+  user: (params: z.infer<NonNullable<typeof apiConfig.endpoints.getUser.params>>) =>
+    queryOptions({
+      queryKey: queryKeys.users.user(params),
+      queryFn: (): Promise<z.infer<NonNullable<typeof apiConfig.endpoints.getUser.response>>> => apiClient.getUser(params),
+      staleTime: 1000 * 60 * 5,
+    }),
+  searchUsers: (filters?: z.infer<NonNullable<typeof apiConfig.endpoints.searchUsers.query>>) =>
+    queryOptions({
+      queryKey: queryKeys.users.searchUsers(filters),
+      queryFn: (): Promise<z.infer<NonNullable<typeof apiConfig.endpoints.searchUsers.response>>> => apiClient.searchUsers(filters),
+      staleTime: 1000 * 60 * 5,
+    }),
+  userPosts: (params: z.infer<NonNullable<typeof apiConfig.endpoints.getUserPosts.params>>, filters?: z.infer<NonNullable<typeof apiConfig.endpoints.getUserPosts.query>>) =>
+    queryOptions({
+      queryKey: queryKeys.users.userPosts(params, filters),
+      queryFn: (): Promise<z.infer<NonNullable<typeof apiConfig.endpoints.getUserPosts.response>>> => apiClient.getUserPosts(params, filters),
+      staleTime: 1000 * 60 * 5,
+    }),
+};
+
+
+export const apiQueryOptions = {
+  users: usersQueryOptions,
+} as const;

package/test-output/server-client.ts

@@ -0,0 +1,32 @@
+import { createAPIClient } from '@cushin/api-runtime';
+import { apiConfig } from '../test-real-endpoints.mjs';
+import { z } from 'zod';
+
+// Type the methods based on endpoints
+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;
+};
+
+/**
+ * Server-side API client (no auth, direct API calls)
+ * Use this in Server Components, Server Actions, and Route Handlers
+ */
+export const serverClient = createAPIClient(apiConfig) as APIClientMethods;

package/test-output/types.ts

@@ -0,0 +1,61 @@
+// Auto-generated type definitions
+// Do not edit this file manually
+
+import type { z } from 'zod';
+import { apiConfig } from '../test-real-endpoints.mjs';
+
+
+// Re-export endpoint configuration types
+export type { APIConfig, APIEndpoint, HTTPMethod } from '@cushin/api-runtime';
+
+/**
+ * Type helper to extract params schema from an endpoint
+ */
+export type ExtractParams<T> = T extends { params: infer P extends z.ZodType }
+  ? z.infer<P>
+  : never;
+
+/**
+ * Type helper to extract query schema from an endpoint
+ */
+export type ExtractQuery<T> = T extends { query: infer Q extends z.ZodType }
+  ? z.infer<Q>
+  : never;
+
+/**
+ * Type helper to extract body schema from an endpoint
+ */
+export type ExtractBody<T> = T extends { body: infer B extends z.ZodType }
+  ? z.infer<B>
+  : never;
+
+/**
+ * Type helper to extract response schema from an endpoint
+ */
+export type ExtractResponse<T> = T extends { response: infer R extends z.ZodType }
+  ? z.infer<R>
+  : never;
+
+/**
+ * Import your API config to get typed endpoints
+ * 
+ */
+export type APIEndpoints = typeof apiConfig.endpoints;
+
+export type ListUsersResponse = z.infer<NonNullable<typeof apiConfig.endpoints.listUsers.response>>;
+export type GetUserResponse = z.infer<NonNullable<typeof apiConfig.endpoints.getUser.response>>;
+export type GetUserParams = z.infer<NonNullable<typeof apiConfig.endpoints.getUser.params>>;
+export type SearchUsersResponse = z.infer<NonNullable<typeof apiConfig.endpoints.searchUsers.response>>;
+export type SearchUsersQuery = z.infer<NonNullable<typeof apiConfig.endpoints.searchUsers.query>>;
+export type GetUserPostsResponse = z.infer<NonNullable<typeof apiConfig.endpoints.getUserPosts.response>>;
+export type GetUserPostsQuery = z.infer<NonNullable<typeof apiConfig.endpoints.getUserPosts.query>>;
+export type GetUserPostsParams = z.infer<NonNullable<typeof apiConfig.endpoints.getUserPosts.params>>;
+export type CreateSessionResponse = z.infer<NonNullable<typeof apiConfig.endpoints.createSession.response>>;
+export type CreateUserResponse = z.infer<NonNullable<typeof apiConfig.endpoints.createUser.response>>;
+export type CreateUserInput = z.infer<NonNullable<typeof apiConfig.endpoints.createUser.body>>;
+export type UpdateUserResponse = z.infer<NonNullable<typeof apiConfig.endpoints.updateUser.response>>;
+export type UpdateUserInput = z.infer<NonNullable<typeof apiConfig.endpoints.updateUser.body>>;
+export type UpdateUserParams = z.infer<NonNullable<typeof apiConfig.endpoints.updateUser.params>>;
+export type DeleteUserResponse = z.infer<NonNullable<typeof apiConfig.endpoints.deleteUser.response>>;
+export type DeleteUserParams = z.infer<NonNullable<typeof apiConfig.endpoints.deleteUser.params>>;
+export type RefreshTokenResponse = z.infer<NonNullable<typeof apiConfig.endpoints.refreshToken.response>>;

package/test-real-endpoints.mjs

@@ -0,0 +1,132 @@
+import { z } from 'zod';
+import { defineEndpoint, defineConfig } from './packages/api-runtime/dist/index.js';
+
+export const apiConfig = defineConfig({
+  baseUrl: 'https://api.example.com',
+  endpoints: {
+    // Case 1: GET - No params, no query
+    listUsers: defineEndpoint({
+      path: '/users',
+      method: 'GET',
+      response: z.object({
+        users: z.array(z.object({ id: z.string(), name: z.string() })),
+      }),
+      description: 'List all users',
+    }),
+
+    // Case 2: GET - Has params only
+    getUser: defineEndpoint({
+      path: '/users/:id',
+      method: 'GET',
+      params: z.object({ id: z.string() }),
+      response: z.object({
+        id: z.string(),
+        name: z.string(),
+        email: z.string(),
+      }),
+      description: 'Get user by ID',
+    }),
+
+    // Case 3: GET - Has query only
+    searchUsers: defineEndpoint({
+      path: '/users/search',
+      method: 'GET',
+      query: z.object({
+        q: z.string(),
+        limit: z.number().optional(),
+      }),
+      response: z.object({
+        results: z.array(z.object({ id: z.string(), name: z.string() })),
+      }),
+      description: 'Search users',
+    }),
+
+    // Case 4: GET - Has params and query
+    getUserPosts: defineEndpoint({
+      path: '/users/:id/posts',
+      method: 'GET',
+      params: z.object({ id: z.string() }),
+      query: z.object({
+        status: z.enum(['draft', 'published']).optional(),
+        limit: z.number().optional(),
+      }),
+      response: z.object({
+        posts: z.array(z.object({ id: z.string(), title: z.string() })),
+      }),
+      description: 'Get user posts',
+    }),
+
+    // Case 5: POST - No params, no body (create session)
+    createSession: defineEndpoint({
+      path: '/sessions',
+      method: 'POST',
+      response: z.object({
+        sessionId: z.string(),
+        expiresAt: z.string(),
+      }),
+      tags: ['auth'],
+      description: 'Create new session',
+    }),
+
+    // Case 6: POST - Has body only
+    createUser: defineEndpoint({
+      path: '/users',
+      method: 'POST',
+      body: z.object({
+        name: z.string(),
+        email: z.string().email(),
+      }),
+      response: z.object({
+        id: z.string(),
+        name: z.string(),
+        email: z.string(),
+      }),
+      tags: ['users'],
+      description: 'Create new user',
+    }),
+
+    // Case 7: POST - Has params and body
+    updateUser: defineEndpoint({
+      path: '/users/:id',
+      method: 'POST',
+      params: z.object({ id: z.string() }),
+      body: z.object({
+        name: z.string().optional(),
+        email: z.string().email().optional(),
+      }),
+      response: z.object({
+        id: z.string(),
+        name: z.string(),
+        email: z.string(),
+      }),
+      tags: ['users'],
+      description: 'Update user',
+    }),
+
+    // Case 8: DELETE - Has params only
+    deleteUser: defineEndpoint({
+      path: '/users/:id',
+      method: 'DELETE',
+      params: z.object({ id: z.string() }),
+      response: z.object({
+        success: z.boolean(),
+      }),
+      tags: ['users'],
+      description: 'Delete user',
+    }),
+
+    // Case 9: PATCH - No params, no body (refresh token)
+    refreshToken: defineEndpoint({
+      path: '/auth/refresh',
+      method: 'PATCH',
+      response: z.object({
+        accessToken: z.string(),
+        refreshToken: z.string(),
+      }),
+      tags: ['auth'],
+      description: 'Refresh access token',
+    }),
+  },
+});
+
+export default apiConfig;