@orpc/openapi 0.17.0 → 0.19.0

package/dist/src/fetch/bracket-notation.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Serialize an object or array into a list of [key, value] pairs.
+ * The key will express by using bracket-notation.
+ *
+ * Notice: This way cannot express the empty object or array.
+ *
+ * @example
+ * ```ts
+ * const payload = {
+ *  name: 'John Doe',
+ *  pets: ['dog', 'cat'],
+ * }
+ *
+ * const entities = serialize(payload)
+ *
+ * expect(entities).toEqual([
+ *  ['name', 'John Doe'],
+ *  ['name[pets][0]', 'dog'],
+ *  ['name[pets][1]', 'cat'],
+ * ])
+ * ```
+ */
+export declare function serialize(payload: unknown, parentKey?: string): [string, unknown][];
+/**
+ * Deserialize a list of [key, value] pairs into an object or array.
+ * The key is expressed by using bracket-notation.
+ *
+ * @example
+ * ```ts
+ * const entities = [
+ *  ['name', 'John Doe'],
+ *  ['name[pets][0]', 'dog'],
+ *  ['name[pets][1]', 'cat'],
+ *  ['name[dogs][]', 'hello'],
+ *  ['name[dogs][]', 'kitty'],
+ * ]
+ *
+ * const payload = deserialize(entities)
+ *
+ * expect(payload).toEqual({
+ *  name: 'John Doe',
+ *  pets: { 0: 'dog', 1: 'cat' },
+ *  dogs: ['hello', 'kitty'],
+ * })
+ * ```
+ */
+export declare function deserialize(entities: readonly (readonly [string, unknown])[]): Record<string, unknown> | unknown[] | undefined;
+/**
+ * Escape the `[`, `]`, and `\` chars in a path segment.
+ *
+ * @example
+ * ```ts
+ * expect(escapeSegment('name[pets')).toEqual('name\\[pets')
+ * ```
+ */
+export declare function escapeSegment(segment: string): string;
+/**
+ * Convert an array of path segments into a path string using bracket-notation.
+ *
+ * For the special char `[`, `]`, and `\` will be escaped by adding `\` at start.
+ *
+ * @example
+ * ```ts
+ * expect(stringifyPath(['name', 'pets', '0'])).toEqual('name[pets][0]')
+ * ```
+ */
+export declare function stringifyPath(path: readonly [string, ...string[]]): string;
+/**
+ * Convert a path string using bracket-notation into an array of path segments.
+ *
+ * For the special char `[`, `]`, and `\` you should escape by adding `\` at start.
+ * It only treats a pair `[${string}]` as a path segment.
+ * If missing or escape it will bypass and treat as normal string.
+ *
+ * @example
+ * ```ts
+ * expect(parsePath('name[pets][0]')).toEqual(['name', 'pets', '0'])
+ * expect(parsePath('name[pets][0')).toEqual(['name', 'pets', '[0'])
+ * expect(parsePath('name[pets[0]')).toEqual(['name', 'pets[0')
+ * expect(parsePath('name\\[pets][0]')).toEqual(['name[pets]', '0'])
+ * ```
+ */
+export declare function parsePath(path: string): [string, ...string[]];
+//# sourceMappingURL=bracket-notation.d.ts.map

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

@@ -1,4 +1,10 @@
-export * from './base-handler';
-export * from './server-handler';
-export * from './serverless-handler';
+export * from './bracket-notation';
+export * from './input-builder-full';
+export * from './input-builder-simple';
+export * from './openapi-handler';
+export * from './openapi-handler-server';
+export * from './openapi-handler-serverless';
+export * from './openapi-payload-codec';
+export * from './openapi-procedure-matcher';
+export * from './schema-coercer';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/fetch/input-builder-full.d.ts

@@ -0,0 +1,11 @@
+import type { Params } from 'hono/router';
+export declare class InputBuilderFull {
+    build(params: Params, query: unknown, headers: unknown, body: unknown): {
+        params: Params;
+        query: unknown;
+        headers: unknown;
+        body: unknown;
+    };
+}
+export type PublicInputBuilderFull = Pick<InputBuilderFull, keyof InputBuilderFull>;
+//# sourceMappingURL=input-builder-full.d.ts.map

package/dist/src/fetch/input-builder-simple.d.ts

@@ -0,0 +1,6 @@
+import type { Params } from 'hono/router';
+export declare class InputBuilderSimple {
+    build(params: Params, payload: unknown): unknown;
+}
+export type PublicInputBuilderSimple = Pick<InputBuilderSimple, keyof InputBuilderSimple>;
+//# sourceMappingURL=input-builder-simple.d.ts.map

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

@@ -0,0 +1,7 @@
+import type { Context, Router } from '@orpc/server';
+import type { OpenAPIHandlerOptions } from './openapi-handler';
+import { OpenAPIHandler } from './openapi-handler';
+export declare class OpenAPIServerHandler<T extends Context> extends OpenAPIHandler<T> {
+    constructor(router: Router<T, any>, options?: NoInfer<OpenAPIHandlerOptions<T>>);
+}
+//# sourceMappingURL=openapi-handler-server.d.ts.map

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

@@ -0,0 +1,7 @@
+import type { Context, Router } from '@orpc/server';
+import type { OpenAPIHandlerOptions } from './openapi-handler';
+import { OpenAPIHandler } from './openapi-handler';
+export declare class OpenAPIServerlessHandler<T extends Context> extends OpenAPIHandler<T> {
+    constructor(router: Router<T, any>, options?: NoInfer<OpenAPIHandlerOptions<T>>);
+}
+//# sourceMappingURL=openapi-handler-serverless.d.ts.map

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

@@ -0,0 +1,30 @@
+import type { ConditionalFetchHandler, FetchOptions } from '@orpc/server/fetch';
+import type { PublicInputBuilderSimple } from './input-builder-simple';
+import { type Context, type Router, type WithSignal } from '@orpc/server';
+import { type Hooks } from '@orpc/shared';
+import { type PublicJSONSerializer } from '../json-serializer';
+import { type PublicInputBuilderFull } from './input-builder-full';
+import { type PublicOpenAPIPayloadCodec } from './openapi-payload-codec';
+import { type Hono, type PublicOpenAPIProcedureMatcher } from './openapi-procedure-matcher';
+import { type SchemaCoercer } from './schema-coercer';
+export type OpenAPIHandlerOptions<T extends Context> = Hooks<Request, Response, T, WithSignal> & {
+    jsonSerializer?: PublicJSONSerializer;
+    procedureMatcher?: PublicOpenAPIProcedureMatcher;
+    payloadCodec?: PublicOpenAPIPayloadCodec;
+    inputBuilderSimple?: PublicInputBuilderSimple;
+    inputBuilderFull?: PublicInputBuilderFull;
+    schemaCoercers?: SchemaCoercer[];
+};
+export declare class OpenAPIHandler<T extends Context> implements ConditionalFetchHandler<T> {
+    private readonly options?;
+    private readonly procedureMatcher;
+    private readonly payloadCodec;
+    private readonly inputBuilderSimple;
+    private readonly inputBuilderFull;
+    private readonly compositeSchemaCoercer;
+    constructor(hono: Hono, router: Router<T, any>, options?: NoInfer<OpenAPIHandlerOptions<T>> | undefined);
+    condition(request: Request): boolean;
+    fetch(request: Request, ...[options]: [options: FetchOptions<T>] | (undefined extends T ? [] : never)): Promise<Response>;
+    private convertToORPCError;
+}
+//# sourceMappingURL=openapi-handler.d.ts.map

package/dist/src/fetch/openapi-payload-codec.d.ts

@@ -0,0 +1,15 @@
+import type { PublicJSONSerializer } from '../json-serializer';
+export declare class OpenAPIPayloadCodec {
+    private readonly jsonSerializer;
+    constructor(jsonSerializer: PublicJSONSerializer);
+    encode(payload: unknown, accept?: string): {
+        body: FormData | Blob | string | undefined;
+        headers?: Headers;
+    };
+    private encodeAsJSON;
+    private encodeAsFormData;
+    private encodeAsURLSearchParams;
+    decode(re: Request | Response | Headers | URLSearchParams | FormData): Promise<unknown>;
+}
+export type PublicOpenAPIPayloadCodec = Pick<OpenAPIPayloadCodec, keyof OpenAPIPayloadCodec>;
+//# sourceMappingURL=openapi-payload-codec.d.ts.map

package/dist/src/fetch/openapi-procedure-matcher.d.ts

@@ -0,0 +1,19 @@
+import type { Router as BaseHono, Params } from 'hono/router';
+import { type ANY_PROCEDURE, type ANY_ROUTER } from '@orpc/server';
+export type Hono = BaseHono<[string, string[]]>;
+export declare class OpenAPIProcedureMatcher {
+    private readonly hono;
+    private readonly router;
+    private pendingRouters;
+    constructor(hono: Hono, router: ANY_ROUTER);
+    match(method: string, pathname: string): Promise<{
+        path: string[];
+        procedure: ANY_PROCEDURE;
+        params: Params;
+    } | undefined>;
+    private add;
+    private handlePendingRouters;
+    private convertOpenAPIPathToRouterPath;
+}
+export type PublicOpenAPIProcedureMatcher = Pick<OpenAPIProcedureMatcher, keyof OpenAPIProcedureMatcher>;
+//# sourceMappingURL=openapi-procedure-matcher.d.ts.map

package/dist/src/fetch/schema-coercer.d.ts

@@ -0,0 +1,10 @@
+import type { Schema } from '@orpc/contract';
+export interface SchemaCoercer {
+    coerce: (schema: Schema, value: unknown) => unknown;
+}
+export declare class CompositeSchemaCoercer implements SchemaCoercer {
+    private readonly coercers;
+    constructor(coercers: SchemaCoercer[]);
+    coerce(schema: Schema, value: unknown): unknown;
+}
+//# sourceMappingURL=schema-coercer.d.ts.map

package/dist/src/index.d.ts

@@ -1,3 +1,12 @@
 /** unnoq */
-export * from './generator';
+export * from './json-serializer';
+export * from './openapi';
+export * from './openapi-content-builder';
+export * from './openapi-generator';
+export * from './openapi-parameters-builder';
+export * from './openapi-path-parser';
+export * from './schema';
+export * from './schema-converter';
+export * from './schema-utils';
+export * from './utils';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/json-serializer.d.ts

@@ -0,0 +1,5 @@
+export declare class JSONSerializer {
+    serialize(payload: unknown): unknown;
+}
+export type PublicJSONSerializer = Pick<JSONSerializer, keyof JSONSerializer>;
+//# sourceMappingURL=json-serializer.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-generator.d.ts

@@ -0,0 +1,51 @@
+import type { ContractRouter } from '@orpc/contract';
+import type { ANY_ROUTER } from '@orpc/server';
+import type { PublicOpenAPIPathParser } from './openapi-path-parser';
+import type { SchemaConverter } from './schema-converter';
+import { type PublicJSONSerializer } from './json-serializer';
+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';
+export interface OpenAPIGeneratorOptions {
+    contentBuilder?: PublicOpenAPIContentBuilder;
+    parametersBuilder?: PublicOpenAPIParametersBuilder;
+    schemaConverters?: SchemaConverter[];
+    schemaUtils?: PublicSchemaUtils;
+    jsonSerializer?: PublicJSONSerializer;
+    pathParser?: PublicOpenAPIPathParser;
+    /**
+     * 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;
+    /**
+     * Throw error when you have error in OpenAPI generator
+     *
+     * @default false
+     */
+    throwOnError?: boolean;
+}
+export declare class OpenAPIGenerator {
+    private readonly options?;
+    private readonly contentBuilder;
+    private readonly parametersBuilder;
+    private readonly schemaConverter;
+    private readonly schemaUtils;
+    private readonly jsonSerializer;
+    private readonly pathParser;
+    constructor(options?: OpenAPIGeneratorOptions | undefined);
+    generate(router: ContractRouter | ANY_ROUTER, doc: Omit<OpenAPI.OpenAPIObject, 'openapi'>): Promise<OpenAPI.OpenAPIObject>;
+    private handleError;
+}
+//# sourceMappingURL=openapi-generator.d.ts.map

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

@@ -0,0 +1,9 @@
+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[];
+}
+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: ("$anchor" | "$comment" | "$defs" | "$dynamicAnchor" | "$dynamicRef" | "$id" | "$schema" | "$vocabulary" | "contentEncoding" | "contentMediaType" | "default" | "definitions" | "deprecated" | "description" | "examples" | "format" | "readOnly" | "title" | "writeOnly")[];
+//# sourceMappingURL=schema.d.ts.map

package/dist/src/utils.d.ts

@@ -9,9 +9,10 @@ export interface EachLeafCallbackOptions {
     path: string[];
 }
 export interface EachContractLeafResultItem {
-    lazy: Lazy<ANY_PROCEDURE> | Lazy<Record<string, ANY_ROUTER>>;
+    router: Lazy<ANY_PROCEDURE> | Lazy<Record<string, ANY_ROUTER> | ANY_PROCEDURE>;
     path: string[];
 }
-export declare function eachContractProcedureLeaf(options: EachLeafOptions, callback: (options: EachLeafCallbackOptions) => void, result?: EachContractLeafResultItem[], isCurrentRouterContract?: boolean): EachContractLeafResultItem[];
+export declare function forEachContractProcedure(options: EachLeafOptions, callback: (options: EachLeafCallbackOptions) => void, result?: EachContractLeafResultItem[], isCurrentRouterContract?: boolean): EachContractLeafResultItem[];
+export declare function forEachAllContractProcedure(router: ContractRouter | ANY_ROUTER, callback: (options: EachLeafCallbackOptions) => void): Promise<void>;
 export declare function standardizeHTTPPath(path: HTTPPath): HTTPPath;
 //# sourceMappingURL=utils.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/openapi",
   "type": "module",
-  "version": "0.17.0",
+  "version": "0.19.0",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -35,18 +35,20 @@
   ],
   "dependencies": {
     "@standard-schema/spec": "1.0.0-beta.4",
+    "@types/content-disposition": "^0.5.8",
+    "content-disposition": "^0.5.4",
     "escape-string-regexp": "^5.0.0",
+    "fast-content-type-parse": "^2.0.0",
+    "hono": "^4.6.12",
     "json-schema-typed": "^8.0.1",
     "openapi3-ts": "^4.4.0",
-    "@orpc/shared": "0.17.0",
-    "@orpc/server": "0.17.0",
-    "@orpc/transformer": "0.17.0",
-    "@orpc/zod": "0.17.0",
-    "@orpc/contract": "0.17.0"
+    "wildcard-match": "^5.1.3",
+    "@orpc/contract": "0.19.0",
+    "@orpc/server": "0.19.0",
+    "@orpc/shared": "0.19.0"
   },
   "devDependencies": {
     "@readme/openapi-parser": "^2.6.0",
-    "hono": "^4.6.12",
     "zod": "^3.24.1"
   },
   "scripts": {

package/dist/chunk-CMRY2Z4J.js

@@ -1,54 +0,0 @@
-// src/utils.ts
-import { isContractProcedure } from "@orpc/contract";
-import { flatLazy, getRouterContract, isLazy, isProcedure } from "@orpc/server";
-function eachContractProcedureLeaf(options, callback, result = [], isCurrentRouterContract = false) {
-  const hiddenContract = getRouterContract(options.router);
-  if (!isCurrentRouterContract && hiddenContract) {
-    return eachContractProcedureLeaf(
-      {
-        path: options.path,
-        router: hiddenContract
-      },
-      callback,
-      result,
-      true
-    );
-  }
-  if (isLazy(options.router)) {
-    result.push({
-      lazy: flatLazy(options.router),
-      path: options.path
-    });
-  } else if (isProcedure(options.router)) {
-    callback({
-      contract: options.router["~orpc"].contract,
-      path: options.path
-    });
-  } else if (isContractProcedure(options.router)) {
-    callback({
-      contract: options.router,
-      path: options.path
-    });
-  } else {
-    for (const key in options.router) {
-      eachContractProcedureLeaf(
-        {
-          router: options.router[key],
-          path: [...options.path, key]
-        },
-        callback,
-        result
-      );
-    }
-  }
-  return result;
-}
-function standardizeHTTPPath(path) {
-  return `/${path.replace(/\/{2,}/g, "/").replace(/^\/|\/$/g, "")}`;
-}
-
-export {
-  eachContractProcedureLeaf,
-  standardizeHTTPPath
-};
-//# sourceMappingURL=chunk-CMRY2Z4J.js.map

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

@@ -1,13 +0,0 @@
-import type { ANY_PROCEDURE, ANY_ROUTER } from '@orpc/server';
-import type { FetchHandler } from '@orpc/server/fetch';
-import type { Router as HonoRouter } from 'hono/router';
-export type ResolveRouter = (router: ANY_ROUTER, method: string, pathname: string) => Promise<{
-    path: string[];
-    procedure: ANY_PROCEDURE;
-    params: Record<string, string>;
-} | undefined>;
-type Routing = HonoRouter<string[]>;
-export declare function createOpenAPIHandler(createHonoRouter: () => Routing): FetchHandler;
-export declare function createResolveRouter(createHonoRouter: () => Routing): ResolveRouter;
-export {};
-//# sourceMappingURL=base-handler.d.ts.map

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

@@ -1,3 +0,0 @@
-import type { FetchHandler } from '@orpc/server/fetch';
-export declare function createOpenAPIServerHandler(): FetchHandler;
-//# sourceMappingURL=server-handler.d.ts.map

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

@@ -1,3 +0,0 @@
-import type { FetchHandler } from '@orpc/server/fetch';
-export declare function createOpenAPIServerlessHandler(): FetchHandler;
-//# sourceMappingURL=serverless-handler.d.ts.map

package/dist/src/generator.d.ts

@@ -1,24 +0,0 @@
-import { type ContractRouter } from '@orpc/contract';
-import { type ANY_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 | ANY_ROUTER;
-} & Omit<OpenAPIObject, 'openapi'>, options?: GenerateOpenAPIOptions): Promise<OpenAPIObject>;
-//# sourceMappingURL=generator.d.ts.map

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

@@ -1,43 +0,0 @@
-import type { StandardSchemaV1 } from '@standard-schema/spec';
-import { type JSONSchema } from 'json-schema-typed/draft-2020-12';
-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: StandardSchemaV1, options?: ZodToJsonSchemaOptions): Exclude<JSONSchema, boolean>;
-export declare function extractJSONSchema(schema: JSONSchema, check: (schema: JSONSchema) => boolean, matches?: JSONSchema[]): {
-    schema: JSONSchema | undefined;
-    matches: JSONSchema[];
-};
-//# sourceMappingURL=zod-to-json-schema.d.ts.map