### Make Requests Using Path-Based Methods

Source: https://context7.com/julien-r44/tuyau/llms.txt

Use raw URL patterns with methods like `get`, `post`, `put`, `patch`, `delete`, and `head`. This is useful when you know the pattern but prefer not to traverse the route tree, or when calling from generic utilities. Requests are typed against the route registry by pattern.

```typescript
// GET /users  — typed against the route registry by pattern
const users = await tuyau.get('/users', {
  query: { email: 'foo@example.com' },
})

// GET /users/:id
const user = await tuyau.get('/users/:id', {
  params: { id: '42' },
  query: { foo: 'bar' },
})

// POST /auth/login
const session = await tuyau.post('/auth/login', {
  body: { email: 'user@example.com', password: 'secret' },
})

// DELETE /posts/:id
await tuyau.delete('/posts/:id', { params: { id: '10' } })

// Nested params
await tuyau.get('/posts/:postId/comments/:commentId/likes/:likeId', {
  params: { postId: '1', commentId: '2', likeId: '3' },
  query: { foo: 'bar' },
})
```

--------------------------------

### Handle errors with TuyauPromise.safe()

Source: https://context7.com/julien-r44/tuyau/llms.txt

Use `.safe()` to get a `[data, null] | [null, TuyauError]` tuple instead of throwing. This enables Go-style error handling without try/catch blocks. Check for errors before accessing data.

```typescript
const [data, error] = await tuyau.api.auth.login({
  body: { email: 'user@example.com', password: 'wrong' },
}).safe()

if (error) {
  if (error.isValidationError()) {
    // error.response is typed as { errors: SimpleError[] }
    console.error('Validation failed:', error.response.errors)
  } else if (error.isStatus(401)) {
    console.error('Unauthorized:', error.response)
  } else if (error.kind === 'network') {
    console.error('Network error:', error.message)
  } else {
    console.error(`HTTP ${error.status}:`, error.response)
  }
  return
}

// data is fully typed — no null checks needed here
console.log('Logged in:', data.token)
```

--------------------------------

### Initialize Tuyau Client with createTuyau

Source: https://context7.com/julien-r44/tuyau/llms.txt

Factory function to initialize the Tuyau HTTP client. Pass the generated registry, base URL, and optional ky options like headers, hooks, and retry configurations.

```typescript
import { createTuyau } from '@tuyau/core/client'
import { registry } from './tuyau/index.ts' // generated registry

const tuyau = createTuyau({
  baseUrl: 'http://localhost:3333',
  registry,
  // Optional: default headers applied to every request
  headers: { 'X-App-Version': '1.0' },
  // Optional: ky lifecycle hooks
  hooks: {
    beforeRequest: [
      (request) => {
        const token = localStorage.getItem('auth_token')
        if (token) request.headers.set('Authorization', `Bearer ${token}`)
      },
    ],
  },
  // Optional: retry configuration
  retry: { limit: 2 },
})
```

--------------------------------

### createTuyauVueQueryClient

Source: https://context7.com/julien-r44/tuyau/llms.txt

Creates a typesafe TanStack Vue Query client with the same API surface as the React Query client, adapted for Vue's Composition API.

```APIDOC
## `createTuyauVueQueryClient` — TanStack Vue Query integration

Creates a typesafe TanStack Vue Query client with the same API surface as the React Query client, adapted for Vue's Composition API.

```typescript
import { createTuyau } from '@tuyau/core/client'
import { createTuyauVueQueryClient } from '@tuyau/vue-query'
import { useQuery, useMutation } from '@tanstack/vue-query'
import { registry } from './tuyau/index.ts'

const tuyau = createTuyau({ baseUrl: 'http://localhost:3333', registry })
const api = createTuyauVueQueryClient({ client: tuyau })

// In a Vue component <script setup>
const { data: user, isLoading } = useQuery(
  api.users.show.queryOptions({ params: { id: '42' } })
)

const loginMutation = useMutation(
  api.auth.login.mutationOptions({
    onSuccess: (data) => {
      router.push('/dashboard')
    },
  })
)

// Trigger the mutation
loginMutation.mutate({ body: { email: 'user@example.com', password: 'secret' } })

// Infinite scroll
const { data: posts, fetchNextPage } = useInfiniteQuery(
  api.posts.index.infiniteQueryOptions(
    { query: { limit: 10 } },
    { getNextPageParam: (_, pages) => pages.length + 1, initialPageParam: 1 }
  )
)
```
```

--------------------------------

### createTuyauReactQueryClient

Source: https://context7.com/julien-r44/tuyau/llms.txt

Creates a typesafe TanStack React Query client that wraps the Tuyau client. Each endpoint node exposes queryOptions, mutationOptions, infiniteQueryOptions, and cache key/filter helpers.

```APIDOC
## `createTuyauReactQueryClient` — TanStack React Query integration

Creates a typesafe TanStack React Query client that wraps the Tuyau client. Each endpoint node exposes `queryOptions`, `mutationOptions`, `infiniteQueryOptions`, and cache key/filter helpers.

```typescript
import { createTuyau } from '@tuyau/core/client'
import { createTuyauReactQueryClient } from '@tuyau/react-query'
import { useQuery, useMutation, useInfiniteQuery, useQueryClient } from '@tanstack/react-query'
import { registry } from './tuyau/index.ts'

const tuyau = createTuyau({ baseUrl: 'http://localhost:3333', registry })
const api = createTuyauReactQueryClient({ client: tuyau })

// --- Query ---
function UserProfile({ id }: { id: string }) {
  const { data, isLoading } = useQuery(
    api.users.show.queryOptions({ params: { id } })
  )
  if (isLoading) return <p>Loading...</p>
  return <p>{data?.name}</p>
}

// --- Mutation ---
function LoginForm() {
  const mutation = useMutation(
    api.auth.login.mutationOptions({
      onSuccess: (data) => {
        localStorage.setItem('token', data.token)
      },
    })
  )
  return (
    <button onClick={() => mutation.mutate({ body: { email: 'user@example.com', password: 'secret' } })}>
      Login
    </button>
  )
}

// --- Infinite Query ---
function UserList() {
  const { data, fetchNextPage } = useInfiniteQuery(
    api.users.index.infiniteQueryOptions(
      { query: { perPage: 20 } },
      {
        getNextPageParam: (lastPage, pages) => pages.length + 1,
        initialPageParam: 1,
      }
    )
  )
  return <div>{/* render pages */}</div>
}

// --- Cache invalidation using pathKey / queryKey ---
function InvalidateExample() {
  const queryClient = useQueryClient()
  const invalidateAllUsers = () => {
    queryClient.invalidateQueries(api.users.pathFilter())
    // or a specific query:
    queryClient.invalidateQueries(api.users.show.queryFilter({ params: { id: '42' } }))
  }
  return <button onClick={invalidateAllUsers}>Refresh Users</button>
}
```
```

--------------------------------

### createTuyau

Source: https://context7.com/julien-r44/tuyau/llms.txt

Factory function to initialize the Tuyau HTTP client. It accepts a generated registry, a base URL, and optional Ky options or plugins.

```APIDOC
## `createTuyau` — Create the typesafe client

Factory function that initializes the Tuyau HTTP client. It accepts a registry (generated by the backend) and a `baseUrl`, plus any [ky](https://github.com/sindresorhus/ky) options (headers, hooks, retry, etc.) and optional plugins.

```typescript
import { createTuyau } from '@tuyau/core/client'
import { registry } from './tuyau/index.ts' // generated registry

const tuyau = createTuyau({
  baseUrl: 'http://localhost:3333',
  registry,
  // Optional: default headers applied to every request
  headers: { 'X-App-Version': '1.0' },
  // Optional: ky lifecycle hooks
  hooks: {
    beforeRequest: [
      (request) => {
        const token = localStorage.getItem('auth_token')
        if (token) request.headers.set('Authorization', `Bearer ${token}`)
      },
    ],
  },
  // Optional: retry configuration
  retry: { limit: 2 },
})

// tuyau.api mirrors your AdonisJS route tree
// Route: POST /auth/login  →  tuyau.api.auth.login(...)
// Route: GET  /users/:id   →  tuyau.api.users.show(...)
```
```

--------------------------------

### tuyau.get / post / put / patch / delete / head

Source: https://context7.com/julien-r44/tuyau/llms.txt

Make requests using the raw URL pattern instead of the fluent chain. Useful when the pattern is known but traversing the tree is not preferred, or when calling from generic utilities.

```APIDOC
## `tuyau.get / post / put / patch / delete / head` — Path-based methods

Make requests using the raw URL pattern instead of the fluent chain. Useful when you know the pattern but prefer not to traverse the tree, or when calling from generic utilities.

```typescript
// GET /users  — typed against the route registry by pattern
const users = await tuyau.get('/users', {
  query: { email: 'foo@example.com' },
})

// GET /users/:id
const user = await tuyau.get('/users/:id', {
  params: { id: '42' },
  query: { foo: 'bar' },
})

// POST /auth/login
const session = await tuyau.post('/auth/login', {
  body: { email: 'user@example.com', password: 'secret' },
})

// DELETE /posts/:id
await tuyau.delete('/posts/:id', { params: { id: '10' } })

// Nested params
await tuyau.get('/posts/:postId/comments/:commentId/likes/:likeId', {
  params: { postId: '1', commentId: '2', likeId: '3' },
  query: { foo: 'bar' },
})
```
```

--------------------------------

### TuyauPromise.safe()

Source: https://context7.com/julien-r44/tuyau/llms.txt

Handles errors gracefully by returning a tuple `[data, null]` on success or `[null, TuyauError]` on failure, enabling Go-style error handling without `try/catch` blocks.

```APIDOC
## `TuyauPromise.safe()` — Non-throwing error handling

All Tuyau requests return a `TuyauPromise` which extends the native `Promise`. The `.safe()` method returns a `[data, null] | [null, TuyauError]` tuple instead of throwing, enabling Go-style error handling without try/catch.

```typescript
const [data, error] = await tuyau.api.auth.login({
  body: { email: 'user@example.com', password: 'wrong' },
}).safe()

if (error) {
  if (error.isValidationError()) {
    // error.response is typed as { errors: SimpleError[] }
    console.error('Validation failed:', error.response.errors)
  } else if (error.isStatus(401)) {
    console.error('Unauthorized:', error.response)
  } else if (error.kind === 'network') {
    console.error('Network error:', error.message)
  } else {
    console.error(`HTTP ${error.status}:`, error.response)
  }
  return
}

// data is fully typed — no null checks needed here
console.log('Logged in:', data.token)
```
```

--------------------------------

### tuyau.current

Source: https://context7.com/julien-r44/tuyau/llms.txt

Detects the active route based on `window.location`, supporting route name matching, wildcards, and optional parameter/query constraints.

```APIDOC
## `tuyau.current` — Active route detection

Determines the current route based on `window.location`. Supports no-argument form (returns the matched route name), name-matching (returns boolean), and optional param/query constraints. Supports `*` wildcards in route names.

```typescript
// Returns the name of the route matching the current URL, or undefined
const routeName = tuyau.current()
// e.g. => "users.show"

// Check if the current URL matches a specific route
tuyau.current('users.show')        // true/false
tuyau.current('users.*')           // true if any users.* route is active (wildcard)
tuyau.current('auth.login')        // false

// Match with specific params
tuyau.current('users.show', { params: { id: '42' } })  // true if /users/42 is current

// Match with query params
tuyau.current('users.show', { query: { tab: 'profile' } })

// Returns false/undefined in SSR environments (no window object)
const isServer = typeof window === 'undefined'
// tuyau.current() => undefined  (server-side)
// tuyau.current('users.show') => false  (server-side)
```
```

--------------------------------

### Create TanStack React Query Client for Tuyau

Source: https://context7.com/julien-r44/tuyau/llms.txt

Integrates Tuyau with TanStack React Query, providing typesafe client wrappers for endpoints. Use this for managing API data fetching and mutations in React applications.

```typescript
import { createTuyau } from '@tuyau/core/client'
import { createTuyauReactQueryClient } from '@tuyau/react-query'
import { useQuery, useMutation, useInfiniteQuery, useQueryClient } from '@tanstack/react-query'
import { registry } from './tuyau/index.ts'

const tuyau = createTuyau({ baseUrl: 'http://localhost:3333', registry })
const api = createTuyauReactQueryClient({ client: tuyau })

// --- Query ---
function UserProfile({ id }: { id: string }) {
  const { data, isLoading } = useQuery(
    api.users.show.queryOptions({ params: { id } })
  )
  if (isLoading) return <p>Loading...</p>
  return <p>{data?.name}</p>
}

// --- Mutation ---
function LoginForm() {
  const mutation = useMutation(
    api.auth.login.mutationOptions({
      onSuccess: (data) => {
        localStorage.setItem('token', data.token)
      },
    })
  )
  return (
    <button onClick={() => mutation.mutate({ body: { email: 'user@example.com', password: 'secret' } })}>
      Login
    </button>
  )
}

// --- Infinite Query ---
function UserList() {
  const { data, fetchNextPage } = useInfiniteQuery(
    api.users.index.infiniteQueryOptions(
      { query: { perPage: 20 } },
      {
        getNextPageParam: (lastPage, pages) => pages.length + 1,
        initialPageParam: 1,
      }
    )
  )
  return <div>{/* render pages */}</div>
}

// --- Cache invalidation using pathKey / queryKey ---
function InvalidateExample() {
  const queryClient = useQueryClient()
  const invalidateAllUsers = () => {
    queryClient.invalidateQueries(api.users.pathFilter())
    // or a specific query:
    queryClient.invalidateQueries(api.users.show.queryFilter({ params: { id: '42' } }))
  }
  return <button onClick={invalidateAllUsers}>Refresh Users</button>
}
```

--------------------------------

### Create TanStack Vue Query Client for Tuyau

Source: https://context7.com/julien-r44/tuyau/llms.txt

Adapts the Tuyau client for Vue's Composition API, offering a similar API surface to the React Query integration. Suitable for managing API state in Vue applications.

```typescript
import { createTuyau } from '@tuyau/core/client'
import { createTuyauVueQueryClient } from '@tuyau/vue-query'
import { useQuery, useMutation } from '@tanstack/vue-query'
import { registry } from './tuyau/index.ts'

const tuyau = createTuyau({ baseUrl: 'http://localhost:3333', registry })
const api = createTuyauVueQueryClient({ client: tuyau })

// In a Vue component <script setup>
const { data: user, isLoading } = useQuery(
  api.users.show.queryOptions({ params: { id: '42' } })
)

const loginMutation = useMutation(
  api.auth.login.mutationOptions({
    onSuccess: (data) => {
      router.push('/dashboard')
    },
  })
)

// Trigger the mutation
loginMutation.mutate({ body: { email: 'user@example.com', password: 'secret' } })

// Infinite scroll
const { data: posts, fetchNextPage } = useInfiniteQuery(
  api.posts.index.infiniteQueryOptions(
    { query: { limit: 10 } },
    { getNextPageParam: (_, pages) => pages.length + 1, initialPageParam: 1 }
  )
)
```

--------------------------------

### Add Authentication Header with Tuyau Plugin

Source: https://context7.com/julien-r44/tuyau/llms.txt

This plugin intercepts requests before they are sent and adds an Authorization header if a token is found in local storage. Ensure the `localStorage` is accessible in your environment.

```typescript
import { createTuyau } from '@tuyau/core/client'
import type { TuyauPlugin } from '@tuyau/core/types'
import { registry } from './tuyau/index.ts'

const authPlugin: TuyauPlugin = ({ options }) => {
  const original = options.hooks?.beforeRequest ?? []
  options.hooks = {
    ...options.hooks,
    beforeRequest: [
      ...original,
      (request) => {
        const token = localStorage.getItem('token')
        if (token) request.headers.set('Authorization', `Bearer ${token}`)
      },
    ],
  }
}

const tuyau = createTuyau({
  baseUrl: 'http://localhost:3333',
  registry,
  plugins: [authPlugin],
})
```

--------------------------------

### Type Helpers

Source: https://context7.com/julien-r44/tuyau/llms.txt

Extract types from the registry to use in server components, validators, or test helpers without instantiating a client.

```APIDOC
## Type Helpers — Extract types from the registry

Tuyau exposes several TypeScript namespace utilities for extracting typed request/response shapes without instantiating a client, useful in server components, validators, or test helpers.

```typescript
import type { Route, Path } from '@tuyau/core/types'

// Route namespace — address endpoints by route name
type LoginBody    = Route.Body<'auth.login'>       // { email: string; password: string }
type LoginQuery   = Route.Query<'auth.login'>      // {}
type LoginParams  = Route.Params<'auth.login'>     // {}
type LoginRes     = Route.Response<'auth.login'>   // { token: string }
type LoginErr     = Route.Error<'auth.login'>      // TuyauError<{ status: 422; response: ... }>

// Path namespace — address endpoints by HTTP method + URL pattern
type GetUserRes   = Path.Response<'GET',  '/users/:id'>
type PostUserBody = Path.Body<'POST', '/users'>

// Use in a utility function
async function loginUser(body: Route.Body<'auth.login'>): Promise<Route.Response<'auth.login'>> {
  return tuyau.api.auth.login({ body })
}

// RouteWithRegistry / PathWithRegistry — same as above but with explicit registry type param
import type { RouteWithRegistry, PathWithRegistry } from '@tuyau/core/types'
import type { registry } from './tuyau/index.ts'

type MyRegistry = (typeof registry)['routes']
type UserBody = RouteWithRegistry.Body<MyRegistry, 'users.store'>
```
```

--------------------------------

### Generate Tuyau Registry Files Programmatically

Source: https://context7.com/julien-r44/tuyau/llms.txt

Use `RegistryGenerator` to programmatically create Tuyau registry files for the client. This can be used to customize route inclusion/exclusion and error types. The generated files can be written to disk or returned as strings.

```typescript
import { RegistryGenerator } from '@tuyau/core/backend/registry_generator'
import type { ScannedRoute } from '@adonisjs/assembler/types'

const generator = new RegistryGenerator({
  // Custom error type for 422 validation errors (default: '{ errors: SimpleError[] }')
  validationErrorType: '{ errors: SimpleError[] }',

  // Filter which routes to include
  routes: {
    only: ['users.*', 'auth.*'],          // include only matching routes
    // except: ['admin.*'],               // OR exclude matching routes (cannot use both)
  },
})

// Generate all three registry files at once
const scannedRoutes: ScannedRoute[] = [] // provided by @adonisjs/assembler

// Write to disk
await generator.writeOutput({
  outputDir: './inertia/tuyau',
  routes: scannedRoutes,
})
// Creates: inertia/tuyau/index.ts, inertia/tuyau/schema.d.ts, inertia/tuyau/tree.d.ts

// Or get the generated strings without writing
const { runtime, types, tree } = generator.generate(scannedRoutes)
console.log(runtime) // content of index.ts
console.log(types)   // content of schema.d.ts
console.log(tree)    // content of tree.d.ts
```

--------------------------------

### tuyau.api.*

Source: https://context7.com/julien-r44/tuyau/llms.txt

Access endpoints via a proxy that mirrors your AdonisJS route name hierarchy. The final call accepts `{ body, query, params, ...kyOptions }` with full TypeScript inference.

```APIDOC
## `tuyau.api.*` — Fluent chained API

Access endpoints via a proxy that mirrors your AdonisJS route name hierarchy. The final call accepts `{ body, query, params, ...kyOptions }` with full TypeScript inference.

```typescript
// POST /auth/login
const token = await tuyau.api.auth.login({
  body: { email: 'user@example.com', password: 'secret' },
})
// token is fully typed as the login controller's return type

// GET /users  (with query params)
const users = await tuyau.api.users.index({
  query: { page: 1, perPage: 20, search: 'julien' },
})

// GET /users/:id  (with route param + query)
const user = await tuyau.api.users.show({
  params: { id: '42' },
  query: { include: 'profile' },
})

// File upload — automatically switches to multipart/form-data
const result = await tuyau.api.users.store({
  body: {
    name: 'Julien',
    avatar: new File(['...'], 'avatar.png', { type: 'image/png' }),
  },
})

// Deeply nested routes
const like = await tuyau.api.posts.comments.likes.toggle({
  params: { postId: '1', commentId: '5', likeId: '3' },
})
```
```

--------------------------------

### Enable SuperJSON Serialization with Tuyau Plugin

Source: https://context7.com/julien-r44/tuyau/llms.txt

This plugin enables SuperJSON for serializing request bodies and deserializing response bodies, allowing complex types like Dates and BigInts to be transmitted over HTTP. Requires corresponding middleware on the backend.

```typescript
// Frontend: add the superjson plugin
import { createTuyau } from '@tuyau/core/client'
import { superjson } from '@tuyau/superjson/client/plugin'
import { registry } from './tuyau/index.ts'

const tuyau = createTuyau({
  baseUrl: 'http://localhost:3333',
  registry,
  plugins: [
    superjson({
      stringifyRequest: true,  // default: true — serialize requests with SuperJSON
      parseResponse: true,     // default: true — deserialize responses with SuperJSON
    }),
  ],
})

// Dates and BigInts now survive the HTTP round-trip transparently
const result = await tuyau.api.users.store({
  body: {
    createdAt: new Date('2024-01-01'),  // sent as SuperJSON-serialized string
    balance: BigInt(1000000),
  },
})
// result.createdAt is a Date instance, not a string

// Backend: register middleware in AdonisJS (start/kernel.ts)
// node ace configure @tuyau/superjson
// Or manually:
// router.use([() => import('@tuyau/superjson/superjson_middleware')])
```

--------------------------------

### tuyau.urlFor

Source: https://context7.com/julien-r44/tuyau/llms.txt

Generates fully qualified URLs for registered routes without making actual HTTP requests, leveraging AdonisJS's URL builder.

```APIDOC
## `tuyau.urlFor` — Generate URLs without making requests

Build fully qualified URLs for any route in the registry. Uses AdonisJS's URL builder under the hood.

```typescript
// Generate a URL without making the HTTP request
const loginUrl = tuyau.urlFor.post('auth.login', {}).url
// => "http://localhost:3333/auth/login"

const userUrl = tuyau.urlFor.get('users.show', { paramsTuple: ['42'] }).url
// => "http://localhost:3333/users/42"
```
```

--------------------------------

### Inspect route metadata with tuyau.getRoute

Source: https://context7.com/julien-r44/tuyau/llms.txt

Retrieve the URL and HTTP methods for a named route. Useful for manual request construction or inspecting routing details.

```typescript
const routeInfo = tuyau.getRoute('users.show', { params: { id: '42' } })
// => { url: '/users/42', methods: ['GET'] }

const loginInfo = tuyau.getRoute('auth.login', {})
// => { url: '/auth/login', methods: ['POST'] }
```

--------------------------------

### Generate URLs with tuyau.urlFor

Source: https://context7.com/julien-r44/tuyau/llms.txt

Build fully qualified URLs for named routes without making HTTP requests. Uses AdonisJS's URL builder internally.

```typescript
// Generate a URL without making the HTTP request
const loginUrl = tuyau.urlFor.post('auth.login', {}).url
// => "http://localhost:3333/auth/login"

const userUrl = tuyau.urlFor.get('users.show', { paramsTuple: ['42'] }).url
// => "http://localhost:3333/users/42"
```

--------------------------------

### responseType

Source: https://context7.com/julien-r44/tuyau/llms.txt

Allows overriding the automatic content-type detection for response parsing, enabling explicit control over how responses are handled (e.g., JSON, ArrayBuffer, text, Blob).

```APIDOC
## `responseType` — Override content-type based response parsing

Pass `responseType` on any request to override automatic content-type detection when parsing responses.

```typescript
// Force parse as JSON even if Content-Type header is text/plain
const data = await tuyau.api.auth.login({
  body: { email: 'foo@example.com', password: 'secret' },
  responseType: 'json',
})

// Force parse as ArrayBuffer (e.g., for PDF downloads)
const buffer = await tuyau.api.downloads.file({
  params: { id: 'report.pdf' },
  responseType: 'arrayBuffer',
})

// Force parse as text
const text = await tuyau.api.some.endpoint({
  responseType: 'text',
})

// Force parse as Blob
const blob = await tuyau.api.some.endpoint({
  responseType: 'blob',
})
```
```

--------------------------------

### Detect active route with tuyau.current

Source: https://context7.com/julien-r44/tuyau/llms.txt

Identify the current route based on `window.location`. Supports route name matching, wildcards, and optional parameter/query constraints. Returns `undefined` or `false` in SSR environments.

```typescript
// Returns the name of the route matching the current URL, or undefined
const routeName = tuyau.current()
// e.g. => "users.show"

// Check if the current URL matches a specific route
tuyau.current('users.show')        // true/false
tuyau.current('users.*')           // true if any users.* route is active (wildcard)
tuyau.current('auth.login')        // false

// Match with specific params
tuyau.current('users.show', { params: { id: '42' } })  // true if /users/42 is current

// Match with query params
tuyau.current('users.show', { query: { tab: 'profile' } })

// Returns false/undefined in SSR environments (no window object)
const isServer = typeof window === 'undefined'
// tuyau.current() => undefined  (server-side)
// tuyau.current('users.show') => false  (server-side)
```

--------------------------------

### Access API Endpoints via Fluent Chained API

Source: https://context7.com/julien-r44/tuyau/llms.txt

Access endpoints using a proxy that mirrors your AdonisJS route hierarchy. The final call accepts an object with body, query, params, and other ky options, benefiting from full TypeScript inference.

```typescript
// POST /auth/login
const token = await tuyau.api.auth.login({
  body: { email: 'user@example.com', password: 'secret' },
})
// token is fully typed as the login controller's return type

// GET /users  (with query params)
const users = await tuyau.api.users.index({
  query: { page: 1, perPage: 20, search: 'julien' },
})

// GET /users/:id  (with route param + query)
const user = await tuyau.api.users.show({
  params: { id: '42' },
  query: { include: 'profile' },
})

// File upload — automatically switches to multipart/form-data
const result = await tuyau.api.users.store({
  body: {
    name: 'Julien',
    avatar: new File(['...'], 'avatar.png', { type: 'image/png' }),
  },
})

// Deeply nested routes
const like = await tuyau.api.posts.comments.likes.toggle({
  params: { postId: '1', commentId: '5', likeId: '3' },
})
```

--------------------------------

### Check route existence with tuyau.has

Source: https://context7.com/julien-r44/tuyau/llms.txt

Determine if a route name is registered in the client's route registry.

```typescript
tuyau.has('users.show')        // true
tuyau.has('auth.login')        // true
tuyau.has('nonexistent.route') // false
```

--------------------------------

### tuyau.getRoute

Source: https://context7.com/julien-r44/tuyau/llms.txt

Retrieves the URL and HTTP methods for a named route, useful for manual request construction or inspecting routing details.

```APIDOC
## `tuyau.getRoute` — Inspect route metadata

Returns the URL and HTTP methods for a named route, useful for constructing requests manually or inspecting routing details.

```typescript
const routeInfo = tuyau.getRoute('users.show', { params: { id: '42' } })
// => { url: '/users/42', methods: ['GET'] }

const loginInfo = tuyau.getRoute('auth.login', {})
// => { url: '/auth/login', methods: ['POST'] }
```
```

--------------------------------

### Extract Types from Tuyau Registry

Source: https://context7.com/julien-r44/tuyau/llms.txt

Provides TypeScript namespace utilities to extract typed request/response shapes directly from the registry. Useful for server components, validators, or test helpers without client instantiation.

```typescript
import type { Route, Path } from '@tuyau/core/types'

// Route namespace — address endpoints by route name
type LoginBody    = Route.Body<'auth.login'>       // { email: string; password: string }
type LoginQuery   = Route.Query<'auth.login'>      // {}
type LoginParams  = Route.Params<'auth.login'>     // {}
type LoginRes     = Route.Response<'auth.login'>   // { token: string }
type LoginErr     = Route.Error<'auth.login'>      // TuyauError<{ status: 422; response: ... }>

// Path namespace — address endpoints by HTTP method + URL pattern
type GetUserRes   = Path.Response<'GET',  '/users/:id'>
type PostUserBody = Path.Body<'POST', '/users'>

// Use in a utility function
async function loginUser(body: Route.Body<'auth.login'>): Promise<Route.Response<'auth.login'>> {
  return tuyau.api.auth.login({ body })
}

// RouteWithRegistry / PathWithRegistry — same as above but with explicit registry type param
import type { RouteWithRegistry, PathWithRegistry } from '@tuyau/core/types'
import type { registry } from './tuyau/index.ts'

type MyRegistry = (typeof registry)['routes']
type UserBody = RouteWithRegistry.Body<MyRegistry, 'users.store'>

```

--------------------------------

### tuyau.request

Source: https://context7.com/julien-r44/tuyau/llms.txt

Call an endpoint by its AdonisJS route name string. This is useful when the route name is dynamic or stored in a variable.

```APIDOC
## `tuyau.request` — Request by route name

Call an endpoint by its AdonisJS route name string. Useful when the name is dynamic or stored in a variable.

```typescript
// Call by dot-separated route name
const result = await tuyau.request('auth.login', {
  body: { email: 'user@example.com', password: 'secret' },
  query: { redirect: '/dashboard' },
})

// Works with .safe() too
const [data, error] = await tuyau.request('users.index', {
  query: { page: 1 },
}).safe()
```
```

--------------------------------

### tuyau.has

Source: https://context7.com/julien-r44/tuyau/llms.txt

Checks if a given route name is registered in the client's route registry, returning a boolean value.

```APIDOC
## `tuyau.has` — Check route existence

Returns `true` if a given route name is registered in the client's registry.

```typescript
tuyau.has('users.show')        // true
tuyau.has('auth.login')        // true
tuyau.has('nonexistent.route') // false
```
```

--------------------------------

### Call Endpoint by Route Name String

Source: https://context7.com/julien-r44/tuyau/llms.txt

Use `tuyau.request` to call an endpoint by its AdonisJS route name string. This is particularly useful when the route name is dynamic or stored in a variable. It also works with `.safe()` for error handling.

```typescript
// Call by dot-separated route name
const result = await tuyau.request('auth.login', {
  body: { email: 'user@example.com', password: 'secret' },
  query: { redirect: '/dashboard' },
})

// Works with .safe() too
const [data, error] = await tuyau.request('users.index', {
  query: { page: 1 },
}).safe()
```

--------------------------------

### Override response parsing with responseType

Source: https://context7.com/julien-r44/tuyau/llms.txt

Force specific response parsing (JSON, ArrayBuffer, text, Blob) regardless of the `Content-Type` header. Useful for handling non-standard responses.

```typescript
// Force parse as JSON even if Content-Type header is text/plain
const data = await tuyau.api.auth.login({
  body: { email: 'foo@example.com', password: 'secret' },
  responseType: 'json',
})

// Force parse as ArrayBuffer (e.g., for PDF downloads)
const buffer = await tuyau.api.downloads.file({
  params: { id: 'report.pdf' },
  responseType: 'arrayBuffer',
})

// Force parse as text
const text = await tuyau.api.some.endpoint({
  responseType: 'text',
})

// Force parse as Blob
const blob = await tuyau.api.some.endpoint({
  responseType: 'blob',
})
```

--------------------------------

### TuyauError.isStatus()

Source: https://context7.com/julien-r44/tuyau/llms.txt

A type guard that narrows the error's `response` property based on the HTTP status code, useful for handling specific error scenarios in both `safe()` and `catch()` blocks.

```APIDOC
## `TuyauError.isStatus()` — Typed status code narrowing

Type guard that narrows the error's `response` property to the type associated with a specific HTTP status code. Works with both `safe()` and `catch()` blocks.

```typescript
try {
  await tuyau.api.users.store({
    body: { name: '', email: 'invalid' },
  })
} catch (error) {
  if (error.isStatus(422)) {
    // error.response is now typed as { errors: SimpleError[] }
    error.response.errors.forEach((e) => console.log(e.message))
  } else if (error.isStatus(403)) {
    // error.response narrowed to the 403 type from your controller
    console.log('Forbidden:', error.response.message)
  } else if (error.isStatus(500)) {
    console.log('Server error')
  }
}

// isValidationError() is a convenience alias for isStatus(422)
const [, err] = await tuyau.api.auth.login({ body: { email: '', password: '' } }).safe()
if (err?.isValidationError()) {
  console.log(err.response.errors) // typed as SimpleError[]
}
```
```

--------------------------------

### Narrow errors with TuyauError.isStatus()

Source: https://context7.com/julien-r44/tuyau/llms.txt

Use `isStatus()` to narrow the error's `response` property based on the HTTP status code. This works in both `safe()` and `catch()` blocks. `isValidationError()` is an alias for `isStatus(422)`.

```typescript
try {
  await tuyau.api.users.store({
    body: { name: '', email: 'invalid' },
  })
} catch (error) {
  if (error.isStatus(422)) {
    // error.response is now typed as { errors: SimpleError[] }
    error.response.errors.forEach((e) => console.log(e.message))
  } else if (error.isStatus(403)) {
    // error.response narrowed to the 403 type from your controller
    console.log('Forbidden:', error.response.message)
  } else if (error.isStatus(500)) {
    console.log('Server error')
  }
}

// isValidationError() is a convenience alias for isStatus(422)
const [, err] = await tuyau.api.auth.login({ body: { email: '', password: '' } }).safe()
if (err?.isValidationError()) {
  console.log(err.response.errors) // typed as SimpleError[]
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.