@orpc/openapi 0.43.0 → 0.44.0

package/README.md

@@ -1,5 +1,5 @@
 <div align="center">
-  <image align="center" src="https://orpc.unnoq.com/logo.webp" width=280 />
+  <image align="center" src="https://orpc.unnoq.com/logo.webp" width=280 alt="oRPC logo" />
 </div>
 
 <h1></h1>

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.D0VMNR6V.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.D0VMNR6V.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.D0VMNR6V.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,29 @@
+import { StandardHandler } from '@orpc/server/standard';
+import { toStandardRequest, 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 = toStandardRequest(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 { StandardRequest, 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: StandardRequest, 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 { StandardRequest, 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: StandardRequest, 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 };