@temporary-name/server 1.9.3-alpha.2957dbc009ec31fa21575f028b83c96651cba827 → 1.9.3-alpha.305aebe633f301e28426c6b15cdfd58ddf45641c

package/dist/index.mjs

@@ -1,13 +1,18 @@
-import { mergePrefix, mergeTags, mergeMeta, parseEndpointDefinition, mergeRoute, prefixRoute, initialSchemas } from '@temporary-name/contract';
-export { ValidationError, eventIterator } from '@temporary-name/contract';
-import { assertNever, splitFirst, ORPCError, onError, resolveMaybeOptionalOptions } from '@temporary-name/shared';
+import { assertNever, splitFirst, ORPCError, onError, isObject, toArray, guard, resolveMaybeOptionalOptions, isTypescriptObject, isPropertyKey } from '@temporary-name/shared';
 export { AsyncIteratorClass, EventPublisher, ORPCError, asyncIteratorToStream as eventIteratorToStream, isDefinedError, onError, onFinish, onStart, onSuccess, streamToAsyncIteratorClass as streamToEventIterator } from '@temporary-name/shared';
+import * as z from '@temporary-name/zod';
 import { SchemaClass, object, core, gatingContext } from '@temporary-name/zod';
 import { g as getCookie } from './shared/server.C1RJffw4.mjs';
-import { P as Procedure, c as createProcedureClient, e as enhanceRouter, C as Contract, a as addMiddleware, l as lazyInternal, g as getLazyMeta, u as unlazy, i as isProcedure, b as isLazy, d as getRouter } from './shared/server.B7tjiDal.mjs';
-export { L as LAZY_SYMBOL, n as createAccessibleLazyRouter, j as isStartWithMiddlewares, f as lazy, m as mergeCurrentContext, k as mergeMiddlewares, h as middlewareOutputFn, r as resolveContractProcedures, t as traverseContractProcedures, o as unlazyRouter } from './shared/server.B7tjiDal.mjs';
+import { P as Procedure, m as mergePrefix, a as mergeTags, e as enhanceRouter, C as Contract, p as parseEndpointDefinition, b as mergeRoute, c as prefixRoute, d as addMiddleware, l as lazyInternal, f as getLazyMeta, u as unlazy, i as isProcedure, h as isLazy, j as getRouter } from './shared/server.ChOv1yG3.mjs';
+export { L as LAZY_SYMBOL, V as ValidationError, q as createAccessibleLazyRouter, w as endpointRegex, g as getDynamicParams, n as isStartWithMiddlewares, k as lazy, o as mergeMiddlewares, r as resolveContractProcedures, s as standardizeHTTPPath, t as traverseContractProcedures, v as unlazyRouter } from './shared/server.ChOv1yG3.mjs';
+import { c as createProcedureClient } from './shared/server.Cza0RB3u.mjs';
+export { m as mergeCurrentContext, a as middlewareOutputFn } from './shared/server.Cza0RB3u.mjs';
+import { J as JsonSchemaXNativeType } from './shared/server.Ny4yD6yY.mjs';
+export { b as JSON_SCHEMA_INPUT_REGISTRY, c as JSON_SCHEMA_OUTPUT_REGISTRY, a as JSON_SCHEMA_REGISTRY, Z as ZodToJsonSchemaConverter, e as eventIterator, g as getEventIteratorSchemaDetails } from './shared/server.Ny4yD6yY.mjs';
 export { getEventMeta, withEventMeta } from '@temporary-name/standard-server';
 import 'cookie';
+import '@temporary-name/server/openapi';
+import 'zod/v4/core';
 
 function validateTokenPrefix(prefix, token) {
   if (prefix && !token.startsWith(prefix)) {
@@ -19,47 +24,57 @@ function validateTokenAuth(config, token, options) {
   validateTokenPrefix(tokenPrefix, token);
   return validate(token, options);
 }
-function authByQuery(config, options) {
-  const { name, tokenPrefix, validate } = config;
-  const query = options.request.url.searchParams;
-  const token = query.get(name);
-  if (!token) return void 0;
-  validateTokenPrefix(tokenPrefix, token);
-  return validate(token, options);
-}
-function authByHeader(config, options) {
-  const authHeader = options.request.headers.get(config.name);
-  return authHeader ? validateTokenAuth(config, authHeader, options) : void 0;
-}
-function authByCookie(config, options) {
-  const cookie = getCookie(options.request.headers, config.name);
-  return cookie ? validateTokenAuth(config, cookie, options) : void 0;
-}
-function authByBearer(config, options) {
-  const authHeader = options.request.headers.get("Authorization");
-  if (!authHeader) return void 0;
-  const [authType, bearer] = splitFirst(authHeader, " ");
-  return authType === "Bearer" ? validateTokenAuth(config, bearer, options) : void 0;
-}
-function authByBasic(config, options) {
-  const authHeader = options.request.headers.get("Authorization");
-  if (!authHeader) return void 0;
-  const [authType, encoded] = splitFirst(authHeader, " ");
-  if (authType !== "Basic") return void 0;
-  const decoded = Buffer.from(encoded, "base64").toString("utf-8");
-  const [username, password] = splitFirst(decoded, ":");
-  validateTokenPrefix(config.tokenPrefix, password);
-  return config.validate(username, password, options);
-}
-function authByType(config, options) {
-  const { type } = config;
-  return type === "header" ? authByHeader(config, options) : type === "query" ? authByQuery(config, options) : type === "cookie" ? authByCookie(config, options) : type === "bearer" ? authByBearer(config, options) : type === "basic" ? authByBasic(config, options) : type === "none" ? false : assertNever(type);
+function runAuth(config, options) {
+  switch (config.type) {
+    case "header": {
+      const authHeader = options.request.headers.get(config.name);
+      return authHeader ? validateTokenAuth(config, authHeader, options) : void 0;
+    }
+    case "query": {
+      const { name, tokenPrefix, validate } = config;
+      const query = options.request.url.searchParams;
+      const token = query.get(name);
+      if (!token) return void 0;
+      validateTokenPrefix(tokenPrefix, token);
+      return validate(token, options);
+    }
+    case "cookie": {
+      const cookie = getCookie(options.request.headers, config.name);
+      return cookie ? validateTokenAuth(config, cookie, options) : void 0;
+    }
+    case "bearer": {
+      const authHeader = options.request.headers.get("Authorization");
+      if (!authHeader) return void 0;
+      const [authType, bearer] = splitFirst(authHeader, " ");
+      return authType === "Bearer" ? validateTokenAuth(config, bearer, options) : void 0;
+    }
+    case "basic": {
+      const authHeader = options.request.headers.get("Authorization");
+      if (!authHeader) return void 0;
+      const [authType, encoded] = splitFirst(authHeader, " ");
+      if (authType !== "Basic") return void 0;
+      const decoded = Buffer.from(encoded, "base64").toString("utf-8");
+      const [username, password] = splitFirst(decoded, ":");
+      validateTokenPrefix(config.tokenPrefix, password);
+      return config.validate(username, password, options);
+    }
+    case "none": {
+      return false;
+    }
+    default: {
+      assertNever(config);
+    }
+  }
 }
 function authDescription(config) {
   const { type } = config;
   return type === "basic" ? "a Basic Authentication header" : type === "bearer" ? "a Bearer Authentication header" : type === "header" ? `a header named "${config.name}"` : type === "query" ? `a query parameter named "${config.name}"` : type === "cookie" ? `a cookie named "${config.name}"` : type === "none" ? "no authentication" : assertNever(type);
 }
 
+function mergeMeta(meta1, meta2) {
+  return { ...meta1, ...meta2 };
+}
+
 class DecoratedProcedure extends Procedure {
   /**
    * Make this procedure callable (works like a function while still being a procedure).
@@ -79,6 +94,13 @@ class DecoratedProcedure extends Procedure {
   }
 }
 
+const initialSchemas = {
+  pathSchema: z.strictObject({}),
+  querySchema: z.strictObject({}),
+  bodySchema: z.strictObject({}),
+  outputSchema: z.unknown()
+};
+
 class ProcedureBuilder extends Contract {
   z;
   constructor(def) {
@@ -160,28 +182,19 @@ class ProcedureBuilder extends Contract {
       outputValidationIndex: this["~orpc"].middlewares.length
     });
   }
-  /**
-   * Uses a middleware to modify the context or improve the pipeline.
-   *
-   * @info Supports both normal middleware and inline middleware implementations.
-   * @note The current context must be satisfy middleware dependent-context
-   * @see {@link https://orpc.unnoq.com/docs/middleware Middleware Docs}
-   */
   use(middleware) {
     return new this.constructor({
       ...this["~orpc"],
       middlewares: addMiddleware(this["~orpc"].middlewares, middleware)
     });
   }
-  // `& {}` is so AuthType will be expanded in parameter info tooltips.
   // The default of false for ValidatedAuthContext is used when you pass in the type 'none'. We use false
   // because we can't use null or undefined (see ValidatedAuthContext) but we still want it to be falsy.
-  useAuth(type, ...rest) {
-    const config = { type, ...rest[0] };
-    const middleware = os.$context().middleware(async (options) => {
+  useAuth(config) {
+    const middleware = baseApi.$context().middleware(async (options) => {
       const { next, context } = options;
       if (context.auth) return next();
-      const auth = await authByType(config, options);
+      const auth = await runAuth(config, options);
       if (auth === void 0) {
         const { authConfigs } = options.procedure["~orpc"];
         if (context.auth !== false && config === authConfigs.at(-1)) {
@@ -271,31 +284,6 @@ function decorateMiddleware(middleware) {
     );
     return mapped;
   };
-  decorated.concat = (concatMiddleware, mapInput) => {
-    const mapped = mapInput ? decorateMiddleware(concatMiddleware).mapInput(mapInput) : concatMiddleware;
-    const concatted = decorateMiddleware((options, input, output, ...rest) => {
-      const merged = middleware(
-        {
-          ...options,
-          next: (...[nextOptions1]) => mapped(
-            {
-              ...options,
-              context: { ...options.context, ...nextOptions1?.context },
-              next: (...[nextOptions2]) => options.next({ context: { ...nextOptions1?.context, ...nextOptions2?.context } })
-            },
-            input,
-            output,
-            ...rest
-          )
-        },
-        input,
-        output,
-        ...rest
-      );
-      return merged;
-    });
-    return concatted;
-  };
   return decorated;
 }
 
@@ -317,25 +305,348 @@ class Builder extends BuilderWithMiddlewares {
     return decorateMiddleware(middleware);
   }
 }
-function createApiBuilder(opts = {}) {
-  return new Builder({
-    route: {},
-    meta: opts.meta ?? {},
-    inputValidationIndex: 0,
-    outputValidationIndex: 0,
-    middlewares: [
-      onError((error, _options) => {
-        console.dir(error, { depth: null });
-      })
-    ],
-    schemas: initialSchemas,
-    // NB: this is a relic from orpc -- I'm not convinced there's a need for this (or if there is, that it's
-    // the best solution). For now I've removed the interface to configure it externally.
-    dedupeLeadingMiddlewares: true,
-    authConfigs: []
-  });
+const baseApi = new Builder({
+  route: {},
+  meta: {},
+  inputValidationIndex: 0,
+  outputValidationIndex: 0,
+  middlewares: [
+    onError((error, _options) => {
+      console.dir(error, { depth: null });
+    })
+  ],
+  schemas: initialSchemas,
+  // NB: this is a relic from orpc -- I'm not convinced there's a need for this (or if there is, that it's
+  // the best solution). For now I've removed the interface to configure it externally.
+  dedupeLeadingMiddlewares: true,
+  authConfigs: []
+});
+
+const FLEXIBLE_DATE_FORMAT_REGEX = /^[^-]+-[^-]+-[^-]+$/;
+class experimental_JsonSchemaCoercer {
+  coerce(schema, value, options = {}) {
+    const [, coerced] = this.#coerce(schema, value, options);
+    return coerced;
+  }
+  #coerce(schema, originalValue, options) {
+    if (typeof schema === "boolean") {
+      return [schema, originalValue];
+    }
+    if (Array.isArray(schema.type)) {
+      return this.#coerce(
+        {
+          anyOf: schema.type.map((type) => ({ ...schema, type }))
+        },
+        originalValue,
+        options
+      );
+    }
+    let coerced = originalValue;
+    let satisfied = true;
+    if (typeof schema.$ref === "string") {
+      const refSchema = options?.components?.[schema.$ref];
+      if (refSchema !== void 0) {
+        const [subSatisfied, subCoerced] = this.#coerce(refSchema, coerced, options);
+        coerced = subCoerced;
+        satisfied = subSatisfied;
+      }
+    }
+    const enumValues = schema.const !== void 0 ? [schema.const] : schema.enum;
+    if (enumValues !== void 0 && !enumValues.includes(coerced)) {
+      if (typeof coerced === "string") {
+        const numberValue = this.#stringToNumber(coerced);
+        if (enumValues.includes(numberValue)) {
+          coerced = numberValue;
+        } else {
+          const booleanValue = this.#stringToBoolean(coerced);
+          if (enumValues.includes(booleanValue)) {
+            coerced = booleanValue;
+          } else {
+            satisfied = false;
+          }
+        }
+      } else {
+        satisfied = false;
+      }
+    }
+    if (typeof schema.type === "string") {
+      switch (schema.type) {
+        case "null": {
+          if (coerced !== null) {
+            satisfied = false;
+          }
+          break;
+        }
+        case "string": {
+          if (typeof coerced !== "string") {
+            satisfied = false;
+          }
+          break;
+        }
+        case "number": {
+          if (typeof coerced === "string") {
+            coerced = this.#stringToNumber(coerced);
+          }
+          if (typeof coerced !== "number") {
+            satisfied = false;
+          }
+          break;
+        }
+        case "integer": {
+          if (typeof coerced === "string") {
+            coerced = this.#stringToInteger(coerced);
+          }
+          if (typeof coerced !== "number" || !Number.isInteger(coerced)) {
+            satisfied = false;
+          }
+          break;
+        }
+        case "boolean": {
+          if (typeof coerced === "string") {
+            coerced = this.#stringToBoolean(coerced);
+          }
+          if (typeof coerced !== "boolean") {
+            satisfied = false;
+          }
+          break;
+        }
+        case "array": {
+          if (Array.isArray(coerced)) {
+            const prefixItemSchemas = "prefixItems" in schema ? toArray(schema.prefixItems) : Array.isArray(schema.items) ? schema.items : [];
+            const itemSchema = Array.isArray(schema.items) ? schema.additionalItems : schema.items;
+            let shouldUseCoercedItems = false;
+            const coercedItems = coerced.map((item, i) => {
+              const subSchema = prefixItemSchemas[i] ?? itemSchema;
+              if (subSchema === void 0) {
+                satisfied = false;
+                return item;
+              }
+              const [subSatisfied, subCoerced] = this.#coerce(subSchema, item, options);
+              if (!subSatisfied) {
+                satisfied = false;
+              }
+              if (subCoerced !== item) {
+                shouldUseCoercedItems = true;
+              }
+              return subCoerced;
+            });
+            if (coercedItems.length < prefixItemSchemas.length) {
+              satisfied = false;
+            }
+            if (shouldUseCoercedItems) {
+              coerced = coercedItems;
+            }
+          } else {
+            satisfied = false;
+          }
+          break;
+        }
+        case "object": {
+          if (Array.isArray(coerced)) {
+            coerced = { ...coerced };
+          }
+          if (isObject(coerced)) {
+            let shouldUseCoercedItems = false;
+            const coercedItems = {};
+            const patternProperties = Object.entries(schema.patternProperties ?? {}).map(
+              ([key, value]) => [new RegExp(key), value]
+            );
+            for (const key in coerced) {
+              const value = coerced[key];
+              const subSchema = schema.properties?.[key] ?? patternProperties.find(([pattern]) => pattern.test(key))?.[1] ?? schema.additionalProperties;
+              if (value === void 0 && !schema.required?.includes(key)) {
+                coercedItems[key] = value;
+              } else if (subSchema === void 0) {
+                coercedItems[key] = value;
+                satisfied = false;
+              } else {
+                const [subSatisfied, subCoerced] = this.#coerce(subSchema, value, options);
+                coercedItems[key] = subCoerced;
+                if (!subSatisfied) {
+                  satisfied = false;
+                }
+                if (subCoerced !== value) {
+                  shouldUseCoercedItems = true;
+                }
+              }
+            }
+            if (schema.required?.some((key) => !Object.hasOwn(coercedItems, key))) {
+              satisfied = false;
+            }
+            if (shouldUseCoercedItems) {
+              coerced = coercedItems;
+            }
+          } else {
+            satisfied = false;
+          }
+          break;
+        }
+      }
+    }
+    if ("x-native-type" in schema && typeof schema["x-native-type"] === "string") {
+      switch (schema["x-native-type"]) {
+        case JsonSchemaXNativeType.Date: {
+          if (typeof coerced === "string") {
+            coerced = this.#stringToDate(coerced);
+          }
+          if (!(coerced instanceof Date)) {
+            satisfied = false;
+          }
+          break;
+        }
+        case JsonSchemaXNativeType.BigInt: {
+          switch (typeof coerced) {
+            case "string":
+              coerced = this.#stringToBigInt(coerced);
+              break;
+            case "number":
+              coerced = this.#numberToBigInt(coerced);
+              break;
+          }
+          if (typeof coerced !== "bigint") {
+            satisfied = false;
+          }
+          break;
+        }
+        case JsonSchemaXNativeType.RegExp: {
+          if (typeof coerced === "string") {
+            coerced = this.#stringToRegExp(coerced);
+          }
+          if (!(coerced instanceof RegExp)) {
+            satisfied = false;
+          }
+          break;
+        }
+        case JsonSchemaXNativeType.Url: {
+          if (typeof coerced === "string") {
+            coerced = this.#stringToURL(coerced);
+          }
+          if (!(coerced instanceof URL)) {
+            satisfied = false;
+          }
+          break;
+        }
+        case JsonSchemaXNativeType.Set: {
+          if (Array.isArray(coerced)) {
+            coerced = this.#arrayToSet(coerced);
+          }
+          if (!(coerced instanceof Set)) {
+            satisfied = false;
+          }
+          break;
+        }
+        case JsonSchemaXNativeType.Map: {
+          if (Array.isArray(coerced)) {
+            coerced = this.#arrayToMap(coerced);
+          }
+          if (!(coerced instanceof Map)) {
+            satisfied = false;
+          }
+          break;
+        }
+      }
+    }
+    if (schema.allOf) {
+      for (const subSchema of schema.allOf) {
+        const [subSatisfied, subCoerced] = this.#coerce(subSchema, coerced, options);
+        coerced = subCoerced;
+        if (!subSatisfied) {
+          satisfied = false;
+        }
+      }
+    }
+    for (const key of ["anyOf", "oneOf"]) {
+      if (schema[key]) {
+        let bestOptions;
+        for (const subSchema of schema[key]) {
+          const [subSatisfied, subCoerced] = this.#coerce(subSchema, coerced, options);
+          if (subSatisfied) {
+            if (!bestOptions || subCoerced === coerced) {
+              bestOptions = { coerced: subCoerced, satisfied: subSatisfied };
+            }
+            if (subCoerced === coerced) {
+              break;
+            }
+          }
+        }
+        coerced = bestOptions ? bestOptions.coerced : coerced;
+        satisfied = bestOptions ? bestOptions.satisfied : false;
+      }
+    }
+    if (typeof schema.not !== "undefined") {
+      const [notSatisfied] = this.#coerce(schema.not, coerced, options);
+      if (notSatisfied) {
+        satisfied = false;
+      }
+    }
+    return [satisfied, coerced];
+  }
+  #stringToNumber(value) {
+    const num = Number.parseFloat(value);
+    if (Number.isNaN(num) || num !== Number(value)) {
+      return value;
+    }
+    return num;
+  }
+  #stringToInteger(value) {
+    const num = Number.parseInt(value);
+    if (Number.isNaN(num) || num !== Number(value)) {
+      return value;
+    }
+    return num;
+  }
+  #stringToBoolean(value) {
+    const lower = value.toLowerCase();
+    if (lower === "false" || lower === "off") {
+      return false;
+    }
+    if (lower === "true" || lower === "on") {
+      return true;
+    }
+    return value;
+  }
+  #stringToBigInt(value) {
+    return guard(() => BigInt(value)) ?? value;
+  }
+  #numberToBigInt(value) {
+    return guard(() => BigInt(value)) ?? value;
+  }
+  #stringToDate(value) {
+    const date = new Date(value);
+    if (Number.isNaN(date.getTime()) || !FLEXIBLE_DATE_FORMAT_REGEX.test(value)) {
+      return value;
+    }
+    return date;
+  }
+  #stringToRegExp(value) {
+    const match = value.match(/^\/(.*)\/([a-z]*)$/);
+    if (match) {
+      const [, pattern, flags] = match;
+      return guard(() => new RegExp(pattern, flags)) ?? value;
+    }
+    return value;
+  }
+  #stringToURL(value) {
+    return guard(() => new URL(value)) ?? value;
+  }
+  #arrayToSet(value) {
+    const set = new Set(value);
+    if (set.size !== value.length) {
+      return value;
+    }
+    return set;
+  }
+  #arrayToMap(value) {
+    if (value.some((item) => !Array.isArray(item) || item.length !== 2)) {
+      return value;
+    }
+    const result = new Map(value);
+    if (result.size !== value.length) {
+      return value;
+    }
+    return result;
+  }
 }
-const os = createApiBuilder();
 
 function createAssertedLazyProcedure(lazied) {
   const lazyProcedure = lazyInternal(async () => {
@@ -381,4 +692,21 @@ function createRouterClient(router, ...rest) {
   return recursive;
 }
 
-export { Builder, BuilderWithMiddlewares, Contract, DecoratedProcedure, Procedure, ProcedureBuilder, addMiddleware, call, createApiBuilder, createAssertedLazyProcedure, createProcedureClient, createRouterClient, decorateMiddleware, enhanceRouter, getLazyMeta, getRouter, isLazy, isProcedure, lazyInternal, os, unlazy };
+function isSchemaIssue(issue) {
+  if (!isTypescriptObject(issue) || typeof issue.message !== "string") {
+    return false;
+  }
+  if (issue.path !== void 0) {
+    if (!Array.isArray(issue.path)) {
+      return false;
+    }
+    if (!issue.path.every(
+      (segment) => isPropertyKey(segment) || isTypescriptObject(segment) && isPropertyKey(segment.key)
+    )) {
+      return false;
+    }
+  }
+  return true;
+}
+
+export { Builder, BuilderWithMiddlewares, Contract, DecoratedProcedure, JsonSchemaXNativeType, Procedure, ProcedureBuilder, addMiddleware, baseApi, call, createAssertedLazyProcedure, createProcedureClient, createRouterClient, decorateMiddleware, enhanceRouter, experimental_JsonSchemaCoercer, getLazyMeta, getRouter, initialSchemas, isLazy, isProcedure, isSchemaIssue, lazyInternal, mergeMeta, parseEndpointDefinition, unlazy };

package/dist/openapi/index.d.mts

@@ -1,9 +1,12 @@
-import { OpenAPI, AnySchema } from '@temporary-name/contract';
-export { OpenAPI } from '@temporary-name/contract';
-import { Contract, TraverseContractProcedureCallbackOptions, ContractRouter, AnyRouter } from '@temporary-name/server';
-import { Promisable, Value, HTTPPath, HTTPMethod } from '@temporary-name/shared';
+import { Contract } from '@temporary-name/server';
+import { OpenAPI, Promisable, Value, HTTPPath, HTTPMethod } from '@temporary-name/shared';
+export { OpenAPI } from '@temporary-name/shared';
+import { Z as ZodToJsonSchemaConverterOptions } from '../shared/server.CjPiuQYH.mjs';
+import { d as AnySchema, b as Contract$1, a9 as TraverseContractProcedureCallbackOptions, $ as ContractRouter, u as AnyRouter } from '../shared/server.DXPMDozZ.mjs';
 import { JSONSchema } from '@temporary-name/interop/json-schema-typed/draft-2020-12';
 export { JSONSchema, ContentEncoding as JSONSchemaContentEncoding, Format as JSONSchemaFormat, TypeName as JSONSchemaTypeName } from '@temporary-name/interop/json-schema-typed/draft-2020-12';
+import '@temporary-name/server/openapi';
+import '@temporary-name/zod';
 
 type OverrideOperationValue = Partial<OpenAPI.OperationObject> | ((current: OpenAPI.OperationObject, procedure: Contract) => OpenAPI.OperationObject);
 /**
@@ -54,29 +57,18 @@ interface SchemaConvertOptions {
      */
     minStructureDepthForRef?: number;
 }
-interface SchemaConverter {
-    convert(schemas: AnySchema | undefined, options: SchemaConvertOptions): Promisable<[required: boolean, jsonSchema: JSONSchema]>;
-}
-interface ConditionalSchemaConverter extends SchemaConverter {
-    condition(schema: AnySchema | undefined, options: SchemaConvertOptions): Promisable<boolean>;
-}
-declare class CompositeSchemaConverter implements SchemaConverter {
-    private readonly converters;
-    constructor(converters: readonly ConditionalSchemaConverter[]);
-    convert(schema: AnySchema | undefined, options: SchemaConvertOptions): Promise<[required: boolean, jsonSchema: JSONSchema]>;
-}
+type SchemaConverter = (schemas: AnySchema | undefined, options: SchemaConvertOptions) => Promisable<[required: boolean, jsonSchema: JSONSchema]>;
 
-interface OpenAPIGeneratorOptions {
-    schemaConverters?: ConditionalSchemaConverter[];
-}
-interface OpenAPIGeneratorGenerateOptions extends Partial<Omit<OpenAPI.Document, 'openapi'>> {
+interface OpenAPIGeneratorGenerateOptions {
+    spec?: Partial<Omit<OpenAPI.Document, 'openapi'>>;
+    schemaConverter?: ZodToJsonSchemaConverterOptions | SchemaConverter;
     /**
      * Exclude procedures from the OpenAPI specification.
      *
      * @deprecated Use `filter` option instead.
      * @default () => false
      */
-    exclude?: (procedure: Contract, path: readonly string[]) => boolean;
+    exclude?: (procedure: Contract$1, path: readonly string[]) => boolean;
     /**
      * Filter procedures. Return `false` to exclude a procedure from the OpenAPI specification.
      *
@@ -116,21 +108,11 @@ interface OpenAPIGeneratorGenerateOptions extends Partial<Omit<OpenAPI.Document,
     }>;
 }
 /**
- * The generator that converts oRPC routers/contracts to OpenAPI specifications.
+ * Generates OpenAPI specifications from oRPC routers/contracts.
  *
  * @see {@link https://orpc.unnoq.com/docs/openapi/openapi-specification OpenAPI Specification Docs}
  */
-declare class OpenAPIGenerator {
-    #private;
-    private readonly converter;
-    constructor(options?: OpenAPIGeneratorOptions);
-    /**
-     * Generates OpenAPI specifications from oRPC routers/contracts.
-     *
-     * @see {@link https://orpc.unnoq.com/docs/openapi/openapi-specification OpenAPI Specification Docs}
-     */
-    generate(router: ContractRouter | AnyRouter, options?: OpenAPIGeneratorGenerateOptions): Promise<OpenAPI.Document>;
-}
+declare function generateOpenApiSpec(router: ContractRouter | AnyRouter, options?: OpenAPIGeneratorGenerateOptions): Promise<OpenAPI.Document>;
 
 /**
  * @internal
@@ -199,5 +181,5 @@ declare const oo: {
     spec: typeof customOpenAPIOperation;
 };
 
-export { CompositeSchemaConverter, LOGIC_KEYWORDS, OpenAPIGenerator, applyCustomOpenAPIOperation, applySchemaOptionality, checkParamsSchema, customOpenAPIOperation, expandArrayableSchema, expandUnionSchema, filterSchemaBranches, getCustomOpenAPIOperation, isAnySchema, isFileSchema, isObjectSchema, isPrimitiveSchema, oo, resolveOpenAPIJsonSchemaRef, separateObjectSchema, toOpenAPIContent, toOpenAPIEventIteratorContent, toOpenAPIMethod, toOpenAPIParameters, toOpenAPIPath, toOpenAPISchema };
-export type { ConditionalSchemaConverter, FileSchema, ObjectSchema, OpenAPIGeneratorGenerateOptions, OpenAPIGeneratorOptions, OverrideOperationValue, SchemaConvertOptions, SchemaConverter, SchemaConverterComponent };
+export { LOGIC_KEYWORDS, applyCustomOpenAPIOperation, applySchemaOptionality, checkParamsSchema, customOpenAPIOperation, expandArrayableSchema, expandUnionSchema, filterSchemaBranches, generateOpenApiSpec, getCustomOpenAPIOperation, isAnySchema, isFileSchema, isObjectSchema, isPrimitiveSchema, oo, resolveOpenAPIJsonSchemaRef, separateObjectSchema, toOpenAPIContent, toOpenAPIEventIteratorContent, toOpenAPIMethod, toOpenAPIParameters, toOpenAPIPath, toOpenAPISchema };
+export type { FileSchema, ObjectSchema, OpenAPIGeneratorGenerateOptions, OverrideOperationValue, SchemaConvertOptions, SchemaConverter, SchemaConverterComponent };