routesync 1.0.0

package/dist/cli.js

@@ -0,0 +1,436 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// packages/cli/src/index.ts
+var import_commander5 = require("commander");
+
+// packages/cli/src/commands/scan.ts
+var import_commander = require("commander");
+var import_ora = __toESM(require("ora"));
+var import_chalk = __toESM(require("chalk"));
+
+// packages/cli/src/parsers/LaravelRouteParser.ts
+var import_fs_extra = __toESM(require("fs-extra"));
+var LaravelRouteParser = class {
+  async parse(filePath) {
+    const content = await import_fs_extra.default.readFile(filePath, "utf-8");
+    return this.parseContent(content);
+  }
+  parseContent(content) {
+    const routes = [];
+    const lines = content.split("\n");
+    let currentAuth = false;
+    let currentMiddleware = [];
+    let insideAuthGroup = false;
+    let insideAdminGroup = false;
+    let braceDepth = 0;
+    let groupBraceDepth = 0;
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.includes("middleware('auth:sanctum')")) {
+        insideAuthGroup = true;
+        currentAuth = true;
+        groupBraceDepth = braceDepth;
+      }
+      if (trimmed.includes("middleware(['auth:sanctum', 'admin'])")) {
+        insideAdminGroup = true;
+        currentMiddleware = ["auth:sanctum", "admin"];
+        groupBraceDepth = braceDepth;
+      }
+      braceDepth += (trimmed.match(/{/g) ?? []).length;
+      braceDepth -= (trimmed.match(/}/g) ?? []).length;
+      if (braceDepth <= groupBraceDepth && insideAuthGroup) {
+        insideAuthGroup = false;
+        currentAuth = false;
+      }
+      if (braceDepth <= groupBraceDepth && insideAdminGroup) {
+        insideAdminGroup = false;
+        currentMiddleware = [];
+      }
+      const routeMatch = trimmed.match(
+        /Route::(get|post|put|patch|delete|match)\(['"]([^'"]+)['"]/i
+      );
+      if (routeMatch) {
+        const method = routeMatch[1].toUpperCase();
+        const path5 = routeMatch[2];
+        routes.push({
+          name: this.inferName(method, path5),
+          method,
+          path: path5,
+          auth: insideAuthGroup || insideAdminGroup,
+          middleware: insideAdminGroup ? ["admin"] : []
+        });
+      }
+    }
+    return routes;
+  }
+  inferName(method, path5) {
+    const parts = path5.replace(/^\//, "").split("/");
+    const resource = parts[0] ?? "resource";
+    const hasId = parts.some((p) => p.startsWith("{"));
+    const map = {
+      GET: hasId ? `${resource}.show` : `${resource}.index`,
+      POST: `${resource}.store`,
+      PUT: `${resource}.update`,
+      PATCH: `${resource}.update`,
+      DELETE: `${resource}.destroy`
+    };
+    return map[method] ?? `${resource}.action`;
+  }
+};
+
+// packages/cli/src/generators/ManifestGenerator.ts
+var import_fs_extra2 = __toESM(require("fs-extra"));
+var ManifestGenerator = class {
+  static generate(routes, baseURL) {
+    return {
+      version: "1.0.0",
+      baseURL,
+      routes,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  static async save(manifest, outputPath) {
+    await import_fs_extra2.default.writeJson(outputPath, manifest, { spaces: 2 });
+  }
+};
+
+// packages/cli/src/commands/scan.ts
+var scanCommand = new import_commander.Command("scan").description("Scan Laravel/PHP routes and output a route manifest").option("-i, --input <path>", "Path to routes/api.php", "routes/api.php").option("-o, --output <path>", "Output manifest path", "routesync.manifest.json").option("-b, --baseURL <url>", "API base URL", "http://localhost/api").action(async (options) => {
+  const spinner = (0, import_ora.default)("Scanning routes...").start();
+  try {
+    const parser = new LaravelRouteParser();
+    const routes = await parser.parse(options.input);
+    const manifest = ManifestGenerator.generate(routes, options.baseURL);
+    await ManifestGenerator.save(manifest, options.output);
+    spinner.succeed(
+      import_chalk.default.green(`Found ${routes.length} routes \u2192 ${options.output}`)
+    );
+    routes.forEach((r) => {
+      console.log(
+        `  ${import_chalk.default.cyan(r.method.padEnd(7))} ${import_chalk.default.white(r.path)} ${r.auth ? import_chalk.default.yellow("[auth]") : ""}`
+      );
+    });
+  } catch (err) {
+    spinner.fail(import_chalk.default.red(`Scan failed: ${err.message}`));
+    process.exit(1);
+  }
+});
+
+// packages/cli/src/commands/generate.ts
+var import_commander2 = require("commander");
+var import_ora2 = __toESM(require("ora"));
+var import_chalk2 = __toESM(require("chalk"));
+
+// packages/cli/src/generators/SDKGenerator.ts
+var import_path = __toESM(require("path"));
+var import_fs_extra3 = __toESM(require("fs-extra"));
+var SDKGenerator = class _SDKGenerator {
+  static async generate(manifest, outputDir) {
+    const grouped = _SDKGenerator.groupByResource(manifest.routes);
+    const lines = [];
+    lines.push(`// Auto-generated by routesync. Do not edit manually.`);
+    lines.push(`// Generated at: ${manifest.generatedAt}`);
+    lines.push(``);
+    lines.push(`import { defineApi } from '@routesync/sdk'`);
+    lines.push(``);
+    lines.push(`export const api = defineApi({`);
+    for (const [group, routes] of Object.entries(grouped)) {
+      lines.push(`  ${group}: {`);
+      for (const route of routes) {
+        const actionName = _SDKGenerator.toActionName(route);
+        lines.push(`    ${actionName}: {`);
+        lines.push(`      method: '${route.method}',`);
+        lines.push(`      path: '${route.path}',`);
+        if (route.auth) lines.push(`      auth: true,`);
+        lines.push(`    },`);
+      }
+      lines.push(`  },`);
+    }
+    lines.push(`})`);
+    lines.push(``);
+    lines.push(`export default api`);
+    await import_fs_extra3.default.writeFile(import_path.default.join(outputDir, "api.ts"), lines.join("\n"));
+  }
+  static groupByResource(routes) {
+    const groups = {};
+    for (const route of routes) {
+      const parts = route.path.replace(/^\//, "").split("/");
+      const group = parts[0]?.replace(/-/g, "_") ?? "root";
+      if (!groups[group]) groups[group] = [];
+      groups[group].push(route);
+    }
+    return groups;
+  }
+  static toActionName(route) {
+    const parts = route.path.replace(/^\//, "").split("/");
+    const method = route.method.toLowerCase();
+    const hasId = parts.some((p) => p.startsWith("{"));
+    if (method === "get" && !hasId) return "index";
+    if (method === "get" && hasId) return "show";
+    if (method === "post") return "store";
+    if (method === "put" || method === "patch") return "update";
+    if (method === "delete") return "destroy";
+    return `${method}Action`;
+  }
+};
+
+// packages/cli/src/generators/TypeGenerator.ts
+var import_path2 = __toESM(require("path"));
+var import_fs_extra4 = __toESM(require("fs-extra"));
+var TypeGenerator = class _TypeGenerator {
+  static async generate(manifest, outputDir) {
+    const lines = [];
+    lines.push(`// Auto-generated by routesync. Do not edit manually.`);
+    lines.push(``);
+    lines.push(`export interface ApiResponse<T = any> {`);
+    lines.push(`  success: boolean`);
+    lines.push(`  message?: string`);
+    lines.push(`  data: T`);
+    lines.push(`  meta?: PaginationMeta`);
+    lines.push(`}`);
+    lines.push(``);
+    lines.push(`export interface PaginationMeta {`);
+    lines.push(`  current_page: number`);
+    lines.push(`  last_page: number`);
+    lines.push(`  per_page: number`);
+    lines.push(`  total: number`);
+    lines.push(`}`);
+    lines.push(``);
+    lines.push(`export interface ApiError {`);
+    lines.push(`  success: false`);
+    lines.push(`  message: string`);
+    lines.push(`  errors?: Record<string, string[]>`);
+    lines.push(`  status?: number`);
+    lines.push(`}`);
+    lines.push(``);
+    const resources = new Set(
+      manifest.routes.map((r) => r.path.replace(/^\//, "").split("/")[0])
+    );
+    for (const resource of resources) {
+      const typeName = _TypeGenerator.toTypeName(resource ?? "");
+      lines.push(`export interface ${typeName} {`);
+      lines.push(`  id: number`);
+      lines.push(`  // TODO: Add ${resource} fields`);
+      lines.push(`  created_at?: string`);
+      lines.push(`  updated_at?: string`);
+      lines.push(`}`);
+      lines.push(``);
+    }
+    await import_fs_extra4.default.writeFile(import_path2.default.join(outputDir, "types.ts"), lines.join("\n"));
+  }
+  static toTypeName(resource) {
+    return resource.replace(/-_/g, " ").split(/[-_]/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
+  }
+};
+
+// packages/cli/src/generators/HookGenerator.ts
+var import_path3 = __toESM(require("path"));
+var import_fs_extra5 = __toESM(require("fs-extra"));
+var HookGenerator = class _HookGenerator {
+  static async generate(manifest, outputDir) {
+    const lines = [];
+    lines.push(`// Auto-generated by routesync. Do not edit manually.`);
+    lines.push(``);
+    lines.push(`import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'`);
+    lines.push(`import { api } from './api'`);
+    lines.push(``);
+    const grouped = _HookGenerator.groupByResource(manifest.routes);
+    for (const [group, routes] of Object.entries(grouped)) {
+      const typeName = _HookGenerator.toTypeName(group);
+      for (const route of routes) {
+        const method = route.method.toUpperCase();
+        const hookName = _HookGenerator.toHookName(group, route);
+        const queryKey = `['${group}']`;
+        if (method === "GET") {
+          lines.push(`export function ${hookName}(params?: Record<string, any>) {`);
+          lines.push(`  return useQuery({`);
+          lines.push(`    queryKey: ${queryKey},`);
+          lines.push(`    queryFn: () => api.${group}.${_HookGenerator.toActionName(route)}({ query: params })`);
+          lines.push(`  })`);
+          lines.push(`}`);
+          lines.push(``);
+        } else {
+          lines.push(`export function ${hookName}() {`);
+          lines.push(`  const queryClient = useQueryClient()`);
+          lines.push(`  return useMutation({`);
+          lines.push(`    mutationFn: (data: any) => api.${group}.${_HookGenerator.toActionName(route)}({ body: data }),`);
+          lines.push(`    onSuccess: () => {`);
+          lines.push(`      queryClient.invalidateQueries({ queryKey: ${queryKey} })`);
+          lines.push(`    }`);
+          lines.push(`  })`);
+          lines.push(`}`);
+          lines.push(``);
+        }
+      }
+    }
+    await import_fs_extra5.default.writeFile(import_path3.default.join(outputDir, "hooks.ts"), lines.join("\n"));
+  }
+  static groupByResource(routes) {
+    const groups = {};
+    for (const route of routes) {
+      const group = route.path.replace(/^\//, "").split("/")[0]?.replace(/-/g, "_") ?? "root";
+      if (!groups[group]) groups[group] = [];
+      groups[group].push(route);
+    }
+    return groups;
+  }
+  static toHookName(group, route) {
+    const method = route.method.toUpperCase();
+    const name = _HookGenerator.toTypeName(group);
+    const hasId = route.path.includes("{");
+    if (method === "GET" && !hasId) return `use${name}List`;
+    if (method === "GET" && hasId) return `use${name}Detail`;
+    if (method === "POST") return `useCreate${name}`;
+    if (method === "PUT" || method === "PATCH") return `useUpdate${name}`;
+    if (method === "DELETE") return `useDelete${name}`;
+    return `use${name}Action`;
+  }
+  static toActionName(route) {
+    const method = route.method.toLowerCase();
+    const hasId = route.path.includes("{");
+    if (method === "get" && !hasId) return "index";
+    if (method === "get" && hasId) return "show";
+    if (method === "post") return "store";
+    if (method === "put" || method === "patch") return "update";
+    if (method === "delete") return "destroy";
+    return "action";
+  }
+  static toTypeName(resource) {
+    return resource.split(/[-_]/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
+  }
+};
+
+// packages/cli/src/commands/generate.ts
+var import_fs_extra6 = __toESM(require("fs-extra"));
+var generateCommand = new import_commander2.Command("generate").description("Generate typed SDK, types, and hooks from route manifest").option("-m, --manifest <path>", "Path to route manifest", "routesync.manifest.json").option("-o, --output <path>", "Output directory", "src/api").option("--no-hooks", "Skip generating React hooks").action(async (options) => {
+  const spinner = (0, import_ora2.default)("Generating SDK...").start();
+  try {
+    if (!import_fs_extra6.default.existsSync(options.manifest)) {
+      throw new Error(
+        `Manifest not found: ${options.manifest}. Run 'routesync scan' first.`
+      );
+    }
+    const manifest = await import_fs_extra6.default.readJson(options.manifest);
+    await import_fs_extra6.default.ensureDir(options.output);
+    spinner.text = "Generating types...";
+    await TypeGenerator.generate(manifest, options.output);
+    spinner.text = "Generating SDK...";
+    await SDKGenerator.generate(manifest, options.output);
+    if (options.hooks !== false) {
+      spinner.text = "Generating hooks...";
+      await HookGenerator.generate(manifest, options.output);
+    }
+    spinner.succeed(import_chalk2.default.green(`SDK generated \u2192 ${options.output}`));
+    console.log(`  ${import_chalk2.default.cyan("api.ts")}     Typed API client`);
+    console.log(`  ${import_chalk2.default.cyan("types.ts")}   Response/request types`);
+    if (options.hooks !== false) {
+      console.log(`  ${import_chalk2.default.cyan("hooks.ts")}   React Query hooks`);
+    }
+  } catch (err) {
+    spinner.fail(import_chalk2.default.red(`Generate failed: ${err.message}`));
+    process.exit(1);
+  }
+});
+
+// packages/cli/src/commands/sync.ts
+var import_commander3 = require("commander");
+var import_ora3 = __toESM(require("ora"));
+var import_chalk3 = __toESM(require("chalk"));
+var import_fs_extra7 = __toESM(require("fs-extra"));
+var syncCommand = new import_commander3.Command("sync").description("Scan routes and generate SDK in one step").option("-i, --input <path>", "Path to routes/api.php", "routes/api.php").option("-o, --output <path>", "Output directory", "src/api").option("-b, --baseURL <url>", "API base URL", "http://localhost/api").option("--no-hooks", "Skip generating React hooks").action(async (options) => {
+  console.log(import_chalk3.default.bold.blue("\n  routesync sync\n"));
+  const steps = [
+    { text: "Scanning Laravel routes" },
+    { text: "Generating types" },
+    { text: "Generating SDK" },
+    { text: "Generating hooks" }
+  ];
+  const spinner = (0, import_ora3.default)(steps[0].text).start();
+  try {
+    const parser = new LaravelRouteParser();
+    const routes = await parser.parse(options.input);
+    const manifest = ManifestGenerator.generate(routes, options.baseURL);
+    spinner.succeed(import_chalk3.default.green(`\u2714 ${steps[0].text} (${routes.length} routes)`));
+    await import_fs_extra7.default.ensureDir(options.output);
+    spinner.start(steps[1].text);
+    await TypeGenerator.generate(manifest, options.output);
+    spinner.succeed(import_chalk3.default.green(`\u2714 ${steps[1].text}`));
+    spinner.start(steps[2].text);
+    await SDKGenerator.generate(manifest, options.output);
+    spinner.succeed(import_chalk3.default.green(`\u2714 ${steps[2].text}`));
+    if (options.hooks !== false) {
+      spinner.start(steps[3].text);
+      await HookGenerator.generate(manifest, options.output);
+      spinner.succeed(import_chalk3.default.green(`\u2714 ${steps[3].text}`));
+    }
+    console.log(import_chalk3.default.bold.green("\n  Sync complete!\n"));
+    console.log(`  Output: ${import_chalk3.default.cyan(options.output)}`);
+  } catch (err) {
+    spinner.fail(import_chalk3.default.red(`Sync failed: ${err.message}`));
+    process.exit(1);
+  }
+});
+
+// packages/cli/src/commands/watch.ts
+var import_commander4 = require("commander");
+var import_chalk4 = __toESM(require("chalk"));
+var import_fs_extra8 = __toESM(require("fs-extra"));
+var import_path4 = __toESM(require("path"));
+var watchCommand = new import_commander4.Command("watch").description("Watch routes file and re-sync on changes").option("-i, --input <path>", "Path to routes/api.php", "routes/api.php").option("-o, --output <path>", "Output directory", "src/api").option("-b, --baseURL <url>", "API base URL", "http://localhost/api").action(async (options) => {
+  console.log(import_chalk4.default.bold.blue("\n  routesync watch\n"));
+  console.log(`  Watching: ${import_chalk4.default.cyan(options.input)}`);
+  console.log(import_chalk4.default.gray("  Press Ctrl+C to stop\n"));
+  let debounceTimer;
+  const onChange = () => {
+    clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(async () => {
+      console.log(import_chalk4.default.yellow(`  [${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] Routes changed, syncing...`));
+      try {
+        const { execSync } = await import("child_process");
+        execSync(
+          `routesync sync --input ${options.input} --output ${options.output} --baseURL ${options.baseURL}`,
+          { stdio: "inherit" }
+        );
+      } catch {
+        console.error(import_chalk4.default.red("  Sync failed"));
+      }
+    }, 300);
+  };
+  if (!import_fs_extra8.default.existsSync(options.input)) {
+    console.error(import_chalk4.default.red(`  File not found: ${options.input}`));
+    process.exit(1);
+  }
+  import_fs_extra8.default.watch(import_path4.default.resolve(options.input), onChange);
+});
+
+// packages/cli/src/index.ts
+var program = new import_commander5.Command();
+program.name("routesync").description("Laravel routes to typed frontend SDKs").version("1.0.0");
+program.addCommand(scanCommand);
+program.addCommand(generateCommand);
+program.addCommand(syncCommand);
+program.addCommand(watchCommand);
+program.parse(process.argv);

package/dist/core.d.mts

@@ -0,0 +1,206 @@
+import { AxiosRequestConfig, AxiosInstance, InternalAxiosRequestConfig, AxiosResponse } from 'axios';
+
+interface ServiceConfig {
+    baseURL: string;
+    token?: string;
+    headers?: Record<string, string>;
+    timeout?: number;
+    retry?: RetryConfig;
+    cache?: boolean;
+}
+interface RetryConfig {
+    attempts: number;
+    delay?: number;
+    statusCodes?: number[];
+}
+interface AuthConfig {
+    type: 'bearer' | 'basic' | 'api-key';
+    token?: string;
+    apiKey?: string;
+    apiKeyHeader?: string;
+}
+
+declare class HttpClient {
+    private client;
+    constructor(config: ServiceConfig);
+    private setupInterceptors;
+    setToken(token: string): void;
+    removeToken(): void;
+    get<T>(url: string, config?: AxiosRequestConfig): Promise<T>;
+    post<T>(url: string, body?: any, config?: AxiosRequestConfig): Promise<T>;
+    put<T>(url: string, body?: any, config?: AxiosRequestConfig): Promise<T>;
+    patch<T>(url: string, body?: any, config?: AxiosRequestConfig): Promise<T>;
+    delete<T>(url: string, config?: AxiosRequestConfig): Promise<T>;
+    upload<T>(url: string, formData: FormData): Promise<T>;
+    getInstance(): AxiosInstance;
+}
+
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+type RouteTransform = (value: unknown) => unknown;
+interface RouteTransformMap {
+    params?: RouteTransform;
+    query?: RouteTransform;
+    body?: RouteTransform;
+    request?: RouteTransform;
+    response?: RouteTransform;
+}
+type RouteMapper = RouteTransform | RouteTransformMap;
+interface RouteParserSchema {
+    parse?: RouteTransform;
+    safeParse?: RouteTransform;
+}
+interface RouteSchemaMap {
+    params?: RouteSchemaValue;
+    query?: RouteSchemaValue;
+    body?: RouteSchemaValue;
+    request?: RouteSchemaValue;
+    response?: RouteSchemaValue;
+}
+type RouteSchemaValue = RouteTransform | RouteParserSchema;
+type RouteSchema = RouteSchemaValue | RouteSchemaMap;
+interface RequestOptions {
+    params?: Record<string, any>;
+    headers?: Record<string, string>;
+    timeout?: number;
+    signal?: AbortSignal;
+}
+interface RouteDefinition {
+    method: HttpMethod;
+    path: string;
+    auth?: boolean;
+    schema?: RouteSchema;
+    mapper?: RouteMapper;
+    headers?: Record<string, string>;
+    cache?: unknown;
+    retry?: unknown;
+    body?: Record<string, any>;
+    params?: Record<string, any>;
+    query?: Record<string, any>;
+}
+interface ApiDefinition {
+    [group: string]: {
+        [action: string]: RouteDefinition;
+    };
+}
+
+declare class Request {
+    private _url;
+    private _method;
+    private _body?;
+    private _options?;
+    url(url: string): this;
+    method(method: HttpMethod): this;
+    body(data: any): this;
+    options(opts: RequestOptions): this;
+    build(): {
+        url: string;
+        method: HttpMethod;
+        body: any;
+        options: RequestOptions | undefined;
+    };
+}
+
+interface ApiResponse<T = any> {
+    success: boolean;
+    message?: string;
+    data: T;
+    meta?: PaginationMeta;
+}
+interface PaginationMeta {
+    current_page: number;
+    last_page: number;
+    per_page: number;
+    total: number;
+    from?: number;
+    to?: number;
+}
+
+declare class Response<T = any> {
+    private raw;
+    constructor(raw: ApiResponse<T>);
+    get data(): T;
+    get success(): boolean;
+    get message(): string | undefined;
+    isOk(): boolean;
+    unwrap(): T;
+}
+
+type RequestInterceptor = (config: InternalAxiosRequestConfig) => InternalAxiosRequestConfig | Promise<InternalAxiosRequestConfig>;
+type ResponseInterceptor = (response: AxiosResponse) => AxiosResponse | Promise<AxiosResponse>;
+type ErrorInterceptor = (error: any) => any;
+declare class Interceptor {
+    private client;
+    constructor(client: AxiosInstance);
+    addRequestInterceptor(onFulfilled: RequestInterceptor, onRejected?: ErrorInterceptor): number;
+    addResponseInterceptor(onFulfilled: ResponseInterceptor, onRejected?: ErrorInterceptor): number;
+    removeRequestInterceptor(id: number): void;
+    removeResponseInterceptor(id: number): void;
+}
+
+declare class TokenManager {
+    private static TOKEN_KEY;
+    private token;
+    set(token: string): void;
+    get(): string | null;
+    clear(): void;
+    exists(): boolean;
+}
+
+declare class AuthMiddleware {
+    private tokenManager;
+    constructor(tokenManager: TokenManager);
+    inject(config: InternalAxiosRequestConfig): InternalAxiosRequestConfig;
+    getAuthHeader(): Record<string, string>;
+}
+
+declare class PathResolver {
+    /**
+     * Resolve path params.
+     * e.g. resolvePath('/produk/:id', { id: 10 }) => '/produk/10'
+     */
+    static resolve(path: string, params?: Record<string, any>): string;
+    static extractParams(path: string): string[];
+    static hasParams(path: string): boolean;
+}
+
+declare class QueryBuilder {
+    static build(params?: Record<string, any>): string;
+    static append(url: string, params?: Record<string, any>): string;
+}
+
+declare class ApiError extends Error {
+    readonly status?: number;
+    readonly errors?: Record<string, string[]>;
+    readonly success = false;
+    constructor(message: string, status?: number, errors?: Record<string, string[]>);
+    isUnauthorized(): boolean;
+    isForbidden(): boolean;
+    isNotFound(): boolean;
+    isValidationError(): boolean;
+    isServerError(): boolean;
+    getFirstError(field: string): string | undefined;
+    getAllErrors(): string[];
+}
+
+declare class ErrorHandler {
+    static handle(error: any): never;
+    static isApiError(error: unknown): error is ApiError;
+}
+
+interface RouteManifest {
+    version: string;
+    baseURL: string;
+    routes: ParsedRoute[];
+    generatedAt: string;
+}
+interface ParsedRoute {
+    name: string;
+    method: string;
+    path: string;
+    auth: boolean;
+    middleware: string[];
+    group?: string;
+    action?: string;
+}
+
+export { type ApiDefinition, ApiError, type ApiResponse, type AuthConfig, AuthMiddleware, ErrorHandler, HttpClient, type HttpMethod, Interceptor, type PaginationMeta, type ParsedRoute, PathResolver, QueryBuilder, Request, type RequestOptions, Response, type RetryConfig, type RouteDefinition, type RouteManifest, type RouteMapper, type RouteParserSchema, type RouteSchema, type RouteSchemaMap, type RouteSchemaValue, type RouteTransform, type RouteTransformMap, type ServiceConfig, TokenManager };