@orpc/openapi 0.0.0-next.ef3ba82 → 0.0.0-next.f17a1a0

package/dist/next.js

@@ -0,0 +1,9 @@
+import {
+  OpenAPIHandler
+} from "./chunk-ATDLVTJE.js";
+import "./chunk-PGCWJMRO.js";
+import "./chunk-XGHV4TH3.js";
+export {
+  OpenAPIHandler
+};
+//# sourceMappingURL=next.js.map

package/dist/node.js

@@ -0,0 +1,30 @@
+import {
+  OpenAPICodec,
+  OpenAPIMatcher
+} from "./chunk-PGCWJMRO.js";
+import "./chunk-XGHV4TH3.js";
+
+// src/adapters/node/openapi-handler.ts
+import { sendStandardResponse, toStandardRequest } from "@orpc/server-standard-node";
+import { StandardHandler } from "@orpc/server/standard";
+var OpenAPIHandler = class {
+  standardHandler;
+  constructor(router, options) {
+    const matcher = options?.matcher ?? new OpenAPIMatcher();
+    const codec = options?.codec ?? new OpenAPICodec();
+    this.standardHandler = new StandardHandler(router, matcher, codec, { ...options });
+  }
+  async handle(req, res, ...rest) {
+    const standardRequest = toStandardRequest(req, res);
+    const result = await this.standardHandler.handle(standardRequest, ...rest);
+    if (!result.matched) {
+      return { matched: false };
+    }
+    await sendStandardResponse(res, result.response);
+    return { matched: true };
+  }
+};
+export {
+  OpenAPIHandler
+};
+//# sourceMappingURL=node.js.map

package/dist/src/adapters/fetch/index.d.ts

@@ -0,0 +1,2 @@
+export * from './openapi-handler';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/adapters/fetch/openapi-handler.d.ts

@@ -0,0 +1,11 @@
+import type { Context, Router } from '@orpc/server';
+import type { FetchHandler, FetchHandleResult } from '@orpc/server/fetch';
+import type { StandardHandleOptions } from '@orpc/server/standard';
+import type { MaybeOptionalOptions } from '@orpc/shared';
+import type { OpenAPIHandlerOptions } from '../standard';
+export declare class OpenAPIHandler<T extends Context> implements FetchHandler<T> {
+    private readonly standardHandler;
+    constructor(router: Router<T, any>, options?: NoInfer<OpenAPIHandlerOptions<T>>);
+    handle(request: Request, ...rest: MaybeOptionalOptions<StandardHandleOptions<T>>): Promise<FetchHandleResult>;
+}
+//# sourceMappingURL=openapi-handler.d.ts.map

package/dist/src/adapters/hono/index.d.ts

@@ -0,0 +1,2 @@
+export * from '../fetch';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/adapters/next/index.d.ts

@@ -0,0 +1,2 @@
+export * from '../fetch';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/adapters/node/index.d.ts

@@ -0,0 +1,2 @@
+export * from './openapi-handler';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/adapters/node/openapi-handler.d.ts

@@ -0,0 +1,11 @@
+import type { Context, Router } from '@orpc/server';
+import type { NodeHttpHandler, NodeHttpHandleResult, NodeHttpRequest, NodeHttpResponse } from '@orpc/server/node';
+import type { StandardHandleOptions } from '@orpc/server/standard';
+import type { MaybeOptionalOptions } from '@orpc/shared';
+import type { OpenAPIHandlerOptions } from '../standard';
+export declare class OpenAPIHandler<T extends Context> implements NodeHttpHandler<T> {
+    private readonly standardHandler;
+    constructor(router: Router<T, any>, options?: NoInfer<OpenAPIHandlerOptions<T>>);
+    handle(req: NodeHttpRequest, res: NodeHttpResponse, ...rest: MaybeOptionalOptions<StandardHandleOptions<T>>): Promise<NodeHttpHandleResult>;
+}
+//# sourceMappingURL=openapi-handler.d.ts.map

package/dist/src/adapters/standard/index.d.ts

@@ -0,0 +1,4 @@
+export * from './openapi-codec';
+export * from './openapi-handler';
+export * from './openapi-matcher';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/adapters/standard/openapi-codec.d.ts

@@ -0,0 +1,13 @@
+import type { ORPCError } from '@orpc/client';
+import type { AnyProcedure } from '@orpc/server';
+import type { StandardRequest, StandardResponse } from '@orpc/server-standard';
+import type { StandardCodec, StandardParams } from '@orpc/server/standard';
+import { OpenAPISerializer } from '@orpc/client/openapi';
+export declare class OpenAPICodec implements StandardCodec {
+    private readonly serializer;
+    constructor(serializer?: OpenAPISerializer);
+    decode(request: StandardRequest, params: StandardParams | undefined, procedure: AnyProcedure): Promise<unknown>;
+    encode(output: unknown, procedure: AnyProcedure): StandardResponse;
+    encodeError(error: ORPCError<any, any>): StandardResponse;
+}
+//# sourceMappingURL=openapi-codec.d.ts.map

package/dist/src/adapters/standard/openapi-handler.d.ts

@@ -0,0 +1,5 @@
+import type { Context } from '@orpc/server';
+import type { RPCHandlerOptions } from '@orpc/server/standard';
+export interface OpenAPIHandlerOptions<T extends Context> extends RPCHandlerOptions<T> {
+}
+//# sourceMappingURL=openapi-handler.d.ts.map

package/dist/src/adapters/standard/openapi-matcher.d.ts

@@ -0,0 +1,10 @@
+import type { AnyRouter } from '@orpc/server';
+import type { StandardMatcher, StandardMatchResult } from '@orpc/server/standard';
+import { type HTTPPath } from '@orpc/contract';
+export declare class OpenAPIMatcher implements StandardMatcher {
+    private readonly tree;
+    private pendingRouters;
+    init(router: AnyRouter, path?: string[]): void;
+    match(method: string, pathname: HTTPPath): Promise<StandardMatchResult>;
+}
+//# sourceMappingURL=openapi-matcher.d.ts.map

package/dist/src/index.d.ts

@@ -1,2 +1,16 @@
 /** unnoq */
-export * from './generator';
+import { setOperationExtender } from './openapi-operation-extender';
+export * from './openapi';
+export * from './openapi-content-builder';
+export * from './openapi-generator';
+export * from './openapi-operation-extender';
+export * from './openapi-parameters-builder';
+export * from './openapi-path-parser';
+export * from './schema';
+export * from './schema-converter';
+export * from './schema-utils';
+export * from './utils';
+export declare const oo: {
+    spec: typeof setOperationExtender;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/src/openapi-content-builder.d.ts

@@ -0,0 +1,10 @@
+import type { OpenAPI } from './openapi';
+import type { JSONSchema } from './schema';
+import type { PublicSchemaUtils } from './schema-utils';
+export declare class OpenAPIContentBuilder {
+    private readonly schemaUtils;
+    constructor(schemaUtils: PublicSchemaUtils);
+    build(jsonSchema: JSONSchema.JSONSchema, options?: Partial<OpenAPI.MediaTypeObject>): OpenAPI.ContentObject;
+}
+export type PublicOpenAPIContentBuilder = Pick<OpenAPIContentBuilder, keyof OpenAPIContentBuilder>;
+//# sourceMappingURL=openapi-content-builder.d.ts.map

package/dist/src/openapi-error.d.ts

@@ -0,0 +1,3 @@
+export declare class OpenAPIError extends Error {
+}
+//# sourceMappingURL=openapi-error.d.ts.map

package/dist/src/openapi-generator.d.ts

@@ -0,0 +1,67 @@
+import type { PublicOpenAPIInputStructureParser } from './openapi-input-structure-parser';
+import type { PublicOpenAPIOutputStructureParser } from './openapi-output-structure-parser';
+import type { PublicOpenAPIPathParser } from './openapi-path-parser';
+import type { SchemaConverter } from './schema-converter';
+import { OpenAPIJsonSerializer } from '@orpc/client/openapi';
+import { type ContractRouter } from '@orpc/contract';
+import { type AnyRouter } from '@orpc/server';
+import { type OpenAPI } from './openapi';
+import { type PublicOpenAPIContentBuilder } from './openapi-content-builder';
+import { type PublicOpenAPIParametersBuilder } from './openapi-parameters-builder';
+import { type PublicSchemaUtils } from './schema-utils';
+type ErrorHandlerStrategy = 'throw' | 'log' | 'ignore';
+export interface OpenAPIGeneratorOptions {
+    contentBuilder?: PublicOpenAPIContentBuilder;
+    parametersBuilder?: PublicOpenAPIParametersBuilder;
+    schemaConverters?: SchemaConverter[];
+    schemaUtils?: PublicSchemaUtils;
+    jsonSerializer?: OpenAPIJsonSerializer;
+    pathParser?: PublicOpenAPIPathParser;
+    inputStructureParser?: PublicOpenAPIInputStructureParser;
+    outputStructureParser?: PublicOpenAPIOutputStructureParser;
+    /**
+     * Throw error when you missing define tag definition on OpenAPI root tags
+     *
+     * Example: if procedure has tags ['foo', 'bar'], and OpenAPI root tags is ['foo'], then error will be thrown
+     * Because OpenAPI root tags is missing 'bar' tag
+     *
+     * @default false
+     */
+    considerMissingTagDefinitionAsError?: boolean;
+    /**
+     * Weather ignore procedures that has no path defined.
+     *
+     * @default false
+     */
+    ignoreUndefinedPathProcedures?: boolean;
+    /**
+     * What to do when we found an error with our router
+     *
+     * @default 'throw'
+     */
+    errorHandlerStrategy?: ErrorHandlerStrategy;
+    /**
+     * Strict error response
+     *
+     * @default true
+     */
+    strictErrorResponses?: boolean;
+}
+export declare class OpenAPIGenerator {
+    private readonly contentBuilder;
+    private readonly parametersBuilder;
+    private readonly schemaConverter;
+    private readonly schemaUtils;
+    private readonly jsonSerializer;
+    private readonly pathParser;
+    private readonly inputStructureParser;
+    private readonly outputStructureParser;
+    private readonly errorHandlerStrategy;
+    private readonly ignoreUndefinedPathProcedures;
+    private readonly considerMissingTagDefinitionAsError;
+    private readonly strictErrorResponses;
+    constructor(options?: OpenAPIGeneratorOptions);
+    generate(router: ContractRouter<any> | AnyRouter, doc: Omit<OpenAPI.OpenAPIObject, 'openapi'>): Promise<OpenAPI.OpenAPIObject>;
+}
+export {};
+//# sourceMappingURL=openapi-generator.d.ts.map

package/dist/src/openapi-input-structure-parser.d.ts

@@ -0,0 +1,22 @@
+import type { AnyContractProcedure } from '@orpc/contract';
+import type { PublicOpenAPIPathParser } from './openapi-path-parser';
+import type { JSONSchema, ObjectSchema } from './schema';
+import type { SchemaConverter } from './schema-converter';
+import type { PublicSchemaUtils } from './schema-utils';
+export interface OpenAPIInputStructureParseResult {
+    paramsSchema: ObjectSchema | undefined;
+    querySchema: ObjectSchema | undefined;
+    headersSchema: ObjectSchema | undefined;
+    bodySchema: JSONSchema.JSONSchema | undefined;
+}
+export declare class OpenAPIInputStructureParser {
+    private readonly schemaConverter;
+    private readonly schemaUtils;
+    private readonly pathParser;
+    constructor(schemaConverter: SchemaConverter, schemaUtils: PublicSchemaUtils, pathParser: PublicOpenAPIPathParser);
+    parse(contract: AnyContractProcedure, structure: 'compact' | 'detailed'): OpenAPIInputStructureParseResult;
+    private parseDetailedSchema;
+    private parseCompactSchema;
+}
+export type PublicOpenAPIInputStructureParser = Pick<OpenAPIInputStructureParser, keyof OpenAPIInputStructureParser>;
+//# sourceMappingURL=openapi-input-structure-parser.d.ts.map

package/dist/src/openapi-operation-extender.d.ts

@@ -0,0 +1,7 @@
+import type { AnyContractProcedure } from '@orpc/contract';
+import type { OpenAPI } from './openapi';
+export type OverrideOperationValue = OpenAPI.OperationObject | ((current: OpenAPI.OperationObject, procedure: AnyContractProcedure) => OpenAPI.OperationObject);
+export declare function setOperationExtender<T extends object>(o: T, extend: OverrideOperationValue): T;
+export declare function getOperationExtender(o: object): OverrideOperationValue | undefined;
+export declare function extendOperation(operation: OpenAPI.OperationObject, procedure: AnyContractProcedure): OpenAPI.OperationObject;
+//# sourceMappingURL=openapi-operation-extender.d.ts.map

package/dist/src/openapi-output-structure-parser.d.ts

@@ -0,0 +1,18 @@
+import type { AnyContractProcedure } from '@orpc/contract';
+import type { JSONSchema, ObjectSchema } from './schema';
+import type { SchemaConverter } from './schema-converter';
+import type { PublicSchemaUtils } from './schema-utils';
+export interface OpenAPIOutputStructureParseResult {
+    headersSchema: ObjectSchema | undefined;
+    bodySchema: JSONSchema.JSONSchema | undefined;
+}
+export declare class OpenAPIOutputStructureParser {
+    private readonly schemaConverter;
+    private readonly schemaUtils;
+    constructor(schemaConverter: SchemaConverter, schemaUtils: PublicSchemaUtils);
+    parse(contract: AnyContractProcedure, structure: 'compact' | 'detailed'): OpenAPIOutputStructureParseResult;
+    private parseDetailedSchema;
+    private parseCompactSchema;
+}
+export type PublicOpenAPIOutputStructureParser = Pick<OpenAPIOutputStructureParser, keyof OpenAPIOutputStructureParser>;
+//# sourceMappingURL=openapi-output-structure-parser.d.ts.map

package/dist/src/openapi-parameters-builder.d.ts

@@ -0,0 +1,12 @@
+import type { OpenAPI } from './openapi';
+import type { JSONSchema } from './schema';
+export declare class OpenAPIParametersBuilder {
+    build(paramIn: OpenAPI.ParameterObject['in'], jsonSchema: JSONSchema.JSONSchema & {
+        type: 'object';
+    } & object, options?: Pick<OpenAPI.ParameterObject, 'example' | 'style' | 'required'>): OpenAPI.ParameterObject[];
+    buildHeadersObject(jsonSchema: JSONSchema.JSONSchema & {
+        type: 'object';
+    } & object, options?: Pick<OpenAPI.ParameterObject, 'example' | 'style' | 'required'>): OpenAPI.HeadersObject;
+}
+export type PublicOpenAPIParametersBuilder = Pick<OpenAPIParametersBuilder, keyof OpenAPIParametersBuilder>;
+//# sourceMappingURL=openapi-parameters-builder.d.ts.map

package/dist/src/openapi-path-parser.d.ts

@@ -0,0 +1,8 @@
+export declare class OpenAPIPathParser {
+    parseDynamicParams(path: string): {
+        name: string;
+        raw: string;
+    }[];
+}
+export type PublicOpenAPIPathParser = Pick<OpenAPIPathParser, keyof OpenAPIPathParser>;
+//# sourceMappingURL=openapi-path-parser.d.ts.map

package/dist/src/openapi.d.ts

@@ -0,0 +1,3 @@
+export { OpenApiBuilder } from 'openapi3-ts/oas31';
+export type * as OpenAPI from 'openapi3-ts/oas31';
+//# sourceMappingURL=openapi.d.ts.map

package/dist/src/schema-converter.d.ts

@@ -0,0 +1,16 @@
+import type { Schema } from '@orpc/contract';
+import type { JSONSchema } from './schema';
+export interface SchemaConvertOptions {
+    strategy: 'input' | 'output';
+}
+export interface SchemaConverter {
+    condition(schema: Schema, options: SchemaConvertOptions): boolean;
+    convert(schema: Schema, options: SchemaConvertOptions): JSONSchema.JSONSchema;
+}
+export declare class CompositeSchemaConverter implements SchemaConverter {
+    private readonly converters;
+    constructor(converters: SchemaConverter[]);
+    condition(): boolean;
+    convert(schema: Schema, options: SchemaConvertOptions): JSONSchema.JSONSchema;
+}
+//# sourceMappingURL=schema-converter.d.ts.map

package/dist/src/schema-utils.d.ts

@@ -0,0 +1,11 @@
+import { type FileSchema, type JSONSchema, type ObjectSchema } from './schema';
+export declare class SchemaUtils {
+    isFileSchema(schema: JSONSchema.JSONSchema): schema is FileSchema;
+    isObjectSchema(schema: JSONSchema.JSONSchema): schema is ObjectSchema;
+    isAnySchema(schema: JSONSchema.JSONSchema): boolean;
+    isUndefinableSchema(schema: JSONSchema.JSONSchema): boolean;
+    separateObjectSchema(schema: ObjectSchema, separatedProperties: string[]): [matched: ObjectSchema, rest: ObjectSchema];
+    filterSchemaBranches(schema: JSONSchema.JSONSchema, check: (schema: JSONSchema.JSONSchema) => boolean, matches?: JSONSchema.JSONSchema[]): [matches: JSONSchema.JSONSchema[], rest: JSONSchema.JSONSchema | undefined];
+}
+export type PublicSchemaUtils = Pick<SchemaUtils, keyof SchemaUtils>;
+//# sourceMappingURL=schema-utils.d.ts.map

package/dist/src/schema.d.ts

@@ -0,0 +1,12 @@
+import * as JSONSchema from 'json-schema-typed/draft-2020-12';
+export { Format as JSONSchemaFormat } from 'json-schema-typed/draft-2020-12';
+export { JSONSchema };
+export type ObjectSchema = JSONSchema.JSONSchema & {
+    type: 'object';
+} & object;
+export type FileSchema = JSONSchema.JSONSchema & {
+    type: 'string';
+    contentMediaType: string;
+} & object;
+export declare const NON_LOGIC_KEYWORDS: string[];
+//# sourceMappingURL=schema.d.ts.map

package/dist/src/utils.d.ts

@@ -0,0 +1,4 @@
+import type { HTTPPath } from '@orpc/contract';
+export declare function standardizeHTTPPath(path: HTTPPath): HTTPPath;
+export declare function toOpenAPI31RoutePattern(path: HTTPPath): string;
+//# sourceMappingURL=utils.d.ts.map

package/dist/standard.js

@@ -0,0 +1,10 @@
+import {
+  OpenAPICodec,
+  OpenAPIMatcher
+} from "./chunk-PGCWJMRO.js";
+import "./chunk-XGHV4TH3.js";
+export {
+  OpenAPICodec,
+  OpenAPIMatcher
+};
+//# sourceMappingURL=standard.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/openapi",
   "type": "module",
-  "version": "0.0.0-next.ef3ba82",
+  "version": "0.0.0-next.f17a1a0",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -19,36 +19,57 @@
       "import": "./dist/index.js",
       "default": "./dist/index.js"
     },
+    "./standard": {
+      "types": "./dist/src/adapters/standard/index.d.ts",
+      "import": "./dist/standard.js",
+      "default": "./dist/standard.js"
+    },
     "./fetch": {
-      "types": "./dist/src/fetch/index.d.ts",
+      "types": "./dist/src/adapters/fetch/index.d.ts",
       "import": "./dist/fetch.js",
       "default": "./dist/fetch.js"
     },
+    "./hono": {
+      "types": "./dist/src/adapters/hono/index.d.ts",
+      "import": "./dist/hono.js",
+      "default": "./dist/hono.js"
+    },
+    "./next": {
+      "types": "./dist/src/adapters/next/index.d.ts",
+      "import": "./dist/next.js",
+      "default": "./dist/next.js"
+    },
+    "./node": {
+      "types": "./dist/src/adapters/node/index.d.ts",
+      "import": "./dist/node.js",
+      "default": "./dist/node.js"
+    },
     "./🔒/*": {
       "types": "./dist/src/*.d.ts"
     }
   },
   "files": [
-    "!dist/*.tsbuildinfo",
+    "!**/*.map",
+    "!**/*.tsbuildinfo",
     "dist"
   ],
   "dependencies": {
-    "escape-string-regexp": "^5.0.0",
+    "@orpc/server-standard": "^0.4.0",
+    "@orpc/server-standard-fetch": "^0.4.0",
+    "@orpc/server-standard-node": "^0.4.0",
     "json-schema-typed": "^8.0.1",
     "openapi3-ts": "^4.4.0",
-    "@orpc/contract": "0.0.0-next.ef3ba82",
-    "@orpc/server": "0.0.0-next.ef3ba82",
-    "@orpc/shared": "0.0.0-next.ef3ba82",
-    "@orpc/zod": "0.0.0-next.ef3ba82",
-    "@orpc/transformer": "0.0.0-next.ef3ba82"
+    "rou3": "^0.5.1",
+    "@orpc/client": "0.0.0-next.f17a1a0",
+    "@orpc/contract": "0.0.0-next.f17a1a0",
+    "@orpc/server": "0.0.0-next.f17a1a0",
+    "@orpc/shared": "0.0.0-next.f17a1a0"
   },
   "devDependencies": {
-    "@readme/openapi-parser": "^2.6.0",
-    "hono": "^4.6.12",
-    "zod": "^3.23.8"
+    "zod": "^3.24.1"
   },
   "scripts": {
-    "build": "tsup --clean --entry.index=src/index.ts --entry.fetch=src/fetch/index.ts --format=esm --onSuccess='tsc -b --noCheck'",
+    "build": "tsup --onSuccess='tsc -b --noCheck'",
     "build:watch": "pnpm run build --watch",
     "type:check": "tsc -b"
   }

package/dist/src/fetch/base-handler.d.ts

@@ -1,14 +0,0 @@
-import type { HTTPPath } from '@orpc/contract';
-import type { FetchHandler } from '@orpc/server/fetch';
-import type { Router as HonoRouter } from 'hono/router';
-import { type Procedure, type Router } from '@orpc/server';
-export type ResolveRouter = (router: Router<any>, method: string, pathname: string) => {
-    path: string[];
-    procedure: Procedure<any, any, any, any, any>;
-    params: Record<string, string>;
-} | undefined;
-type Routing = HonoRouter<[string[], Procedure<any, any, any, any, any>]>;
-export declare function createOpenAPIHandler(createHonoRouter: () => Routing): FetchHandler;
-export declare function createResolveRouter(createHonoRouter: () => Routing): ResolveRouter;
-export declare function openAPIPathToRouterPath(path: HTTPPath): string;
-export {};

package/dist/src/fetch/index.d.ts

@@ -1,3 +0,0 @@
-export * from './base-handler';
-export * from './server-handler';
-export * from './serverless-handler';

package/dist/src/fetch/server-handler.d.ts

@@ -1,2 +0,0 @@
-import type { FetchHandler } from '@orpc/server/fetch';
-export declare function createOpenAPIServerHandler(): FetchHandler;

package/dist/src/fetch/serverless-handler.d.ts

@@ -1,2 +0,0 @@
-import type { FetchHandler } from '@orpc/server/fetch';
-export declare function createOpenAPIServerlessHandler(): FetchHandler;

package/dist/src/generator.d.ts

@@ -1,23 +0,0 @@
-import { type ContractRouter } from '@orpc/contract';
-import { type Router } from '@orpc/server';
-import { type OpenAPIObject } from 'openapi3-ts/oas31';
-export interface GenerateOpenAPIOptions {
-    /**
-     * Throw error when you missing define tag definition on OpenAPI root tags
-     *
-     * Example: if procedure has tags ['foo', 'bar'], and OpenAPI root tags is ['foo'], then error will be thrown
-     * Because OpenAPI root tags is missing 'bar' tag
-     *
-     * @default false
-     */
-    throwOnMissingTagDefinition?: boolean;
-    /**
-     * Weather ignore procedures that has no path defined.
-     *
-     * @default false
-     */
-    ignoreUndefinedPathProcedures?: boolean;
-}
-export declare function generateOpenAPI(opts: {
-    router: ContractRouter | Router<any>;
-} & Omit<OpenAPIObject, 'openapi'>, options?: GenerateOpenAPIOptions): OpenAPIObject;

package/dist/src/zod-to-json-schema.d.ts

@@ -1,42 +0,0 @@
-import { type JSONSchema } from 'json-schema-typed/draft-2020-12';
-import { type ZodTypeAny } from 'zod';
-export declare const NON_LOGIC_KEYWORDS: ("$anchor" | "$comment" | "$defs" | "$dynamicAnchor" | "$dynamicRef" | "$id" | "$schema" | "$vocabulary" | "contentEncoding" | "contentMediaType" | "default" | "definitions" | "deprecated" | "description" | "examples" | "format" | "readOnly" | "title" | "writeOnly")[];
-export declare const UNSUPPORTED_JSON_SCHEMA: {
-    not: {};
-};
-export declare const UNDEFINED_JSON_SCHEMA: {
-    const: string;
-};
-export interface ZodToJsonSchemaOptions {
-    /**
-     * Max depth of lazy type, if it exceeds.
-     *
-     * Used `{}` when reach max depth
-     *
-     * @default 5
-     */
-    maxLazyDepth?: number;
-    /**
-     * The length used to track the depth of lazy type
-     *
-     * @internal
-     */
-    lazyDepth?: number;
-    /**
-     * The expected json schema for input or output zod schema
-     *
-     * @default input
-     */
-    mode?: 'input' | 'output';
-    /**
-     * Track if current level schema is handled custom json schema to prevent recursive
-     *
-     * @internal
-     */
-    isHandledCustomJSONSchema?: boolean;
-}
-export declare function zodToJsonSchema(schema: ZodTypeAny, options?: ZodToJsonSchemaOptions): Exclude<JSONSchema, boolean>;
-export declare function extractJSONSchema(schema: JSONSchema, check: (schema: JSONSchema) => boolean, matches?: JSONSchema[]): {
-    schema: JSONSchema | undefined;
-    matches: JSONSchema[];
-};