hono-takibi 0.9.1 → 0.9.5

package/README.md

@@ -33,31 +33,6 @@ If you have OpenAPI specifications, Hono Takibi automates the conversion process
 npx hono-takibi path/to/input.{yaml,json,tsp} -o path/to/output.ts
 ```
 
-## CLI
-
-### Options
-
-basic
-
-```bash
-Options:
-  --export-type        export TypeScript type aliases
-  --export-schema      export Zod schema objects
-  --template           generate app file and handler stubs
-  --test               generate empty *.test.ts files
-  --base-path <path>   api prefix (default: /)
-```
-
-template
-
-> **⚠️** When using the `--template` option, you must specify a valid directory path. Ensure the directory exists before executing the 
-
-### Example
-
-```bash
-npx hono-takibi path/to/input.{yaml,json,tsp} -o path/to/output.ts --export-type --export-schema --template --base-path '/api/v1'
-```
-
 input:
 
 ```yaml
@@ -112,101 +87,177 @@ export const getRoute = createRoute({
 
 ![](https://raw.githubusercontent.com/nakita628/hono-takibi/refs/heads/main/assets/demo/hono-takibi.gif)
 
-## HonoTakibiVite
+## CLI
 
-### Automatic Code Regeneration & HMR
+### Options
 
-With **HonoTakibiVite**, saving your OpenAPI spec while the Vite dev server is running instantly regenerates the code.
+basic
 
-### OpenAPI Schema Requirements
+```bash
+Options:
+  --export-type        export TypeScript type aliases
+  --export-schema      export Zod schema objects
+  --template           generate app file and handler stubs
+  --test               generate empty *.test.ts files
+  --base-path <path>   api prefix (default: /)
+```
 
-- Your OpenAPI definition must include **only the `#/components/schemas/` section**.
-- It must be fully compliant with **OpenAPI 3.0 or later (e.g., 3.0 or 3.1)**.
-- Do **not** include `paths`, `tags`, or any other OpenAPI sections.
+template
 
-### Supported Input Formats
+> **⚠️** When using the `--template` option, you must specify a valid directory path. Ensure the directory exists before executing the 
 
-You may specify the input file in one of the following formats:
+### Example
 
-- `.yaml` — OpenAPI YAML (schemas only)
-- `.json` — OpenAPI JSON (schemas only)
-- `.tsp` — TypeSpec source file
+```bash
+npx hono-takibi path/to/input.{yaml,json,tsp} -o path/to/output.ts --export-type --export-schema --template --base-path '/api/v1'
+```
 
-### TypeSpec Setup (if using `.tsp`)
+## Configuration File (`hono-takibi.config.ts`)
 
-If you use a `.tsp` TypeSpec file, you must set up the TypeSpec environment and install required libraries:
+Config used by both the CLI and the Vite plugin.
 
-- @typespec/http
-- @typespec/rest
-- ...other
+## Essentials
 
-### Example
+* Put **`hono-takibi.config.ts`** at repo root.
+* Default‑export with `defineConfig(...)`.
+* `input`: **`openapi.yaml`** (recommended), or `*.json` / `*.tsp`.
 
-`vite.config.ts`
+> **About `split`**
+>
+> * `split: true` → `output` is a **directory**; many files + `index.ts`.
+> * `split` **omitted** or `false` → `output` is a **single `*.ts` file** (one file only).
+
+---
+
+## Single‑file
+
+One file. Set top‑level `output` (don’t define `schema`/`route`).
 
 ```ts
-import { defineConfig } from 'vite'
-import HonoTakibiVite from 'hono-takibi/vite-plugin'
+import { defineConfig } from 'hono-takibi/config'
 
 export default defineConfig({
-  plugins: [
-    HonoTakibiVite({
-      input: 'main.tsp',
-      output: 'index.ts',
-      exportType: true,
-      exportSchema: true,
-    }),
-  ],
+  input: 'openapi.yaml',
+  'zod-openapi': {
+    output: './src/index.ts',
+    exportSchema: true,
+    exportType: true,
+  },
 })
 ```
 
-### Demo
+---
 
-![](https://raw.githubusercontent.com/nakita628/hono-takibi/refs/heads/main/assets/vite/hono-takibi-vite.gif)
+## Schemas & Routes
+
+Define **both** `schema` and `route` (don’t set top‑level `output`).
+
+```ts
+import { defineConfig } from 'hono-takibi/config'
+
+export default defineConfig({
+  input: 'openapi.yaml',
+  'zod-openapi': {
+    // split ON → outputs are directories
+    schema: { output: './src/schemas', split: true },
+    route: { output: './src/routes', import: '../schemas', split: true },
+
+    // split OFF example (one file each):
+    // schema: { output: './src/schemas/index.ts' },
+    // route: { output: './src/routes/index.ts', import: '../schemas' },
+  },
+})
+```
+
+---
+
+## RPC (optional)
+
+Works with either pattern.
+
+* `split: true` → `output` is a **directory**; many files + `index.ts`.
+* `split` **omitted** or `false` → `output` is **one `*.ts` file**.
+
+**Example (split: true)**
+
+```ts
+import { defineConfig } from 'hono-takibi/config'
 
+export default defineConfig({
+  input: 'openapi.yaml',
+  'zod-openapi': { output: './src/index.ts', exportSchema: true, exportType: true },
+  rpc: { output: './src/rpc', import: '../client', split: true },
+})
+```
 
-## With AI Prompt
+**Example (single file; split omitted/false)**
 
-### Sample Prompt — Schemas-Only Extractor (OpenAPI 3+)
+```ts
+import { defineConfig } from 'hono-takibi/config'
 
-A copy‑and‑paste prompt for **any LLM** that extracts **only** the contents of `#/components/schemas/` from an OpenAPI document.
+export default defineConfig({
+  input: 'openapi.yaml',
+  'zod-openapi': { output: './src/index.ts', exportSchema: true, exportType: true },
+  rpc: { output: './src/rpc/index.ts', import: '../client' },
+})
+```
+
+---
+
+## Vite Plugin (`honoTakibiVite`)
 
-## Prompt　Example
+Auto‑regenerates on changes and reloads dev server.
 
-```md
-You are a **Schemas‑Only Extractor** for OpenAPI 3+.
+```ts
+// vite.config.ts
+import { honoTakibiVite } from 'hono-takibi/vite-plugin'
+import { defineConfig } from 'vite'
+
+export default defineConfig({
+  plugins: [honoTakibiVite()],
+})
+```
+
+**What it does**
+
+* **Watches**: the config, your `input`, and nearby `**/*.{yaml,json,tsp}`.
+* **Generates** outputs per your config (single‑file or split, plus `rpc`).
+* **Cleans** old generated files safely when paths or `split` change.
+
+That’s it — set `input`, choose one of the two patterns, and (optionally) add `rpc`. ✅
+
+### Demo (Vite + HMR)
+
+![](https://raw.githubusercontent.com/nakita628/hono-takibi/refs/heads/main/assets/vite/hono-takibi-vite.gif)
 
-## 1. Version
-- Accept files that start with `openapi: "3.0.0"` or newer.
-- Otherwise reply with: `Unsupported OpenAPI version (must be 3.0+).`
 
-## 2. Scope
-- Look **only** inside `#/components/schemas/`. Ignore everything else.
-- `$ref` must also point inside that section.
+## AI Prompt Example
 
-## 3. Schemas section present?
-- If `components.schemas` is missing, reply with: `Missing '#/components/schemas/' section. Cannot proceed.`
+```sh
+Generate one **OpenAPI 3.x+** YAML (prefer **3.1.0**).
 
-## 4. File type
-- Accept **.yaml**, **.json**, or **.tsp** files.
-- Otherwise reply with: `Unsupported input file extension.`
+Rules:
+- Use only `components.schemas` (no other `components`).
+- Never include `parameters:`.
+- No path params; all inputs in `requestBody` (`application/json`) with `$ref: '#/components/schemas/*'`.
+- All responses use `application/json` with `$ref: '#/components/schemas/*'`.
+- POST-only action routes: `/resource/create|get|search|update|delete`.
+- No inline schemas in `paths`.
 
-## Format tips
-- `format: uuid` usually means **UUID v4**.
-- Other accepted identifiers include `uuidv6`, `uuidv7`, `ulid`, `cuid`, etc.
-- With **hono‑takibi**, you can generate **Zod schemas** directly from a custom OpenAPI file.
+Fill, then generate:
+- title / version / tags
+- resources & fields
+- ops per resource: create / get / search / update / delete
 
-## What the LLM should do
-1. Validate the file with the four rules above.
-2. If it passes, output **only** the YAML/JSON fragment under `#/components/schemas/` (preserve indentation).
-3. Otherwise, output the exact error message above—nothing more.
+**Output format (strict):**
+- Return a **single fenced code block** labeled `yaml` that contains **only** the YAML.
+- No text before or after the code block.
 ```
 
 ### ⚠️ WARNING: Potential Breaking Changes Without Notice
 
 **This package is in active development and may introduce breaking changes without prior notice.**
 Specifically:
-- Query parameter coercion behavior may change
 - Schema generation logic might be updated
 - Output code structure could be modified
 - Example value handling might be altered

package/dist/cli/index.d.ts

@@ -5,17 +5,16 @@
  *
  * ```mermaid
  * flowchart TD
- *   A["Start honoTakibi()"] --> B["args = process.argv.slice(2)"]
- *   B --> C{"isHelpRequested(args) ?"}
- *   C -->|Yes| D["return { ok:true, value: HELP_TEXT }"]
- *   C -->|No| E["cliResult = parseCli(args)"]
- *   E --> F{"cliResult.ok ?"}
- *   F -->|No| G["return { ok:false, error: cliResult.error }"]
- *   F -->|Yes| H["cli = cliResult.value"]
- *   H --> I["takibiResult = await takibi(cli.input, cli.output, ...options)"]
- *   I --> J{"takibiResult.ok ?"}
- *   J -->|No| K["return { ok:false, error: takibiResult.error }"]
- *   J -->|Yes| L["return { ok:true, value: takibiResult.value }"]
+ *   A["Start honoTakibi"] --> B["Parse args"]
+ *   B --> C{"Help requested?"}
+ *   C -- Yes --> D["Return help text"]
+ *   C -- No --> E["parseCli(args)"]
+ *   E --> F{"cliResult.ok?"}
+ *   F -- No --> G["Return parse error"]
+ *   F -- Yes --> H["Run takibi"]
+ *   H --> I{"takibi.ok?"}
+ *   I -- No --> J["Return takibi error"]
+ *   I -- Yes --> K["Return success message"]
  * ```
  *
  * **Options**
@@ -31,9 +30,9 @@
  * - `{ ok: false, error: string }` on validation or generation errors
  */
 export declare function honoTakibi(): Promise<{
-    ok: true;
-    value: string;
+    readonly ok: true;
+    readonly value: string;
 } | {
-    ok: false;
-    error: string;
+    readonly ok: false;
+    readonly error: string;
 }>;

package/dist/cli/index.js

@@ -1,9 +1,16 @@
 import { existsSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { config } from '../config/index.js';
+import { route } from '../core/route.js';
 import { rpc } from '../core/rpc.js';
+import { schema } from '../core/schema.js';
 import { takibi } from '../core/takibi.js';
+// import { honoRpcWithSWR } from '../generator/swr/index.js'
 import { parseCli } from '../utils/index.js';
+/**
+ * CLI usage help text shown when `-h`/`--help` is provided.
+ * Kept as a single template for easy updates and snapshot stability.
+ */
 const HELP_TEXT = `Usage: hono-takibi <input.{yaml,json,tsp}> -o <routes.ts> [options]
 
 Options:
@@ -20,17 +27,16 @@ Options:
  *
  * ```mermaid
  * flowchart TD
- *   A["Start honoTakibi()"] --> B["args = process.argv.slice(2)"]
- *   B --> C{"isHelpRequested(args) ?"}
- *   C -->|Yes| D["return { ok:true, value: HELP_TEXT }"]
- *   C -->|No| E["cliResult = parseCli(args)"]
- *   E --> F{"cliResult.ok ?"}
- *   F -->|No| G["return { ok:false, error: cliResult.error }"]
- *   F -->|Yes| H["cli = cliResult.value"]
- *   H --> I["takibiResult = await takibi(cli.input, cli.output, ...options)"]
- *   I --> J{"takibiResult.ok ?"}
- *   J -->|No| K["return { ok:false, error: takibiResult.error }"]
- *   J -->|Yes| L["return { ok:true, value: takibiResult.value }"]
+ *   A["Start honoTakibi"] --> B["Parse args"]
+ *   B --> C{"Help requested?"}
+ *   C -- Yes --> D["Return help text"]
+ *   C -- No --> E["parseCli(args)"]
+ *   E --> F{"cliResult.ok?"}
+ *   F -- No --> G["Return parse error"]
+ *   F -- Yes --> H["Run takibi"]
+ *   H --> I{"takibi.ok?"}
+ *   I -- No --> J["Return takibi error"]
+ *   I -- Yes --> K["Return success message"]
  * ```
  *
  * **Options**
@@ -46,7 +52,7 @@ Options:
  * - `{ ok: false, error: string }` on validation or generation errors
  */
 export async function honoTakibi() {
-    // Slice the arguments to remove the first two (node and script path)
+    /** Slice the arguments to remove the first two (node and script path) */
     const args = process.argv.slice(2);
     const isHelpRequested = (args) => {
         return args.length === 1 && (args[0] === '--help' || args[0] === '-h');
@@ -59,11 +65,11 @@ export async function honoTakibi() {
         };
     }
     const abs = resolve(process.cwd(), 'hono-takibi.config.ts');
+    /** If config file does not exist, parse CLI arguments */
     if (!existsSync(abs)) {
         const cliResult = parseCli(args);
-        if (!cliResult.ok) {
+        if (!cliResult.ok)
             return { ok: false, error: cliResult.error };
-        }
         const cli = cliResult.value;
         const takibiResult = await takibi(cli.input, cli.output, cli.exportSchema ?? false, cli.exportType ?? false, cli.template ?? false, cli.test ?? false, cli.basePath);
         if (!takibiResult.ok) {
@@ -74,19 +80,38 @@ export async function honoTakibi() {
             value: takibiResult.value,
         };
     }
+    /** If config file exists, parse config file */
     const configResult = await config();
     if (!configResult.ok) {
         return { ok: false, error: configResult.error };
     }
     const c = configResult.value;
-    const takibiResult = c['hono-takibi']
-        ? await takibi(c['hono-takibi']?.input, c['hono-takibi']?.output, c['hono-takibi']?.exportSchema ?? false, c['hono-takibi']?.exportType ?? false, false, // template
+    /** takibi */
+    const takibiResult = c['zod-openapi']?.output
+        ? await takibi(c.input, c['zod-openapi']?.output, c['zod-openapi']?.exportSchema ?? false, c['zod-openapi']?.exportType ?? false, false, // template
         false)
         : undefined;
     if (takibiResult && !takibiResult.ok) {
         return { ok: false, error: takibiResult.error };
     }
-    const rpcResult = c.rpc ? await rpc(c.rpc.input, c.rpc.output, c.rpc.import) : undefined;
+    /** schema */
+    const schemaResult = c['zod-openapi']?.schema
+        ? await schema(c.input, c['zod-openapi'].schema.output, c['zod-openapi'].schema.exportType ?? false, c['zod-openapi']?.schema.split ?? false)
+        : undefined;
+    if (schemaResult && !schemaResult.ok) {
+        return { ok: false, error: schemaResult.error };
+    }
+    /** route */
+    const routeResult = c['zod-openapi']?.route
+        ? await route(c.input, c['zod-openapi'].route.output, c['zod-openapi'].route.import, c['zod-openapi'].route.split ?? false)
+        : undefined;
+    if (routeResult && !routeResult.ok) {
+        return { ok: false, error: routeResult.error };
+    }
+    /** rpc */
+    const rpcResult = c.rpc
+        ? await rpc(c.input, c.rpc.output, c.rpc.import, c.rpc.split ?? false)
+        : undefined;
     if (rpcResult && !rpcResult.ok) {
         return { ok: false, error: rpcResult.error };
     }

package/dist/config/index.d.ts

@@ -1,22 +1,37 @@
 type Config = {
-    'hono-takibi'?: {
-        input: `${string}.yaml` | `${string}.json` | `${string}.tsp`;
-        output: `${string}.ts`;
-        exportType?: boolean;
-        exportSchema?: boolean;
+    readonly input: `${string}.yaml` | `${string}.json` | `${string}.tsp`;
+    readonly 'zod-openapi'?: {
+        readonly output?: `${string}.ts`;
+        readonly exportType?: boolean;
+        readonly exportSchema?: boolean;
+        readonly schema?: {
+            readonly output: string | `${string}.ts`;
+            readonly exportType?: boolean;
+            readonly split?: boolean;
+        };
+        readonly route?: {
+            readonly output: string | `${string}.ts`;
+            readonly import: string;
+            readonly split?: boolean;
+        };
     };
-    rpc?: {
-        input: `${string}.yaml` | `${string}.json` | `${string}.tsp`;
-        output: `${string}.ts`;
-        import: string;
+    readonly rpc?: {
+        readonly output: string | `${string}.ts`;
+        readonly import: string;
+        readonly split?: boolean;
     };
 };
 export declare function config(): Promise<{
-    ok: true;
-    value: Config;
+    readonly ok: true;
+    readonly value: Config;
 } | {
-    ok: false;
-    error: string;
+    readonly ok: false;
+    readonly error: string;
 }>;
-export declare function defineConfig(config: Config): Config;
+/**
+ * Helper to define a config with full type completion.
+ *
+ * @see config
+ */
+export declare function defineConfig(c: Config): Config;
 export {};

package/dist/config/index.js

@@ -1,23 +1,33 @@
+import { existsSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { register } from 'tsx/esm/api';
+import { parseConfig } from '../utils/index.js';
 export async function config() {
     const abs = resolve(process.cwd(), 'hono-takibi.config.ts');
-    // if (!existsSync(abs)) {
-    //   return { ok: false, error: `Config not found: ${abs}` }
-    // }
-    register();
+    if (!existsSync(abs))
+        return { ok: false, error: `Config not found: ${abs}` };
     try {
-        const mod = await import(pathToFileURL(abs).href);
-        if (!('default' in mod)) {
+        register();
+        const url = pathToFileURL(abs).href;
+        const mod = await import(/* @vite-ignore */ url);
+        if (!('default' in mod) || mod.default === undefined) {
             return { ok: false, error: 'Config must export default object' };
         }
-        return { ok: true, value: mod.default };
+        const result = parseConfig(mod.default);
+        if (!result.ok)
+            return { ok: false, error: result.error };
+        return { ok: true, value: result.value };
     }
     catch (e) {
         return { ok: false, error: e instanceof Error ? e.message : String(e) };
     }
 }
-export function defineConfig(config) {
-    return config;
+/**
+ * Helper to define a config with full type completion.
+ *
+ * @see config
+ */
+export function defineConfig(c) {
+    return c;
 }

package/dist/core/route.d.ts

@@ -0,0 +1,7 @@
+export declare function route(input: `${string}.yaml` | `${string}.json` | `${string}.tsp`, output: string | `${string}.ts`, importPath: string, split?: boolean): Promise<{
+    readonly ok: true;
+    readonly value: string;
+} | {
+    readonly ok: false;
+    readonly error: string;
+}>;

package/dist/core/route.js

@@ -0,0 +1,99 @@
+import path from 'node:path';
+import { fmt } from '../format/index.js';
+import { mkdir, writeFile } from '../fsp/index.js';
+import { routeCode } from '../generator/zod-openapi-hono/openapi/route/index.js';
+import { parseOpenAPI } from '../openapi/index.js';
+const findSchemaTokens = (code) => Array.from(new Set(Array.from(code.matchAll(/\b([A-Za-z_$][A-Za-z0-9_$]*Schema)\b/g))
+    .map((m) => m[1] ?? '')
+    .filter(Boolean)));
+const extractRouteBlocks = (src) => {
+    const re = /export\s+const\s+([A-Za-z_$][A-Za-z0-9_$]*)Route\s*=/g;
+    const hits = [];
+    for (const m of src.matchAll(re)) {
+        const name = (m[1] ?? '').trim();
+        const start = m.index ?? 0;
+        if (name)
+            hits.push({ name, start });
+    }
+    return hits.map((h, i) => {
+        const start = h.start;
+        const end = i + 1 < hits.length ? (hits[i + 1]?.start ?? src.length) : src.length;
+        return { name: h.name, block: src.slice(start, end).trim() };
+    });
+};
+const lowerFirst = (s) => (s ? s.charAt(0).toLowerCase() + s.slice(1) : s);
+export async function route(input, output, importPath, split) {
+    const openAPIResult = await parseOpenAPI(input);
+    if (!openAPIResult.ok) {
+        return { ok: false, error: openAPIResult.error };
+    }
+    const openAPI = openAPIResult.value;
+    const routesSrc = routeCode(openAPI.paths);
+    if (!split) {
+        const includeZ = routesSrc.includes('z.');
+        const schemaTokens = findSchemaTokens(routesSrc);
+        const importHono = `import { createRoute${includeZ ? ', z' : ''} } from '@hono/zod-openapi'`;
+        const importSchemas = schemaTokens.length > 0 ? `import { ${schemaTokens.join(',')} } from '${importPath}'` : '';
+        const finalSrc = [importHono, importSchemas, '\n', routesSrc].filter(Boolean).join('\n');
+        const fmtResult = await fmt(finalSrc);
+        if (!fmtResult.ok)
+            return { ok: false, error: fmtResult.error };
+        const mkdirResult = await mkdir(path.dirname(output));
+        if (!mkdirResult.ok)
+            return { ok: false, error: mkdirResult.error };
+        const writeResult = await writeFile(output, fmtResult.value);
+        return writeResult.ok
+            ? { ok: true, value: `Generated route code written to ${output}` }
+            : { ok: false, error: writeResult.error };
+    }
+    const outDir = output.replace(/\.ts$/, '');
+    const blocks = extractRouteBlocks(routesSrc);
+    if (blocks.length === 0) {
+        const includeZ = routesSrc.includes('z.');
+        const schemaTokens = findSchemaTokens(routesSrc);
+        const importHono = `import { createRoute${includeZ ? ', z' : ''} } from '@hono/zod-openapi'`;
+        const importSchemas = schemaTokens.length > 0 ? `import { ${schemaTokens.join(',')} } from '${importPath}'` : '';
+        const finalSrc = [importHono, importSchemas, '\n', routesSrc].filter(Boolean).join('\n');
+        const fmtResult = await fmt(finalSrc);
+        if (!fmtResult.ok)
+            return { ok: false, error: fmtResult.error };
+        const mkdirResult = await mkdir(path.dirname(output));
+        if (!mkdirResult.ok)
+            return { ok: false, error: mkdirResult.error };
+        const writeResult = await writeFile(output, fmtResult.value);
+        return writeResult.ok
+            ? { ok: true, value: `Generated route code written to ${output}` }
+            : { ok: false, error: writeResult.error };
+    }
+    for (const { name, block } of blocks) {
+        const includeZ = block.includes('z.');
+        const schemaTokens = findSchemaTokens(block);
+        const importHono = `import { createRoute${includeZ ? ', z' : ''} } from '@hono/zod-openapi'`;
+        const importSchemas = schemaTokens.length > 0 ? `import { ${schemaTokens.join(',')} } from '${importPath}'` : '';
+        const fileSrc = [importHono, importSchemas, '\n', block, ''].filter(Boolean).join('\n');
+        const fmtResult = await fmt(fileSrc);
+        if (!fmtResult.ok)
+            return { ok: false, error: fmtResult.error };
+        const filePath = `${outDir}/${lowerFirst(name)}.ts`;
+        const mkdirResult = await mkdir(path.dirname(filePath));
+        if (!mkdirResult.ok)
+            return { ok: false, error: mkdirResult.error };
+        const writeResult = await writeFile(filePath, fmtResult.value);
+        if (!writeResult.ok)
+            return { ok: false, error: writeResult.error };
+    }
+    const indexBody = `${blocks
+        .sort()
+        .map(({ name }) => `export * from './${lowerFirst(name)}'`)
+        .join('\n')}\n`;
+    const fmtResult = await fmt(indexBody);
+    if (!fmtResult.ok)
+        return { ok: false, error: fmtResult.error };
+    const mkdirResult = await mkdir(path.dirname(`${outDir}/index.ts`));
+    if (!mkdirResult.ok)
+        return { ok: false, error: mkdirResult.error };
+    const writeResult = await writeFile(`${outDir}/index.ts`, fmtResult.value);
+    if (!writeResult.ok)
+        return { ok: false, error: writeResult.error };
+    return { ok: true, value: `Generated route code written to ${outDir}/*.ts (index.ts included)` };
+}

package/dist/core/rpc.d.ts

@@ -1,7 +1,13 @@
-export declare function rpc(input: `${string}.yaml` | `${string}.json` | `${string}.tsp`, output: `${string}.ts`, importCode: string): Promise<{
-    ok: true;
-    value: string;
+/**
+ * Generate RPC client wrappers from an OpenAPI/TypeSpec source.
+ *
+ * - When `split=true`, writes one file per RPC function under `output` (directory) and an `index.ts` barrel.
+ * - Otherwise, emits a single `.ts` file at `output`.
+ */
+export declare function rpc(input: `${string}.yaml` | `${string}.json` | `${string}.tsp`, output: string | `${string}.ts`, importPath: string, split?: boolean): Promise<{
+    readonly ok: true;
+    readonly value: string;
 } | {
-    ok: false;
-    error: string;
+    readonly ok: false;
+    readonly error: string;
 }>;