@orpc/openapi 0.0.0-next.bc564a6 → 0.0.0-next.bf323bf

package/dist/index.js

@@ -1,9 +1,53 @@
 import {
   JSONSerializer,
-  forEachAllContractProcedure,
-  forEachContractProcedure,
   standardizeHTTPPath
-} from "./chunk-Q2LSK6YZ.js";
+} from "./chunk-HC5PVG4R.js";
+
+// src/openapi-operation-extender.ts
+import { isProcedure } from "@orpc/server";
+var OPERATION_EXTENDER_SYMBOL = Symbol("ORPC_OPERATION_EXTENDER");
+function setOperationExtender(o, extend) {
+  return new Proxy(o, {
+    get(target, prop, receiver) {
+      if (prop === OPERATION_EXTENDER_SYMBOL) {
+        return extend;
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+}
+function getOperationExtender(o) {
+  return o[OPERATION_EXTENDER_SYMBOL];
+}
+function extendOperation(operation, procedure) {
+  const operationExtenders = [];
+  for (const errorItem of Object.values(procedure["~orpc"].errorMap)) {
+    const maybeExtender = getOperationExtender(errorItem);
+    if (maybeExtender) {
+      operationExtenders.push(maybeExtender);
+    }
+  }
+  if (isProcedure(procedure)) {
+    for (const middleware of procedure["~orpc"].middlewares) {
+      const maybeExtender = getOperationExtender(middleware);
+      if (maybeExtender) {
+        operationExtenders.push(maybeExtender);
+      }
+    }
+  }
+  let currentOperation = operation;
+  for (const extender of operationExtenders) {
+    if (typeof extender === "function") {
+      currentOperation = extender(currentOperation, procedure);
+    } else {
+      currentOperation = {
+        ...currentOperation,
+        ...extender
+      };
+    }
+  }
+  return currentOperation;
+}
 
 // src/openapi.ts
 import { OpenApiBuilder } from "openapi3-ts/oas31";
@@ -36,7 +80,8 @@ var OpenAPIContentBuilder = class {
 };
 
 // src/openapi-generator.ts
-import { fallbackContractConfig as fallbackContractConfig2, fallbackORPCErrorStatus } from "@orpc/contract";
+import { fallbackContractConfig as fallbackContractConfig2, fallbackORPCErrorStatus, getEventIteratorSchemaDetails } from "@orpc/contract";
+import { eachAllContractProcedure } from "@orpc/server";
 import { group } from "@orpc/shared";
 
 // src/openapi-error.ts
@@ -184,14 +229,14 @@ var OpenAPIOutputStructureParser = class {
 };
 
 // src/openapi-parameters-builder.ts
-import { get, isPlainObject, omit } from "@orpc/shared";
+import { get, isObject, omit } from "@orpc/shared";
 var OpenAPIParametersBuilder = class {
   build(paramIn, jsonSchema, options) {
     const parameters = [];
     for (const name in jsonSchema.properties) {
       const schema = jsonSchema.properties[name];
       const paramExamples = jsonSchema.examples?.filter((example) => {
-        return isPlainObject(example) && name in example;
+        return isObject(example) && name in example;
       }).map((example) => {
         return example[name];
       });
@@ -252,7 +297,7 @@ var CompositeSchemaConverter = class {
 };
 
 // src/schema-utils.ts
-import { isPlainObject as isPlainObject2 } from "@orpc/shared";
+import { isObject as isObject2 } from "@orpc/shared";
 
 // src/schema.ts
 import * as JSONSchema from "json-schema-typed/draft-2020-12";
@@ -314,7 +359,7 @@ var SchemaUtils = class {
     }, {});
     matched.required = schema.required?.filter((key) => separatedProperties.includes(key));
     matched.examples = schema.examples?.map((example) => {
-      if (!isPlainObject2(example)) {
+      if (!isObject2(example)) {
         return example;
       }
       return Object.entries(example).reduce((acc, [key, value]) => {
@@ -330,7 +375,7 @@ var SchemaUtils = class {
     }, {});
     rest.required = schema.required?.filter((key) => !separatedProperties.includes(key));
     rest.examples = schema.examples?.map((example) => {
-      if (!isPlainObject2(example)) {
+      if (!isObject2(example)) {
         return example;
       }
       return Object.entries(example).reduce((acc, [key, value]) => {
@@ -406,7 +451,10 @@ var OpenAPIGenerator = class {
       openapi: "3.1.1"
     });
     const rootTags = doc.tags?.map((tag) => tag.name) ?? [];
-    await forEachAllContractProcedure(router, ({ contract, path }) => {
+    await eachAllContractProcedure({
+      path: [],
+      router
+    }, ({ contract, path }) => {
       try {
         const def = contract["~orpc"];
         if (this.ignoreUndefinedPathProcedures && def.route?.path === void 0) {
@@ -414,26 +462,123 @@ var OpenAPIGenerator = class {
         }
         const method = fallbackContractConfig2("defaultMethod", def.route?.method);
         const httpPath = def.route?.path ? standardizeHTTPPath(def.route?.path) : `/${path.map(encodeURIComponent).join("/")}`;
-        const inputStructure = fallbackContractConfig2("defaultInputStructure", def.route?.inputStructure);
-        const outputStructure = fallbackContractConfig2("defaultOutputStructure", def.route?.outputStructure);
-        const { paramsSchema, querySchema, headersSchema, bodySchema } = this.inputStructureParser.parse(contract, inputStructure);
-        const { headersSchema: resHeadersSchema, bodySchema: resBodySchema } = this.outputStructureParser.parse(contract, outputStructure);
-        const params = paramsSchema ? this.parametersBuilder.build("path", paramsSchema, {
-          required: true
-        }) : [];
-        const query = querySchema ? this.parametersBuilder.build("query", querySchema) : [];
-        const headers = headersSchema ? this.parametersBuilder.build("header", headersSchema) : [];
-        const parameters = [...params, ...query, ...headers];
-        const requestBody = bodySchema !== void 0 ? {
-          required: this.schemaUtils.isUndefinableSchema(bodySchema),
-          content: this.contentBuilder.build(bodySchema)
-        } : void 0;
-        const responses = {};
-        responses[fallbackContractConfig2("defaultSuccessStatus", def.route?.successStatus)] = {
-          description: fallbackContractConfig2("defaultSuccessDescription", def.route?.successDescription),
-          content: resBodySchema !== void 0 ? this.contentBuilder.build(resBodySchema) : void 0,
-          headers: resHeadersSchema !== void 0 ? this.parametersBuilder.buildHeadersObject(resHeadersSchema) : void 0
-        };
+        const { parameters, requestBody } = (() => {
+          const eventIteratorSchemaDetails = getEventIteratorSchemaDetails(def.inputSchema);
+          if (eventIteratorSchemaDetails) {
+            const requestBody3 = {
+              required: true,
+              content: {
+                "text/event-stream": {
+                  schema: {
+                    oneOf: [
+                      {
+                        type: "object",
+                        properties: {
+                          event: { type: "string", const: "message" },
+                          data: this.schemaConverter.convert(eventIteratorSchemaDetails.yields, { strategy: "input" }),
+                          id: { type: "string" },
+                          retry: { type: "number" }
+                        },
+                        required: ["event", "data"]
+                      },
+                      {
+                        type: "object",
+                        properties: {
+                          event: { type: "string", const: "done" },
+                          data: this.schemaConverter.convert(eventIteratorSchemaDetails.returns, { strategy: "input" }),
+                          id: { type: "string" },
+                          retry: { type: "number" }
+                        },
+                        required: ["event", "data"]
+                      },
+                      {
+                        type: "object",
+                        properties: {
+                          event: { type: "string", const: "error" },
+                          data: {},
+                          id: { type: "string" },
+                          retry: { type: "number" }
+                        },
+                        required: ["event", "data"]
+                      }
+                    ]
+                  }
+                }
+              }
+            };
+            return { requestBody: requestBody3, parameters: [] };
+          }
+          const inputStructure = fallbackContractConfig2("defaultInputStructure", def.route?.inputStructure);
+          const { paramsSchema, querySchema, headersSchema, bodySchema } = this.inputStructureParser.parse(contract, inputStructure);
+          const params = paramsSchema ? this.parametersBuilder.build("path", paramsSchema, {
+            required: true
+          }) : [];
+          const query = querySchema ? this.parametersBuilder.build("query", querySchema) : [];
+          const headers = headersSchema ? this.parametersBuilder.build("header", headersSchema) : [];
+          const parameters2 = [...params, ...query, ...headers];
+          const requestBody2 = bodySchema !== void 0 ? {
+            required: this.schemaUtils.isUndefinableSchema(bodySchema),
+            content: this.contentBuilder.build(bodySchema)
+          } : void 0;
+          return { parameters: parameters2, requestBody: requestBody2 };
+        })();
+        const { responses } = (() => {
+          const eventIteratorSchemaDetails = getEventIteratorSchemaDetails(def.outputSchema);
+          if (eventIteratorSchemaDetails) {
+            const responses3 = {};
+            responses3[fallbackContractConfig2("defaultSuccessStatus", def.route?.successStatus)] = {
+              description: fallbackContractConfig2("defaultSuccessDescription", def.route?.successDescription),
+              content: {
+                "text/event-stream": {
+                  schema: {
+                    oneOf: [
+                      {
+                        type: "object",
+                        properties: {
+                          event: { type: "string", const: "message" },
+                          data: this.schemaConverter.convert(eventIteratorSchemaDetails.yields, { strategy: "input" }),
+                          id: { type: "string" },
+                          retry: { type: "number" }
+                        },
+                        required: ["event", "data"]
+                      },
+                      {
+                        type: "object",
+                        properties: {
+                          event: { type: "string", const: "done" },
+                          data: this.schemaConverter.convert(eventIteratorSchemaDetails.returns, { strategy: "input" }),
+                          id: { type: "string" },
+                          retry: { type: "number" }
+                        },
+                        required: ["event", "data"]
+                      },
+                      {
+                        type: "object",
+                        properties: {
+                          event: { type: "string", const: "error" },
+                          data: {},
+                          id: { type: "string" },
+                          retry: { type: "number" }
+                        },
+                        required: ["event", "data"]
+                      }
+                    ]
+                  }
+                }
+              }
+            };
+            return { responses: responses3 };
+          }
+          const outputStructure = fallbackContractConfig2("defaultOutputStructure", def.route?.outputStructure);
+          const { headersSchema: resHeadersSchema, bodySchema: resBodySchema } = this.outputStructureParser.parse(contract, outputStructure);
+          const responses2 = {};
+          responses2[fallbackContractConfig2("defaultSuccessStatus", def.route?.successStatus)] = {
+            description: fallbackContractConfig2("defaultSuccessDescription", def.route?.successDescription),
+            content: resBodySchema !== void 0 ? this.contentBuilder.build(resBodySchema) : void 0,
+            headers: resHeadersSchema !== void 0 ? this.parametersBuilder.buildHeadersObject(resHeadersSchema) : void 0
+          };
+          return { responses: responses2 };
+        })();
         const errors = group(Object.entries(def.errorMap ?? {}).filter(([_, config]) => config).map(([code, config]) => ({
           ...config,
           code,
@@ -504,8 +649,9 @@ var OpenAPIGenerator = class {
           requestBody,
           responses
         };
+        const extendedOperation = extendOperation(operation, contract);
         builder.addPath(httpPath, {
-          [method.toLocaleLowerCase()]: operation
+          [method.toLocaleLowerCase()]: extendedOperation
         });
       } catch (e) {
         if (e instanceof OpenAPIError) {
@@ -527,6 +673,11 @@ var OpenAPIGenerator = class {
     return this.jsonSerializer.serialize(builder.getSpec());
   }
 };
+
+// src/index.ts
+var oo = {
+  spec: setOperationExtender
+};
 export {
   CompositeSchemaConverter,
   JSONSchema,
@@ -539,8 +690,10 @@ export {
   OpenAPIPathParser,
   OpenApiBuilder,
   SchemaUtils,
-  forEachAllContractProcedure,
-  forEachContractProcedure,
+  extendOperation,
+  getOperationExtender,
+  oo,
+  setOperationExtender,
   standardizeHTTPPath
 };
 //# sourceMappingURL=index.js.map

package/dist/next.js

@@ -1,34 +1,9 @@
 import {
-  OpenAPIServerHandler,
-  OpenAPIServerlessHandler
-} from "./chunk-VFGNQS5W.js";
-import {
-  CompositeSchemaCoercer,
-  InputStructureCompact,
-  InputStructureDetailed,
-  OpenAPIHandler,
-  OpenAPIPayloadCodec,
-  OpenAPIProcedureMatcher,
-  deserialize,
-  escapeSegment,
-  parsePath,
-  serialize,
-  stringifyPath
-} from "./chunk-SOVQ5ARD.js";
-import "./chunk-Q2LSK6YZ.js";
+  OpenAPIHandler
+} from "./chunk-5QMOOQSF.js";
+import "./chunk-TOZPXKQC.js";
+import "./chunk-HC5PVG4R.js";
 export {
-  CompositeSchemaCoercer,
-  InputStructureCompact,
-  InputStructureDetailed,
-  OpenAPIHandler,
-  OpenAPIPayloadCodec,
-  OpenAPIProcedureMatcher,
-  OpenAPIServerHandler,
-  OpenAPIServerlessHandler,
-  deserialize,
-  escapeSegment,
-  parsePath,
-  serialize,
-  stringifyPath
+  OpenAPIHandler
 };
 //# sourceMappingURL=next.js.map

package/dist/node.js

@@ -1,46 +1,30 @@
 import {
-  OpenAPIHandler
-} from "./chunk-SOVQ5ARD.js";
-import "./chunk-Q2LSK6YZ.js";
+  OpenAPICodec,
+  OpenAPIMatcher
+} from "./chunk-TOZPXKQC.js";
+import "./chunk-HC5PVG4R.js";
 
 // src/adapters/node/openapi-handler.ts
-import { createRequest, sendResponse } from "@orpc/server/node";
-var OpenAPIHandler2 = class {
-  openapiFetchHandler;
-  constructor(hono, router, options) {
-    this.openapiFetchHandler = new OpenAPIHandler(hono, router, options);
+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(options);
+    const codec = options?.codec ?? new OpenAPICodec(options);
+    this.standardHandler = new StandardHandler(router, matcher, codec, { ...options });
   }
-  async handle(req, res, ...[options]) {
-    const request = createRequest(req, res);
-    const castedOptions = options ?? {};
-    const result = await this.openapiFetchHandler.handle(request, castedOptions);
-    if (result.matched === false) {
+  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 options?.beforeSend?.(result.response, castedOptions.context);
-    await sendResponse(res, result.response);
+    await sendStandardResponse(res, result.response);
     return { matched: true };
   }
 };
-
-// src/adapters/node/openapi-handler-server.ts
-import { TrieRouter } from "hono/router/trie-router";
-var OpenAPIServerHandler = class extends OpenAPIHandler2 {
-  constructor(router, options) {
-    super(new TrieRouter(), router, options);
-  }
-};
-
-// src/adapters/node/openapi-handler-serverless.ts
-import { LinearRouter } from "hono/router/linear-router";
-var OpenAPIServerlessHandler = class extends OpenAPIHandler2 {
-  constructor(router, options) {
-    super(new LinearRouter(), router, options);
-  }
-};
 export {
-  OpenAPIHandler2 as OpenAPIHandler,
-  OpenAPIServerHandler,
-  OpenAPIServerlessHandler
+  OpenAPIHandler
 };
 //# sourceMappingURL=node.js.map

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

@@ -1,10 +1,2 @@
-export * from './bracket-notation';
-export * from './input-structure-compact';
-export * from './input-structure-detailed';
 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/adapters/fetch/openapi-handler.d.ts

@@ -1,32 +1,11 @@
 import type { Context, Router } from '@orpc/server';
-import type { FetchHandler, FetchHandleRest, FetchHandleResult } from '@orpc/server/fetch';
-import type { PublicInputStructureCompact } from './input-structure-compact';
-import { type Hooks } from '@orpc/shared';
-import { type PublicJSONSerializer } from '../../json-serializer';
-import { type PublicInputStructureDetailed } from './input-structure-detailed';
-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, FetchHandleResult, T, any> & {
-    jsonSerializer?: PublicJSONSerializer;
-    procedureMatcher?: PublicOpenAPIProcedureMatcher;
-    payloadCodec?: PublicOpenAPIPayloadCodec;
-    inputBuilderSimple?: PublicInputStructureCompact;
-    inputBuilderFull?: PublicInputStructureDetailed;
-    schemaCoercers?: SchemaCoercer[];
-};
+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 options?;
-    private readonly procedureMatcher;
-    private readonly payloadCodec;
-    private readonly inputStructureCompact;
-    private readonly inputStructureDetailed;
-    private readonly compositeSchemaCoercer;
-    constructor(hono: Hono, router: Router<T, any>, options?: NoInfer<OpenAPIHandlerOptions<T>> | undefined);
-    handle(request: Request, ...[options]: FetchHandleRest<T>): Promise<FetchHandleResult>;
-    private decodeInput;
-    private encodeOutput;
-    private assertDetailedOutput;
-    private convertToORPCError;
+    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/node/index.d.ts

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

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

@@ -1,11 +1,11 @@
 import type { Context, Router } from '@orpc/server';
-import type { IncomingMessage, ServerResponse } from 'node:http';
-import type { OpenAPIHandlerOptions } from '../fetch/openapi-handler';
-import type { Hono } from '../fetch/openapi-procedure-matcher';
-import { type RequestHandler, type RequestHandleRest, type RequestHandleResult } from '@orpc/server/node';
-export declare class OpenAPIHandler<T extends Context> implements RequestHandler<T> {
-    private readonly openapiFetchHandler;
-    constructor(hono: Hono, router: Router<T, any>, options?: NoInfer<OpenAPIHandlerOptions<T>>);
-    handle(req: IncomingMessage, res: ServerResponse, ...[options]: RequestHandleRest<T>): Promise<RequestHandleResult>;
+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,6 @@
+export * as BracketNotation from './bracket-notation';
+export * from './openapi-codec';
+export * from './openapi-handler';
+export * from './openapi-matcher';
+export * from './openapi-serializer';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,16 @@
+import type { AnyProcedure } from '@orpc/server';
+import type { StandardRequest, StandardResponse } from '@orpc/server-standard';
+import type { StandardCodec, StandardParams } from '@orpc/server/standard';
+import { type ORPCError } from '@orpc/contract';
+import { OpenAPISerializer } from './openapi-serializer';
+export interface OpenAPICodecOptions {
+    serializer?: OpenAPISerializer;
+}
+export declare class OpenAPICodec implements StandardCodec {
+    private readonly serializer;
+    constructor(options?: OpenAPICodecOptions);
+    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,7 @@
+import type { Context } from '@orpc/server';
+import type { RPCHandlerOptions } from '@orpc/server/standard';
+import type { OpenAPICodecOptions } from './openapi-codec';
+import type { OpenAPIMatcherOptions } from './openapi-matcher';
+export interface OpenAPIHandlerOptions<T extends Context> extends RPCHandlerOptions<T>, OpenAPIMatcherOptions, OpenAPICodecOptions {
+}
+//# sourceMappingURL=openapi-handler.d.ts.map

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

@@ -0,0 +1,20 @@
+import type { AnyRouter } from '@orpc/server';
+import type { StandardMatcher, StandardMatchResult } from '@orpc/server/standard';
+import { type HTTPPath } from '@orpc/contract';
+export interface OpenAPIMatcherOptions {
+    /**
+     * Ignore procedure that does not have a method defined in the contract.
+     *
+     * @default false
+     */
+    ignoreUndefinedMethod?: boolean;
+}
+export declare class OpenAPIMatcher implements StandardMatcher {
+    private readonly tree;
+    private readonly ignoreUndefinedMethod;
+    constructor(options?: OpenAPIMatcherOptions);
+    private pendingRouters;
+    init(router: AnyRouter, path?: string[]): void;
+    match(method: string, pathname: HTTPPath): Promise<StandardMatchResult>;
+}
+//# sourceMappingURL=openapi-matcher.d.ts.map

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

@@ -0,0 +1,11 @@
+import type { PublicJSONSerializer } from '../../json-serializer';
+export interface OpenAPISerializerOptions {
+    jsonSerializer?: PublicJSONSerializer;
+}
+export declare class OpenAPISerializer {
+    private readonly jsonSerializer;
+    constructor(options?: OpenAPISerializerOptions);
+    serialize(data: unknown): unknown;
+    deserialize(serialized: unknown): unknown;
+}
+//# sourceMappingURL=openapi-serializer.d.ts.map

package/dist/src/index.d.ts

@@ -1,12 +1,17 @@
 /** unnoq */
+import { setOperationExtender } from './openapi-operation-extender';
 export * from './json-serializer';
 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-generator.d.ts

@@ -1,9 +1,9 @@
-import type { AnyRouter } 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 ContractRouter } from '@orpc/contract';
+import { type AnyRouter } from '@orpc/server';
 import { type PublicJSONSerializer } from './json-serializer';
 import { type OpenAPI } from './openapi';
 import { type PublicOpenAPIContentBuilder } from './openapi-content-builder';

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/utils.d.ts

@@ -1,18 +1,3 @@
-import type { AnyContractProcedure, AnyContractRouter, HTTPPath } from '@orpc/contract';
-import type { AnyProcedure, AnyRouter, Lazy } from '@orpc/server';
-export interface EachLeafOptions {
-    router: AnyContractRouter | AnyRouter;
-    path: string[];
-}
-export interface EachLeafCallbackOptions {
-    contract: AnyContractProcedure;
-    path: string[];
-}
-export interface EachContractLeafResultItem {
-    router: Lazy<AnyProcedure> | Lazy<Record<string, AnyRouter> | AnyProcedure>;
-    path: string[];
-}
-export declare function forEachContractProcedure(options: EachLeafOptions, callback: (options: EachLeafCallbackOptions) => void, result?: EachContractLeafResultItem[], isCurrentRouterContract?: boolean): EachContractLeafResultItem[];
-export declare function forEachAllContractProcedure(router: AnyContractRouter | AnyRouter, callback: (options: EachLeafCallbackOptions) => void): Promise<void>;
+import type { HTTPPath } from '@orpc/contract';
 export declare function standardizeHTTPPath(path: HTTPPath): HTTPPath;
 //# sourceMappingURL=utils.d.ts.map

package/dist/standard.js

@@ -0,0 +1,14 @@
+import {
+  OpenAPICodec,
+  OpenAPIMatcher,
+  OpenAPISerializer,
+  bracket_notation_exports
+} from "./chunk-TOZPXKQC.js";
+import "./chunk-HC5PVG4R.js";
+export {
+  bracket_notation_exports as BracketNotation,
+  OpenAPICodec,
+  OpenAPIMatcher,
+  OpenAPISerializer
+};
+//# sourceMappingURL=standard.js.map