@orpc/openapi 0.0.0-next.af8ac85 → 0.0.0-next.b2e67f7

package/dist/next.js

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

package/dist/node.js

@@ -0,0 +1,30 @@
+import {
+  OpenAPICodec,
+  OpenAPIMatcher
+} from "./chunk-LTTK3H5J.js";
+import "./chunk-XGHV4TH3.js";
+
+// src/adapters/node/openapi-handler.ts
+import { StandardHandler } from "@orpc/server/standard";
+import { sendStandardResponse, toStandardRequest } from "@orpc/standard-server-node";
+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 { StandardCodec, StandardParams } from '@orpc/server/standard';
+import type { StandardRequest, StandardResponse } from '@orpc/standard-server';
+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,12 +1,16 @@
 /** unnoq */
-export * from './json-serializer';
+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-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

@@ -1,19 +1,24 @@
-import type { ContractRouter } from '@orpc/contract';
-import type { ANY_ROUTER } from '@orpc/server';
+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 { type PublicJSONSerializer } from './json-serializer';
+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?: PublicJSONSerializer;
+    jsonSerializer?: OpenAPIJsonSerializer;
     pathParser?: PublicOpenAPIPathParser;
+    inputStructureParser?: PublicOpenAPIInputStructureParser;
+    outputStructureParser?: PublicOpenAPIOutputStructureParser;
     /**
      * Throw error when you missing define tag definition on OpenAPI root tags
      *
@@ -30,22 +35,33 @@ export interface OpenAPIGeneratorOptions {
      */
     ignoreUndefinedPathProcedures?: boolean;
     /**
-     * Throw error when you have error in OpenAPI generator
+     * What to do when we found an error with our router
      *
-     * @default false
+     * @default 'throw'
+     */
+    errorHandlerStrategy?: ErrorHandlerStrategy;
+    /**
+     * Strict error response
+     *
+     * @default true
      */
-    throwOnError?: boolean;
+    strictErrorResponses?: 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;
+    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

@@ -4,6 +4,9 @@ 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/schema-converter.d.ts

@@ -4,8 +4,8 @@ export interface SchemaConvertOptions {
     strategy: 'input' | 'output';
 }
 export interface SchemaConverter {
-    condition: (schema: Schema, options: SchemaConvertOptions) => boolean;
-    convert: (schema: Schema, options: SchemaConvertOptions) => JSONSchema.JSONSchema;
+    condition(schema: Schema, options: SchemaConvertOptions): boolean;
+    convert(schema: Schema, options: SchemaConvertOptions): JSONSchema.JSONSchema;
 }
 export declare class CompositeSchemaConverter implements SchemaConverter {
     private readonly converters;

package/dist/src/schema.d.ts

@@ -8,5 +8,5 @@ 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")[];
+export declare const NON_LOGIC_KEYWORDS: string[];
 //# sourceMappingURL=schema.d.ts.map

package/dist/src/utils.d.ts

@@ -1,18 +1,4 @@
-import type { ContractRouter, HTTPPath, WELL_CONTRACT_PROCEDURE } from '@orpc/contract';
-import type { ANY_PROCEDURE, ANY_ROUTER, Lazy } from '@orpc/server';
-export interface EachLeafOptions {
-    router: ContractRouter | ANY_ROUTER;
-    path: string[];
-}
-export interface EachLeafCallbackOptions {
-    contract: WELL_CONTRACT_PROCEDURE;
-    path: string[];
-}
-export interface EachContractLeafResultItem {
-    router: Lazy<ANY_PROCEDURE> | Lazy<Record<string, ANY_ROUTER> | ANY_PROCEDURE>;
-    path: string[];
-}
-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>;
+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-LTTK3H5J.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.af8ac85",
+  "version": "0.0.0-next.b2e67f7",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -19,11 +19,31 @@
       "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"
     }
@@ -34,25 +54,22 @@
     "dist"
   ],
   "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",
-    "wildcard-match": "^5.1.3",
-    "@orpc/contract": "0.0.0-next.af8ac85",
-    "@orpc/server": "0.0.0-next.af8ac85",
-    "@orpc/shared": "0.0.0-next.af8ac85"
+    "rou3": "^0.5.1",
+    "@orpc/client": "0.0.0-next.b2e67f7",
+    "@orpc/server": "0.0.0-next.b2e67f7",
+    "@orpc/shared": "0.0.0-next.b2e67f7",
+    "@orpc/contract": "0.0.0-next.b2e67f7",
+    "@orpc/standard-server": "0.0.0-next.b2e67f7",
+    "@orpc/standard-server-fetch": "0.0.0-next.b2e67f7",
+    "@orpc/standard-server-node": "0.0.0-next.b2e67f7"
   },
   "devDependencies": {
-    "@readme/openapi-parser": "^2.6.0",
     "zod": "^3.24.1"
   },
   "scripts": {
-    "build": "tsup --clean --sourcemap --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/chunk-KNYXLM77.js

@@ -1,107 +0,0 @@
-// src/json-serializer.ts
-import { isPlainObject } from "@orpc/shared";
-var JSONSerializer = class {
-  serialize(payload) {
-    if (payload instanceof Set)
-      return this.serialize([...payload]);
-    if (payload instanceof Map)
-      return this.serialize([...payload.entries()]);
-    if (Array.isArray(payload)) {
-      return payload.map((v) => v === void 0 ? "undefined" : this.serialize(v));
-    }
-    if (Number.isNaN(payload))
-      return "NaN";
-    if (typeof payload === "bigint")
-      return payload.toString();
-    if (payload instanceof Date && Number.isNaN(payload.getTime())) {
-      return "Invalid Date";
-    }
-    if (payload instanceof RegExp)
-      return payload.toString();
-    if (payload instanceof URL)
-      return payload.toString();
-    if (!isPlainObject(payload))
-      return payload;
-    return Object.keys(payload).reduce(
-      (carry, key) => {
-        const val = payload[key];
-        carry[key] = this.serialize(val);
-        return carry;
-      },
-      {}
-    );
-  }
-};
-
-// src/utils.ts
-import { isContractProcedure } from "@orpc/contract";
-import { getRouterContract, isLazy, isProcedure, unlazy } from "@orpc/server";
-function forEachContractProcedure(options, callback, result = [], isCurrentRouterContract = false) {
-  const hiddenContract = getRouterContract(options.router);
-  if (!isCurrentRouterContract && hiddenContract) {
-    return forEachContractProcedure(
-      {
-        path: options.path,
-        router: hiddenContract
-      },
-      callback,
-      result,
-      true
-    );
-  }
-  if (isLazy(options.router)) {
-    result.push({
-      router: 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) {
-      forEachContractProcedure(
-        {
-          router: options.router[key],
-          path: [...options.path, key]
-        },
-        callback,
-        result
-      );
-    }
-  }
-  return result;
-}
-async function forEachAllContractProcedure(router, callback) {
-  const pending = [{
-    path: [],
-    router
-  }];
-  for (const item of pending) {
-    const lazies = forEachContractProcedure(item, callback);
-    for (const lazy of lazies) {
-      const { default: router2 } = await unlazy(lazy.router);
-      pending.push({
-        path: lazy.path,
-        router: router2
-      });
-    }
-  }
-}
-function standardizeHTTPPath(path) {
-  return `/${path.replace(/\/{2,}/g, "/").replace(/^\/|\/$/g, "")}`;
-}
-
-export {
-  JSONSerializer,
-  forEachContractProcedure,
-  forEachAllContractProcedure,
-  standardizeHTTPPath
-};
-//# sourceMappingURL=chunk-KNYXLM77.js.map

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

@@ -1,84 +0,0 @@
-/**
- * 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,10 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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