@orpc/openapi 0.0.0-next.eb37cbe → 0.0.0-next.eb45166

package/dist/index.js

@@ -1,362 +0,0 @@
-import {
-  JSONSerializer,
-  forEachAllContractProcedure,
-  forEachContractProcedure,
-  standardizeHTTPPath
-} from "./chunk-KNYXLM77.js";
-
-// src/openapi.ts
-import { OpenApiBuilder } from "openapi3-ts/oas31";
-
-// src/openapi-content-builder.ts
-import { findDeepMatches } from "@orpc/shared";
-var OpenAPIContentBuilder = class {
-  constructor(schemaUtils) {
-    this.schemaUtils = schemaUtils;
-  }
-  build(jsonSchema, options) {
-    const isFileSchema = this.schemaUtils.isFileSchema.bind(this.schemaUtils);
-    const [matches, schema] = this.schemaUtils.filterSchemaBranches(jsonSchema, isFileSchema);
-    const files = matches;
-    const content = {};
-    for (const file of files) {
-      content[file.contentMediaType] = {
-        schema: file
-      };
-    }
-    const isStillHasFileSchema = findDeepMatches(isFileSchema, schema).values.length > 0;
-    if (schema !== void 0) {
-      content[isStillHasFileSchema ? "multipart/form-data" : "application/json"] = {
-        schema,
-        ...options
-      };
-    }
-    return content;
-  }
-};
-
-// src/openapi-parameters-builder.ts
-import { get, isPlainObject } 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;
-      }).map((example) => {
-        return example[name];
-      });
-      const paramSchema = {
-        examples: paramExamples?.length ? paramExamples : void 0,
-        ...schema === true ? {} : schema === false ? { not: {} } : schema
-      };
-      const paramExample = get(options?.example, [name]);
-      parameters.push({
-        name,
-        in: paramIn,
-        required: typeof options?.required === "boolean" ? options.required : jsonSchema.required?.includes(name) ?? false,
-        schema: paramSchema,
-        example: paramExample,
-        style: options?.style
-      });
-    }
-    return parameters;
-  }
-};
-
-// src/openapi-path-parser.ts
-var OpenAPIPathParser = class {
-  parseDynamicParams(path) {
-    const raws = path.match(/\{([^}]+)\}/g) ?? [];
-    return raws.map((raw) => {
-      const name = raw.slice(1, -1).split(":")[0];
-      return { name, raw };
-    });
-  }
-};
-
-// src/schema-converter.ts
-var CompositeSchemaConverter = class {
-  converters;
-  constructor(converters) {
-    this.converters = converters;
-  }
-  condition() {
-    return true;
-  }
-  convert(schema, options) {
-    for (const converter of this.converters) {
-      if (converter.condition(schema, options)) {
-        return converter.convert(schema, options);
-      }
-    }
-    return {};
-  }
-};
-
-// src/schema-utils.ts
-import { isPlainObject as isPlainObject2 } from "@orpc/shared";
-
-// src/schema.ts
-import * as JSONSchema from "json-schema-typed/draft-2020-12";
-import { Format } from "json-schema-typed/draft-2020-12";
-var NON_LOGIC_KEYWORDS = [
-  // Core Documentation Keywords
-  "$anchor",
-  "$comment",
-  "$defs",
-  "$id",
-  "title",
-  "description",
-  // Value Keywords
-  "default",
-  "deprecated",
-  "examples",
-  // Metadata Keywords
-  "$schema",
-  "definitions",
-  // Legacy, but still used
-  "readOnly",
-  "writeOnly",
-  // Display and UI Hints
-  "contentMediaType",
-  "contentEncoding",
-  "format",
-  // Custom Extensions
-  "$vocabulary",
-  "$dynamicAnchor",
-  "$dynamicRef"
-];
-
-// src/schema-utils.ts
-var SchemaUtils = class {
-  isFileSchema(schema) {
-    return typeof schema === "object" && schema.type === "string" && typeof schema.contentMediaType === "string";
-  }
-  isObjectSchema(schema) {
-    return typeof schema === "object" && schema.type === "object";
-  }
-  isAnySchema(schema) {
-    return schema === true || Object.keys(schema).length === 0;
-  }
-  isUndefinableSchema(schema) {
-    const [matches] = this.filterSchemaBranches(schema, (schema2) => {
-      if (typeof schema2 === "boolean") {
-        return schema2;
-      }
-      return Object.keys(schema2).length === 0;
-    });
-    return matches.length > 0;
-  }
-  separateObjectSchema(schema, separatedProperties) {
-    const matched = { ...schema };
-    const rest = { ...schema };
-    matched.properties = Object.entries(schema.properties ?? {}).filter(([key]) => separatedProperties.includes(key)).reduce((acc, [key, value]) => {
-      acc[key] = value;
-      return acc;
-    }, {});
-    matched.required = schema.required?.filter((key) => separatedProperties.includes(key));
-    matched.examples = schema.examples?.map((example) => {
-      if (!isPlainObject2(example)) {
-        return example;
-      }
-      return Object.entries(example).reduce((acc, [key, value]) => {
-        if (separatedProperties.includes(key)) {
-          acc[key] = value;
-        }
-        return acc;
-      }, {});
-    });
-    rest.properties = Object.entries(schema.properties ?? {}).filter(([key]) => !separatedProperties.includes(key)).reduce((acc, [key, value]) => {
-      acc[key] = value;
-      return acc;
-    }, {});
-    rest.required = schema.required?.filter((key) => !separatedProperties.includes(key));
-    rest.examples = schema.examples?.map((example) => {
-      if (!isPlainObject2(example)) {
-        return example;
-      }
-      return Object.entries(example).reduce((acc, [key, value]) => {
-        if (!separatedProperties.includes(key)) {
-          acc[key] = value;
-        }
-        return acc;
-      }, {});
-    });
-    return [matched, rest];
-  }
-  filterSchemaBranches(schema, check, matches = []) {
-    if (check(schema)) {
-      matches.push(schema);
-      return [matches, void 0];
-    }
-    if (typeof schema === "boolean") {
-      return [matches, schema];
-    }
-    if (schema.anyOf && Object.keys(schema).every(
-      (k) => k === "anyOf" || NON_LOGIC_KEYWORDS.includes(k)
-    )) {
-      const anyOf = schema.anyOf.map((s) => this.filterSchemaBranches(s, check, matches)[1]).filter((v) => !!v);
-      if (anyOf.length === 1 && typeof anyOf[0] === "object") {
-        return [matches, { ...schema, anyOf: void 0, ...anyOf[0] }];
-      }
-      return [matches, { ...schema, anyOf }];
-    }
-    if (schema.oneOf && Object.keys(schema).every(
-      (k) => k === "oneOf" || NON_LOGIC_KEYWORDS.includes(k)
-    )) {
-      const oneOf = schema.oneOf.map((s) => this.filterSchemaBranches(s, check, matches)[1]).filter((v) => !!v);
-      if (oneOf.length === 1 && typeof oneOf[0] === "object") {
-        return [matches, { ...schema, oneOf: void 0, ...oneOf[0] }];
-      }
-      return [matches, { ...schema, oneOf }];
-    }
-    return [matches, schema];
-  }
-};
-
-// src/openapi-generator.ts
-var OpenAPIGenerator = class {
-  constructor(options) {
-    this.options = options;
-    this.parametersBuilder = options?.parametersBuilder ?? new OpenAPIParametersBuilder();
-    this.schemaConverter = new CompositeSchemaConverter(options?.schemaConverters ?? []);
-    this.schemaUtils = options?.schemaUtils ?? new SchemaUtils();
-    this.jsonSerializer = options?.jsonSerializer ?? new JSONSerializer();
-    this.contentBuilder = options?.contentBuilder ?? new OpenAPIContentBuilder(this.schemaUtils);
-    this.pathParser = new OpenAPIPathParser();
-  }
-  contentBuilder;
-  parametersBuilder;
-  schemaConverter;
-  schemaUtils;
-  jsonSerializer;
-  pathParser;
-  async generate(router, doc) {
-    const builder = new OpenApiBuilder({
-      ...doc,
-      openapi: "3.1.1"
-    });
-    const rootTags = doc.tags?.map((tag) => tag.name) ?? [];
-    await forEachAllContractProcedure(router, ({ contract, path }) => {
-      const def = contract["~orpc"];
-      if (this.options?.ignoreUndefinedPathProcedures && def.route?.path === void 0) {
-        return;
-      }
-      const method = def.route?.method ?? "POST";
-      const httpPath = def.route?.path ? standardizeHTTPPath(def.route?.path) : `/${path.map(encodeURIComponent).join("/")}`;
-      let inputSchema = this.schemaConverter.convert(def.InputSchema, { strategy: "input" });
-      const outputSchema = this.schemaConverter.convert(def.OutputSchema, { strategy: "output" });
-      const params = (() => {
-        const dynamic = this.pathParser.parseDynamicParams(httpPath);
-        if (!dynamic.length) {
-          return void 0;
-        }
-        if (this.schemaUtils.isAnySchema(inputSchema)) {
-          return void 0;
-        }
-        if (!this.schemaUtils.isObjectSchema(inputSchema)) {
-          this.handleError(
-            new Error(
-              `When path has parameters, input schema must be an object [${path.join(".")}]`
-            )
-          );
-          return void 0;
-        }
-        const [matched, rest] = this.schemaUtils.separateObjectSchema(inputSchema, dynamic.map((v) => v.name));
-        inputSchema = rest;
-        return this.parametersBuilder.build("path", matched, {
-          example: def.inputExample,
-          required: true
-        });
-      })();
-      const query = (() => {
-        if (method !== "GET" || Object.keys(inputSchema).length === 0) {
-          return void 0;
-        }
-        if (this.schemaUtils.isAnySchema(inputSchema)) {
-          return void 0;
-        }
-        if (!this.schemaUtils.isObjectSchema(inputSchema)) {
-          this.handleError(
-            new Error(
-              `When method is GET, input schema must be an object [${path.join(".")}]`
-            )
-          );
-          return void 0;
-        }
-        return this.parametersBuilder.build("query", inputSchema, {
-          example: def.inputExample
-        });
-      })();
-      const parameters = [...params ?? [], ...query ?? []];
-      const requestBody = (() => {
-        if (method === "GET") {
-          return void 0;
-        }
-        return {
-          required: this.schemaUtils.isUndefinableSchema(inputSchema),
-          content: this.contentBuilder.build(inputSchema, {
-            example: def.inputExample
-          })
-        };
-      })();
-      const successResponse = {
-        description: "OK",
-        content: this.contentBuilder.build(outputSchema, {
-          example: def.outputExample
-        })
-      };
-      if (this.options?.considerMissingTagDefinitionAsError && def.route?.tags) {
-        const missingTag = def.route?.tags.find((tag) => !rootTags.includes(tag));
-        if (missingTag !== void 0) {
-          this.handleError(
-            new Error(
-              `Tag "${missingTag}" is missing definition. Please define it in OpenAPI root tags object. [${path.join(".")}]`
-            )
-          );
-        }
-      }
-      const operation = {
-        summary: def.route?.summary,
-        description: def.route?.description,
-        deprecated: def.route?.deprecated,
-        tags: def.route?.tags ? [...def.route.tags] : void 0,
-        operationId: path.join("."),
-        parameters: parameters.length ? parameters : void 0,
-        requestBody,
-        responses: {
-          [def.route?.successStatus ?? 200]: successResponse
-        }
-      };
-      builder.addPath(httpPath, {
-        [method.toLocaleLowerCase()]: operation
-      });
-    });
-    return this.jsonSerializer.serialize(builder.getSpec());
-  }
-  handleError(error) {
-    if (this.options?.throwOnError) {
-      throw error;
-    }
-    console.error(error);
-  }
-};
-export {
-  CompositeSchemaConverter,
-  JSONSchema,
-  Format as JSONSchemaFormat,
-  JSONSerializer,
-  NON_LOGIC_KEYWORDS,
-  OpenAPIContentBuilder,
-  OpenAPIGenerator,
-  OpenAPIParametersBuilder,
-  OpenAPIPathParser,
-  OpenApiBuilder,
-  SchemaUtils,
-  forEachAllContractProcedure,
-  forEachContractProcedure,
-  standardizeHTTPPath
-};
-//# sourceMappingURL=index.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

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

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

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

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

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

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

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

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

package/dist/src/index.d.ts

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

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

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

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

@@ -1,10 +0,0 @@
-import type { OpenAPI } from './openapi';
-import type { JSONSchema } from './schema';
-import type { PublicSchemaUtils } from './schema-utils';
-export declare class OpenAPIContentBuilder {
-    private readonly schemaUtils;
-    constructor(schemaUtils: PublicSchemaUtils);
-    build(jsonSchema: JSONSchema.JSONSchema, options?: Partial<OpenAPI.MediaTypeObject>): OpenAPI.ContentObject;
-}
-export type PublicOpenAPIContentBuilder = Pick<OpenAPIContentBuilder, keyof OpenAPIContentBuilder>;
-//# sourceMappingURL=openapi-content-builder.d.ts.map

package/dist/src/openapi-generator.d.ts

@@ -1,51 +0,0 @@
-import type { ContractRouter } from '@orpc/contract';
-import type { ANY_ROUTER } from '@orpc/server';
-import type { PublicOpenAPIPathParser } from './openapi-path-parser';
-import type { SchemaConverter } from './schema-converter';
-import { type PublicJSONSerializer } from './json-serializer';
-import { type OpenAPI } from './openapi';
-import { type PublicOpenAPIContentBuilder } from './openapi-content-builder';
-import { type PublicOpenAPIParametersBuilder } from './openapi-parameters-builder';
-import { type PublicSchemaUtils } from './schema-utils';
-export interface OpenAPIGeneratorOptions {
-    contentBuilder?: PublicOpenAPIContentBuilder;
-    parametersBuilder?: PublicOpenAPIParametersBuilder;
-    schemaConverters?: SchemaConverter[];
-    schemaUtils?: PublicSchemaUtils;
-    jsonSerializer?: PublicJSONSerializer;
-    pathParser?: PublicOpenAPIPathParser;
-    /**
-     * Throw error when you missing define tag definition on OpenAPI root tags
-     *
-     * Example: if procedure has tags ['foo', 'bar'], and OpenAPI root tags is ['foo'], then error will be thrown
-     * Because OpenAPI root tags is missing 'bar' tag
-     *
-     * @default false
-     */
-    considerMissingTagDefinitionAsError?: boolean;
-    /**
-     * Weather ignore procedures that has no path defined.
-     *
-     * @default false
-     */
-    ignoreUndefinedPathProcedures?: boolean;
-    /**
-     * Throw error when you have error in OpenAPI generator
-     *
-     * @default false
-     */
-    throwOnError?: boolean;
-}
-export declare class OpenAPIGenerator {
-    private readonly options?;
-    private readonly contentBuilder;
-    private readonly parametersBuilder;
-    private readonly schemaConverter;
-    private readonly schemaUtils;
-    private readonly jsonSerializer;
-    private readonly pathParser;
-    constructor(options?: OpenAPIGeneratorOptions | undefined);
-    generate(router: ContractRouter | ANY_ROUTER, doc: Omit<OpenAPI.OpenAPIObject, 'openapi'>): Promise<OpenAPI.OpenAPIObject>;
-    private handleError;
-}
-//# sourceMappingURL=openapi-generator.d.ts.map

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

@@ -1,9 +0,0 @@
-import type { OpenAPI } from './openapi';
-import type { JSONSchema } from './schema';
-export declare class OpenAPIParametersBuilder {
-    build(paramIn: OpenAPI.ParameterObject['in'], jsonSchema: JSONSchema.JSONSchema & {
-        type: 'object';
-    } & object, options?: Pick<OpenAPI.ParameterObject, 'example' | 'style' | 'required'>): OpenAPI.ParameterObject[];
-}
-export type PublicOpenAPIParametersBuilder = Pick<OpenAPIParametersBuilder, keyof OpenAPIParametersBuilder>;
-//# sourceMappingURL=openapi-parameters-builder.d.ts.map

package/dist/src/openapi-path-parser.d.ts

@@ -1,8 +0,0 @@
-export declare class OpenAPIPathParser {
-    parseDynamicParams(path: string): {
-        name: string;
-        raw: string;
-    }[];
-}
-export type PublicOpenAPIPathParser = Pick<OpenAPIPathParser, keyof OpenAPIPathParser>;
-//# sourceMappingURL=openapi-path-parser.d.ts.map