hono-takibi 0.9.74 → 0.9.75

package/dist/cli/index.js

@@ -128,18 +128,18 @@ function parseCli(args) {
             test: args.includes('--test'),
             basePath: getFlagValue(args, '--base-path') ?? '/', // default: /
             componentsOptions: {
-                exportSchemas: args.includes('--export-schemas') ?? false,
-                exportSchemasTypes: args.includes('--export-schemas-types') ?? false,
-                exportParameters: args.includes('--export-parameters') ?? false,
-                exportParametersTypes: args.includes('--export-parameters-types') ?? false,
-                exportSecuritySchemes: args.includes('--export-security-schemes') ?? false,
-                exportRequestBodies: args.includes('--export-request-bodies') ?? false,
-                exportResponses: args.includes('--export-responses') ?? false,
-                exportHeaders: args.includes('--export-headers') ?? false,
-                exportHeadersTypes: args.includes('--export-headers-types') ?? false,
-                exportExamples: args.includes('--export-examples') ?? false,
-                exportLinks: args.includes('--export-links') ?? false,
-                exportCallbacks: args.includes('--export-callbacks') ?? false,
+                exportSchemas: args.includes('--export-schemas'),
+                exportSchemasTypes: args.includes('--export-schemas-types'),
+                exportParameters: args.includes('--export-parameters'),
+                exportParametersTypes: args.includes('--export-parameters-types'),
+                exportSecuritySchemes: args.includes('--export-security-schemes'),
+                exportRequestBodies: args.includes('--export-request-bodies'),
+                exportResponses: args.includes('--export-responses'),
+                exportHeaders: args.includes('--export-headers'),
+                exportHeadersTypes: args.includes('--export-headers-types'),
+                exportExamples: args.includes('--export-examples'),
+                exportLinks: args.includes('--export-links'),
+                exportCallbacks: args.includes('--export-callbacks'),
             },
         },
     };

package/dist/generator/zod-openapi-hono/app/index.d.ts

@@ -1,10 +1,16 @@
 import type { OpenAPI } from '../../../openapi/index.js';
 /**
- * Generates a Hono app with OpenAPI and Swagger UI integration.
+ * Generates a Hono app with OpenAPI integration.
  *
  * @param openapi - The OpenAPI specification.
  * @param output - The output file name (e.g., 'user.ts').
  * @param basePath - Optional base path for the app.
  * @returns The generated application code as a string.
+ *
+ * @example
+ * ```ts
+ * const code = app(openapiSpec, 'routes.ts', '/api')
+ * // Returns generated Hono app code with route handlers
+ * ```
  */
 export declare function app(openapi: OpenAPI, output: `${string}.ts`, basePath: string): string;

package/dist/generator/zod-openapi-hono/app/index.js

@@ -1,11 +1,17 @@
-import { isHttpMethod, methodPath, registerComponent } from '../../../utils/index.js';
+import { isHttpMethod, methodPath } from '../../../utils/index.js';
 /**
- * Generates a Hono app with OpenAPI and Swagger UI integration.
+ * Generates a Hono app with OpenAPI integration.
  *
  * @param openapi - The OpenAPI specification.
  * @param output - The output file name (e.g., 'user.ts').
  * @param basePath - Optional base path for the app.
  * @returns The generated application code as a string.
+ *
+ * @example
+ * ```ts
+ * const code = app(openapiSpec, 'routes.ts', '/api')
+ * // Returns generated Hono app code with route handlers
+ * ```
  */
 export function app(openapi, output, basePath) {
     const getRouteMaps = (openapi) => {
@@ -24,27 +30,12 @@ export function app(openapi, output, basePath) {
         return routeMappings;
     };
     const routeMappings = getRouteMaps(openapi);
-    const handlerNames = Array.from(new Set(routeMappings.map((m) => m.handlerName))).sort();
-    const handlerImport = handlerNames.length > 0 ? `import{${handlerNames.join(',')}}from'./handlers'` : '';
-    const routeNames = Array.from(new Set(routeMappings.map((m) => m.routeName))).sort();
+    const routeNames = [...new Set(routeMappings.map((m) => m.routeName))];
     const routeModule = `./${output.replace(/^.*\//, '').replace(/\.ts$/, '')}`;
     const routesImport = routeNames.length > 0 ? `import{${routeNames.join(',')}}from'${routeModule}'` : '';
-    const path = basePath === '/' ? '/doc' : `${basePath}/doc`;
-    const registerComponentCode = openapi.components?.securitySchemes
-        ? registerComponent(openapi.components.securitySchemes)
-        : '';
-    const versionStr = String(openapi.openapi ?? '').trim();
-    const [majStr, minStr] = versionStr.split('.', 3);
-    const major = Number.isFinite(Number(majStr)) ? Number(majStr) : 0;
-    const minor = Number.isFinite(Number(minStr)) ? Number(minStr) : 0;
-    const is31Plus = major > 3 || (major === 3 && minor >= 1);
-    const doc = is31Plus ? 'doc31' : 'doc';
-    const importSection = [
-        `import{swaggerUI}from'@hono/swagger-ui'`,
-        `import{OpenAPIHono}from'@hono/zod-openapi'`,
-        handlerImport,
-        routesImport,
-    ]
+    const handlerNames = [...new Set(routeMappings.map((m) => m.handlerName))];
+    const handlerImport = handlerNames.length > 0 ? `import{${handlerNames.join(',')}}from'./handlers'` : '';
+    const importSection = [`import{OpenAPIHono}from'@hono/zod-openapi'`, routesImport, handlerImport]
         .filter(Boolean)
         .join('\n');
     const appInit = basePath !== '/'
@@ -54,23 +45,10 @@ export function app(openapi, output, basePath) {
         routeMappings
             .map(({ routeName, handlerName }) => `.openapi(${routeName},${handlerName})`)
             .join('\n');
-    const docs = Object.fromEntries(Object.entries({
-        openapi: openapi.openapi,
-        info: openapi.info,
-        servers: openapi.servers,
-        tags: openapi.tags,
-        externalDocs: openapi.externalDocs,
-    }).filter(([, v]) => v !== undefined));
-    const swagger = `if(process.env.NODE_ENV === 'development'){` +
-        `${registerComponentCode}\n` +
-        `app.${doc}('/doc',${JSON.stringify(docs)})` +
-        `.get('/ui',swaggerUI({url:'${path}'}))` +
-        '}';
     return [
         importSection,
         appInit,
         apiInit,
-        swagger,
         'export type AddType=typeof api',
         'export default app',
     ].join('\n\n');

package/dist/generator/zod-to-openapi/z/integer.d.ts

@@ -1,9 +1,25 @@
 import type { Schema } from '../../../openapi/index.js';
 /**
  * Generates a Zod schema for integer types based on OpenAPI schema.
- * Supports int32, int64, and bigint formats.
+ *
+ * Supports int32, int64, and bigint formats with min/max constraints.
  *
  * @param schema - The OpenAPI schema object
  * @returns The Zod schema string
+ *
+ * @example
+ * ```ts
+ * // Basic integer
+ * integer({ type: 'integer' })
+ * // → 'z.int()'
+ *
+ * // int64 with constraints
+ * integer({ type: 'integer', format: 'int64', minimum: 0, maximum: 100 })
+ * // → 'z.int64().min(0n).max(100n)'
+ *
+ * // Exclusive minimum (greater than)
+ * integer({ type: 'integer', exclusiveMinimum: 0 })
+ * // → 'z.int().positive()'
+ * ```
  */
 export declare function integer(schema: Schema): string;

package/dist/generator/zod-to-openapi/z/integer.js

@@ -1,9 +1,25 @@
 /**
  * Generates a Zod schema for integer types based on OpenAPI schema.
- * Supports int32, int64, and bigint formats.
+ *
+ * Supports int32, int64, and bigint formats with min/max constraints.
  *
  * @param schema - The OpenAPI schema object
  * @returns The Zod schema string
+ *
+ * @example
+ * ```ts
+ * // Basic integer
+ * integer({ type: 'integer' })
+ * // → 'z.int()'
+ *
+ * // int64 with constraints
+ * integer({ type: 'integer', format: 'int64', minimum: 0, maximum: 100 })
+ * // → 'z.int64().min(0n).max(100n)'
+ *
+ * // Exclusive minimum (greater than)
+ * integer({ type: 'integer', exclusiveMinimum: 0 })
+ * // → 'z.int().positive()'
+ * ```
  */
 export function integer(schema) {
     const base = schema.format === 'int32'
@@ -31,12 +47,10 @@ export function integer(schema) {
         if (value === 0 && schema.exclusiveMinimum === false) {
             return '.nonnegative()';
         }
-        // > value → .gt(...)
         if ((schema.exclusiveMinimum === true || schema.minimum === undefined) &&
             typeof value === 'number') {
             return `.gt(${lit(value)})`;
         }
-        // >= value → .min(...)
         if (typeof schema.minimum === 'number') {
             return `.min(${lit(schema.minimum)})`;
         }

package/dist/generator/zod-to-openapi/z/number.d.ts

@@ -1,9 +1,25 @@
 import type { Schema } from '../../../openapi/index.js';
 /**
  * Generates a Zod schema for number types based on OpenAPI schema.
- * Supports float, float32, float64, and number formats.
+ *
+ * Supports float, float32, float64, and number formats with constraints.
  *
  * @param schema - The OpenAPI schema object
  * @returns The Zod schema string
+ *
+ * @example
+ * ```ts
+ * // Basic number
+ * number({ type: 'number' })
+ * // → 'z.number()'
+ *
+ * // Float with constraints
+ * number({ type: 'number', format: 'float', minimum: 0, maximum: 1.0 })
+ * // → 'z.float32().min(0).max(1)'
+ *
+ * // Positive number (exclusive minimum = 0)
+ * number({ type: 'number', minimum: 0, exclusiveMinimum: true })
+ * // → 'z.number().positive()'
+ * ```
  */
 export declare function number(schema: Schema): string;

package/dist/generator/zod-to-openapi/z/number.js

@@ -1,9 +1,25 @@
 /**
  * Generates a Zod schema for number types based on OpenAPI schema.
- * Supports float, float32, float64, and number formats.
+ *
+ * Supports float, float32, float64, and number formats with constraints.
  *
  * @param schema - The OpenAPI schema object
  * @returns The Zod schema string
+ *
+ * @example
+ * ```ts
+ * // Basic number
+ * number({ type: 'number' })
+ * // → 'z.number()'
+ *
+ * // Float with constraints
+ * number({ type: 'number', format: 'float', minimum: 0, maximum: 1.0 })
+ * // → 'z.float32().min(0).max(1)'
+ *
+ * // Positive number (exclusive minimum = 0)
+ * number({ type: 'number', minimum: 0, exclusiveMinimum: true })
+ * // → 'z.number().positive()'
+ * ```
  */
 export function number(schema) {
     const base = schema.format === 'float' || schema.format === 'float32'

package/dist/generator/zod-to-openapi/z/object.d.ts

@@ -8,7 +8,26 @@ import type { Schema } from '../../../openapi/index.js';
  * - additionalProperties: false → `z.strictObject({...})`
  * - additionalProperties: Schema → `z.record(z.string(), ...)`
  *
- * @param schema - Schema definition.
- * @returns The Zod object schema string.
+ * @param schema - Schema definition
+ * @returns The Zod object schema string
+ *
+ * @example
+ * ```ts
+ * // Basic object with properties
+ * object({
+ *   type: 'object',
+ *   properties: { name: { type: 'string' } },
+ *   required: ['name']
+ * })
+ * // → 'z.object({name:z.string()})'
+ *
+ * // Strict object (no additional properties)
+ * object({ type: 'object', additionalProperties: false })
+ * // → 'z.strictObject({})'
+ *
+ * // Record type (dictionary)
+ * object({ type: 'object', additionalProperties: { type: 'number' } })
+ * // → 'z.record(z.string(),z.number())'
+ * ```
  */
 export declare function object(schema: Schema): string;

package/dist/generator/zod-to-openapi/z/object.js

@@ -9,8 +9,27 @@ import { zodToOpenAPI } from '../index.js';
  * - additionalProperties: false → `z.strictObject({...})`
  * - additionalProperties: Schema → `z.record(z.string(), ...)`
  *
- * @param schema - Schema definition.
- * @returns The Zod object schema string.
+ * @param schema - Schema definition
+ * @returns The Zod object schema string
+ *
+ * @example
+ * ```ts
+ * // Basic object with properties
+ * object({
+ *   type: 'object',
+ *   properties: { name: { type: 'string' } },
+ *   required: ['name']
+ * })
+ * // → 'z.object({name:z.string()})'
+ *
+ * // Strict object (no additional properties)
+ * object({ type: 'object', additionalProperties: false })
+ * // → 'z.strictObject({})'
+ *
+ * // Record type (dictionary)
+ * object({ type: 'object', additionalProperties: { type: 'number' } })
+ * // → 'z.record(z.string(),z.number())'
+ * ```
  */
 export function object(schema) {
     // Delegate combinators to zodToOpenAPI

package/dist/helper/index.d.ts

@@ -5,5 +5,5 @@ export { core } from './core.js';
 export { makeExports } from './exports.js';
 export { makeCallbacks, makeContent, makeEncoding, makeExamples, makeHeadersAndReferences, makeLinkOrReference, makeMedia, makeOperationCallbacks, makeOperationResponses, makeParameters, makeRef, makeRequest, makeRequestBody, makeRequestParams, makeResponses, } from './openapi.js';
 export { findSchemaRefs, makeSchemaCode, makeSchemaInfo, makeSchemaInfos, makeSplitSchemaFile, makeTypeDefinition, makeTypeDefinitions, } from './schema.js';
-export { makeRecordTypeString, makeTypeString } from './type.js';
+export { makeTypeString } from './type.js';
 export { wrap } from './wrap.js';

package/dist/helper/index.js

@@ -5,5 +5,5 @@ export { core } from './core.js';
 export { makeExports } from './exports.js';
 export { makeCallbacks, makeContent, makeEncoding, makeExamples, makeHeadersAndReferences, makeLinkOrReference, makeMedia, makeOperationCallbacks, makeOperationResponses, makeParameters, makeRef, makeRequest, makeRequestBody, makeRequestParams, makeResponses, } from './openapi.js';
 export { findSchemaRefs, makeSchemaCode, makeSchemaInfo, makeSchemaInfos, makeSplitSchemaFile, makeTypeDefinition, makeTypeDefinitions, } from './schema.js';
-export { makeRecordTypeString, makeTypeString } from './type.js';
+export { makeTypeString } from './type.js';
 export { wrap } from './wrap.js';

package/dist/helper/openapi.d.ts

@@ -81,9 +81,22 @@ export declare function makeExamples(examples: {
     };
 }): string;
 /**
- * generates a responses code from the given responses object.
- * @param responses
- * @returns
+ * Generates response code for an operation's responses object.
+ *
+ * Converts OpenAPI operation responses into a TypeScript object literal string
+ * with status codes as keys and response definitions as values.
+ *
+ * @param responses - The responses object from an OpenAPI operation
+ * @returns Object literal string with status code keys and response values
+ *
+ * @example
+ * ```ts
+ * makeOperationResponses({
+ *   '200': { description: 'Success', content: {...} },
+ *   'default': { description: 'Error' }
+ * })
+ * // → '{200:{description:"Success",content:{...}},"default":{description:"Error"}}'
+ * ```
  */
 export declare function makeOperationResponses(responses: Operation['responses']): string;
 /**
@@ -96,21 +109,64 @@ export declare function makeHeaderResponses(headers: {
     readonly [k: string]: Header | Reference;
 }): string;
 /**
- * generates a response code from the given responses object.
- * @param responses
- * @returns
+ * Generates code for a single response object.
+ *
+ * Handles both $ref references and inline response definitions,
+ * including headers, content, and links.
+ *
+ * @param responses - OpenAPI response object or reference
+ * @returns TypeScript code string for the response
+ *
+ * @example
+ * ```ts
+ * // Reference
+ * makeResponses({ $ref: '#/components/responses/NotFound' })
+ * // → 'NotFoundResponse'
+ *
+ * // Inline
+ * makeResponses({ description: 'Success', content: {...} })
+ * // → '{description:"Success",content:{...}}'
+ * ```
  */
 export declare function makeResponses(responses: Responses): string;
 /**
- * generates a header code from the given headers object.
- * @param headers Headers object
- * @returns
+ * Generates code for a header or header reference.
+ *
+ * Handles both $ref references and inline header definitions with
+ * all OpenAPI header properties (description, required, schema, etc.).
+ *
+ * @param headers - OpenAPI header object or reference
+ * @returns TypeScript code string for the header
+ *
+ * @example
+ * ```ts
+ * // Reference
+ * makeHeadersAndReferences({ $ref: '#/components/headers/XRequestId' })
+ * // → 'XRequestIdHeaderSchema'
+ *
+ * // Inline
+ * makeHeadersAndReferences({ schema: { type: 'string' }, required: true })
+ * // → '{required:true,schema:z.string()}'
+ * ```
  */
 export declare function makeHeadersAndReferences(headers: Header | Reference): string;
 /**
- * generates a link or reference code from the given link or reference object.
- * @param linkOrReference
- * @returns
+ * Generates code for a link or link reference.
+ *
+ * Handles OpenAPI link objects with operationRef, operationId,
+ * parameters, requestBody, and other link properties.
+ *
+ * @param linkOrReference - OpenAPI link object or reference
+ * @returns TypeScript code string for the link
+ *
+ * @example
+ * ```ts
+ * makeLinkOrReference({
+ *   operationId: 'getUser',
+ *   parameters: { userId: '$response.body#/id' }
+ * })
+ * // → '{operationId:"getUser",parameters:{"userId":"$response.body#/id"}}'
+ * ```
  */
 export declare function makeLinkOrReference(linkOrReference: Link | Reference): string;
 /**
@@ -121,9 +177,25 @@ export declare function makeLinkOrReference(linkOrReference: Link | Reference):
  */
 export declare function makeOperationCallbacks(callbacks: Operation['callbacks']): string | undefined;
 /**
- * generates callbacks
- * @param callbacks
- * @returns
+ * Generates code for OpenAPI callbacks object.
+ *
+ * Converts callbacks with their path items and operations into
+ * TypeScript code. Handles $ref references to callback components.
+ *
+ * @param callbacks - OpenAPI callbacks object with path expressions
+ * @returns TypeScript code string for the callbacks
+ *
+ * @example
+ * ```ts
+ * makeCallbacks({
+ *   onPaymentComplete: {
+ *     '{$request.body#/callbackUrl}': {
+ *       post: { requestBody: {...}, responses: {...} }
+ *     }
+ *   }
+ * })
+ * // → '"onPaymentComplete":{post:{requestBody:{...},responses:{...}}}'
+ * ```
  */
 export declare function makeCallbacks(callbacks: Callbacks | {
     readonly [k: string]: {
@@ -133,29 +205,86 @@ export declare function makeCallbacks(callbacks: Callbacks | {
     };
 }): string;
 /**
- * generates content
- * @param content
- * @returns
+ * Generates code for OpenAPI content object.
+ *
+ * Processes each media type in the content object and generates
+ * corresponding TypeScript code. Handles both $ref references
+ * and inline media definitions.
+ *
+ * @param content - OpenAPI content object with media types
+ * @returns Array of media type code strings
+ *
+ * @example
+ * ```ts
+ * makeContent({
+ *   'application/json': { schema: { type: 'object', properties: {...} } }
+ * })
+ * // → ["'application/json':{schema:z.object({...})}"]
+ * ```
  */
 export declare function makeContent(content: Content | {
     readonly [k: string]: Media | Reference;
 }): string[];
 /**
- * generates a request body code from the given request body object.
- * @param body RequestBody object
- * @returns
+ * Generates code for an OpenAPI request body.
+ *
+ * Handles both $ref references and inline request body definitions
+ * with description, content, and required properties.
+ *
+ * @param body - OpenAPI request body object or reference
+ * @returns TypeScript code string for the request body
+ *
+ * @example
+ * ```ts
+ * // Reference
+ * makeRequestBody({ $ref: '#/components/requestBodies/CreateUser' })
+ * // → 'CreateUserRequestBody'
+ *
+ * // Inline
+ * makeRequestBody({
+ *   content: { 'application/json': { schema: {...} } },
+ *   required: true
+ * })
+ * // → '{content:{"application/json":{schema:...}},required:true}'
+ * ```
  */
 export declare function makeRequestBody(body: RequestBody | Reference): string;
 /**
- * generates a media code from the given media object.
- * @param media Media object
- * @returns
+ * Generates code for an OpenAPI media object.
+ *
+ * Converts media type definitions including schema, examples,
+ * and encoding into TypeScript code.
+ *
+ * @param media - OpenAPI media object
+ * @returns TypeScript code string for the media
+ *
+ * @example
+ * ```ts
+ * makeMedia({
+ *   schema: { type: 'object', properties: { name: { type: 'string' } } },
+ *   example: { name: 'John' }
+ * })
+ * // → '{schema:z.object({name:z.string()}),example:{"name":"John"}}'
+ * ```
  */
 export declare function makeMedia(media: Media): string;
 /**
- * generates an encoding code from the given encoding object.
- * @param encoding
- * @returns
+ * Generates code for an OpenAPI encoding object.
+ *
+ * Handles encoding properties for multipart request bodies including
+ * contentType, headers, and nested encoding configurations.
+ *
+ * @param encoding - OpenAPI encoding object
+ * @returns TypeScript code string for the encoding
+ *
+ * @example
+ * ```ts
+ * makeEncoding({
+ *   contentType: 'image/png',
+ *   headers: { 'X-Custom': { schema: { type: 'string' } } }
+ * })
+ * // → 'contentType:"image/png",headers:{"X-Custom":{schema:z.string()}}'
+ * ```
  */
 export declare function makeEncoding(encoding: Encoding): string;
 /**

package/dist/helper/openapi.js

@@ -174,13 +174,26 @@ export function makeExamples(examples) {
     return `{${result}}`;
 }
 /**
- * generates a responses code from the given responses object.
- * @param responses
- * @returns
+ * Generates response code for an operation's responses object.
+ *
+ * Converts OpenAPI operation responses into a TypeScript object literal string
+ * with status codes as keys and response definitions as values.
+ *
+ * @param responses - The responses object from an OpenAPI operation
+ * @returns Object literal string with status code keys and response values
+ *
+ * @example
+ * ```ts
+ * makeOperationResponses({
+ *   '200': { description: 'Success', content: {...} },
+ *   'default': { description: 'Error' }
+ * })
+ * // → '{200:{description:"Success",content:{...}},"default":{description:"Error"}}'
+ * ```
  */
 export function makeOperationResponses(responses) {
     const result = Object.entries(responses)
-        .map(([StatusCode, res]) => `${/^\d+$/.test(StatusCode) ? StatusCode : `'${StatusCode}'`}:${makeResponses(res)}`)
+        .map(([statusCode, res]) => `${/^\d+$/.test(statusCode) ? statusCode : `'${statusCode}'`}:${makeResponses(res)}`)
         // .map(([statusCode, res]) => `${JSON.stringify(statusCode)}:${makeResponses(res)}`)
         .join(',');
     return `{${result}}`;
@@ -198,9 +211,24 @@ export function makeHeaderResponses(headers) {
     return `z.object({${result}})`;
 }
 /**
- * generates a response code from the given responses object.
- * @param responses
- * @returns
+ * Generates code for a single response object.
+ *
+ * Handles both $ref references and inline response definitions,
+ * including headers, content, and links.
+ *
+ * @param responses - OpenAPI response object or reference
+ * @returns TypeScript code string for the response
+ *
+ * @example
+ * ```ts
+ * // Reference
+ * makeResponses({ $ref: '#/components/responses/NotFound' })
+ * // → 'NotFoundResponse'
+ *
+ * // Inline
+ * makeResponses({ description: 'Success', content: {...} })
+ * // → '{description:"Success",content:{...}}'
+ * ```
  */
 export function makeResponses(responses) {
     if (responses.$ref) {
@@ -224,9 +252,24 @@ export function makeResponses(responses) {
     return `{${result}}`;
 }
 /**
- * generates a header code from the given headers object.
- * @param headers Headers object
- * @returns
+ * Generates code for a header or header reference.
+ *
+ * Handles both $ref references and inline header definitions with
+ * all OpenAPI header properties (description, required, schema, etc.).
+ *
+ * @param headers - OpenAPI header object or reference
+ * @returns TypeScript code string for the header
+ *
+ * @example
+ * ```ts
+ * // Reference
+ * makeHeadersAndReferences({ $ref: '#/components/headers/XRequestId' })
+ * // → 'XRequestIdHeaderSchema'
+ *
+ * // Inline
+ * makeHeadersAndReferences({ schema: { type: 'string' }, required: true })
+ * // → '{required:true,schema:z.string()}'
+ * ```
  */
 export function makeHeadersAndReferences(headers) {
     if ('$ref' in headers && headers.$ref) {
@@ -260,9 +303,22 @@ export function makeHeadersAndReferences(headers) {
     return `{${result}}`;
 }
 /**
- * generates a link or reference code from the given link or reference object.
- * @param linkOrReference
- * @returns
+ * Generates code for a link or link reference.
+ *
+ * Handles OpenAPI link objects with operationRef, operationId,
+ * parameters, requestBody, and other link properties.
+ *
+ * @param linkOrReference - OpenAPI link object or reference
+ * @returns TypeScript code string for the link
+ *
+ * @example
+ * ```ts
+ * makeLinkOrReference({
+ *   operationId: 'getUser',
+ *   parameters: { userId: '$response.body#/id' }
+ * })
+ * // → '{operationId:"getUser",parameters:{"userId":"$response.body#/id"}}'
+ * ```
  */
 export function makeLinkOrReference(linkOrReference) {
     const result = [
@@ -321,9 +377,25 @@ export function makeOperationCallbacks(callbacks) {
     return `{${result}}`;
 }
 /**
- * generates callbacks
- * @param callbacks
- * @returns
+ * Generates code for OpenAPI callbacks object.
+ *
+ * Converts callbacks with their path items and operations into
+ * TypeScript code. Handles $ref references to callback components.
+ *
+ * @param callbacks - OpenAPI callbacks object with path expressions
+ * @returns TypeScript code string for the callbacks
+ *
+ * @example
+ * ```ts
+ * makeCallbacks({
+ *   onPaymentComplete: {
+ *     '{$request.body#/callbackUrl}': {
+ *       post: { requestBody: {...}, responses: {...} }
+ *     }
+ *   }
+ * })
+ * // → '"onPaymentComplete":{post:{requestBody:{...},responses:{...}}}'
+ * ```
  */
 export function makeCallbacks(callbacks) {
     const isRef = (v) => {
@@ -395,9 +467,22 @@ export function makeCallbacks(callbacks) {
         .join(',');
 }
 /**
- * generates content
- * @param content
- * @returns
+ * Generates code for OpenAPI content object.
+ *
+ * Processes each media type in the content object and generates
+ * corresponding TypeScript code. Handles both $ref references
+ * and inline media definitions.
+ *
+ * @param content - OpenAPI content object with media types
+ * @returns Array of media type code strings
+ *
+ * @example
+ * ```ts
+ * makeContent({
+ *   'application/json': { schema: { type: 'object', properties: {...} } }
+ * })
+ * // → ["'application/json':{schema:z.object({...})}"]
+ * ```
  */
 export function makeContent(content) {
     const isMedia = (v) => typeof v === 'object' && v !== null && 'schema' in v;
@@ -417,9 +502,27 @@ export function makeContent(content) {
         .filter((v) => v !== undefined);
 }
 /**
- * generates a request body code from the given request body object.
- * @param body RequestBody object
- * @returns
+ * Generates code for an OpenAPI request body.
+ *
+ * Handles both $ref references and inline request body definitions
+ * with description, content, and required properties.
+ *
+ * @param body - OpenAPI request body object or reference
+ * @returns TypeScript code string for the request body
+ *
+ * @example
+ * ```ts
+ * // Reference
+ * makeRequestBody({ $ref: '#/components/requestBodies/CreateUser' })
+ * // → 'CreateUserRequestBody'
+ *
+ * // Inline
+ * makeRequestBody({
+ *   content: { 'application/json': { schema: {...} } },
+ *   required: true
+ * })
+ * // → '{content:{"application/json":{schema:...}},required:true}'
+ * ```
  */
 export function makeRequestBody(body) {
     if ('$ref' in body && body.$ref) {
@@ -435,9 +538,22 @@ export function makeRequestBody(body) {
     return `{${result}}`;
 }
 /**
- * generates a media code from the given media object.
- * @param media Media object
- * @returns
+ * Generates code for an OpenAPI media object.
+ *
+ * Converts media type definitions including schema, examples,
+ * and encoding into TypeScript code.
+ *
+ * @param media - OpenAPI media object
+ * @returns TypeScript code string for the media
+ *
+ * @example
+ * ```ts
+ * makeMedia({
+ *   schema: { type: 'object', properties: { name: { type: 'string' } } },
+ *   example: { name: 'John' }
+ * })
+ * // → '{schema:z.object({name:z.string()}),example:{"name":"John"}}'
+ * ```
  */
 export function makeMedia(media) {
     const encodingCode = media.encoding
@@ -459,9 +575,22 @@ export function makeMedia(media) {
     return `{${result}}`;
 }
 /**
- * generates an encoding code from the given encoding object.
- * @param encoding
- * @returns
+ * Generates code for an OpenAPI encoding object.
+ *
+ * Handles encoding properties for multipart request bodies including
+ * contentType, headers, and nested encoding configurations.
+ *
+ * @param encoding - OpenAPI encoding object
+ * @returns TypeScript code string for the encoding
+ *
+ * @example
+ * ```ts
+ * makeEncoding({
+ *   contentType: 'image/png',
+ *   headers: { 'X-Custom': { schema: { type: 'string' } } }
+ * })
+ * // → 'contentType:"image/png",headers:{"X-Custom":{schema:z.string()}}'
+ * ```
  */
 export function makeEncoding(encoding) {
     const nestedEncoding = encoding.encoding

package/dist/helper/type.d.ts

@@ -20,18 +20,3 @@ import type { Schema } from '../openapi/index.js';
  * ```
  */
 export declare function makeTypeString(schema: Schema, selfTypeName: string, cyclicGroup?: ReadonlySet<string>): string;
-/**
- * Generates a TypeScript record type string from an OpenAPI schema.
- *
- * @param valueSchema - The OpenAPI schema for the record values.
- * @param selfTypeName - The name of the current type (for self-reference detection).
- * @param cyclicGroup - Optional set of type names in a cyclic dependency group.
- * @returns A TypeScript record type string like `{[key:string]:ValueType}`.
- *
- * @example
- * ```ts
- * makeRecordTypeString({ type: 'string' }, 'Config')
- * // → '{[key:string]:string}'
- * ```
- */
-export declare function makeRecordTypeString(valueSchema: Schema, selfTypeName: string, cyclicGroup?: ReadonlySet<string>): string;

package/dist/helper/type.js

@@ -161,21 +161,3 @@ function makeObjectTypeString(schema, selfTypeName, cyclicGroup) {
     });
     return `{${propertyStrings.join(';')}}`;
 }
-/**
- * Generates a TypeScript record type string from an OpenAPI schema.
- *
- * @param valueSchema - The OpenAPI schema for the record values.
- * @param selfTypeName - The name of the current type (for self-reference detection).
- * @param cyclicGroup - Optional set of type names in a cyclic dependency group.
- * @returns A TypeScript record type string like `{[key:string]:ValueType}`.
- *
- * @example
- * ```ts
- * makeRecordTypeString({ type: 'string' }, 'Config')
- * // → '{[key:string]:string}'
- * ```
- */
-export function makeRecordTypeString(valueSchema, selfTypeName, cyclicGroup) {
-    const valueType = makeTypeString(valueSchema, selfTypeName, cyclicGroup);
-    return `{[key:string]:${valueType}}`;
-}

package/dist/utils/index.d.ts

@@ -8,13 +8,6 @@ export declare function normalizeTypes(t?: 'string' | 'number' | 'integer' | 'da
     'string' | 'number' | 'integer' | 'date' | 'boolean' | 'array' | 'object' | 'null',
     ...('string' | 'number' | 'integer' | 'date' | 'boolean' | 'array' | 'object' | 'null')[]
 ]): ("string" | "number" | "boolean" | "object" | "integer" | "date" | "array" | "null")[];
-/**
- * Generates registration code for OpenAPI `securitySchemes`.
- *
- * @param securitySchemes - Record of scheme name to scheme properties.
- * @returns Multiline string of registration statements.
- */
-export declare function registerComponent(securitySchemes: Record<string, unknown>): string;
 /**
  * Checks if a value is a non-null object (record-like).
  *

package/dist/utils/index.js

@@ -7,19 +7,6 @@
 export function normalizeTypes(t) {
     return t === undefined ? [] : Array.isArray(t) ? t : [t];
 }
-/**
- * Generates registration code for OpenAPI `securitySchemes`.
- *
- * @param securitySchemes - Record of scheme name to scheme properties.
- * @returns Multiline string of registration statements.
- */
-export function registerComponent(securitySchemes) {
-    return Object.entries(securitySchemes)
-        .map(([name, scheme]) => {
-        return `app.openAPIRegistry.registerComponent('securitySchemes','${name}',${JSON.stringify(scheme)})`;
-    })
-        .join('\n');
-}
 /**
  * Checks if a value is a non-null object (record-like).
  *

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "hono-takibi",
   "description": "Hono Takibi is a CLI tool that generates Hono routes from OpenAPI specifications.",
-  "version": "0.9.74",
+  "version": "0.9.75",
   "type": "module",
   "license": "MIT",
   "keywords": [