@orpc/openapi 0.0.0-next.da8ae32 → 0.0.0-next.df024bb

package/README.md

@@ -0,0 +1,91 @@
+<div align="center">
+  <image align="center" src="https://orpc.unnoq.com/logo.webp" width=280 alt="oRPC logo" />
+</div>
+
+<h1></h1>
+
+<div align="center">
+  <a href="https://codecov.io/gh/unnoq/orpc">
+    <img alt="codecov" src="https://codecov.io/gh/unnoq/orpc/branch/main/graph/badge.svg">
+  </a>
+  <a href="https://www.npmjs.com/package/@orpc/openapi">
+    <img alt="weekly downloads" src="https://img.shields.io/npm/dw/%40orpc%2Fopenapi?logo=npm" />
+  </a>
+  <a href="https://github.com/unnoq/orpc/blob/main/LICENSE">
+    <img alt="MIT License" src="https://img.shields.io/github/license/unnoq/orpc?logo=open-source-initiative" />
+  </a>
+  <a href="https://discord.gg/TXEbwRBvQn">
+    <img alt="Discord" src="https://img.shields.io/discord/1308966753044398161?color=7389D8&label&logo=discord&logoColor=ffffff" />
+  </a>
+</div>
+
+<h3 align="center">Typesafe APIs Made Simple 🪄</h3>
+
+**oRPC is a powerful combination of RPC and OpenAPI**, makes it easy to build APIs that are end-to-end type-safe and adhere to OpenAPI standards, ensuring a smooth and enjoyable developer experience.
+
+---
+
+## Highlights
+
+- **End-to-End Type Safety 🔒**: Ensure complete type safety from inputs to outputs and errors, bridging server and client seamlessly.
+- **First-Class OpenAPI 📄**: Adheres to the OpenAPI standard out of the box, ensuring seamless integration and comprehensive API documentation.
+- **Contract-First Development 📜**: (Optional) Define your API contract upfront and implement it with confidence.
+- **Exceptional Developer Experience ✨**: Enjoy a streamlined workflow with robust typing and clear, in-code documentation.
+- **Multi-Runtime Support 🌍**: Run your code seamlessly on Cloudflare, Deno, Bun, Node.js, and more.
+- **Framework Integrations 🧩**: Supports Tanstack Query (React, Vue), Pinia Colada, and more.
+- **Server Actions ⚡️**: Fully compatible with React Server Actions on Next.js, TanStack Start, and more.
+- **Standard Schema Support 🗂️**: Effortlessly work with Zod, Valibot, ArkType, and others right out of the box.
+- **Fast & Lightweight 💨**: Built on native APIs across all runtimes – optimized for speed and efficiency.
+- **Native Types 📦**: Enjoy built-in support for Date, File, Blob, BigInt, URL and more with no extra setup.
+- **Lazy Router ⏱️**: Improve cold start times with our lazy routing feature.
+- **SSE & Streaming 📡**: Provides SSE and streaming features – perfect for real-time notifications and AI-powered streaming responses.
+- **Reusability 🔄**: Write once and reuse your code across multiple purposes effortlessly.
+- **Extendability 🔌**: Easily enhance oRPC with plugins, middleware, and interceptors.
+- **Reliability 🛡️**: Well-tested, fully TypeScript, production-ready, and MIT licensed for peace of mind.
+- **Simplicity 💡**: Enjoy straightforward, clean code with no hidden magic.
+
+## Documentation
+
+You can find the full documentation [here](https://orpc.unnoq.com).
+
+## Packages
+
+- [@orpc/contract](https://www.npmjs.com/package/@orpc/contract): Build your API contract.
+- [@orpc/server](https://www.npmjs.com/package/@orpc/server): Build your API or implement API contract.
+- [@orpc/client](https://www.npmjs.com/package/@orpc/client): Consume your API on the client with type-safety.
+- [@orpc/react-query](https://www.npmjs.com/package/@orpc/react-query): Integration with [React Query](https://tanstack.com/query/latest/docs/framework/react/overview).
+- [@orpc/vue-query](https://www.npmjs.com/package/@orpc/vue-query): Integration with [Vue Query](https://tanstack.com/query/latest/docs/framework/vue/overview).
+- [@orpc/vue-colada](https://www.npmjs.com/package/@orpc/vue-colada): Integration with [Pinia Colada](https://pinia-colada.esm.dev/).
+- [@orpc/openapi](https://www.npmjs.com/package/@orpc/openapi): Generate OpenAPI specs and handle OpenAPI requests.
+- [@orpc/zod](https://www.npmjs.com/package/@orpc/zod): More schemas that [Zod](https://zod.dev/) doesn't support yet.
+
+## `@orpc/openapi`
+
+Generate OpenAPI specs and handle OpenAPI requests. Read the [documentation](https://orpc.unnoq.com/docs/openapi/getting-started) for more information.
+
+```ts
+import { createServer } from 'node:http'
+import { OpenAPIHandler } from '@orpc/openapi/node'
+import { CORSPlugin } from '@orpc/server/plugins'
+
+const handler = new OpenAPIHandler(router, {
+  plugins: [new CORSPlugin()]
+})
+
+const server = createServer(async (req, res) => {
+  const result = await handler.handle(req, res, {
+    context: { headers: req.headers }
+  })
+
+  if (!result.matched) {
+    res.statusCode = 404
+    res.end('No procedure matched')
+  }
+})
+
+server.listen(3000, '127.0.0.1', () => console.log('Listening on 127.0.0.1:3000'))
+```
+
+## License
+
+Distributed under the MIT License. See [LICENSE](https://github.com/unnoq/orpc/blob/main/LICENSE) for more information.

package/dist/adapters/fetch/index.d.mts

@@ -0,0 +1,14 @@
+import { Context, Router } from '@orpc/server';
+import { FetchHandler, FetchHandleResult } from '@orpc/server/fetch';
+import { StandardHandleOptions } from '@orpc/server/standard';
+import { MaybeOptionalOptions } from '@orpc/shared';
+import { ToFetchResponseOptions } from '@orpc/standard-server-fetch';
+import { O as OpenAPIHandlerOptions } from '../../shared/openapi.Dz_6xooR.mjs';
+
+declare class OpenAPIHandler<T extends Context> implements FetchHandler<T> {
+    private readonly standardHandler;
+    constructor(router: Router<T, any>, options?: NoInfer<OpenAPIHandlerOptions<T>>);
+    handle(request: Request, ...[options,]: MaybeOptionalOptions<StandardHandleOptions<T> & ToFetchResponseOptions>): Promise<FetchHandleResult>;
+}
+
+export { OpenAPIHandler };

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

@@ -0,0 +1,14 @@
+import { Context, Router } from '@orpc/server';
+import { FetchHandler, FetchHandleResult } from '@orpc/server/fetch';
+import { StandardHandleOptions } from '@orpc/server/standard';
+import { MaybeOptionalOptions } from '@orpc/shared';
+import { ToFetchResponseOptions } from '@orpc/standard-server-fetch';
+import { O as OpenAPIHandlerOptions } from '../../shared/openapi.Dz_6xooR.js';
+
+declare class OpenAPIHandler<T extends Context> implements FetchHandler<T> {
+    private readonly standardHandler;
+    constructor(router: Router<T, any>, options?: NoInfer<OpenAPIHandlerOptions<T>>);
+    handle(request: Request, ...[options,]: MaybeOptionalOptions<StandardHandleOptions<T> & ToFetchResponseOptions>): Promise<FetchHandleResult>;
+}
+
+export { OpenAPIHandler };

package/dist/adapters/fetch/index.mjs

@@ -0,0 +1,10 @@
+export { O as OpenAPIHandler } from '../../shared/openapi.BcJH4F9P.mjs';
+import '@orpc/server/standard';
+import '@orpc/standard-server-fetch';
+import '../../shared/openapi.CDsfPHgw.mjs';
+import '@orpc/contract';
+import '@orpc/openapi-client/standard';
+import '@orpc/shared';
+import '@orpc/server';
+import 'rou3';
+import '../../shared/openapi.BHG_gu5Z.mjs';

package/dist/adapters/hono/index.d.mts

@@ -0,0 +1,7 @@
+export { OpenAPIHandler } from '../fetch/index.mjs';
+import '@orpc/server';
+import '@orpc/server/fetch';
+import '@orpc/server/standard';
+import '@orpc/shared';
+import '@orpc/standard-server-fetch';
+import '../../shared/openapi.Dz_6xooR.mjs';

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

@@ -0,0 +1,7 @@
+export { OpenAPIHandler } from '../fetch/index.js';
+import '@orpc/server';
+import '@orpc/server/fetch';
+import '@orpc/server/standard';
+import '@orpc/shared';
+import '@orpc/standard-server-fetch';
+import '../../shared/openapi.Dz_6xooR.js';

package/dist/adapters/hono/index.mjs

@@ -0,0 +1,10 @@
+export { O as OpenAPIHandler } from '../../shared/openapi.BcJH4F9P.mjs';
+import '@orpc/server/standard';
+import '@orpc/standard-server-fetch';
+import '../../shared/openapi.CDsfPHgw.mjs';
+import '@orpc/contract';
+import '@orpc/openapi-client/standard';
+import '@orpc/shared';
+import '@orpc/server';
+import 'rou3';
+import '../../shared/openapi.BHG_gu5Z.mjs';

package/dist/adapters/next/index.d.mts

@@ -0,0 +1,7 @@
+export { OpenAPIHandler } from '../fetch/index.mjs';
+import '@orpc/server';
+import '@orpc/server/fetch';
+import '@orpc/server/standard';
+import '@orpc/shared';
+import '@orpc/standard-server-fetch';
+import '../../shared/openapi.Dz_6xooR.mjs';

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

@@ -0,0 +1,7 @@
+export { OpenAPIHandler } from '../fetch/index.js';
+import '@orpc/server';
+import '@orpc/server/fetch';
+import '@orpc/server/standard';
+import '@orpc/shared';
+import '@orpc/standard-server-fetch';
+import '../../shared/openapi.Dz_6xooR.js';

package/dist/adapters/next/index.mjs

@@ -0,0 +1,10 @@
+export { O as OpenAPIHandler } from '../../shared/openapi.BcJH4F9P.mjs';
+import '@orpc/server/standard';
+import '@orpc/standard-server-fetch';
+import '../../shared/openapi.CDsfPHgw.mjs';
+import '@orpc/contract';
+import '@orpc/openapi-client/standard';
+import '@orpc/shared';
+import '@orpc/server';
+import 'rou3';
+import '../../shared/openapi.BHG_gu5Z.mjs';

package/dist/adapters/node/index.d.mts

@@ -0,0 +1,14 @@
+import { Context, Router } from '@orpc/server';
+import { NodeHttpHandler, NodeHttpRequest, NodeHttpResponse, NodeHttpHandleResult } from '@orpc/server/node';
+import { StandardHandleOptions } from '@orpc/server/standard';
+import { MaybeOptionalOptions } from '@orpc/shared';
+import { SendStandardResponseOptions } from '@orpc/standard-server-node';
+import { O as OpenAPIHandlerOptions } from '../../shared/openapi.Dz_6xooR.mjs';
+
+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, ...[options,]: MaybeOptionalOptions<StandardHandleOptions<T> & SendStandardResponseOptions>): Promise<NodeHttpHandleResult>;
+}
+
+export { OpenAPIHandler };

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

@@ -0,0 +1,14 @@
+import { Context, Router } from '@orpc/server';
+import { NodeHttpHandler, NodeHttpRequest, NodeHttpResponse, NodeHttpHandleResult } from '@orpc/server/node';
+import { StandardHandleOptions } from '@orpc/server/standard';
+import { MaybeOptionalOptions } from '@orpc/shared';
+import { SendStandardResponseOptions } from '@orpc/standard-server-node';
+import { O as OpenAPIHandlerOptions } from '../../shared/openapi.Dz_6xooR.js';
+
+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, ...[options,]: MaybeOptionalOptions<StandardHandleOptions<T> & SendStandardResponseOptions>): Promise<NodeHttpHandleResult>;
+}
+
+export { OpenAPIHandler };

package/dist/adapters/node/index.mjs

@@ -0,0 +1,31 @@
+import { StandardHandler } from '@orpc/server/standard';
+import { toStandardLazyRequest, sendStandardResponse } from '@orpc/standard-server-node';
+import { a as OpenAPIMatcher, O as OpenAPICodec } from '../../shared/openapi.CDsfPHgw.mjs';
+import '@orpc/contract';
+import '@orpc/openapi-client/standard';
+import '@orpc/shared';
+import '@orpc/server';
+import 'rou3';
+import '../../shared/openapi.BHG_gu5Z.mjs';
+
+class OpenAPIHandler {
+  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, ...[
+    options = {}
+  ]) {
+    const standardRequest = toStandardLazyRequest(req, res);
+    const result = await this.standardHandler.handle(standardRequest, options);
+    if (!result.matched) {
+      return { matched: false };
+    }
+    await sendStandardResponse(res, result.response, options);
+    return { matched: true };
+  }
+}
+
+export { OpenAPIHandler };

package/dist/adapters/standard/index.d.mts

@@ -0,0 +1,24 @@
+import { ORPCError } from '@orpc/client';
+import { AnyProcedure, AnyRouter } from '@orpc/server';
+import { StandardCodec, StandardParams, StandardMatcher, StandardMatchResult } from '@orpc/server/standard';
+import { StandardLazyRequest, StandardResponse } from '@orpc/standard-server';
+import { OpenAPISerializer } from '@orpc/openapi-client/standard';
+export { O as OpenAPIHandlerOptions } from '../../shared/openapi.Dz_6xooR.mjs';
+import { HTTPPath } from '@orpc/contract';
+
+declare class OpenAPICodec implements StandardCodec {
+    private readonly serializer;
+    constructor(serializer?: OpenAPISerializer);
+    decode(request: StandardLazyRequest, params: StandardParams | undefined, procedure: AnyProcedure): Promise<unknown>;
+    encode(output: unknown, procedure: AnyProcedure): StandardResponse;
+    encodeError(error: ORPCError<any, any>): StandardResponse;
+}
+
+declare class OpenAPIMatcher implements StandardMatcher {
+    private readonly tree;
+    private pendingRouters;
+    init(router: AnyRouter, path?: string[]): void;
+    match(method: string, pathname: HTTPPath): Promise<StandardMatchResult>;
+}
+
+export { OpenAPICodec, OpenAPIMatcher };

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

@@ -0,0 +1,24 @@
+import { ORPCError } from '@orpc/client';
+import { AnyProcedure, AnyRouter } from '@orpc/server';
+import { StandardCodec, StandardParams, StandardMatcher, StandardMatchResult } from '@orpc/server/standard';
+import { StandardLazyRequest, StandardResponse } from '@orpc/standard-server';
+import { OpenAPISerializer } from '@orpc/openapi-client/standard';
+export { O as OpenAPIHandlerOptions } from '../../shared/openapi.Dz_6xooR.js';
+import { HTTPPath } from '@orpc/contract';
+
+declare class OpenAPICodec implements StandardCodec {
+    private readonly serializer;
+    constructor(serializer?: OpenAPISerializer);
+    decode(request: StandardLazyRequest, params: StandardParams | undefined, procedure: AnyProcedure): Promise<unknown>;
+    encode(output: unknown, procedure: AnyProcedure): StandardResponse;
+    encodeError(error: ORPCError<any, any>): StandardResponse;
+}
+
+declare class OpenAPIMatcher implements StandardMatcher {
+    private readonly tree;
+    private pendingRouters;
+    init(router: AnyRouter, path?: string[]): void;
+    match(method: string, pathname: HTTPPath): Promise<StandardMatchResult>;
+}
+
+export { OpenAPICodec, OpenAPIMatcher };

package/dist/adapters/standard/index.mjs

@@ -0,0 +1,7 @@
+export { O as OpenAPICodec, a as OpenAPIMatcher } from '../../shared/openapi.CDsfPHgw.mjs';
+import '@orpc/contract';
+import '@orpc/openapi-client/standard';
+import '@orpc/shared';
+import '@orpc/server';
+import 'rou3';
+import '../../shared/openapi.BHG_gu5Z.mjs';

package/dist/index.d.mts

@@ -0,0 +1,169 @@
+import { AnyContractProcedure, Schema, ContractRouter, HTTPPath } from '@orpc/contract';
+import * as OpenAPI from 'openapi3-ts/oas31';
+export { OpenAPI };
+export { OpenApiBuilder } from 'openapi3-ts/oas31';
+import * as JSONSchema from 'json-schema-typed/draft-2020-12';
+export { JSONSchema };
+export { Format as JSONSchemaFormat } from 'json-schema-typed/draft-2020-12';
+import { OpenAPIJsonSerializer } from '@orpc/openapi-client/standard';
+import { AnyRouter } from '@orpc/server';
+
+type OverrideOperationValue = OpenAPI.OperationObject | ((current: OpenAPI.OperationObject, procedure: AnyContractProcedure) => OpenAPI.OperationObject);
+declare function setOperationExtender<T extends object>(o: T, extend: OverrideOperationValue): T;
+declare function getOperationExtender(o: object): OverrideOperationValue | undefined;
+declare function extendOperation(operation: OpenAPI.OperationObject, procedure: AnyContractProcedure): OpenAPI.OperationObject;
+
+type ObjectSchema = JSONSchema.JSONSchema & {
+    type: 'object';
+} & object;
+type FileSchema = JSONSchema.JSONSchema & {
+    type: 'string';
+    contentMediaType: string;
+} & object;
+declare const NON_LOGIC_KEYWORDS: string[];
+
+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];
+}
+type PublicSchemaUtils = Pick<SchemaUtils, keyof SchemaUtils>;
+
+declare class OpenAPIContentBuilder {
+    private readonly schemaUtils;
+    constructor(schemaUtils: PublicSchemaUtils);
+    build(jsonSchema: JSONSchema.JSONSchema, options?: Partial<OpenAPI.MediaTypeObject>): OpenAPI.ContentObject;
+}
+type PublicOpenAPIContentBuilder = Pick<OpenAPIContentBuilder, keyof OpenAPIContentBuilder>;
+
+declare class OpenAPIPathParser {
+    parseDynamicParams(path: string): {
+        name: string;
+        raw: string;
+    }[];
+}
+type PublicOpenAPIPathParser = Pick<OpenAPIPathParser, keyof OpenAPIPathParser>;
+
+interface SchemaConvertOptions {
+    strategy: 'input' | 'output';
+}
+interface SchemaConverter {
+    condition(schema: Schema, options: SchemaConvertOptions): boolean;
+    convert(schema: Schema, options: SchemaConvertOptions): JSONSchema.JSONSchema;
+}
+declare class CompositeSchemaConverter implements SchemaConverter {
+    private readonly converters;
+    constructor(converters: SchemaConverter[]);
+    condition(): boolean;
+    convert(schema: Schema, options: SchemaConvertOptions): JSONSchema.JSONSchema;
+}
+
+interface OpenAPIInputStructureParseResult {
+    paramsSchema: ObjectSchema | undefined;
+    querySchema: ObjectSchema | undefined;
+    headersSchema: ObjectSchema | undefined;
+    bodySchema: JSONSchema.JSONSchema | undefined;
+}
+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;
+}
+type PublicOpenAPIInputStructureParser = Pick<OpenAPIInputStructureParser, keyof OpenAPIInputStructureParser>;
+
+interface OpenAPIOutputStructureParseResult {
+    headersSchema: ObjectSchema | undefined;
+    bodySchema: JSONSchema.JSONSchema | undefined;
+}
+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;
+}
+type PublicOpenAPIOutputStructureParser = Pick<OpenAPIOutputStructureParser, keyof OpenAPIOutputStructureParser>;
+
+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;
+}
+type PublicOpenAPIParametersBuilder = Pick<OpenAPIParametersBuilder, keyof OpenAPIParametersBuilder>;
+
+type ErrorHandlerStrategy = 'throw' | 'log' | 'ignore';
+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;
+}
+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>;
+}
+
+declare function standardizeHTTPPath(path: HTTPPath): HTTPPath;
+declare function toOpenAPI31RoutePattern(path: HTTPPath): string;
+
+/** unnoq */
+
+declare const oo: {
+    spec: typeof setOperationExtender;
+};
+
+export { CompositeSchemaConverter, type FileSchema, NON_LOGIC_KEYWORDS, type ObjectSchema, OpenAPIContentBuilder, OpenAPIGenerator, type OpenAPIGeneratorOptions, OpenAPIParametersBuilder, OpenAPIPathParser, type OverrideOperationValue, type PublicOpenAPIContentBuilder, type PublicOpenAPIParametersBuilder, type PublicOpenAPIPathParser, type PublicSchemaUtils, type SchemaConvertOptions, type SchemaConverter, SchemaUtils, extendOperation, getOperationExtender, oo, setOperationExtender, standardizeHTTPPath, toOpenAPI31RoutePattern };

package/dist/index.d.ts

@@ -0,0 +1,169 @@
+import { AnyContractProcedure, Schema, ContractRouter, HTTPPath } from '@orpc/contract';
+import * as OpenAPI from 'openapi3-ts/oas31';
+export { OpenAPI };
+export { OpenApiBuilder } from 'openapi3-ts/oas31';
+import * as JSONSchema from 'json-schema-typed/draft-2020-12';
+export { JSONSchema };
+export { Format as JSONSchemaFormat } from 'json-schema-typed/draft-2020-12';
+import { OpenAPIJsonSerializer } from '@orpc/openapi-client/standard';
+import { AnyRouter } from '@orpc/server';
+
+type OverrideOperationValue = OpenAPI.OperationObject | ((current: OpenAPI.OperationObject, procedure: AnyContractProcedure) => OpenAPI.OperationObject);
+declare function setOperationExtender<T extends object>(o: T, extend: OverrideOperationValue): T;
+declare function getOperationExtender(o: object): OverrideOperationValue | undefined;
+declare function extendOperation(operation: OpenAPI.OperationObject, procedure: AnyContractProcedure): OpenAPI.OperationObject;
+
+type ObjectSchema = JSONSchema.JSONSchema & {
+    type: 'object';
+} & object;
+type FileSchema = JSONSchema.JSONSchema & {
+    type: 'string';
+    contentMediaType: string;
+} & object;
+declare const NON_LOGIC_KEYWORDS: string[];
+
+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];
+}
+type PublicSchemaUtils = Pick<SchemaUtils, keyof SchemaUtils>;
+
+declare class OpenAPIContentBuilder {
+    private readonly schemaUtils;
+    constructor(schemaUtils: PublicSchemaUtils);
+    build(jsonSchema: JSONSchema.JSONSchema, options?: Partial<OpenAPI.MediaTypeObject>): OpenAPI.ContentObject;
+}
+type PublicOpenAPIContentBuilder = Pick<OpenAPIContentBuilder, keyof OpenAPIContentBuilder>;
+
+declare class OpenAPIPathParser {
+    parseDynamicParams(path: string): {
+        name: string;
+        raw: string;
+    }[];
+}
+type PublicOpenAPIPathParser = Pick<OpenAPIPathParser, keyof OpenAPIPathParser>;
+
+interface SchemaConvertOptions {
+    strategy: 'input' | 'output';
+}
+interface SchemaConverter {
+    condition(schema: Schema, options: SchemaConvertOptions): boolean;
+    convert(schema: Schema, options: SchemaConvertOptions): JSONSchema.JSONSchema;
+}
+declare class CompositeSchemaConverter implements SchemaConverter {
+    private readonly converters;
+    constructor(converters: SchemaConverter[]);
+    condition(): boolean;
+    convert(schema: Schema, options: SchemaConvertOptions): JSONSchema.JSONSchema;
+}
+
+interface OpenAPIInputStructureParseResult {
+    paramsSchema: ObjectSchema | undefined;
+    querySchema: ObjectSchema | undefined;
+    headersSchema: ObjectSchema | undefined;
+    bodySchema: JSONSchema.JSONSchema | undefined;
+}
+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;
+}
+type PublicOpenAPIInputStructureParser = Pick<OpenAPIInputStructureParser, keyof OpenAPIInputStructureParser>;
+
+interface OpenAPIOutputStructureParseResult {
+    headersSchema: ObjectSchema | undefined;
+    bodySchema: JSONSchema.JSONSchema | undefined;
+}
+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;
+}
+type PublicOpenAPIOutputStructureParser = Pick<OpenAPIOutputStructureParser, keyof OpenAPIOutputStructureParser>;
+
+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;
+}
+type PublicOpenAPIParametersBuilder = Pick<OpenAPIParametersBuilder, keyof OpenAPIParametersBuilder>;
+
+type ErrorHandlerStrategy = 'throw' | 'log' | 'ignore';
+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;
+}
+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>;
+}
+
+declare function standardizeHTTPPath(path: HTTPPath): HTTPPath;
+declare function toOpenAPI31RoutePattern(path: HTTPPath): string;
+
+/** unnoq */
+
+declare const oo: {
+    spec: typeof setOperationExtender;
+};
+
+export { CompositeSchemaConverter, type FileSchema, NON_LOGIC_KEYWORDS, type ObjectSchema, OpenAPIContentBuilder, OpenAPIGenerator, type OpenAPIGeneratorOptions, OpenAPIParametersBuilder, OpenAPIPathParser, type OverrideOperationValue, type PublicOpenAPIContentBuilder, type PublicOpenAPIParametersBuilder, type PublicOpenAPIPathParser, type PublicSchemaUtils, type SchemaConvertOptions, type SchemaConverter, SchemaUtils, extendOperation, getOperationExtender, oo, setOperationExtender, standardizeHTTPPath, toOpenAPI31RoutePattern };