hono-openapi 0.4.7 → 0.5.0-rc.0

package/src/effect.d.ts

@@ -1,33 +0,0 @@
-import { Schema } from "effect";
-import type { Env, Input as HonoInput, MiddlewareHandler, ValidationTargets } from "hono";
-import type { HasUndefined, ResolverResult } from "./types.js";
-/**
- * Generate a resolver for an Effect schema
- * @param schema Effect schema
- * @returns Resolver result
- */
-export declare function resolver<Type, Context>(schema: Schema.Schema<Type, Context, never>): ResolverResult;
-/**
- * Create a validator middleware
- * @param target Target for validation
- * @param schema Effect schema
- * @returns Middleware handler
- */
-export declare function validator<Type, Context, Target extends keyof ValidationTargets, E extends Env, P extends string, In = Schema.Schema<Type, Context, never>["Encoded"], Out = Schema.Schema<Type, Context, never>["Type"], I extends HonoInput = {
-    in: HasUndefined<In> extends true ? {
-        [K in Target]?: K extends "json" ? In : HasUndefined<keyof ValidationTargets[K]> extends true ? {
-            [K2 in keyof In]?: ValidationTargets[K][K2];
-        } : {
-            [K2 in keyof In]: ValidationTargets[K][K2];
-        };
-    } : {
-        [K in Target]: K extends "json" ? In : HasUndefined<keyof ValidationTargets[K]> extends true ? {
-            [K2 in keyof In]?: ValidationTargets[K][K2];
-        } : {
-            [K2 in keyof In]: ValidationTargets[K][K2];
-        };
-    };
-    out: {
-        [K in Target]: Out;
-    };
-}, V extends I = I>(target: Target, schema: Schema.Schema<Type, Context, never>): MiddlewareHandler<E, P, V>;

package/src/helper.d.ts

@@ -1,10 +0,0 @@
-import type { OpenAPIV3 } from "openapi-types";
-import type { OpenAPIRoute, OpenApiSpecsOptions } from "./types.js";
-export declare const ALLOWED_METHODS: readonly ["GET", "PUT", "POST", "DELETE", "OPTIONS", "HEAD", "PATCH", "TRACE"];
-export declare const toOpenAPIPath: (path: string) => string;
-export declare const capitalize: (word: string) => string;
-export declare const generateOperationId: (method: string, paths: string) => string;
-export declare function registerSchemaPath({ path, method: _method, data, schema, }: OpenAPIRoute & {
-    schema: Partial<OpenAPIV3.PathsObject>;
-}): void;
-export declare function filterPaths(paths: OpenAPIV3.PathsObject, { excludeStaticFile, exclude, }: Pick<OpenApiSpecsOptions, "excludeStaticFile" | "exclude">): OpenAPIV3.PathsObject<{}, {}>;

package/src/index.d.ts

@@ -1,4 +0,0 @@
-export { generateSpecs, openAPISpecs } from "./openapi.js";
-export { describeRoute, generateRouteSpecs } from "./route.js";
-export type * from "./types.js";
-export * from "./utils.js";

package/src/openapi.d.ts

@@ -1,201 +0,0 @@
-import type { Context, Env, Hono, Input, Schema } from "hono";
-import type { BlankEnv, BlankInput, BlankSchema, MiddlewareHandler } from "hono/types";
-import type { OpenAPIV3 } from "openapi-types";
-import type { OpenAPIRouteHandlerConfig, OpenApiSpecsOptions } from "./types.js";
-/**
- * Route handler for OpenAPI specs
- * @param hono Instance of Hono
- * @param options Options for generating OpenAPI specs
- * @returns Middleware handler for OpenAPI specs
- */
-export declare function openAPISpecs<E extends Env = BlankEnv, P extends string = string, I extends Input = BlankInput, S extends Schema = BlankSchema>(hono: Hono<E, S, P>, options?: OpenApiSpecsOptions): MiddlewareHandler<E, P, I>;
-/**
- * Generate OpenAPI specs for the given Hono instance
- * @param hono Instance of Hono
- * @param options Options for generating OpenAPI specs
- * @param config Configuration for OpenAPI route handler
- * @param Context Route context for hiding routes
- * @returns OpenAPI specs
- */
-export declare function generateSpecs<E extends Env = BlankEnv, P extends string = string, I extends Input = BlankInput, S extends Schema = BlankSchema>(hono: Hono<E, S, P>, options?: OpenApiSpecsOptions, config?: OpenAPIRouteHandlerConfig, c?: Context<E, P, I>): Promise<{
-    tags: OpenAPIV3.TagObject[] | undefined;
-    info: {
-        title: string;
-        description: string;
-        termsOfService?: string;
-        contact?: OpenAPIV3.ContactObject;
-        license?: OpenAPIV3.LicenseObject;
-        version: string;
-    };
-    paths: {
-        [x: string]: ({
-            $ref?: string;
-            summary?: string;
-            description?: string;
-            servers?: OpenAPIV3.ServerObject[];
-            parameters?: (OpenAPIV3.ReferenceObject | OpenAPIV3.ParameterObject)[];
-        } & {
-            get?: {
-                tags?: string[];
-                summary?: string;
-                description?: string;
-                externalDocs?: OpenAPIV3.ExternalDocumentationObject;
-                operationId?: string;
-                parameters?: (OpenAPIV3.ReferenceObject | OpenAPIV3.ParameterObject)[];
-                requestBody?: OpenAPIV3.ReferenceObject | OpenAPIV3.RequestBodyObject;
-                responses: OpenAPIV3.ResponsesObject;
-                callbacks?: {
-                    [callback: string]: OpenAPIV3.ReferenceObject | OpenAPIV3.CallbackObject;
-                };
-                deprecated?: boolean;
-                security?: OpenAPIV3.SecurityRequirementObject[];
-                servers?: OpenAPIV3.ServerObject[];
-            } | undefined;
-            put?: {
-                tags?: string[];
-                summary?: string;
-                description?: string;
-                externalDocs?: OpenAPIV3.ExternalDocumentationObject;
-                operationId?: string;
-                parameters?: (OpenAPIV3.ReferenceObject | OpenAPIV3.ParameterObject)[];
-                requestBody?: OpenAPIV3.ReferenceObject | OpenAPIV3.RequestBodyObject;
-                responses: OpenAPIV3.ResponsesObject;
-                callbacks?: {
-                    [callback: string]: OpenAPIV3.ReferenceObject | OpenAPIV3.CallbackObject;
-                };
-                deprecated?: boolean;
-                security?: OpenAPIV3.SecurityRequirementObject[];
-                servers?: OpenAPIV3.ServerObject[];
-            } | undefined;
-            post?: {
-                tags?: string[];
-                summary?: string;
-                description?: string;
-                externalDocs?: OpenAPIV3.ExternalDocumentationObject;
-                operationId?: string;
-                parameters?: (OpenAPIV3.ReferenceObject | OpenAPIV3.ParameterObject)[];
-                requestBody?: OpenAPIV3.ReferenceObject | OpenAPIV3.RequestBodyObject;
-                responses: OpenAPIV3.ResponsesObject;
-                callbacks?: {
-                    [callback: string]: OpenAPIV3.ReferenceObject | OpenAPIV3.CallbackObject;
-                };
-                deprecated?: boolean;
-                security?: OpenAPIV3.SecurityRequirementObject[];
-                servers?: OpenAPIV3.ServerObject[];
-            } | undefined;
-            delete?: {
-                tags?: string[];
-                summary?: string;
-                description?: string;
-                externalDocs?: OpenAPIV3.ExternalDocumentationObject;
-                operationId?: string;
-                parameters?: (OpenAPIV3.ReferenceObject | OpenAPIV3.ParameterObject)[];
-                requestBody?: OpenAPIV3.ReferenceObject | OpenAPIV3.RequestBodyObject;
-                responses: OpenAPIV3.ResponsesObject;
-                callbacks?: {
-                    [callback: string]: OpenAPIV3.ReferenceObject | OpenAPIV3.CallbackObject;
-                };
-                deprecated?: boolean;
-                security?: OpenAPIV3.SecurityRequirementObject[];
-                servers?: OpenAPIV3.ServerObject[];
-            } | undefined;
-            options?: {
-                tags?: string[];
-                summary?: string;
-                description?: string;
-                externalDocs?: OpenAPIV3.ExternalDocumentationObject;
-                operationId?: string;
-                parameters?: (OpenAPIV3.ReferenceObject | OpenAPIV3.ParameterObject)[];
-                requestBody?: OpenAPIV3.ReferenceObject | OpenAPIV3.RequestBodyObject;
-                responses: OpenAPIV3.ResponsesObject;
-                callbacks?: {
-                    [callback: string]: OpenAPIV3.ReferenceObject | OpenAPIV3.CallbackObject;
-                };
-                deprecated?: boolean;
-                security?: OpenAPIV3.SecurityRequirementObject[];
-                servers?: OpenAPIV3.ServerObject[];
-            } | undefined;
-            head?: {
-                tags?: string[];
-                summary?: string;
-                description?: string;
-                externalDocs?: OpenAPIV3.ExternalDocumentationObject;
-                operationId?: string;
-                parameters?: (OpenAPIV3.ReferenceObject | OpenAPIV3.ParameterObject)[];
-                requestBody?: OpenAPIV3.ReferenceObject | OpenAPIV3.RequestBodyObject;
-                responses: OpenAPIV3.ResponsesObject;
-                callbacks?: {
-                    [callback: string]: OpenAPIV3.ReferenceObject | OpenAPIV3.CallbackObject;
-                };
-                deprecated?: boolean;
-                security?: OpenAPIV3.SecurityRequirementObject[];
-                servers?: OpenAPIV3.ServerObject[];
-            } | undefined;
-            patch?: {
-                tags?: string[];
-                summary?: string;
-                description?: string;
-                externalDocs?: OpenAPIV3.ExternalDocumentationObject;
-                operationId?: string;
-                parameters?: (OpenAPIV3.ReferenceObject | OpenAPIV3.ParameterObject)[];
-                requestBody?: OpenAPIV3.ReferenceObject | OpenAPIV3.RequestBodyObject;
-                responses: OpenAPIV3.ResponsesObject;
-                callbacks?: {
-                    [callback: string]: OpenAPIV3.ReferenceObject | OpenAPIV3.CallbackObject;
-                };
-                deprecated?: boolean;
-                security?: OpenAPIV3.SecurityRequirementObject[];
-                servers?: OpenAPIV3.ServerObject[];
-            } | undefined;
-            trace?: {
-                tags?: string[];
-                summary?: string;
-                description?: string;
-                externalDocs?: OpenAPIV3.ExternalDocumentationObject;
-                operationId?: string;
-                parameters?: (OpenAPIV3.ReferenceObject | OpenAPIV3.ParameterObject)[];
-                requestBody?: OpenAPIV3.ReferenceObject | OpenAPIV3.RequestBodyObject;
-                responses: OpenAPIV3.ResponsesObject;
-                callbacks?: {
-                    [callback: string]: OpenAPIV3.ReferenceObject | OpenAPIV3.CallbackObject;
-                };
-                deprecated?: boolean;
-                security?: OpenAPIV3.SecurityRequirementObject[];
-                servers?: OpenAPIV3.ServerObject[];
-            } | undefined;
-        }) | undefined;
-    };
-    components: {
-        schemas: {
-            [x: string]: OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject;
-        };
-        responses?: {
-            [key: string]: OpenAPIV3.ReferenceObject | OpenAPIV3.ResponseObject;
-        };
-        parameters?: {
-            [key: string]: OpenAPIV3.ReferenceObject | OpenAPIV3.ParameterObject;
-        };
-        examples?: {
-            [key: string]: OpenAPIV3.ReferenceObject | OpenAPIV3.ExampleObject;
-        };
-        requestBodies?: {
-            [key: string]: OpenAPIV3.ReferenceObject | OpenAPIV3.RequestBodyObject;
-        };
-        headers?: {
-            [key: string]: OpenAPIV3.ReferenceObject | OpenAPIV3.HeaderObject;
-        };
-        securitySchemes?: {
-            [key: string]: OpenAPIV3.ReferenceObject | OpenAPIV3.SecuritySchemeObject;
-        };
-        links?: {
-            [key: string]: OpenAPIV3.ReferenceObject | OpenAPIV3.LinkObject;
-        };
-        callbacks?: {
-            [key: string]: OpenAPIV3.ReferenceObject | OpenAPIV3.CallbackObject;
-        };
-    };
-    openapi: string;
-    servers?: OpenAPIV3.ServerObject[] | undefined;
-    security?: OpenAPIV3.SecurityRequirementObject[] | undefined;
-    externalDocs?: OpenAPIV3.ExternalDocumentationObject | undefined;
-}>;

package/src/route.d.ts

@@ -1,49 +0,0 @@
-import type { MiddlewareHandler } from "hono/types";
-import type { ClientErrorStatusCode, ServerErrorStatusCode } from "hono/utils/http-status";
-import type { DescribeRouteOptions, OpenAPIRouteHandlerConfig } from "./types.js";
-/**
- * Describe a route with OpenAPI specs.
- * @param specs Options for describing a route
- * @returns Middleware handler
- */
-export declare function describeRoute(specs: DescribeRouteOptions): MiddlewareHandler;
-/**
- * Generate OpenAPI specs for the given route
- * @param config Route handler configuration
- * @param docs Route description in OpenAPI specs
- * @param defaultOptions Default options for describing a route
- */
-export declare function generateRouteSpecs(config: OpenAPIRouteHandlerConfig, docs: DescribeRouteOptions, defaultOptions?: DescribeRouteOptions): Promise<{
-    docs: {
-        responses: {
-            [x: string]: import("openapi-types").OpenAPIV3.ReferenceObject | (import("openapi-types").OpenAPIV3.ResponseObject & {
-                content?: {
-                    [key: string]: Omit<import("openapi-types").OpenAPIV3.MediaTypeObject, "schema"> & {
-                        schema?: import("openapi-types").OpenAPIV3.ReferenceObject | import("openapi-types").OpenAPIV3.SchemaObject | import("./types.js").ResolverResult;
-                    };
-                };
-            });
-        };
-        tags?: string[];
-        summary?: string;
-        description?: string;
-        externalDocs?: import("openapi-types").OpenAPIV3.ExternalDocumentationObject;
-        operationId?: string;
-        requestBody?: import("openapi-types").OpenAPIV3.ReferenceObject | import("openapi-types").OpenAPIV3.RequestBodyObject;
-        callbacks?: {
-            [callback: string]: import("openapi-types").OpenAPIV3.ReferenceObject | import("openapi-types").OpenAPIV3.CallbackObject;
-        };
-        deprecated?: boolean;
-        security?: import("openapi-types").OpenAPIV3.SecurityRequirementObject[];
-        servers?: import("openapi-types").OpenAPIV3.ServerObject[];
-        hide?: boolean | (<E extends import("hono").Env = import("hono").Env, P extends string = string, I extends import("hono").Input = import("hono/types").BlankInput>(c: import("hono").Context<E, P, I>) => boolean);
-        validateResponse?: boolean | {
-            status: ClientErrorStatusCode | ServerErrorStatusCode;
-            message?: string;
-        };
-        parameters?: (import("openapi-types").OpenAPIV3.ParameterObject | (import("openapi-types").OpenAPIV3.ParameterObject & {
-            schema: import("./types.js").ResolverResult;
-        }))[];
-    };
-    components: {};
-}>;

package/src/toOpenAPISchema.d.ts

@@ -1,21 +0,0 @@
-import type { JSONSchema, ParserOptions } from "@apidevtools/json-schema-ref-parser";
-import type { JSONSchema4 } from "json-schema";
-import type { OpenAPIV3 } from "openapi-types";
-export type addPrefixToObject = {
-    [K in keyof JSONSchema as `x-${K}`]: JSONSchema[K];
-};
-export interface Options {
-    cloneSchema?: boolean;
-    dereference?: boolean;
-    convertUnreferencedDefinitions?: boolean;
-    dereferenceOptions?: ParserOptions | undefined;
-}
-type ExtendedJSONSchema = addPrefixToObject & JSONSchema;
-export type SchemaType = ExtendedJSONSchema & {
-    example?: JSONSchema["examples"][number];
-    "x-patternProperties"?: JSONSchema["patternProperties"];
-    nullable?: boolean;
-};
-export type SchemaTypeKeys = keyof SchemaType;
-declare const convert: <T extends object = JSONSchema4>(schema: T, options?: Options) => Promise<OpenAPIV3.Document>;
-export default convert;

package/src/typebox.d.ts

@@ -1,25 +0,0 @@
-import { type Hook } from "@hono/typebox-validator";
-import type { Static, TSchema } from "@sinclair/typebox";
-import type { Env, MiddlewareHandler, ValidationTargets } from "hono";
-import type { ResolverResult } from "./types.js";
-/**
- * Generate a resolver for a TypeBox schema
- * @param schema TypeBox schema
- * @returns Resolver result
- */
-export declare function resolver<T extends TSchema>(schema: T): ResolverResult;
-/**
- * Create a validator middleware
- * @param target Target for validation
- * @param schema TypeBox schema
- * @param hook Hook for validation
- * @returns Middleware handler
- */
-export declare function validator<T extends TSchema, Target extends keyof ValidationTargets, E extends Env, P extends string, V extends {
-    in: {
-        [K in Target]: Static<T>;
-    };
-    out: {
-        [K in Target]: Static<T>;
-    };
-}>(target: Target, schema: T, hook?: Hook<Static<T>, E, P>): MiddlewareHandler<E, P, V>;

package/src/types.d.ts

@@ -1,101 +0,0 @@
-import type { Context, Env, Input } from "hono";
-import type { BlankInput } from "hono/types";
-import type { ClientErrorStatusCode, ServerErrorStatusCode } from "hono/utils/http-status";
-import type { OpenAPIV3 } from "openapi-types";
-import type { ALLOWED_METHODS } from "./helper.js";
-export type HasUndefined<T> = undefined extends T ? true : false;
-export type PromiseOr<T> = T | Promise<T>;
-export type OpenAPIRouteHandlerConfig = {
-    version: "3.0.0" | "3.0.1" | "3.0.2" | "3.0.3" | "3.1.0";
-    components: OpenAPIV3.ComponentsObject["schemas"];
-} & {
-    [key: string]: unknown;
-};
-export type ResolverResult = {
-    builder: (options?: OpenAPIRouteHandlerConfig) => PromiseOr<{
-        schema: OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject;
-        components?: OpenAPIV3.ComponentsObject["schemas"];
-    }>;
-    validator: (values: unknown) => PromiseOr<void>;
-};
-export type HandlerResponse = {
-    resolver: (config: OpenAPIRouteHandlerConfig, defaultOptions?: DescribeRouteOptions) => PromiseOr<{
-        docs: OpenAPIV3.OperationObject;
-        components?: OpenAPIV3.ComponentsObject["schemas"];
-    }>;
-    metadata?: Record<string, unknown>;
-};
-export type DescribeRouteOptions = Omit<OpenAPIV3.OperationObject, "responses" | "parameters"> & {
-    /**
-     * Pass `true` to hide route from OpenAPI/swagger document
-     */
-    hide?: boolean | (<E extends Env = Env, P extends string = string, I extends Input = BlankInput>(c: Context<E, P, I>) => boolean);
-    /**
-     * Validate response of the route
-     */
-    validateResponse?: boolean | {
-        status: ClientErrorStatusCode | ServerErrorStatusCode;
-        message?: string;
-    };
-    /**
-     * Responses of the request
-     */
-    responses?: {
-        [key: string]: (OpenAPIV3.ResponseObject & {
-            content?: {
-                [key: string]: Omit<OpenAPIV3.MediaTypeObject, "schema"> & {
-                    schema?: OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject | ResolverResult;
-                };
-            };
-        }) | OpenAPIV3.ReferenceObject;
-    };
-    /**
-     * Parameters of the request
-     */
-    parameters?: (OpenAPIV3.ParameterObject | (OpenAPIV3.ParameterObject & {
-        schema: ResolverResult;
-    }))[];
-};
-export interface OpenAPIRoute {
-    path: string;
-    method: (typeof ALLOWED_METHODS)[number] | "ALL";
-    data?: DescribeRouteOptions | Pick<OpenAPIV3.OperationObject, "parameters" | "requestBody">;
-}
-export type OpenApiSpecsOptions = {
-    /**
-     * Customize OpenAPI config, refers to Swagger 2.0 config
-     *
-     * @see https://swagger.io/specification/v2/
-     */
-    documentation?: Omit<Partial<OpenAPIV3.Document>, "x-express-openapi-additional-middleware" | "x-express-openapi-validation-strict">;
-    /**
-     * Include paths which don't have the handlers.
-     * This is useful when you want to document the
-     * API without implementing it or index all the paths.
-     */
-    includeEmptyPaths?: boolean;
-    /**
-     * Determine if Swagger should exclude static files.
-     *
-     * @default true
-     */
-    excludeStaticFile?: boolean;
-    /**
-     * Paths to exclude from OpenAPI endpoint
-     *
-     * @default []
-     */
-    exclude?: string | RegExp | Array<string | RegExp>;
-    /**
-     * Exclude methods from Open API
-     */
-    excludeMethods?: (typeof ALLOWED_METHODS)[number][];
-    /**
-     * Exclude tags from OpenAPI
-     */
-    excludeTags?: string[];
-    /**
-     * Default options for `describeRoute` method
-     */
-    defaultOptions?: Partial<Record<(typeof ALLOWED_METHODS)[number] | "ALL", DescribeRouteOptions>>;
-};

package/src/utils.d.ts

@@ -1,31 +0,0 @@
-import type { ValidationTargets } from "hono";
-import type { OpenAPIV3 } from "openapi-types";
-import type { ResolverResult } from "./types.js";
-/**
- * The unique symbol for the middlewares, which makes it easier to identify them. Not meant to be used directly, unless you're creating a custom middleware.
- */
-export declare const uniqueSymbol: unique symbol;
-/**
- * Generate OpenAPI docs for a validator middleware. Not meant to be used directly, unless you're creating a custom middleware.
- */
-export declare function generateValidatorDocs<Target extends keyof ValidationTargets>(target: Target, _result: ReturnType<ResolverResult["builder"]>): Promise<{
-    docs: Pick<{
-        tags?: string[];
-        summary?: string;
-        description?: string;
-        externalDocs?: OpenAPIV3.ExternalDocumentationObject;
-        operationId?: string;
-        parameters?: (OpenAPIV3.ReferenceObject | OpenAPIV3.ParameterObject)[];
-        requestBody?: OpenAPIV3.ReferenceObject | OpenAPIV3.RequestBodyObject;
-        responses: OpenAPIV3.ResponsesObject;
-        callbacks?: {
-            [callback: string]: OpenAPIV3.ReferenceObject | OpenAPIV3.CallbackObject;
-        };
-        deprecated?: boolean;
-        security?: OpenAPIV3.SecurityRequirementObject[];
-        servers?: OpenAPIV3.ServerObject[];
-    }, "parameters" | "requestBody">;
-    components: {
-        [key: string]: OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject;
-    } | undefined;
-}>;

package/src/valibot.d.ts

@@ -1,36 +0,0 @@
-import { type Hook } from "@hono/valibot-validator";
-import { type ConversionConfig } from "@valibot/to-json-schema";
-import type { Env, Input as HonoInput, MiddlewareHandler, ValidationTargets } from "hono";
-import { type BaseIssue, type BaseSchema, type GenericSchema, type GenericSchemaAsync, type InferInput, type InferOutput } from "valibot";
-import type { HasUndefined, ResolverResult } from "./types.js";
-/**
- * Generate a resolver for a Valibot schema
- * @param schema Valibot schema
- * @returns Resolver result
- */
-export declare function resolver<T extends BaseSchema<unknown, unknown, BaseIssue<unknown>>>(schema: T, config?: ConversionConfig): ResolverResult;
-/**
- * Create a validator middleware
- * @param target Target for validation
- * @param schema Valibot schema
- * @param hook Hook for validation
- * @returns Middleware handler
- */
-export declare function validator<T extends GenericSchema | GenericSchemaAsync, Target extends keyof ValidationTargets, E extends Env, P extends string, In = InferInput<T>, Out = InferOutput<T>, I extends HonoInput = {
-    in: HasUndefined<In> extends true ? {
-        [K in Target]?: K extends "json" ? In : HasUndefined<keyof ValidationTargets[K]> extends true ? {
-            [K2 in keyof In]?: ValidationTargets[K][K2];
-        } : {
-            [K2 in keyof In]: ValidationTargets[K][K2];
-        };
-    } : {
-        [K in Target]: K extends "json" ? In : HasUndefined<keyof ValidationTargets[K]> extends true ? {
-            [K2 in keyof In]?: ValidationTargets[K][K2];
-        } : {
-            [K2 in keyof In]: ValidationTargets[K][K2];
-        };
-    };
-    out: {
-        [K in Target]: Out;
-    };
-}, V extends I = I>(target: Target, schema: T, hook?: Hook<T, E, P>): MiddlewareHandler<E, P, V>;

package/src/zod.d.ts

@@ -1,31 +0,0 @@
-import { type Hook } from "@hono/zod-validator";
-import type { Env, Input, MiddlewareHandler, ValidationTargets } from "hono";
-import type { ZodSchema, z } from "zod";
-import type { HasUndefined, ResolverResult } from "./types.js";
-/**
- * Generate a resolver for a Zod schema
- * @param schema Zod schema
- * @returns Resolver result
- */
-export declare function resolver<T extends ZodSchema>(schema: T): ResolverResult;
-/**
- * Create a validator middleware
- * @param target Target for validation
- * @param schema Zod schema
- * @param hook Hook for validation
- * @returns Middleware handler
- */
-export declare function validator<T extends ZodSchema, Target extends keyof ValidationTargets, E extends Env, P extends string, In = z.input<T>, Out = z.output<T>, I extends Input = {
-    in: HasUndefined<In> extends true ? {
-        [K in Target]?: In extends ValidationTargets[K] ? In : {
-            [K2 in keyof In]?: ValidationTargets[K][K2];
-        };
-    } : {
-        [K in Target]: In extends ValidationTargets[K] ? In : {
-            [K2 in keyof In]: ValidationTargets[K][K2];
-        };
-    };
-    out: {
-        [K in Target]: Out;
-    };
-}, V extends I = I>(target: Target, schema: T, hook?: Hook<z.infer<T>, E, P, Target>): MiddlewareHandler<E, P, V>;

package/toOpenAPISchema.cjs

@@ -1 +0,0 @@
-"use strict";var e=require("json-schema-walker");const t=["$ref","definitions","title","multipleOf","maximum","exclusiveMaximum","minimum","exclusiveMinimum","maxLength","minLength","pattern","maxItems","minItems","uniqueItems","maxProperties","minProperties","required","enum","type","not","allOf","oneOf","anyOf","items","properties","additionalProperties","description","format","default","nullable","discriminator","readOnly","writeOnly","example","externalDocs","deprecated","xml"];let n=class extends Error{constructor(e){super(e),this.name="InvalidTypeError",this.message=e}};const i="x-",r=async(t,n)=>{if("object"!=typeof t)return t;if(t.type){const i=new e.Walker;return await i.loadSchema({definitions:n.definitions||[],...t,$schema:n.$schema},{dereference:!0,cloneSchema:!0,dereferenceOptions:{dereference:{circular:"ignore"}}}),await i.walk(o,i.vocabularies.DRAFT_07),"definitions"in i.rootSchema&&(i.rootSchema.definitions=void 0),i.rootSchema}if(Array.isArray(t)){const e=t;if(e.includes("null")){const t=e.filter((e=>"null"!==e));return{type:1===t.length?t[0]:t,nullable:!0}}}return t};function o(e){let r=e;return r?(r=function(e){return"object"!=typeof e||(e.$schema=void 0,e.$id=void 0,"id"in e&&(e.id=void 0)),e}(r),r=function(e){if("object"!=typeof e)return e;if(void 0===e.type)return e;if(function(e){if("object"==typeof e&&!Array.isArray(e)){if(e&&"$ref"in e&&e.$ref)return;if(e&&"properties"in e&&e.properties)return}const t=Array.isArray(e)?e:[e];for(const e of t)if(e&&!a.has(e))throw new n(`Type "${e}" is not a valid type`)}(e.type),Array.isArray(e.type)){e.type.includes("null")&&(e.nullable=!0);const t=e.type.filter((e=>"null"!==e));0===t.length?e.type=void 0:1===t.length?e.type=t[0]:(e.type=void 0,e.anyOf=t.map((e=>({type:e}))))}else"null"===e.type&&(e.type=void 0,e.nullable=!0);return e}(r),r=function(e){void 0!==e.const&&(e.enum=[e.const],e.const=void 0);return e}(r),r=function(e){const t=e.dependencies;if("object"!=typeof t)return e;e.dependencies=void 0,Array.isArray(e.allOf)||(e.allOf=[]);for(const n in t){const i={oneOf:[{not:{required:[n]}},{required:[n,t[n]].flat()}]};e.allOf.push(i)}return e}(r),r=function(e){for(const t of["oneOf","anyOf"]){const n=e[t];if(!n)continue;if(!Array.isArray(n))return e;if(!n.some((e=>"null"===e.type)))return e;const i=n.filter((e=>"null"!==e.type));for(const e of i)e.nullable=!0;e[t]=i}return e}(r),r=function(e){if("object"!=typeof e)return e;"if"in e&&e.if&&e.then&&(e.oneOf=[{allOf:[e.if,e.then].filter(Boolean)},{allOf:[{not:e.if},e.else].filter(Boolean)}],e.if=void 0,e.then=void 0,e.else=void 0);return e}(r),r=function(e){"number"==typeof e.exclusiveMaximum&&(e.maximum=e.exclusiveMaximum,e.exclusiveMaximum=!0);"number"==typeof e.exclusiveMinimum&&(e.minimum=e.exclusiveMinimum,e.exclusiveMinimum=!0);return e}(r),r=function(e){e.examples&&Array.isArray(e.examples)&&(e.example=e.examples[0],e.examples=void 0);return e}(r),"object"==typeof r.patternProperties&&(r=function(e){return e["x-patternProperties"]=e.patternProperties,e.patternProperties=void 0,e.additionalProperties??=!0,e}(r)),"array"===r.type&&void 0===r.items&&(r.items={}),r=function(e){const n=Object.keys(e);for(const r of n)if(!r.startsWith(i)&&!t.includes(r)){e[`${i}${r}`]=e[r],e[r]=void 0}return e}(r),r):r}const a=new Set(["null","boolean","object","array","number","string","integer"]);exports.convert=async(t,n)=>{const i=new e.Walker;await i.loadSchema(t,n),await i.walk(o,i.vocabularies.DRAFT_07);const a=i.rootSchema;if(a?.definitions)for(const e in a.definitions){const n=a.definitions[e];a.definitions[e]=await r(n,t)}return a};

package/toOpenAPISchema.js

@@ -1 +0,0 @@
-import{Walker as e}from"json-schema-walker";const t=["$ref","definitions","title","multipleOf","maximum","exclusiveMaximum","minimum","exclusiveMinimum","maxLength","minLength","pattern","maxItems","minItems","uniqueItems","maxProperties","minProperties","required","enum","type","not","allOf","oneOf","anyOf","items","properties","additionalProperties","description","format","default","nullable","discriminator","readOnly","writeOnly","example","externalDocs","deprecated","xml"];let n=class extends Error{constructor(e){super(e),this.name="InvalidTypeError",this.message=e}};const i="x-",r=async(t,n)=>{if("object"!=typeof t)return t;if(t.type){const i=new e;return await i.loadSchema({definitions:n.definitions||[],...t,$schema:n.$schema},{dereference:!0,cloneSchema:!0,dereferenceOptions:{dereference:{circular:"ignore"}}}),await i.walk(a,i.vocabularies.DRAFT_07),"definitions"in i.rootSchema&&(i.rootSchema.definitions=void 0),i.rootSchema}if(Array.isArray(t)){const e=t;if(e.includes("null")){const t=e.filter((e=>"null"!==e));return{type:1===t.length?t[0]:t,nullable:!0}}}return t},o=async(t,n)=>{const i=new e;await i.loadSchema(t,n),await i.walk(a,i.vocabularies.DRAFT_07);const o=i.rootSchema;if(o?.definitions)for(const e in o.definitions){const n=o.definitions[e];o.definitions[e]=await r(n,t)}return o};function a(e){let r=e;return r?(r=function(e){return"object"!=typeof e||(e.$schema=void 0,e.$id=void 0,"id"in e&&(e.id=void 0)),e}(r),r=function(e){if("object"!=typeof e)return e;if(void 0===e.type)return e;if(function(e){if("object"==typeof e&&!Array.isArray(e)){if(e&&"$ref"in e&&e.$ref)return;if(e&&"properties"in e&&e.properties)return}const t=Array.isArray(e)?e:[e];for(const e of t)if(e&&!s.has(e))throw new n(`Type "${e}" is not a valid type`)}(e.type),Array.isArray(e.type)){e.type.includes("null")&&(e.nullable=!0);const t=e.type.filter((e=>"null"!==e));0===t.length?e.type=void 0:1===t.length?e.type=t[0]:(e.type=void 0,e.anyOf=t.map((e=>({type:e}))))}else"null"===e.type&&(e.type=void 0,e.nullable=!0);return e}(r),r=function(e){void 0!==e.const&&(e.enum=[e.const],e.const=void 0);return e}(r),r=function(e){const t=e.dependencies;if("object"!=typeof t)return e;e.dependencies=void 0,Array.isArray(e.allOf)||(e.allOf=[]);for(const n in t){const i={oneOf:[{not:{required:[n]}},{required:[n,t[n]].flat()}]};e.allOf.push(i)}return e}(r),r=function(e){for(const t of["oneOf","anyOf"]){const n=e[t];if(!n)continue;if(!Array.isArray(n))return e;if(!n.some((e=>"null"===e.type)))return e;const i=n.filter((e=>"null"!==e.type));for(const e of i)e.nullable=!0;e[t]=i}return e}(r),r=function(e){if("object"!=typeof e)return e;"if"in e&&e.if&&e.then&&(e.oneOf=[{allOf:[e.if,e.then].filter(Boolean)},{allOf:[{not:e.if},e.else].filter(Boolean)}],e.if=void 0,e.then=void 0,e.else=void 0);return e}(r),r=function(e){"number"==typeof e.exclusiveMaximum&&(e.maximum=e.exclusiveMaximum,e.exclusiveMaximum=!0);"number"==typeof e.exclusiveMinimum&&(e.minimum=e.exclusiveMinimum,e.exclusiveMinimum=!0);return e}(r),r=function(e){e.examples&&Array.isArray(e.examples)&&(e.example=e.examples[0],e.examples=void 0);return e}(r),"object"==typeof r.patternProperties&&(r=function(e){return e["x-patternProperties"]=e.patternProperties,e.patternProperties=void 0,e.additionalProperties??=!0,e}(r)),"array"===r.type&&void 0===r.items&&(r.items={}),r=function(e){const n=Object.keys(e);for(const r of n)if(!r.startsWith(i)&&!t.includes(r)){e[`${i}${r}`]=e[r],e[r]=void 0}return e}(r),r):r}const s=new Set(["null","boolean","object","array","number","string","integer"]);export{o as c};

package/typebox.cjs

@@ -1 +0,0 @@
-"use strict";var e=require("@hono/typebox-validator"),r=require("@sinclair/typebox/value"),a=require("./toOpenAPISchema.cjs"),t=require("./utils.cjs");function i(e){return{builder:async()=>({schema:await a.convert(e)}),validator:a=>{r.Value.Parse(e,a)}}}require("json-schema-walker"),exports.resolver=i,exports.validator=function(r,a,o){const s=e.tbValidator(r,a,o);return Object.assign(s,{[t.uniqueSymbol]:{resolver:async e=>t.generateValidatorDocs(r,await i(a).builder(e))}})};

package/typebox.d.cts

@@ -1 +0,0 @@
-export * from "./src/typebox";

package/typebox.d.ts

@@ -1 +0,0 @@
-export * from "./src/typebox.js";

package/typebox.js

@@ -1 +0,0 @@
-import{tbValidator as r}from"@hono/typebox-validator";import{Value as o}from"@sinclair/typebox/value";import{c as a}from"./toOpenAPISchema.js";import{u as t,g as e}from"./utils.js";import"json-schema-walker";function i(r){return{builder:async()=>({schema:await a(r)}),validator:a=>{o.Parse(r,a)}}}function s(o,a,s){const n=r(o,a,s);return Object.assign(n,{[t]:{resolver:async r=>e(o,await i(a).builder(r))}})}export{i as resolver,s as validator};

package/utils.cjs

@@ -1 +0,0 @@
-"use strict";const e=Symbol("openapi");exports.generateValidatorDocs=async function(e,s){const t=await s,n={};if("form"===e||"json"===e){const s="json"===e?"application/json":"multipart/form-data";n.requestBody&&"content"in n.requestBody&&n.requestBody.content?n.requestBody.content[s]={schema:t.schema}:n.requestBody={content:{[s]:{schema:t.schema}}}}else{const s=[];if("$ref"in t.schema)s.push({in:e,name:t.schema.$ref,schema:t.schema});else for(const[n,o]of Object.entries(t.schema.properties??{}))s.push({in:e,name:n,schema:o,required:t.schema.required?.includes(n)});n.parameters=s}return{docs:n,components:t.components}},exports.uniqueSymbol=e;

package/utils.js

@@ -1 +0,0 @@
-const e=Symbol("openapi");async function s(e,s){const n=await s,o={};if("form"===e||"json"===e){const s="json"===e?"application/json":"multipart/form-data";o.requestBody&&"content"in o.requestBody&&o.requestBody.content?o.requestBody.content[s]={schema:n.schema}:o.requestBody={content:{[s]:{schema:n.schema}}}}else{const s=[];if("$ref"in n.schema)s.push({in:e,name:n.schema.$ref,schema:n.schema});else for(const[o,t]of Object.entries(n.schema.properties??{}))s.push({in:e,name:o,schema:t,required:n.schema.required?.includes(o)});o.parameters=s}return{docs:o,components:n.components}}export{s as g,e as u};

package/valibot.cjs

@@ -1 +0,0 @@
-"use strict";var e=require("@hono/valibot-validator"),r=require("@valibot/to-json-schema"),a=require("valibot"),o=require("./toOpenAPISchema.cjs"),t=require("./utils.cjs");function i(e,t){return{builder:async()=>({schema:await o.convert(r.toJsonSchema(e,t))}),validator:async r=>{await a.parseAsync(e,r)}}}require("json-schema-walker"),exports.resolver=i,exports.validator=function(r,a,o){const s=e.vValidator(r,a,o);return Object.assign(s,{[t.uniqueSymbol]:{resolver:async e=>t.generateValidatorDocs(r,await i(a,{errorMode:"ignore"}).builder(e))}})};

package/valibot.d.cts

@@ -1 +0,0 @@
-export * from "./src/valibot";

package/valibot.d.ts

@@ -1 +0,0 @@
-export * from "./src/valibot.js";

package/valibot.js

@@ -1 +0,0 @@
-import{vValidator as o}from"@hono/valibot-validator";import{toJsonSchema as r}from"@valibot/to-json-schema";import{parseAsync as a}from"valibot";import{c as t}from"./toOpenAPISchema.js";import{u as i,g as s}from"./utils.js";import"json-schema-walker";function e(o,i){return{builder:async()=>({schema:await t(r(o,i))}),validator:async r=>{await a(o,r)}}}function n(r,a,t){const n=o(r,a,t);return Object.assign(n,{[i]:{resolver:async o=>s(r,await e(a,{errorMode:"ignore"}).builder(o))}})}export{e as resolver,n as validator};

package/zod.cjs

@@ -1 +0,0 @@
-"use strict";var e=require("@hono/zod-validator"),r=require("zod-openapi"),a=require("./utils.cjs");function t(e){return{builder:a=>{const{version:t,...o}=a??{};return r.createSchema(e,a?{openapi:t,...o}:void 0)},validator:e.parse}}exports.resolver=t,exports.validator=function(r,o,i){const n=e.zValidator(r,o,i);return Object.assign(n,{[a.uniqueSymbol]:{resolver:async e=>a.generateValidatorDocs(r,await t(o).builder(e)),metadata:{schemaType:"input"}}})};

package/zod.d.cts

@@ -1 +0,0 @@
-export * from "./src/zod";

package/zod.d.ts

@@ -1 +0,0 @@
-export * from "./src/zod.js";

package/zod.js

@@ -1 +0,0 @@
-import{zValidator as o}from"@hono/zod-validator";import{createSchema as r}from"zod-openapi";import{u as t,g as a}from"./utils.js";function i(o){return{builder:t=>{const{version:a,...i}=t??{};return r(o,t?{openapi:a,...i}:void 0)},validator:o.parse}}function e(r,e,n){const s=o(r,e,n);return Object.assign(s,{[t]:{resolver:async o=>a(r,await i(e).builder(o)),metadata:{schemaType:"input"}}})}export{i as resolver,e as validator};