@tuyau/core 1.0.0 → 1.2.0

package/build/backend/generate_registry.d.ts

@@ -1,3 +1,5 @@
+import { AllHooks } from '@adonisjs/assembler/types';
+
 /**
  * Extending the HTTP response interface to include status and response
  * in the return type.
@@ -180,7 +182,6 @@ declare module '@adonisjs/core/http' {
         };
     }
 }
-
 interface GenerateRegistryConfig {
     /**
      * Path to write the generated registry directory
@@ -202,9 +203,18 @@ interface GenerateRegistryConfig {
          */
         except?: Array<string | RegExp | ((routeName: string) => boolean)>;
     };
+    /**
+     * Custom TypeScript type string for 422 validation error responses.
+     * When not provided, uses the default VineJS SimpleErrorReporter format.
+     * Set to `false` to disable auto-adding 422 errors.
+     */
+    validationErrorType?: string | false;
 }
-declare function generateRegistry(options?: GenerateRegistryConfig): {
-    run(devServer: any, routesScanner: any): Promise<void>;
-};
+
+/**
+ * AdonisJS assembler hook that scans routes and generates
+ * the tuyau typed client registry files (runtime, schema, tree).
+ */
+declare function generateRegistry(options?: GenerateRegistryConfig): AllHooks['init'][number];
 
 export { generateRegistry };

package/build/backend/generate_registry.js

@@ -1,144 +1,198 @@
 // src/backend/types.ts
 import "@adonisjs/core/http";
 
-// src/backend/generate_registry.ts
+// src/backend/registry_generator.ts
 import { dirname } from "path";
 import { writeFile, mkdir } from "fs/promises";
 import stringHelpers from "@adonisjs/core/helpers/string";
-async function writeOutputFile(filePath, content) {
-  const dir = dirname(filePath);
-  await mkdir(dir, { recursive: true });
-  await writeFile(filePath, content);
-}
-function matchesPattern(routeName, pattern) {
-  if (typeof pattern === "string") return routeName.includes(pattern);
-  if (pattern instanceof RegExp) return pattern.test(routeName);
-  if (typeof pattern === "function") return pattern(routeName);
-  return false;
-}
-function filterRoute(route, filters) {
-  if (!filters) {
+var DEFAULT_VALIDATION_ERROR_TYPE = "{ errors: SimpleError[] }";
+var RegistryGenerator = class {
+  #validationErrorType;
+  #routesFilter;
+  constructor(options) {
+    this.#validationErrorType = options?.validationErrorType === void 0 ? DEFAULT_VALIDATION_ERROR_TYPE : options.validationErrorType;
+    this.#routesFilter = options?.routes;
+  }
+  /**
+   * Test a route name against a string, regex, or function pattern.
+   */
+  #matchesPattern(routeName, pattern) {
+    if (typeof pattern === "string") return routeName.includes(pattern);
+    if (pattern instanceof RegExp) return pattern.test(routeName);
+    if (typeof pattern === "function") return pattern(routeName);
+    return false;
+  }
+  /**
+   * Check if a route passes the configured only/except filters.
+   * Returns true when no filters are set.
+   */
+  filterRoute(route) {
+    if (!this.#routesFilter) return true;
+    const { only, except } = this.#routesFilter;
+    if (only && except)
+      throw new Error('Cannot use both "only" and "except" filters at the same time');
+    if (only) return only.some((pattern) => this.#matchesPattern(route.name, pattern));
+    if (except) return !except.some((pattern) => this.#matchesPattern(route.name, pattern));
     return true;
   }
-  const { only, except } = filters;
-  if (only && except)
-    throw new Error('Cannot use both "only" and "except" filters at the same time');
-  if (only) {
-    return only.some((pattern) => matchesPattern(route.name, pattern));
+  /**
+   * Convert `import('app/...')` paths to `import('#app/...')` subpath
+   * imports and strip `.ts` extensions.
+   */
+  #normalizeImportPaths(typeString) {
+    return typeString.replace(/import\('app\//g, "import('#app/").replace(/\.ts'\)/g, "')");
   }
-  if (except) {
-    return !except.some((pattern) => matchesPattern(route.name, pattern));
+  /**
+   * Strip server-only properties (matcher, etc.) from route tokens.
+   */
+  #sanitizeTokens(tokens) {
+    return tokens.map(({ old, type, val, end }) => ({ old, type, val, end }));
   }
-  return true;
-}
-function generateRouteParams(route) {
-  const dynamicParams = route.tokens.filter((token) => token.type === 1);
-  const paramsType = dynamicParams.map((token) => `${token.val}: ParamValue`).join("; ");
-  const paramsTuple = dynamicParams.map(() => "ParamValue").join(", ");
-  return { paramsType, paramsTuple };
-}
-function buildTreeStructure(routes) {
-  const tree = /* @__PURE__ */ new Map();
-  for (const route of routes) {
-    const segments = route.name.split(".");
-    let current = tree;
-    for (let i = 0; i < segments.length; i++) {
-      const segment = stringHelpers.camelCase(segments[i]);
-      const isLast = i === segments.length - 1;
-      if (isLast) {
-        if (current.has(segment) && current.get(segment) instanceof Map) {
-          current.get(segment).set("$self", { routeName: route.name, route });
-        } else {
-          current.set(segment, { routeName: route.name, route });
-        }
-      } else {
-        if (!current.has(segment)) {
-          current.set(segment, /* @__PURE__ */ new Map());
+  /**
+   * Extract dynamic params from route tokens and return
+   * the TS type string and tuple representation.
+   */
+  #generateRouteParams(route) {
+    const dynamicParams = route.tokens.filter((token) => token.type === 1 || token.type === 2);
+    const paramsType = dynamicParams.map((token) => {
+      if (token.type === 2) return "'*': ParamValue[]";
+      return `${token.val}: ParamValue`;
+    }).join("; ");
+    const paramsTuple = dynamicParams.map(() => "ParamValue").join(", ");
+    return { paramsType, paramsTuple };
+  }
+  /**
+   * Wrap a response type with `ExtractResponse` (and `Awaited`
+   * for `ReturnType<>`) to extract the `__response` property.
+   */
+  #wrapResponseType(responseType) {
+    if (responseType === "unknown" || responseType === "{}") return responseType;
+    if (responseType.startsWith("ReturnType<")) return `ExtractResponse<Awaited<${responseType}>>`;
+    return `ExtractResponse<${responseType}>`;
+  }
+  /**
+   * Wrap a response type with `ExtractErrorResponse` to
+   * extract non-2xx error types from the response union.
+   */
+  #wrapErrorResponseType(responseType) {
+    if (responseType === "unknown" || responseType === "{}") return "unknown";
+    if (responseType.startsWith("ReturnType<"))
+      return `ExtractErrorResponse<Awaited<${responseType}>>`;
+    return `ExtractErrorResponse<${responseType}>`;
+  }
+  /**
+   * Resolve body and query type strings based on the HTTP method.
+   * GET/HEAD routes use `ExtractQueryForGet`, others use
+   * `ExtractBody`/`ExtractQuery`.
+   */
+  #determineBodyAndQueryTypes(options) {
+    const { methods, requestType } = options;
+    const primaryMethod = methods[0];
+    const isGetLike = primaryMethod === "GET" || primaryMethod === "HEAD";
+    const hasValidator = requestType !== "{}";
+    if (!hasValidator) return { bodyType: "{}", queryType: "{}" };
+    if (isGetLike) return { bodyType: "{}", queryType: `ExtractQueryForGet<${requestType}>` };
+    return {
+      bodyType: `ExtractBody<${requestType}>`,
+      queryType: `ExtractQuery<${requestType}>`
+    };
+  }
+  /**
+   * Build a nested Map from dot-separated route names.
+   * Uses `$self` to handle nodes that are both a leaf and a prefix.
+   */
+  #buildTreeStructure(routes) {
+    const tree = /* @__PURE__ */ new Map();
+    for (const route of routes) {
+      const segments = route.name.split(".");
+      let current = tree;
+      for (let i = 0; i < segments.length; i++) {
+        const segment = stringHelpers.camelCase(segments[i]);
+        const isLast = i === segments.length - 1;
+        if (isLast) {
+          if (current.has(segment) && current.get(segment) instanceof Map) {
+            current.get(segment).set("$self", { routeName: route.name, route });
+          } else {
+            current.set(segment, { routeName: route.name, route });
+          }
         } else {
-          const existing = current.get(segment);
-          if (!(existing instanceof Map)) {
-            const newMap = /* @__PURE__ */ new Map();
-            newMap.set("$self", existing);
-            current.set(segment, newMap);
+          if (!current.has(segment)) {
+            current.set(segment, /* @__PURE__ */ new Map());
+          } else {
+            const existing = current.get(segment);
+            if (!(existing instanceof Map)) {
+              const newMap = /* @__PURE__ */ new Map();
+              newMap.set("$self", existing);
+              current.set(segment, newMap);
+            }
           }
+          current = current.get(segment);
         }
-        current = current.get(segment);
       }
     }
+    return tree;
   }
-  return tree;
-}
-function generateTreeInterface(tree, indent = 2) {
-  const spaces = " ".repeat(indent);
-  const lines = [];
-  for (const [key, value] of tree) {
-    if (key === "$self") continue;
-    if (value instanceof Map) {
-      const selfRoute = value.get("$self");
-      if (selfRoute) {
-        lines.push(`${spaces}${key}: typeof routes['${selfRoute.routeName}'] & {`);
-        lines.push(generateTreeInterface(value, indent + 2));
-        lines.push(`${spaces}}`);
+  /**
+   * Recursively emit TS interface lines from the nested tree Map.
+   * Nodes with `$self` produce intersection types.
+   */
+  #generateTreeInterface(tree, indent = 2) {
+    const spaces = " ".repeat(indent);
+    const lines = [];
+    for (const [key, value] of tree) {
+      if (key === "$self") continue;
+      if (value instanceof Map) {
+        const selfRoute = value.get("$self");
+        if (selfRoute) {
+          lines.push(`${spaces}${key}: typeof routes['${selfRoute.routeName}'] & {`);
+          lines.push(this.#generateTreeInterface(value, indent + 2));
+          lines.push(`${spaces}}`);
+        } else {
+          lines.push(`${spaces}${key}: {`);
+          lines.push(this.#generateTreeInterface(value, indent + 2));
+          lines.push(`${spaces}}`);
+        }
       } else {
-        lines.push(`${spaces}${key}: {`);
-        lines.push(generateTreeInterface(value, indent + 2));
-        lines.push(`${spaces}}`);
+        lines.push(`${spaces}${key}: typeof routes['${value.routeName}']`);
       }
-    } else {
-      lines.push(`${spaces}${key}: typeof routes['${value.routeName}']`);
     }
+    return lines.join("\n");
   }
-  return lines.join("\n");
-}
-function normalizeImportPaths(typeString) {
-  return typeString.replace(/import\('app\//g, "import('#app/").replace(/\.ts'\)/g, "')");
-}
-function sanitizeTokens(tokens) {
-  return tokens.map(({ old, type, val, end }) => ({ old, type, val, end }));
-}
-function generateRuntimeRegistryEntry(route) {
-  const routeName = route.name;
-  const sanitizedTokens = sanitizeTokens(route.tokens);
-  return `  '${routeName}': {
+  /**
+   * Generate a single runtime registry entry for a route
+   * (methods, pattern, tokens, and a typed placeholder).
+   */
+  generateRuntimeRegistryEntry(route) {
+    const routeName = route.name;
+    const sanitizedTokens = this.#sanitizeTokens(route.tokens);
+    return `  '${routeName}': {
     methods: ${JSON.stringify(route.methods)},
     pattern: '${route.pattern}',
     tokens: ${JSON.stringify(sanitizedTokens)},
     types: placeholder as Registry['${routeName}']['types'],
   }`;
-}
-function wrapResponseType(responseType) {
-  if (responseType === "unknown" || responseType === "{}") return responseType;
-  if (responseType.startsWith("ReturnType<")) {
-    return `ExtractResponse<Awaited<${responseType}>>`;
-  }
-  return `ExtractResponse<${responseType}>`;
-}
-function determineBodyAndQueryTypes(options) {
-  const { methods, requestType } = options;
-  const primaryMethod = methods[0];
-  const isGetLike = primaryMethod === "GET" || primaryMethod === "HEAD";
-  const hasValidator = requestType !== "{}";
-  if (!hasValidator) {
-    return { bodyType: "{}", queryType: "{}" };
-  }
-  if (isGetLike) {
-    return { bodyType: "{}", queryType: `ExtractQueryForGet<${requestType}>` };
   }
-  return {
-    bodyType: `ExtractBody<${requestType}>`,
-    queryType: `ExtractQuery<${requestType}>`
-  };
-}
-function generateTypesRegistryEntry(route) {
-  const requestType = normalizeImportPaths(route.request?.type || "{}");
-  const responseType = wrapResponseType(route.response?.type || "unknown");
-  const { paramsType, paramsTuple } = generateRouteParams(route);
-  const routeName = route.name;
-  const { bodyType, queryType } = determineBodyAndQueryTypes({
-    methods: route.methods,
-    requestType
-  });
-  return `  '${routeName}': {
+  /**
+   * Generate a single type-level registry entry for a route
+   * (body, query, params, response, and error response types).
+   */
+  generateTypesRegistryEntry(route) {
+    const requestType = this.#normalizeImportPaths(route.request?.type || "{}");
+    const rawResponseType = route.response?.type || "unknown";
+    const responseType = this.#wrapResponseType(rawResponseType);
+    const hasValidator = requestType !== "{}";
+    let errorResponseType = this.#wrapErrorResponseType(rawResponseType);
+    if (hasValidator && this.#validationErrorType !== false) {
+      const validationError = `{ status: 422; response: ${this.#validationErrorType} }`;
+      errorResponseType = errorResponseType === "unknown" ? validationError : `${errorResponseType} | ${validationError}`;
+    }
+    const { paramsType, paramsTuple } = this.#generateRouteParams(route);
+    const routeName = route.name;
+    const { bodyType, queryType } = this.#determineBodyAndQueryTypes({
+      methods: route.methods,
+      requestType
+    });
+    return `  '${routeName}': {
     methods: ${JSON.stringify(route.methods)}
     pattern: '${route.pattern}'
     types: {
@@ -147,12 +201,17 @@ function generateTypesRegistryEntry(route) {
       params: ${paramsType ? `{ ${paramsType} }` : "{}"}
       query: ${queryType}
       response: ${responseType}
+      errorResponse: ${errorResponseType}
     }
   }`;
-}
-function generateRuntimeContent(routes) {
-  const registryEntries = routes.map(generateRuntimeRegistryEntry).join(",\n");
-  return `/* eslint-disable prettier/prettier */
+  }
+  /**
+   * Generate the full runtime registry file (`index.ts`)
+   * with route definitions and module augmentation.
+   */
+  generateRuntimeContent(routes) {
+    const registryEntries = routes.map((route) => this.generateRuntimeRegistryEntry(route)).join(",\n");
+    return `/* eslint-disable prettier/prettier */
 import type { AdonisEndpoint } from '@tuyau/core/types'
 import type { Registry } from './schema.d.ts'
 import type { ApiDefinition } from './tree.d.ts'
@@ -177,25 +236,28 @@ declare module '@tuyau/core/types' {
   }
 }
 `;
-}
-function generateTreeContent(routes) {
-  const tree = buildTreeStructure(routes);
-  const treeInterface = generateTreeInterface(tree);
-  return `/* eslint-disable prettier/prettier */
-import type { routes } from './index.ts'
-
-export interface ApiDefinition {
-${treeInterface}
-}
-`;
-}
-function generateTypesContent(routes) {
-  const registryEntries = routes.map(generateTypesRegistryEntry).join("\n");
-  return `/* eslint-disable prettier/prettier */
+  }
+  /**
+   * Generate the types-only registry file (`schema.d.ts`)
+   * with request/response type definitions for each route.
+   */
+  generateTypesContent(routes) {
+    const registryEntries = routes.map((route) => this.generateTypesRegistryEntry(route)).join("\n");
+    const useDefaultValidationType = this.#validationErrorType === DEFAULT_VALIDATION_ERROR_TYPE;
+    const coreImports = [
+      "ExtractBody",
+      "ExtractErrorResponse",
+      "ExtractQuery",
+      "ExtractQueryForGet",
+      "ExtractResponse"
+    ];
+    const vineImports = ["InferInput"];
+    if (useDefaultValidationType) vineImports.push("SimpleError");
+    return `/* eslint-disable prettier/prettier */
 /// <reference path="../manifest.d.ts" />
 
-import type { ExtractBody, ExtractQuery, ExtractQueryForGet, ExtractResponse } from '@tuyau/core/types'
-import type { InferInput } from '@vinejs/vine/types'
+import type { ${coreImports.join(", ")} } from '@tuyau/core/types'
+import type { ${vineImports.join(", ")} } from '@vinejs/vine/types'
 
 export type ParamValue = string | number | bigint | boolean
 
@@ -203,35 +265,71 @@ export interface Registry {
 ${registryEntries}
 }
 `;
+  }
+  /**
+   * Generate the tree types file (`tree.d.ts`) with a nested
+   * interface mirroring the dot-separated route name hierarchy.
+   */
+  generateTreeContent(routes) {
+    const tree = this.#buildTreeStructure(routes);
+    const treeInterface = this.#generateTreeInterface(tree);
+    return `/* eslint-disable prettier/prettier */
+import type { routes } from './index.ts'
+
+export interface ApiDefinition {
+${treeInterface}
 }
+`;
+  }
+  /**
+   * Write a file to disk, creating parent directories if needed.
+   */
+  async #writeFile(filePath, content) {
+    const dir = dirname(filePath);
+    await mkdir(dir, { recursive: true });
+    await writeFile(filePath, content);
+  }
+  /**
+   * Generate all three registry files at once.
+   * Returns the content strings without writing to disk.
+   */
+  generate(routes) {
+    return {
+      runtime: this.generateRuntimeContent(routes),
+      types: this.generateTypesContent(routes),
+      tree: this.generateTreeContent(routes)
+    };
+  }
+  /**
+   * Generate and write all registry files (index.ts, schema.d.ts, tree.d.ts)
+   * to the given output directory.
+   */
+  async writeOutput(options) {
+    const result = this.generate(options.routes);
+    const dir = options.outputDir.replace(/\/$/, "");
+    await Promise.all([
+      this.#writeFile(`${dir}/index.ts`, result.runtime),
+      this.#writeFile(`${dir}/schema.d.ts`, result.types),
+      this.#writeFile(`${dir}/tree.d.ts`, result.tree)
+    ]);
+    return result;
+  }
+};
+
+// src/backend/generate_registry.ts
 function generateRegistry(options) {
-  const config = {
-    output: "./.adonisjs/client/registry",
-    ...options
-  };
+  const generator = new RegistryGenerator(options);
+  const outputDir = options?.output ?? "./.adonisjs/client/registry";
   return {
     async run(_, hooks) {
       hooks.add("routesScanning", (_2, routesScanner) => {
-        routesScanner.filter((route) => {
-          return filterRoute(route, config.routes);
-        });
+        routesScanner.filter((route) => generator.filterRoute(route));
       });
       hooks.add("routesScanned", async (devServer, routesScanner) => {
         const startTime = process.hrtime();
-        const scannedRoutes = routesScanner.getScannedRoutes();
-        const runtimeContent = generateRuntimeContent(scannedRoutes);
-        const typesContent = generateTypesContent(scannedRoutes);
-        const treeContent = generateTreeContent(scannedRoutes);
-        const registryDir = config.output.replace(/\/$/, "");
-        const runtimePath = `${registryDir}/index.ts`;
-        const typesPath = `${registryDir}/schema.d.ts`;
-        const treePath = `${registryDir}/tree.d.ts`;
-        await Promise.all([
-          writeOutputFile(runtimePath, runtimeContent),
-          writeOutputFile(typesPath, typesContent),
-          writeOutputFile(treePath, treeContent)
-        ]);
-        devServer.ui.logger.info(`tuyau: created api client registry (${registryDir})`, {
+        const routes = routesScanner.getScannedRoutes();
+        await generator.writeOutput({ outputDir, routes });
+        devServer.ui.logger.info(`tuyau: created api client registry (${outputDir})`, {
           startTime
         });
       });

package/build/client/index.d.ts

@@ -1,6 +1,7 @@
 import { UrlFor } from '@adonisjs/http-server/client/url_builder';
-import { TuyauRegistry, TuyauConfiguration, AdonisEndpoint, InferRoutes, TransformApiDefinition, InferTree, RegistryGroupedByMethod, PatternsByMethod, RequestArgs, EndpointByMethodPattern, StrKeys, Method } from './types/index.js';
-import { KyResponse, KyRequest, HTTPError } from 'ky';
+import { T as TuyauRegistry, a as TuyauConfiguration, A as AdonisEndpoint, I as InferRoutes, b as TransformApiDefinition, c as InferTree, R as RegistryGroupedByMethod, P as PatternsByMethod, d as RequestArgs, E as EndpointByMethodPattern, e as TuyauPromise, f as ErrorResponseOf, S as StrKeys, M as Method, C as CurrentRouteOptions } from '../index-SVztBh2W.js';
+export { g as TuyauError, h as TuyauHTTPError, i as TuyauNetworkError } from '../index-SVztBh2W.js';
+import 'ky';
 
 /**
  * Main client class for making HTTP requests to AdonisJS endpoints
@@ -20,31 +21,31 @@ declare class Tuyau<Reg extends TuyauRegistry, Routes extends Record<string, Ado
     /**
      * Makes a GET request to the specified pattern
      */
-    get<P extends PatternsByMethod<Routes, 'GET'>>(pattern: P, args: RequestArgs<EndpointByMethodPattern<Routes, 'GET', P>>): Promise<EndpointByMethodPattern<Routes, 'GET', P>['types']['response']>;
+    get<P extends PatternsByMethod<Routes, 'GET'>>(pattern: P, args: RequestArgs<EndpointByMethodPattern<Routes, 'GET', P>>): TuyauPromise<EndpointByMethodPattern<Routes, 'GET', P>['types']['response'], ErrorResponseOf<EndpointByMethodPattern<Routes, 'GET', P>>>;
     /**
      * Makes a POST request to the specified pattern
      */
-    post<P extends PatternsByMethod<Routes, 'POST'>>(pattern: P, args: RequestArgs<EndpointByMethodPattern<Routes, 'POST', P>>): Promise<EndpointByMethodPattern<Routes, 'POST', P>['types']['response']>;
+    post<P extends PatternsByMethod<Routes, 'POST'>>(pattern: P, args: RequestArgs<EndpointByMethodPattern<Routes, 'POST', P>>): TuyauPromise<EndpointByMethodPattern<Routes, 'POST', P>['types']['response'], ErrorResponseOf<EndpointByMethodPattern<Routes, 'POST', P>>>;
     /**
      * Makes a PUT request to the specified pattern
      */
-    put<P extends PatternsByMethod<Routes, 'PUT'>>(pattern: P, args: RequestArgs<EndpointByMethodPattern<Routes, 'PUT', P>>): Promise<EndpointByMethodPattern<Routes, 'PUT', P>['types']['response']>;
+    put<P extends PatternsByMethod<Routes, 'PUT'>>(pattern: P, args: RequestArgs<EndpointByMethodPattern<Routes, 'PUT', P>>): TuyauPromise<EndpointByMethodPattern<Routes, 'PUT', P>['types']['response'], ErrorResponseOf<EndpointByMethodPattern<Routes, 'PUT', P>>>;
     /**
      * Makes a PATCH request to the specified pattern
      */
-    patch<P extends PatternsByMethod<Routes, 'PATCH'>>(pattern: P, args: RequestArgs<EndpointByMethodPattern<Routes, 'PATCH', P>>): Promise<EndpointByMethodPattern<Routes, 'PATCH', P>['types']['response']>;
+    patch<P extends PatternsByMethod<Routes, 'PATCH'>>(pattern: P, args: RequestArgs<EndpointByMethodPattern<Routes, 'PATCH', P>>): TuyauPromise<EndpointByMethodPattern<Routes, 'PATCH', P>['types']['response'], ErrorResponseOf<EndpointByMethodPattern<Routes, 'PATCH', P>>>;
     /**
      * Makes a DELETE request to the specified pattern
      */
-    delete<P extends PatternsByMethod<Routes, 'DELETE'>>(pattern: P, args: RequestArgs<EndpointByMethodPattern<Routes, 'DELETE', P>>): Promise<EndpointByMethodPattern<Routes, 'DELETE', P>['types']['response']>;
+    delete<P extends PatternsByMethod<Routes, 'DELETE'>>(pattern: P, args: RequestArgs<EndpointByMethodPattern<Routes, 'DELETE', P>>): TuyauPromise<EndpointByMethodPattern<Routes, 'DELETE', P>['types']['response'], ErrorResponseOf<EndpointByMethodPattern<Routes, 'DELETE', P>>>;
     /**
      * Makes a HEAD request to the specified pattern
      */
-    head<P extends PatternsByMethod<Routes, 'HEAD'>>(pattern: P, args: RequestArgs<EndpointByMethodPattern<Routes, 'HEAD', P>>): Promise<EndpointByMethodPattern<Routes, 'HEAD', P>['types']['response']>;
+    head<P extends PatternsByMethod<Routes, 'HEAD'>>(pattern: P, args: RequestArgs<EndpointByMethodPattern<Routes, 'HEAD', P>>): TuyauPromise<EndpointByMethodPattern<Routes, 'HEAD', P>['types']['response'], ErrorResponseOf<EndpointByMethodPattern<Routes, 'HEAD', P>>>;
     /**
      * Makes a request to a named endpoint
      */
-    request<Name extends StrKeys<Routes>>(name: Name, args: RequestArgs<Routes[Name]>): Promise<Routes[Name]['types']['response']>;
+    request<Name extends StrKeys<Routes>>(name: Name, args: RequestArgs<Routes[Name]>): TuyauPromise<Routes[Name]['types']['response'], ErrorResponseOf<Routes[Name]>>;
     /**
      * Gets route information by name including URL and HTTP method
      */
@@ -52,29 +53,26 @@ declare class Tuyau<Reg extends TuyauRegistry, Routes extends Record<string, Ado
         url: string;
         methods: Method[];
     };
+    /**
+     * Checks if a route name exists in the registry.
+     */
+    has(routeName: StrKeys<Routes>): boolean;
+    /**
+     * Determines the current route based on `window.location`.
+     *
+     * - **No arguments** — returns the current route name, or `undefined`
+     *   if no route matches (or running server-side).
+     * - **With a route name** — returns `true` if the current URL matches
+     *   that route. Supports `*` wildcards.
+     * - **With options** — additionally checks that the current URL params
+     *   and/or query match the provided values.
+     */
+    current(): StrKeys<Routes> | undefined;
+    current(routeName: StrKeys<Routes> | (string & {}), options?: CurrentRouteOptions): boolean;
 }
 /**
  * Factory function to create a new Tuyau client instance
  */
 declare function createTuyau<Reg extends TuyauRegistry>(config: TuyauConfiguration<Reg>): Tuyau<Reg, InferRoutes<Reg>>;
 
-declare function parseResponse(response?: KyResponse): Promise<unknown>;
-declare class TuyauHTTPError extends Error {
-    status: number | undefined;
-    rawResponse: KyResponse | undefined;
-    rawRequest: KyRequest | undefined;
-    response: any;
-    constructor(kyError: HTTPError, response: any);
-}
-/**
- * Network error that occurs when the server is unreachable or the client is offline
- */
-declare class TuyauNetworkError extends Error {
-    cause: Error;
-    constructor(cause: Error, request?: {
-        url: string;
-        method: string;
-    });
-}
-
-export { Tuyau, TuyauHTTPError, TuyauNetworkError, createTuyau, parseResponse };
+export { Tuyau, TuyauPromise, createTuyau };