interface RouteDefinition {
  input: unknown   // Combined input type
  output: unknown  // Response type
  error: unknown   // Error type
}

type HttpQueryMethod = 'get' | 'options' | 'head'

type HttpMutationMethod = 'post' | 'put' | 'patch' | 'delete'

type HttpMethod = HttpQueryMethod | HttpMutationMethod

interface EdenFetchError<TStatus extends number = number, TValue = unknown> {
  status: TStatus
  value: TValue
}

import { useMutation } from '@tanstack/react-query'
import type { EdenFetchError } from 'eden-tanstack-react-query'

const { mutate, error } = useMutation(eden.users.post.mutationOptions())

// error is typed as EdenFetchError
if (error) {
  if (error.status === 400) {
    // Validation error
    console.log('Validation:', error.value)
  } else if (error.status === 500) {
    // Server error
    console.log('Server error:', error.value)
  }
}

type EdenQueryKey<TInput = unknown> =
  | [path: string[]]
  | [path: string[], meta: EdenQueryKeyMeta<TInput>]

// Examples:
[['users', 'get']]
[['users', 'get'], { input: { role: 'admin' } }]
[['posts', 'get'], { input: { limit: 10 }, type: 'infinite' }]

type EdenMutationKey = [path: string[]]

// Example:
[['users', 'post']]

type EdenQueryKeyMeta<TInput = unknown> = {
  input?: TInput
  type?: 'query' | 'infinite'
}

type QueryType = 'query' | 'infinite' | 'any'

// For GET/HEAD/OPTIONS: returns query parameters type
// For POST/PUT/PATCH/DELETE: returns body type
type InferRouteInput<TRoute, TMethod> = TMethod extends 'get' | 'head' | 'options'
  ? QueryParams
  : Body

type ExtractRoutes<TApp extends AnyElysia> = TApp['~Routes']

type UserRoute = GetRoute<typeof app, '/users/:id', 'get'>

type Params = ExtractPathParams<'/users/:id/posts/:postId'>
// => 'id' | 'postId'

type Params = PathParamsToObject<'/users/:id/posts/:postId'>
// => { id: string; postId: string }

// Usage
type Proxy = EdenOptionsProxy<typeof app>
// Proxy.users.get.queryOptions(...)
// Proxy.users({ id: '1' }).get.queryOptions(...)
// Proxy.users.post.mutationOptions(...)

import type { inferInput } from 'eden-tanstack-react-query'

type UserInput = inferInput<typeof eden.users.get>

import type { inferOutput } from 'eden-tanstack-react-query'

type UserOutput = inferOutput<typeof eden.users.get>

import type { inferError } from 'eden-tanstack-react-query'

type UserError = inferError<typeof eden.users.get>

interface EdenQueryBaseOptions {
  eden?: {
    /** Abort request on component unmount */
    abortOnUnmount?: boolean
  }
}

interface EdenQueryOptionsResult {
  eden: {
    path: string
  }
}

type Cursor = ExtractCursorType<{ cursor?: string; limit: number }>
// => string

type HasCursor = HasCursorInput<{ cursor?: string }>  // true
type NoCursor = HasCursorInput<{ limit: number }>     // false

type Partial = DeepPartial<{ user: { name: string; email: string } }>
// => { user?: { name?: string; email?: string } }