hono-takibi 0.9.99994 → 0.9.99996

package/README.md

@@ -30,7 +30,7 @@ npx hono-takibi path/to/input.{yaml,json,tsp} -o path/to/output.ts
 Create `hono-takibi.config.ts`:
 
 ```ts
-import { defineConfig } from 'hono-takibi/config'
+import { defineConfig } from 'hono-takibi'
 
 export default defineConfig({
   input: 'openapi.yaml',
@@ -200,7 +200,6 @@ export default app
 ```ts
 export default defineConfig({
   input: 'openapi.yaml',
-  output: './src/index.ts',
   template: { define: true },
 })
 ```
@@ -221,7 +220,7 @@ export const getUsersIdRoute = defineOpenAPIRoute({
 })
 ```
 
-Component schemas go to `components/index.ts` (override with `components.output`). Set `template.output` to change the route directory (default `./src/routes`).
+The app entry defaults to `src/index.ts` (override with `output`, which must be an `index.ts` path such as `./server/index.ts`). Route files always go to `routes/` next to the app entry, and component schemas to `components/index.ts` (override with `components.output`). When `output` is omitted, `components.output` also anchors the layout: `components: { output: './server/components/index.ts' }` puts the app entry at `server/index.ts` and routes at `server/routes/`.
 
 ## Client Library Integrations
 
@@ -305,15 +304,15 @@ export default defineConfig({
 
 ## Full Config Reference
 
-Some options are mutually exclusive: `output` ↔ `routes`, `components.output` ↔ per-type components, `template.define` ↔ `routeHandler`.
+Some options are mutually exclusive: `output` ↔ `routes`, `template.define` ↔ `routes`, `components.output` ↔ per-type components, `template.define` ↔ `routeHandler`.
 
 ```ts
-import { defineConfig } from 'hono-takibi/config'
+import { defineConfig } from 'hono-takibi'
 
 export default defineConfig({
   input: 'openapi.yaml',
 
-  output: './src/routes.ts', // single-file mode; with template.define, the app entry (required)
+  output: './src/routes.ts', // single-file mode; with template.define, the app entry (an index.ts path, default ./src/index.ts)
   basePath: '/api',
   readonly: true,
   // format: {}, // oxfmt FormatConfig
@@ -322,7 +321,6 @@ export default defineConfig({
     test: true,
     routeHandler: false, // true: RouteHandler exports
     define: false, // true: defineOpenAPIRoute output
-    // output: './src/routes', // define mode dir (default ./src/routes)
     pathAlias: '@/',
     testFramework: 'vitest', // "vitest" | "vite-plus" | "bun"
   },

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export {}

package/dist/cli.js

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+import { readConfig } from "./index.js";
+import { r as setFormatOptions } from "./emit-CFR63U4L.js";
+import { n as parseOpenAPI, r as takibi, t as makeJob } from "./shared-DnibnCI5.js";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+//#region src/cli/index.ts
+const HELP_TEXT = `Usage: hono-takibi <input.{yaml,json,tsp}> -o <output.ts>
+
+Options:
+  -h, --help                  display help for command`;
+function parseCli(args) {
+	const input = args[0];
+	const oIdx = args.indexOf("-o");
+	const output = oIdx !== -1 ? args[oIdx + 1] : void 0;
+	const isYamlOrJsonOrTsp = (i) => i.endsWith(".yaml") || i.endsWith(".json") || i.endsWith(".tsp");
+	const isTs = (o) => o.endsWith(".ts");
+	if (!(input && output && isYamlOrJsonOrTsp(input) && isTs(output))) return {
+		ok: false,
+		error: HELP_TEXT
+	};
+	return {
+		ok: true,
+		value: {
+			input,
+			output
+		}
+	};
+}
+async function honoTakibi() {
+	const args = process.argv.slice(2);
+	if (args.length === 1 && (args[0] === "--help" || args[0] === "-h")) return {
+		ok: true,
+		value: HELP_TEXT
+	};
+	if (!existsSync(resolve(process.cwd(), "hono-takibi.config.ts"))) {
+		const cliResult = parseCli(args);
+		if (!cliResult.ok) return {
+			ok: false,
+			error: cliResult.error
+		};
+		const { input, output } = cliResult.value;
+		const openAPIResult = await parseOpenAPI(input);
+		if (!openAPIResult.ok) return {
+			ok: false,
+			error: openAPIResult.error
+		};
+		const openAPI = openAPIResult.value;
+		const takibiResult = await takibi(openAPI, output, {
+			readonly: false,
+			exportSchemas: false,
+			exportSchemasTypes: false,
+			exportResponses: false,
+			exportParameters: false,
+			exportParametersTypes: false,
+			exportExamples: false,
+			exportRequestBodies: false,
+			exportHeaders: false,
+			exportHeadersTypes: false,
+			exportSecuritySchemes: false,
+			exportLinks: false,
+			exportCallbacks: false,
+			exportPathItems: false,
+			exportMediaTypes: false,
+			exportMediaTypesTypes: false
+		});
+		if (!takibiResult.ok) return {
+			ok: false,
+			error: takibiResult.error
+		};
+		return {
+			ok: true,
+			value: takibiResult.value
+		};
+	}
+	const readConfigResult = await readConfig();
+	if (!readConfigResult.ok) return {
+		ok: false,
+		error: readConfigResult.error
+	};
+	const config = readConfigResult.value;
+	if (config.format) setFormatOptions(config.format);
+	const openAPIResult = await parseOpenAPI(config.input);
+	if (!openAPIResult.ok) return {
+		ok: false,
+		error: openAPIResult.error
+	};
+	const openAPI = openAPIResult.value;
+	const jobs = makeJob(openAPI, config);
+	const results = await Promise.all(jobs.map((job) => job.run(job.output)));
+	const e = results.find((result) => !result.ok);
+	if (e) return e;
+	return {
+		ok: true,
+		value: results.map((result) => result.ok ? result.value : "").filter((v) => v !== "").join("\n")
+	};
+}
+//#endregion
+//#region src/index.ts
+honoTakibi().then((result) => {
+	if (result.ok) {
+		console.log(result.value);
+		process.exit(0);
+	} else {
+		console.error(result.error);
+		process.exit(1);
+	}
+});
+//#endregion
+export {};

package/dist/config/index.js

@@ -1,216 +1,2 @@
-import { existsSync } from "node:fs";
-import { resolve } from "node:path";
-import { pathToFileURL } from "node:url";
-import "oxfmt";
-import * as z from "zod";
-//#region src/config/index.ts
-const DirectoryOutputSchema = z.string().regex(/^(?!.*\.ts$).+/, { error: "split mode requires directory, not .ts file" });
-const FileOutputSchema = z.string().transform((v) => v.endsWith(".ts") ? v : `${v}/index.ts`);
-const OutputSchema = z.discriminatedUnion("split", [z.object({
-	split: z.literal(true),
-	output: DirectoryOutputSchema,
-	import: z.string().exactOptional()
-}).readonly(), z.object({
-	split: z.literal(false).optional().default(false),
-	output: FileOutputSchema,
-	import: z.string().exactOptional()
-}).readonly()]).exactOptional();
-const ExportTypesOutputSchema = z.discriminatedUnion("split", [z.object({
-	split: z.literal(true),
-	output: DirectoryOutputSchema,
-	import: z.string().exactOptional(),
-	exportTypes: z.boolean().default(false)
-}).readonly(), z.object({
-	split: z.literal(false).optional().default(false),
-	output: FileOutputSchema,
-	import: z.string().exactOptional(),
-	exportTypes: z.boolean().default(false)
-}).readonly()]).exactOptional();
-const HooksSchema = z.discriminatedUnion("split", [z.object({
-	split: z.literal(true),
-	output: DirectoryOutputSchema,
-	import: z.string(),
-	client: z.string().default("client")
-}).readonly(), z.object({
-	split: z.literal(false).optional().default(false),
-	output: FileOutputSchema,
-	import: z.string(),
-	client: z.string().default("client")
-}).readonly()]).exactOptional();
-const RpcSchema = z.discriminatedUnion("split", [z.object({
-	split: z.literal(true),
-	output: DirectoryOutputSchema,
-	import: z.string(),
-	client: z.string().default("client"),
-	parseResponse: z.boolean().default(false),
-	docs: z.boolean().default(false)
-}).readonly(), z.object({
-	split: z.literal(false).optional().default(false),
-	output: FileOutputSchema,
-	import: z.string(),
-	client: z.string().default("client"),
-	parseResponse: z.boolean().default(false),
-	docs: z.boolean().default(false)
-}).readonly()]).exactOptional();
-const ConfigSchema = z.object({
-	input: z.templateLiteral([z.string().min(1), z.enum([
-		".yaml",
-		".json",
-		".tsp"
-	])], { error: "must be .yaml | .json | .tsp" }),
-	output: z.templateLiteral([z.string().min(1), z.enum([".ts"])], { error: "must be .ts file" }).exactOptional(),
-	basePath: z.string().default("/"),
-	readonly: z.boolean().exactOptional(),
-	format: z.custom(() => true).exactOptional(),
-	template: z.discriminatedUnion("define", [z.object({
-		define: z.literal(true),
-		output: z.string().regex(/^(?!.*\.ts$).+/, { error: "template.output must be a directory, not a .ts file" }).default("src/routes"),
-		test: z.boolean().default(false),
-		pathAlias: z.string().exactOptional(),
-		testFramework: z.enum([
-			"vitest",
-			"vite-plus",
-			"bun"
-		]).default("vitest").exactOptional()
-	}).readonly(), z.object({
-		define: z.literal(false).optional().default(false),
-		routeHandler: z.boolean().default(false),
-		output: z.string().regex(/^(?!.*\.ts$).+/, { error: "template.output must be a directory, not a .ts file" }).exactOptional(),
-		test: z.boolean().default(false),
-		pathAlias: z.string().exactOptional(),
-		testFramework: z.enum([
-			"vitest",
-			"vite-plus",
-			"bun"
-		]).default("vitest").exactOptional()
-	}).readonly()]).exactOptional(),
-	exportSchemas: z.boolean().default(false),
-	exportSchemasTypes: z.boolean().default(false),
-	exportResponses: z.boolean().default(false),
-	exportParameters: z.boolean().default(false),
-	exportParametersTypes: z.boolean().default(false),
-	exportExamples: z.boolean().default(false),
-	exportRequestBodies: z.boolean().default(false),
-	exportHeaders: z.boolean().default(false),
-	exportHeadersTypes: z.boolean().default(false),
-	exportSecuritySchemes: z.boolean().default(false),
-	exportLinks: z.boolean().default(false),
-	exportCallbacks: z.boolean().default(false),
-	exportPathItems: z.boolean().default(false),
-	exportMediaTypes: z.boolean().default(false),
-	exportMediaTypesTypes: z.boolean().default(false),
-	routes: OutputSchema,
-	webhooks: OutputSchema,
-	components: z.object({
-		output: z.templateLiteral([z.string().min(1), z.enum([".ts"])], { error: "must be .ts file" }).exactOptional(),
-		schemas: ExportTypesOutputSchema,
-		responses: OutputSchema,
-		parameters: ExportTypesOutputSchema,
-		examples: OutputSchema,
-		requestBodies: OutputSchema,
-		headers: ExportTypesOutputSchema,
-		securitySchemes: OutputSchema,
-		links: OutputSchema,
-		callbacks: OutputSchema,
-		pathItems: OutputSchema,
-		mediaTypes: ExportTypesOutputSchema
-	}).readonly().refine((v) => !(v.output && [
-		"schemas",
-		"responses",
-		"parameters",
-		"examples",
-		"requestBodies",
-		"headers",
-		"securitySchemes",
-		"links",
-		"callbacks",
-		"pathItems",
-		"mediaTypes"
-	].some((k) => v[k] !== void 0)), { message: "components.output is mutually exclusive with per-type component outputs (schemas, responses, ...). Use output for single-file mode, or per-type fields for split mode." }).exactOptional(),
-	type: z.object({
-		readonly: z.boolean().exactOptional(),
-		output: z.templateLiteral([z.string().min(1), z.enum([".ts"])], { error: "must be .ts file" })
-	}).readonly().exactOptional(),
-	rpc: RpcSchema,
-	swr: HooksSchema,
-	"tanstack-query": HooksSchema,
-	"preact-query": HooksSchema,
-	"solid-query": HooksSchema,
-	"vue-query": HooksSchema,
-	"svelte-query": HooksSchema,
-	"angular-query": HooksSchema,
-	test: z.object({
-		output: FileOutputSchema,
-		import: z.string(),
-		testFramework: z.enum([
-			"vitest",
-			"vite-plus",
-			"bun"
-		]).default("vitest").exactOptional()
-	}).readonly().exactOptional(),
-	mock: z.object({
-		output: FileOutputSchema,
-		useExamples: z.boolean().exactOptional(),
-		locale: z.string().regex(/^[A-Za-z_]{1,40}$/, { error: "Invalid faker locale. Use a code like 'ja', 'en', or 'zh_CN'." }).exactOptional(),
-		delay: z.union([
-			z.number().int().nonnegative().max(6e4),
-			z.literal(false),
-			z.object({
-				min: z.number().int().nonnegative().max(6e4),
-				max: z.number().int().nonnegative().max(6e4)
-			}).readonly().refine((v) => v.min <= v.max, { message: "delay.min must be <= delay.max. Swap the values or remove one." })
-		]).exactOptional(),
-		arrayMin: z.number().int().nonnegative().max(1e3).exactOptional(),
-		arrayMax: z.number().int().nonnegative().max(1e3).exactOptional()
-	}).readonly().refine((v) => v.arrayMin === void 0 || v.arrayMax === void 0 || v.arrayMin <= v.arrayMax, { message: "arrayMin must be <= arrayMax. Swap the values or remove one." }).exactOptional(),
-	docs: z.discriminatedUnion("curl", [z.object({
-		output: z.templateLiteral([z.string().min(1), z.enum([".md"])], { error: "must be .md file" }),
-		curl: z.literal(true),
-		baseUrl: z.string({ error: "baseUrl is required when curl is true" }),
-		entry: z.never({ error: "entry cannot be specified when curl is true" }).optional()
-	}).readonly(), z.object({
-		output: z.templateLiteral([z.string().min(1), z.enum([".md"])], { error: "must be .md file" }),
-		curl: z.literal(false).default(false).optional(),
-		entry: z.string().exactOptional(),
-		baseUrl: z.string().exactOptional()
-	}).readonly()]).exactOptional()
-}).readonly().refine((v) => !(v.output && v.routes), { message: "output and routes are mutually exclusive. Use output for single-file mode, or routes for separate route output." }).refine((v) => !(v.template?.define && !v.output), { message: "template.define requires output (the app entry file, e.g. ./src/index.ts)." });
-function parseConfig(config) {
-	const result = ConfigSchema.safeParse(config);
-	if (!result.success) {
-		const issue = result.error.issues[0];
-		return {
-			ok: false,
-			error: `Invalid config: ${issue.path.length > 0 ? `${issue.path.join(".")}: ` : ""}${issue.message}`
-		};
-	}
-	return {
-		ok: true,
-		value: result.data
-	};
-}
-async function readConfig() {
-	const abs = resolve(process.cwd(), "hono-takibi.config.ts");
-	if (!existsSync(abs)) return {
-		ok: false,
-		error: `Config not found: ${abs}`
-	};
-	try {
-		const mod = await import(pathToFileURL(abs).href);
-		if (typeof mod !== "object" || mod === null || !("default" in mod) || mod.default === void 0) return {
-			ok: false,
-			error: "Config must export default object"
-		};
-		return parseConfig(mod.default);
-	} catch (e) {
-		return {
-			ok: false,
-			error: e instanceof Error ? e.message : String(e)
-		};
-	}
-}
-function defineConfig(config) {
-	return config;
-}
-//#endregion
+import { defineConfig, parseConfig, readConfig } from "../index.js";
 export { defineConfig, parseConfig, readConfig };

package/dist/core/docs/index.d.ts

@@ -1,14 +1,13 @@
-import { t as OpenAPI } from "../../index-BFnCNZSw.js";
-
+import { t as OpenAPI } from "../../index-CQcc43cH.js";
 //#region src/core/docs/index.d.ts
 declare function docs(openAPI: OpenAPI, output: string, entry?: string, basePath?: string, curl?: boolean, baseUrl?: string): Promise<{
+  readonly value?: never;
   readonly ok: false;
   readonly error: string;
-  readonly value?: never;
 } | {
+  readonly error?: never;
   readonly ok: true;
   readonly value: `Generated docs written to ${string}`;
-  readonly error?: never;
 }>;
 //#endregion
 export { docs };

package/dist/core/docs/index.js

@@ -1,2 +1,2 @@
-import { t as docs } from "../../docs-380Wcu6a.js";
+import { t as docs } from "../../docs-DJEuJ8Cn.js";
 export { docs };

package/dist/core/hooks/index.d.ts

@@ -1,109 +1,108 @@
-import { t as OpenAPI } from "../../index-BFnCNZSw.js";
-
+import { t as OpenAPI } from "../../index-CQcc43cH.js";
 //#region src/core/hooks/index.d.ts
 declare const HOOK_CONFIGS: {
   readonly swr: {
-    readonly packageName: "swr";
-    readonly frameworkName: "SWR";
-    readonly hookPrefix: "use";
-    readonly queryFn: "useSWR";
-    readonly mutationFn: "useSWRMutation";
-    readonly useQueryOptionsType: "SWRConfiguration";
-    readonly useMutationOptionsType: "SWRMutationConfiguration";
+    readonly packageName: 'swr';
+    readonly frameworkName: 'SWR';
+    readonly hookPrefix: 'use';
+    readonly queryFn: 'useSWR';
+    readonly mutationFn: 'useSWRMutation';
+    readonly useQueryOptionsType: 'SWRConfiguration';
+    readonly useMutationOptionsType: 'SWRMutationConfiguration';
     readonly isSWR: true;
-    readonly immutableQueryFn: "useSWRImmutable";
-    readonly infiniteQueryFn: "useSWRInfinite";
-    readonly useInfiniteQueryOptionsType: "SWRInfiniteConfiguration";
+    readonly immutableQueryFn: 'useSWRImmutable';
+    readonly infiniteQueryFn: 'useSWRInfinite';
+    readonly useInfiniteQueryOptionsType: 'SWRInfiniteConfiguration';
   };
   readonly 'tanstack-query': {
-    readonly packageName: "@tanstack/react-query";
-    readonly frameworkName: "TanStack Query";
-    readonly hookPrefix: "use";
-    readonly queryFn: "useQuery";
-    readonly mutationFn: "useMutation";
-    readonly useQueryOptionsType: "UseQueryOptions";
-    readonly useMutationOptionsType: "UseMutationOptions";
+    readonly packageName: '@tanstack/react-query';
+    readonly frameworkName: 'TanStack Query';
+    readonly hookPrefix: 'use';
+    readonly queryFn: 'useQuery';
+    readonly mutationFn: 'useMutation';
+    readonly useQueryOptionsType: 'UseQueryOptions';
+    readonly useMutationOptionsType: 'UseMutationOptions';
     readonly hasQueryOptionsHelper: true;
     readonly hasMutationOptionsHelper: true;
-    readonly suspenseQueryFn: "useSuspenseQuery";
-    readonly infiniteQueryFn: "useInfiniteQuery";
-    readonly suspenseInfiniteQueryFn: "useSuspenseInfiniteQuery";
-    readonly useInfiniteQueryOptionsType: "UseInfiniteQueryOptions";
-    readonly useSuspenseInfiniteQueryOptionsType: "UseSuspenseInfiniteQueryOptions";
+    readonly suspenseQueryFn: 'useSuspenseQuery';
+    readonly infiniteQueryFn: 'useInfiniteQuery';
+    readonly suspenseInfiniteQueryFn: 'useSuspenseInfiniteQuery';
+    readonly useInfiniteQueryOptionsType: 'UseInfiniteQueryOptions';
+    readonly useSuspenseInfiniteQueryOptionsType: 'UseSuspenseInfiniteQueryOptions';
     readonly hasInfiniteQueryOptionsHelper: true;
-    readonly useSuspenseQueryOptionsType: "UseSuspenseQueryOptions";
+    readonly useSuspenseQueryOptionsType: 'UseSuspenseQueryOptions';
   };
   readonly 'preact-query': {
-    readonly packageName: "@tanstack/preact-query";
-    readonly frameworkName: "Preact Query";
-    readonly hookPrefix: "use";
-    readonly queryFn: "useQuery";
-    readonly mutationFn: "useMutation";
-    readonly useQueryOptionsType: "UseQueryOptions";
-    readonly useMutationOptionsType: "UseMutationOptions";
+    readonly packageName: '@tanstack/preact-query';
+    readonly frameworkName: 'Preact Query';
+    readonly hookPrefix: 'use';
+    readonly queryFn: 'useQuery';
+    readonly mutationFn: 'useMutation';
+    readonly useQueryOptionsType: 'UseQueryOptions';
+    readonly useMutationOptionsType: 'UseMutationOptions';
     readonly hasQueryOptionsHelper: true;
     readonly hasMutationOptionsHelper: true;
-    readonly suspenseQueryFn: "useSuspenseQuery";
-    readonly infiniteQueryFn: "useInfiniteQuery";
-    readonly suspenseInfiniteQueryFn: "useSuspenseInfiniteQuery";
-    readonly useInfiniteQueryOptionsType: "UseInfiniteQueryOptions";
-    readonly useSuspenseInfiniteQueryOptionsType: "UseSuspenseInfiniteQueryOptions";
+    readonly suspenseQueryFn: 'useSuspenseQuery';
+    readonly infiniteQueryFn: 'useInfiniteQuery';
+    readonly suspenseInfiniteQueryFn: 'useSuspenseInfiniteQuery';
+    readonly useInfiniteQueryOptionsType: 'UseInfiniteQueryOptions';
+    readonly useSuspenseInfiniteQueryOptionsType: 'UseSuspenseInfiniteQueryOptions';
     readonly hasInfiniteQueryOptionsHelper: true;
-    readonly useSuspenseQueryOptionsType: "UseSuspenseQueryOptions";
+    readonly useSuspenseQueryOptionsType: 'UseSuspenseQueryOptions';
   };
   readonly 'solid-query': {
-    readonly packageName: "@tanstack/solid-query";
-    readonly frameworkName: "Solid Query";
-    readonly hookPrefix: "create";
-    readonly queryFn: "createQuery";
-    readonly mutationFn: "createMutation";
+    readonly packageName: '@tanstack/solid-query';
+    readonly frameworkName: 'Solid Query';
+    readonly hookPrefix: 'create';
+    readonly queryFn: 'createQuery';
+    readonly mutationFn: 'createMutation';
     readonly useThunk: true;
-    readonly useQueryOptionsType: "CreateQueryOptions";
-    readonly useMutationOptionsType: "CreateMutationOptions";
+    readonly useQueryOptionsType: 'CreateQueryOptions';
+    readonly useMutationOptionsType: 'CreateMutationOptions';
     readonly hasQueryOptionsHelper: true;
-    readonly infiniteQueryFn: "createInfiniteQuery";
-    readonly useInfiniteQueryOptionsType: "CreateInfiniteQueryOptions";
+    readonly infiniteQueryFn: 'createInfiniteQuery';
+    readonly useInfiniteQueryOptionsType: 'CreateInfiniteQueryOptions';
     readonly hasInfiniteQueryOptionsHelper: true;
   };
   readonly 'vue-query': {
-    readonly packageName: "@tanstack/vue-query";
-    readonly frameworkName: "Vue Query";
-    readonly hookPrefix: "use";
-    readonly queryFn: "useQuery";
-    readonly mutationFn: "useMutation";
-    readonly useQueryOptionsType: "UseQueryOptions";
-    readonly useMutationOptionsType: "UseMutationOptions";
+    readonly packageName: '@tanstack/vue-query';
+    readonly frameworkName: 'Vue Query';
+    readonly hookPrefix: 'use';
+    readonly queryFn: 'useQuery';
+    readonly mutationFn: 'useMutation';
+    readonly useQueryOptionsType: 'UseQueryOptions';
+    readonly useMutationOptionsType: 'UseMutationOptions';
     readonly isVueQuery: true;
-    readonly infiniteQueryFn: "useInfiniteQuery";
-    readonly useInfiniteQueryOptionsType: "UseInfiniteQueryOptions";
+    readonly infiniteQueryFn: 'useInfiniteQuery';
+    readonly useInfiniteQueryOptionsType: 'UseInfiniteQueryOptions';
   };
   readonly 'svelte-query': {
-    readonly packageName: "@tanstack/svelte-query";
-    readonly frameworkName: "Svelte Query";
-    readonly hookPrefix: "create";
-    readonly queryFn: "createQuery";
-    readonly mutationFn: "createMutation";
+    readonly packageName: '@tanstack/svelte-query';
+    readonly frameworkName: 'Svelte Query';
+    readonly hookPrefix: 'create';
+    readonly queryFn: 'createQuery';
+    readonly mutationFn: 'createMutation';
     readonly useThunk: true;
-    readonly useQueryOptionsType: "CreateQueryOptions";
-    readonly useMutationOptionsType: "CreateMutationOptions";
+    readonly useQueryOptionsType: 'CreateQueryOptions';
+    readonly useMutationOptionsType: 'CreateMutationOptions';
     readonly hasQueryOptionsHelper: true;
-    readonly infiniteQueryFn: "createInfiniteQuery";
-    readonly useInfiniteQueryOptionsType: "CreateInfiniteQueryOptions";
+    readonly infiniteQueryFn: 'createInfiniteQuery';
+    readonly useInfiniteQueryOptionsType: 'CreateInfiniteQueryOptions';
     readonly hasInfiniteQueryOptionsHelper: true;
   };
   readonly 'angular-query': {
-    readonly packageName: "@tanstack/angular-query-experimental";
-    readonly frameworkName: "Angular Query";
-    readonly hookPrefix: "inject";
-    readonly queryFn: "injectQuery";
-    readonly mutationFn: "injectMutation";
-    readonly useQueryOptionsType: "CreateQueryOptions";
-    readonly useMutationOptionsType: "CreateMutationOptions";
+    readonly packageName: '@tanstack/angular-query-experimental';
+    readonly frameworkName: 'Angular Query';
+    readonly hookPrefix: 'inject';
+    readonly queryFn: 'injectQuery';
+    readonly mutationFn: 'injectMutation';
+    readonly useQueryOptionsType: 'CreateQueryOptions';
+    readonly useMutationOptionsType: 'CreateMutationOptions';
     readonly hasQueryOptionsHelper: true;
     readonly hasMutationOptionsHelper: false;
     readonly hasInfiniteQueryOptionsHelper: true;
-    readonly infiniteQueryFn: "injectInfiniteQuery";
-    readonly useInfiniteQueryOptionsType: "CreateInfiniteQueryOptions";
+    readonly infiniteQueryFn: 'injectInfiniteQuery';
+    readonly useInfiniteQueryOptionsType: 'CreateInfiniteQueryOptions';
     readonly useThunk: true;
   };
 };
@@ -111,9 +110,9 @@ declare function hooks(openAPI: OpenAPI, output: string, importPath: string, lib
   readonly split?: boolean;
   readonly clientName?: string;
 }): Promise<{
+  readonly value?: never;
   readonly ok: false;
   readonly error: string;
-  readonly value?: never;
 } | {
   readonly ok: true;
   readonly value: `Generated ${string} hooks written to ${string}`;

package/dist/core/hooks/index.js

@@ -1,2 +1,2 @@
-import { t as hooks } from "../../hooks-CkiatAe9.js";
+import { t as hooks } from "../../hooks-BfmklyQ_.js";
 export { hooks };

package/dist/core/rpc/index.d.ts

@@ -1,5 +1,4 @@
-import { t as OpenAPI } from "../../index-BFnCNZSw.js";
-
+import { t as OpenAPI } from "../../index-CQcc43cH.js";
 //#region src/core/rpc/index.d.ts
 /**
  * Generates RPC client wrapper functions from OpenAPI specification.
@@ -15,9 +14,9 @@ import { t as OpenAPI } from "../../index-BFnCNZSw.js";
  * @returns Promise resolving to success message or error
  */
 declare function rpc(openAPI: OpenAPI, output: string, importPath: string, split?: boolean, clientName?: string, useParseResponse?: boolean, basePath?: string, docs?: boolean): Promise<{
+  readonly value?: never;
   readonly ok: false;
   readonly error: string;
-  readonly value?: never;
 } | {
   readonly ok: true;
   readonly value: `Generated rpc code written to ${string}`;

package/dist/core/rpc/index.js

@@ -1,6 +1,6 @@
 import { t as emit } from "../../emit-CFR63U4L.js";
-import { A as makeInferRequestType, M as methodPath, c as isOperationLike, f as isRecord, o as isOpenAPIPaths } from "../../guard-zvkMUVYD.js";
-import { a as parsePathItem, i as operationHasArgs, o as resolveSplitOutDir, r as makeOperationDeps, t as formatPath } from "../../rpc-CepeggWU.js";
+import { N as methodPath, c as isOperationLike, f as isRecord, j as makeInferRequestType, o as isOpenAPIPaths } from "../../guard-B2ZfZYyO.js";
+import { a as parsePathItem, i as operationHasArgs, o as resolveSplitOutDir, r as makeOperationDeps, t as formatPath } from "../../rpc-vbCXB2S_.js";
 import path from "node:path";
 //#region src/core/rpc/index.ts
 /**

package/dist/core/type/index.d.ts

@@ -1,5 +1,4 @@
-import { t as OpenAPI } from "../../index-BFnCNZSw.js";
-
+import { t as OpenAPI } from "../../index-CQcc43cH.js";
 //#region src/core/type/index.d.ts
 /**
  * Generates TypeScript type declarations from OpenAPI specification.
@@ -10,13 +9,13 @@ import { t as OpenAPI } from "../../index-BFnCNZSw.js";
  * @returns Result with success message or error
  */
 declare function type(openAPI: OpenAPI, output: `${string}.ts`, readonly?: boolean): Promise<{
+  readonly error?: never;
   readonly ok: true;
   readonly value: `Generated type code written to ${string}.ts`;
-  readonly error?: never;
 } | {
+  readonly value?: never;
   readonly ok: false;
   readonly error: string;
-  readonly value?: never;
 }>;
 //#endregion
 export { type };