ts-typed-api 0.1.21 → 0.1.23

package/README_HONO_ADAPTER.md

@@ -0,0 +1,136 @@
+# Hono Cloudflare Workers Adapter
+
+This adapter allows you to use `ts-typed-api` with [Hono](https://hono.dev/) framework in Cloudflare Workers, while maintaining the same API definitions and handler functions as the Express version.
+
+## Installation
+
+```bash
+npm install hono
+```
+
+## Usage
+
+### Basic Setup
+
+```typescript
+import { Hono } from 'hono';
+import { RegisterHonoHandlers } from 'ts-typed-api';
+import { ApiDefinition } from './definitions';
+
+const app = new Hono();
+
+// Use the same API definitions and handlers as Express
+RegisterHonoHandlers(app, ApiDefinition, {
+    domain: {
+        endpoint: async (req, res) => {
+            res.respond(200, { message: 'Hello from Cloudflare Workers!' });
+        }
+    }
+});
+
+// Export for Cloudflare Workers
+export default app;
+```
+
+### File Upload Support
+
+The adapter supports file uploads using Hono's `parseBody()` method, which is compatible with Cloudflare Workers:
+
+```typescript
+import { CreateApiDefinition, CreateResponses } from 'ts-typed-api';
+
+const ApiDefinition = CreateApiDefinition({
+    endpoints: {
+        upload: {
+            file: {
+                method: 'POST',
+                path: '/upload',
+                fileUpload: {
+                    single: {
+                        fieldName: 'file',
+                        maxSize: 10 * 1024 * 1024, // 10MB
+                        allowedMimeTypes: ['image/jpeg', 'image/png']
+                    }
+                },
+                responses: CreateResponses({
+                    200: z.object({ filename: z.string() })
+                })
+            }
+        }
+    }
+});
+
+// Handler works the same as Express
+RegisterHonoHandlers(app, ApiDefinition, {
+    upload: {
+        file: async (req, res) => {
+            const file = req.file; // File object with buffer, mimetype, etc.
+            // Process file...
+            res.respond(200, { filename: file.originalname });
+        }
+    }
+});
+```
+
+### Middleware Support
+
+```typescript
+const authMiddleware = async (req, res, next, endpointInfo) => {
+    const authHeader = req.headers.get('authorization');
+    if (!authHeader?.startsWith('Bearer ')) {
+        return res.status(401).json({
+            error: [{ field: "authorization", type: "general", message: "Unauthorized" }]
+        });
+    }
+    await next();
+};
+
+RegisterHonoHandlers(app, ApiDefinition, handlers, [authMiddleware]);
+```
+
+## Key Differences from Express
+
+1. **File Handling**: Uses `Uint8Array` instead of `Buffer` for file contents
+2. **Headers**: Use `req.headers.get()` instead of `req.headers[]`
+3. **Response Methods**: Hono uses `c.json()` instead of Express `res.json()`
+4. **Middleware**: Adapted to work with Hono's middleware system
+
+## Cloudflare Workers Deployment
+
+```javascript
+// wrangler.toml
+name = "my-api"
+main = "src/index.ts"
+compatibility_date = "2023-01-01"
+
+// src/index.ts
+import app from './app';
+
+export default {
+    fetch: app.fetch
+};
+```
+
+## API Compatibility
+
+The `RegisterHonoHandlers` function has the same signature as `RegisterHandlers`:
+
+```typescript
+RegisterHonoHandlers<TDef extends ApiDefinitionSchema>(
+    app: Hono,
+    apiDefinition: TDef,
+    objectHandlers: ObjectHandlers<TDef>,
+    middlewares?: AnyMiddleware<TDef>[]
+): void
+```
+
+This means you can switch between Express and Hono by simply changing the import and app initialization, while keeping your API definitions and handlers unchanged.
+
+## Supported File Upload Configurations
+
+- `single`: Single file upload
+- `array`: Multiple files with same field name
+- `fields`: Multiple files with different field names
+- `any`: Accept any files
+
+All configurations work the same as in the Express version but use Workers-compatible APIs.

package/dist/hono-cloudflare-workers.d.ts

@@ -0,0 +1,33 @@
+import { Hono, Context } from 'hono';
+import { z } from 'zod';
+import { ApiDefinitionSchema } from './definition';
+import { TypedRequest, TypedResponse } from './router';
+import { SpecificRouteHandler } from './handler';
+import { ObjectHandlers, AnyMiddleware, EndpointMiddleware } from './object-handlers';
+export type HonoFile = File;
+export declare const honoFileSchema: z.ZodObject<{
+    fieldname: z.ZodString;
+    originalname: z.ZodString;
+    encoding: z.ZodString;
+    mimetype: z.ZodString;
+    size: z.ZodNumber;
+    buffer: z.ZodOptional<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>;
+    file: z.ZodOptional<z.ZodCustom<import("buffer").File, import("buffer").File>>;
+    destination: z.ZodOptional<z.ZodString>;
+    filename: z.ZodOptional<z.ZodString>;
+    path: z.ZodOptional<z.ZodString>;
+    stream: z.ZodOptional<z.ZodAny>;
+}, z.core.$strip>;
+export type HonoFileType = z.infer<typeof honoFileSchema>;
+export type HonoTypedContext<TDef extends ApiDefinitionSchema, TDomain extends keyof TDef['endpoints'], TRouteKey extends keyof TDef['endpoints'][TDomain]> = Context & {
+    params: TypedRequest<TDef, TDomain, TRouteKey>['params'];
+    query: TypedRequest<TDef, TDomain, TRouteKey>['query'];
+    body: TypedRequest<TDef, TDomain, TRouteKey>['body'];
+    file?: HonoFile;
+    files?: HonoFile[] | {
+        [fieldname: string]: HonoFile[];
+    };
+    respond: TypedResponse<TDef, TDomain, TRouteKey>['respond'];
+};
+export declare function registerHonoRouteHandlers<TDef extends ApiDefinitionSchema>(app: Hono, apiDefinition: TDef, routeHandlers: Array<SpecificRouteHandler<TDef>>, middlewares?: EndpointMiddleware<TDef>[]): void;
+export declare function RegisterHonoHandlers<TDef extends ApiDefinitionSchema>(app: Hono, apiDefinition: TDef, objectHandlers: ObjectHandlers<TDef>, middlewares?: AnyMiddleware<TDef>[]): void;

package/dist/hono-cloudflare-workers.js

@@ -0,0 +1,474 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.honoFileSchema = void 0;
+exports.registerHonoRouteHandlers = registerHonoRouteHandlers;
+exports.RegisterHonoHandlers = RegisterHonoHandlers;
+const zod_1 = require("zod");
+// Hono-compatible file schema for Workers environment
+exports.honoFileSchema = zod_1.z.object({
+    fieldname: zod_1.z.string(),
+    originalname: zod_1.z.string(),
+    encoding: zod_1.z.string(),
+    mimetype: zod_1.z.string(),
+    size: zod_1.z.number(),
+    buffer: zod_1.z.instanceof(Uint8Array).optional(), // Workers use Uint8Array instead of Buffer
+    file: zod_1.z.instanceof(File).optional(), // Direct File object access
+    destination: zod_1.z.string().optional(),
+    filename: zod_1.z.string().optional(),
+    path: zod_1.z.string().optional(),
+    stream: zod_1.z.any().optional(),
+});
+// Helper function to preprocess query parameters for type coercion
+function preprocessQueryParams(query, querySchema) {
+    if (!querySchema || !query)
+        return query;
+    const processedQuery = { ...query };
+    if (querySchema instanceof zod_1.z.ZodObject) {
+        const shape = querySchema.shape;
+        for (const [key, value] of Object.entries(processedQuery)) {
+            if (typeof value === 'string' && shape[key]) {
+                const fieldSchema = shape[key];
+                let innerSchema = fieldSchema;
+                if (fieldSchema instanceof zod_1.z.ZodOptional) {
+                    innerSchema = fieldSchema._def.innerType;
+                }
+                if (fieldSchema instanceof zod_1.z.ZodDefault) {
+                    innerSchema = fieldSchema._def.innerType;
+                }
+                while (innerSchema instanceof zod_1.z.ZodOptional || innerSchema instanceof zod_1.z.ZodDefault) {
+                    if (innerSchema instanceof zod_1.z.ZodOptional) {
+                        innerSchema = innerSchema._def.innerType;
+                    }
+                    else if (innerSchema instanceof zod_1.z.ZodDefault) {
+                        innerSchema = innerSchema._def.innerType;
+                    }
+                }
+                if (innerSchema instanceof zod_1.z.ZodNumber) {
+                    const numValue = Number(value);
+                    if (!isNaN(numValue)) {
+                        processedQuery[key] = numValue;
+                    }
+                }
+                else if (innerSchema instanceof zod_1.z.ZodBoolean) {
+                    if (value === 'true') {
+                        processedQuery[key] = true;
+                    }
+                    else if (value === 'false') {
+                        processedQuery[key] = false;
+                    }
+                }
+            }
+        }
+    }
+    return processedQuery;
+}
+// Helper function to create file upload middleware for Hono/Workers
+function createHonoFileUploadMiddleware(config) {
+    return async (c, next) => {
+        try {
+            if (config.single) {
+                const formData = await c.req.parseBody({ all: false });
+                const file = formData[config.single.fieldName];
+                if (file instanceof File) {
+                    // Validate file
+                    if (config.single.maxSize && file.size > config.single.maxSize) {
+                        return c.json({
+                            data: null,
+                            error: [{ field: 'file', message: `File size exceeds ${config.single.maxSize} bytes`, type: 'body' }]
+                        }, 422);
+                    }
+                    if (config.single.allowedMimeTypes && !config.single.allowedMimeTypes.includes(file.type)) {
+                        return c.json({
+                            data: null,
+                            error: [{ field: 'file', message: `File type ${file.type} not allowed`, type: 'body' }]
+                        }, 422);
+                    }
+                    // Attach file to context
+                    c.file = {
+                        fieldname: config.single.fieldName,
+                        originalname: file.name,
+                        encoding: '7bit',
+                        mimetype: file.type,
+                        size: file.size,
+                        buffer: new Uint8Array(await file.arrayBuffer()),
+                        file: file
+                    };
+                }
+            }
+            else if (config.array) {
+                const formData = await c.req.parseBody({ all: true });
+                const files = formData[config.array.fieldName];
+                if (Array.isArray(files)) {
+                    // Validate files
+                    if (config.array.maxCount && files.length > config.array.maxCount) {
+                        return c.json({
+                            data: null,
+                            error: [{ field: 'file', message: `Maximum ${config.array.maxCount} files allowed`, type: 'body' }]
+                        }, 422);
+                    }
+                    const processedFiles = [];
+                    for (const file of files) {
+                        if (file instanceof File) {
+                            if (config.array.maxSize && file.size > config.array.maxSize) {
+                                return c.json({
+                                    data: null,
+                                    error: [{ field: 'file', message: `File size exceeds ${config.array.maxSize} bytes`, type: 'body' }]
+                                }, 422);
+                            }
+                            if (config.array.allowedMimeTypes && !config.array.allowedMimeTypes.includes(file.type)) {
+                                return c.json({
+                                    data: null,
+                                    error: [{ field: 'file', message: `File type ${file.type} not allowed`, type: 'body' }]
+                                }, 422);
+                            }
+                            processedFiles.push({
+                                fieldname: config.array.fieldName,
+                                originalname: file.name,
+                                encoding: '7bit',
+                                mimetype: file.type,
+                                size: file.size,
+                                buffer: new Uint8Array(await file.arrayBuffer()),
+                                file: file
+                            });
+                        }
+                    }
+                    c.files = processedFiles;
+                }
+            }
+            else if (config.fields) {
+                const formData = await c.req.parseBody({ all: true });
+                const filesMap = {};
+                for (const fieldConfig of config.fields) {
+                    const files = formData[fieldConfig.fieldName];
+                    if (Array.isArray(files)) {
+                        if (fieldConfig.maxCount && files.length > fieldConfig.maxCount) {
+                            return c.json({
+                                data: null,
+                                error: [{ field: fieldConfig.fieldName, message: `Maximum ${fieldConfig.maxCount} files allowed`, type: 'body' }]
+                            }, 422);
+                        }
+                        const processedFiles = [];
+                        for (const file of files) {
+                            if (file instanceof File) {
+                                if (fieldConfig.maxSize && file.size > fieldConfig.maxSize) {
+                                    return c.json({
+                                        data: null,
+                                        error: [{ field: fieldConfig.fieldName, message: `File size exceeds ${fieldConfig.maxSize} bytes`, type: 'body' }]
+                                    }, 422);
+                                }
+                                if (fieldConfig.allowedMimeTypes && !fieldConfig.allowedMimeTypes.includes(file.type)) {
+                                    return c.json({
+                                        data: null,
+                                        error: [{ field: fieldConfig.fieldName, message: `File type ${file.type} not allowed`, type: 'body' }]
+                                    }, 422);
+                                }
+                                processedFiles.push({
+                                    fieldname: fieldConfig.fieldName,
+                                    originalname: file.name,
+                                    encoding: '7bit',
+                                    mimetype: file.type,
+                                    size: file.size,
+                                    buffer: new Uint8Array(await file.arrayBuffer()),
+                                    file: file
+                                });
+                            }
+                        }
+                        filesMap[fieldConfig.fieldName] = processedFiles;
+                    }
+                }
+                c.files = filesMap;
+            }
+            else if (config.any) {
+                const formData = await c.req.parseBody({ all: true });
+                // Process all files
+                const allFiles = [];
+                for (const [key, value] of Object.entries(formData)) {
+                    if (value instanceof File) {
+                        if (config.any.maxSize && value.size > config.any.maxSize) {
+                            return c.json({
+                                data: null,
+                                error: [{ field: key, message: `File size exceeds ${config.any.maxSize} bytes`, type: 'body' }]
+                            }, 422);
+                        }
+                        if (config.any.allowedMimeTypes && !config.any.allowedMimeTypes.includes(value.type)) {
+                            return c.json({
+                                data: null,
+                                error: [{ field: key, message: `File type ${value.type} not allowed`, type: 'body' }]
+                            }, 422);
+                        }
+                        allFiles.push({
+                            fieldname: key,
+                            originalname: value.name,
+                            encoding: '7bit',
+                            mimetype: value.type,
+                            size: value.size,
+                            buffer: new Uint8Array(await value.arrayBuffer()),
+                            file: value
+                        });
+                    }
+                }
+                c.files = allFiles;
+            }
+            await next();
+        }
+        catch (error) {
+            console.error('File upload middleware error:', error);
+            return c.json({
+                data: null,
+                error: [{ field: 'file', message: 'File upload processing failed', type: 'body' }]
+            }, 422);
+        }
+    };
+}
+// Register route handlers with Hono, now generic over TDef
+function registerHonoRouteHandlers(app, apiDefinition, routeHandlers, middlewares) {
+    routeHandlers.forEach((specificHandlerIterationItem) => {
+        const { domain, routeKey, handler } = specificHandlerIterationItem;
+        const currentDomain = domain;
+        const currentRouteKey = routeKey;
+        const routeDefinition = apiDefinition.endpoints[currentDomain][currentRouteKey];
+        if (!routeDefinition) {
+            console.error(`Route definition not found for domain "${String(currentDomain)}" and routeKey "${String(currentRouteKey)}"`);
+            return;
+        }
+        const { path, method } = routeDefinition;
+        // Apply prefix from API definition if it exists
+        const fullPath = apiDefinition.prefix
+            ? `${apiDefinition.prefix.startsWith('/') ? apiDefinition.prefix : `/${apiDefinition.prefix}`}${path}`.replace(/\/+/g, '/')
+            : path;
+        const honoMiddleware = async (c) => {
+            try {
+                // Parse and validate request
+                const parsedParams = ('params' in routeDefinition && routeDefinition.params)
+                    ? routeDefinition.params.parse(c.req.param())
+                    : c.req.param();
+                const preprocessedQuery = ('query' in routeDefinition && routeDefinition.query)
+                    ? preprocessQueryParams(c.req.query(), routeDefinition.query)
+                    : c.req.query();
+                const parsedQuery = ('query' in routeDefinition && routeDefinition.query)
+                    ? routeDefinition.query.parse(preprocessedQuery)
+                    : preprocessedQuery;
+                let parsedBody = undefined;
+                if (method === 'POST' || method === 'PUT' || method === 'DELETE' || method === 'PATCH') {
+                    if ('body' in routeDefinition && routeDefinition.body) {
+                        // For JSON requests
+                        if (c.req.header('content-type')?.includes('application/json')) {
+                            parsedBody = routeDefinition.body.parse(await c.req.json());
+                        }
+                        else {
+                            // For form data or other body types
+                            parsedBody = routeDefinition.body.parse(await c.req.parseBody());
+                        }
+                    }
+                    else {
+                        parsedBody = await c.req.parseBody();
+                    }
+                }
+                // Attach parsed data to context
+                c.params = parsedParams;
+                c.query = parsedQuery;
+                c.body = parsedBody;
+                // Add respond method to context
+                c.respond = (status, data) => {
+                    const responseSchema = routeDefinition.responses[status];
+                    if (!responseSchema) {
+                        console.error(`No response schema defined for status ${status} in route ${String(currentDomain)}/${String(currentRouteKey)}`);
+                        c.__response = c.json({
+                            data: null,
+                            error: [{ field: "general", type: "general", message: "Internal server error: Undefined response schema for status." }]
+                        }, 500);
+                        return;
+                    }
+                    let responseBody;
+                    if (status === 422) {
+                        responseBody = {
+                            data: null,
+                            error: data
+                        };
+                    }
+                    else {
+                        // Always use unified response format since CreateResponses wraps all schemas
+                        responseBody = {
+                            data: data,
+                            error: null
+                        };
+                    }
+                    const validationResult = responseSchema.safeParse(responseBody);
+                    if (validationResult.success) {
+                        // Handle 204 responses specially - they must not have a body
+                        if (status === 204) {
+                            c.__response = new Response(null, { status: status });
+                        }
+                        else {
+                            c.__response = c.json(validationResult.data, status);
+                        }
+                    }
+                    else {
+                        console.error(`FATAL: Constructed response body failed Zod validation for status ${status} in route ${String(currentDomain)}/${String(currentRouteKey)}.`, validationResult.error.issues, 'Expected schema shape:', responseSchema._def?.shape, 'Provided data:', data, 'Constructed response body:', responseBody);
+                        c.__response = c.json({
+                            data: null,
+                            error: [{ field: "general", type: "general", message: "Internal server error: Constructed response failed validation." }]
+                        }, 500);
+                    }
+                };
+                // Create Express-like req/res objects for handler compatibility
+                const fakeReq = {
+                    params: parsedParams,
+                    query: parsedQuery,
+                    body: parsedBody,
+                    file: c.file,
+                    files: c.files,
+                    headers: c.req.header(),
+                    ip: c.req.header('CF-Connecting-IP') || '127.0.0.1',
+                    method: c.req.method,
+                    path: c.req.path,
+                    originalUrl: c.req.url
+                };
+                const fakeRes = {
+                    respond: c.respond
+                };
+                const specificHandlerFn = handler;
+                await specificHandlerFn(fakeReq, fakeRes);
+                // Return the response created by the handler
+                if (c.__response) {
+                    return c.__response;
+                }
+                else {
+                    console.error('No response was set by the handler');
+                    return c.json({
+                        data: null,
+                        error: [{ field: "general", type: "general", message: "Internal server error: No response set by handler." }]
+                    }, 500);
+                }
+            }
+            catch (error) {
+                if (error instanceof zod_1.z.ZodError) {
+                    const mappedErrors = error.issues.map(err => {
+                        let errorType = 'general';
+                        const pathZero = String(err.path[0]);
+                        if (pathZero === 'params')
+                            errorType = 'param';
+                        else if (pathZero === 'query')
+                            errorType = 'query';
+                        else if (pathZero === 'body')
+                            errorType = 'body';
+                        return {
+                            field: err.path.join('.') || 'request',
+                            message: err.message,
+                            type: errorType,
+                        };
+                    });
+                    const errorResponseBody = { data: null, error: mappedErrors };
+                    const schema422 = routeDefinition.responses[422];
+                    if (schema422) {
+                        const validationResult = schema422.safeParse(errorResponseBody);
+                        if (validationResult.success) {
+                            return c.json(validationResult.data, 422);
+                        }
+                        else {
+                            console.error("FATAL: Constructed 422 error response failed its own schema validation.", validationResult.error.issues);
+                            return c.json({ error: [{ field: "general", type: "general", message: "Internal server error constructing validation error response." }] }, 500);
+                        }
+                    }
+                    else {
+                        console.error("Error: 422 schema not found for route, sending raw Zod errors.");
+                        return c.json({ error: mappedErrors }, 422);
+                    }
+                }
+                else if (error instanceof Error) {
+                    console.error(`Error in ${method} ${path}:`, error.message);
+                    return c.json({ error: [{ field: "general", type: "general", message: 'Internal server error' }] }, 500);
+                }
+                else {
+                    console.error(`Unknown error in ${method} ${path}:`, error);
+                    return c.json({ error: [{ field: "general", type: "general", message: 'An unknown error occurred' }] }, 500);
+                }
+            }
+        };
+        // Create middleware wrappers
+        const middlewareWrappers = [];
+        // Add file upload middleware if configured
+        if (routeDefinition.fileUpload) {
+            try {
+                const fileUploadMiddleware = createHonoFileUploadMiddleware(routeDefinition.fileUpload);
+                middlewareWrappers.push(fileUploadMiddleware);
+            }
+            catch (error) {
+                console.error(`Error creating file upload middleware for ${currentDomain}.${currentRouteKey}:`, error);
+                return;
+            }
+        }
+        if (middlewares && middlewares.length > 0) {
+            middlewares.forEach(middleware => {
+                const wrappedMiddleware = async (c, next) => {
+                    try {
+                        await middleware(c.req, c.res, next, { domain: currentDomain, routeKey: currentRouteKey });
+                    }
+                    catch (error) {
+                        console.error('Middleware error:', error);
+                        return next();
+                    }
+                };
+                middlewareWrappers.push(wrappedMiddleware);
+            });
+        }
+        // Register route with middlewares
+        const allHandlers = [...middlewareWrappers, honoMiddleware];
+        // Register with Hono
+        switch (method.toUpperCase()) {
+            case 'GET':
+                app.get(fullPath, ...allHandlers);
+                break;
+            case 'POST':
+                app.post(fullPath, ...allHandlers);
+                break;
+            case 'PATCH':
+                app.patch(fullPath, ...allHandlers);
+                break;
+            case 'PUT':
+                app.put(fullPath, ...allHandlers);
+                break;
+            case 'DELETE':
+                app.delete(fullPath, ...allHandlers);
+                break;
+            default:
+                console.warn(`Unsupported HTTP method: ${method} for path ${fullPath}`);
+        }
+    });
+}
+// Transform object-based handlers to array format
+function transformObjectHandlersToArray(objectHandlers) {
+    const handlerArray = [];
+    for (const domain in objectHandlers) {
+        if (Object.prototype.hasOwnProperty.call(objectHandlers, domain)) {
+            const domainHandlers = objectHandlers[domain];
+            for (const routeKey in domainHandlers) {
+                if (Object.prototype.hasOwnProperty.call(domainHandlers, routeKey)) {
+                    const handler = domainHandlers[routeKey];
+                    handlerArray.push({
+                        domain,
+                        routeKey,
+                        handler
+                    });
+                }
+            }
+        }
+    }
+    return handlerArray;
+}
+// Main utility function that registers object-based handlers with Hono
+function RegisterHonoHandlers(app, apiDefinition, objectHandlers, middlewares) {
+    const handlerArray = transformObjectHandlersToArray(objectHandlers);
+    // Convert AnyMiddleware to EndpointMiddleware by checking function arity
+    const endpointMiddlewares = middlewares?.map(middleware => {
+        if (middleware.length === 4) {
+            return middleware;
+        }
+        else {
+            return ((req, res, next) => {
+                return middleware(req, res, next);
+            });
+        }
+    }) || [];
+    registerHonoRouteHandlers(app, apiDefinition, handlerArray, endpointMiddlewares);
+}

package/dist/index.d.ts

@@ -5,3 +5,4 @@ export { CreateApiDefinition, CreateResponses, ApiDefinitionSchema } from './def
 export { RegisterHandlers, EndpointMiddleware, UniversalEndpointMiddleware, SimpleMiddleware, EndpointInfo } from './object-handlers';
 export { File as UploadedFile } from './router';
 export { z as ZodSchema } from 'zod';
+export { RegisterHonoHandlers, registerHonoRouteHandlers, HonoFile, HonoFileType, honoFileSchema, HonoTypedContext } from './hono-cloudflare-workers';

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ZodSchema = exports.RegisterHandlers = exports.CreateResponses = exports.CreateApiDefinition = exports.generateOpenApiSpec2 = exports.generateOpenApiSpec = exports.FetchHttpClientAdapter = exports.ApiClient = void 0;
+exports.honoFileSchema = exports.registerHonoRouteHandlers = exports.RegisterHonoHandlers = exports.ZodSchema = exports.RegisterHandlers = exports.CreateResponses = exports.CreateApiDefinition = exports.generateOpenApiSpec2 = exports.generateOpenApiSpec = exports.FetchHttpClientAdapter = exports.ApiClient = void 0;
 var client_1 = require("./client");
 Object.defineProperty(exports, "ApiClient", { enumerable: true, get: function () { return client_1.ApiClient; } });
 Object.defineProperty(exports, "FetchHttpClientAdapter", { enumerable: true, get: function () { return client_1.FetchHttpClientAdapter; } });
@@ -15,3 +15,8 @@ var object_handlers_1 = require("./object-handlers");
 Object.defineProperty(exports, "RegisterHandlers", { enumerable: true, get: function () { return object_handlers_1.RegisterHandlers; } });
 var zod_1 = require("zod");
 Object.defineProperty(exports, "ZodSchema", { enumerable: true, get: function () { return zod_1.z; } });
+// Hono adapter for Cloudflare Workers
+var hono_cloudflare_workers_1 = require("./hono-cloudflare-workers");
+Object.defineProperty(exports, "RegisterHonoHandlers", { enumerable: true, get: function () { return hono_cloudflare_workers_1.RegisterHonoHandlers; } });
+Object.defineProperty(exports, "registerHonoRouteHandlers", { enumerable: true, get: function () { return hono_cloudflare_workers_1.registerHonoRouteHandlers; } });
+Object.defineProperty(exports, "honoFileSchema", { enumerable: true, get: function () { return hono_cloudflare_workers_1.honoFileSchema; } });