@orpc/openapi 0.0.0-next.e361acd → 0.0.0-next.e563486

package/dist/index.mjs

@@ -0,0 +1,303 @@
+import { isProcedure, resolveContractProcedures, toHttpPath } from '@orpc/server';
+import { fallbackORPCErrorStatus, fallbackORPCErrorMessage } from '@orpc/client';
+import { fallbackContractConfig, getEventIteratorSchemaDetails } from '@orpc/contract';
+import { StandardOpenAPIJsonSerializer } from '@orpc/openapi-client/standard';
+import { clone } from '@orpc/shared';
+import { t as toOpenAPIMethod, a as toOpenAPIPath, b as toOpenAPIEventIteratorContent, g as getDynamicParams, i as isAnySchema, c as isObjectSchema, d as separateObjectSchema, e as checkParamsSchema, f as toOpenAPIParameters, h as toOpenAPIContent, j as toOpenAPISchema } from './shared/openapi.DZzpQAb-.mjs';
+export { L as LOGIC_KEYWORDS, l as filterSchemaBranches, k as isFileSchema, s as standardizeHTTPPath } from './shared/openapi.DZzpQAb-.mjs';
+export { Format as JSONSchemaFormat } from 'json-schema-typed/draft-2020-12';
+
+const OPERATION_EXTENDER_SYMBOL = Symbol("ORPC_OPERATION_EXTENDER");
+function customOpenAPIOperation(o, extend) {
+  return new Proxy(o, {
+    get(target, prop, receiver) {
+      if (prop === OPERATION_EXTENDER_SYMBOL) {
+        return extend;
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+}
+function getCustomOpenAPIOperation(o) {
+  return o[OPERATION_EXTENDER_SYMBOL];
+}
+function applyCustomOpenAPIOperation(operation, contract) {
+  const operationCustoms = [];
+  for (const errorItem of Object.values(contract["~orpc"].errorMap)) {
+    const maybeExtender = errorItem ? getCustomOpenAPIOperation(errorItem) : void 0;
+    if (maybeExtender) {
+      operationCustoms.push(maybeExtender);
+    }
+  }
+  if (isProcedure(contract)) {
+    for (const middleware of contract["~orpc"].middlewares) {
+      const maybeExtender = getCustomOpenAPIOperation(middleware);
+      if (maybeExtender) {
+        operationCustoms.push(maybeExtender);
+      }
+    }
+  }
+  let currentOperation = operation;
+  for (const custom of operationCustoms) {
+    if (typeof custom === "function") {
+      currentOperation = custom(currentOperation, contract);
+    } else {
+      currentOperation = {
+        ...currentOperation,
+        ...custom
+      };
+    }
+  }
+  return currentOperation;
+}
+
+class CompositeSchemaConverter {
+  converters;
+  constructor(converters) {
+    this.converters = converters;
+  }
+  convert(schema, options) {
+    for (const converter of this.converters) {
+      if (converter.condition(schema, options)) {
+        return converter.convert(schema, options);
+      }
+    }
+    return [false, {}];
+  }
+}
+
+class OpenAPIGeneratorError extends Error {
+}
+class OpenAPIGenerator {
+  serializer;
+  converter;
+  constructor(options = {}) {
+    this.serializer = new StandardOpenAPIJsonSerializer(options);
+    this.converter = new CompositeSchemaConverter(options.schemaConverters ?? []);
+  }
+  async generate(router, base) {
+    const doc = clone(base);
+    doc.openapi = "3.1.1";
+    const errors = [];
+    await resolveContractProcedures({ path: [], router }, ({ contract, path }) => {
+      const operationId = path.join(".");
+      try {
+        const def = contract["~orpc"];
+        const method = toOpenAPIMethod(fallbackContractConfig("defaultMethod", def.route.method));
+        const httpPath = toOpenAPIPath(def.route.path ?? toHttpPath(path));
+        const operationObjectRef = {
+          operationId,
+          summary: def.route.summary,
+          description: def.route.description,
+          deprecated: def.route.deprecated,
+          tags: def.route.tags?.map((tag) => tag)
+        };
+        this.#request(operationObjectRef, def);
+        this.#successResponse(operationObjectRef, def);
+        this.#errorResponse(operationObjectRef, def);
+        doc.paths ??= {};
+        doc.paths[httpPath] ??= {};
+        doc.paths[httpPath][method] = applyCustomOpenAPIOperation(operationObjectRef, contract);
+      } catch (e) {
+        if (!(e instanceof OpenAPIGeneratorError)) {
+          throw e;
+        }
+        errors.push(
+          `[OpenAPIGenerator] Error occurred while generating OpenAPI for procedure at path: ${operationId}
+${e.message}`
+        );
+      }
+    });
+    if (errors.length) {
+      throw new OpenAPIGeneratorError(
+        `Some error occurred during OpenAPI generation:
+
+${errors.join("\n\n")}`
+      );
+    }
+    return this.serializer.serialize(doc)[0];
+  }
+  #request(ref, def) {
+    const method = fallbackContractConfig("defaultMethod", def.route.method);
+    const details = getEventIteratorSchemaDetails(def.inputSchema);
+    if (details) {
+      ref.requestBody = {
+        required: true,
+        content: toOpenAPIEventIteratorContent(
+          this.converter.convert(details.yields, { strategy: "input" }),
+          this.converter.convert(details.returns, { strategy: "input" })
+        )
+      };
+      return;
+    }
+    const dynamicParams = getDynamicParams(def.route.path);
+    const inputStructure = fallbackContractConfig("defaultInputStructure", def.route.inputStructure);
+    let [required, schema] = this.converter.convert(def.inputSchema, { strategy: "input" });
+    if (isAnySchema(schema) && !dynamicParams?.length) {
+      return;
+    }
+    if (inputStructure === "compact") {
+      if (dynamicParams?.length) {
+        const error2 = new OpenAPIGeneratorError(
+          'When input structure is "compact", and path has dynamic params, input schema must be an object with all dynamic params as required.'
+        );
+        if (!isObjectSchema(schema)) {
+          throw error2;
+        }
+        const [paramsSchema, rest] = separateObjectSchema(schema, dynamicParams);
+        schema = rest;
+        required = rest.required ? rest.required.length !== 0 : false;
+        if (!checkParamsSchema(paramsSchema, dynamicParams)) {
+          throw error2;
+        }
+        ref.parameters ??= [];
+        ref.parameters.push(...toOpenAPIParameters(paramsSchema, "path"));
+      }
+      if (method === "GET") {
+        if (!isObjectSchema(schema)) {
+          throw new OpenAPIGeneratorError(
+            'When method is "GET", input schema must satisfy: object | any | unknown'
+          );
+        }
+        ref.parameters ??= [];
+        ref.parameters.push(...toOpenAPIParameters(schema, "query"));
+      } else {
+        ref.requestBody = {
+          required,
+          content: toOpenAPIContent(schema)
+        };
+      }
+      return;
+    }
+    const error = new OpenAPIGeneratorError(
+      'When input structure is "detailed", input schema must satisfy: { params?: Record<string, unknown>, query?: Record<string, unknown>, headers?: Record<string, unknown>, body?: unknown }'
+    );
+    if (!isObjectSchema(schema)) {
+      throw error;
+    }
+    if (dynamicParams?.length && (schema.properties?.params === void 0 || !isObjectSchema(schema.properties.params) || !checkParamsSchema(schema.properties.params, dynamicParams))) {
+      throw new OpenAPIGeneratorError(
+        'When input structure is "detailed" and path has dynamic params, the "params" schema must be an object with all dynamic params as required.'
+      );
+    }
+    for (const from of ["params", "query", "headers"]) {
+      const fromSchema = schema.properties?.[from];
+      if (fromSchema !== void 0) {
+        if (!isObjectSchema(fromSchema)) {
+          throw error;
+        }
+        const parameterIn = from === "params" ? "path" : from === "headers" ? "header" : "query";
+        ref.parameters ??= [];
+        ref.parameters.push(...toOpenAPIParameters(fromSchema, parameterIn));
+      }
+    }
+    if (schema.properties?.body !== void 0) {
+      ref.requestBody = {
+        required: schema.required?.includes("body"),
+        content: toOpenAPIContent(schema.properties.body)
+      };
+    }
+  }
+  #successResponse(ref, def) {
+    const outputSchema = def.outputSchema;
+    const status = fallbackContractConfig("defaultSuccessStatus", def.route.successStatus);
+    const description = fallbackContractConfig("defaultSuccessDescription", def.route?.successDescription);
+    const eventIteratorSchemaDetails = getEventIteratorSchemaDetails(outputSchema);
+    const outputStructure = fallbackContractConfig("defaultOutputStructure", def.route.outputStructure);
+    if (eventIteratorSchemaDetails) {
+      ref.responses ??= {};
+      ref.responses[status] = {
+        description,
+        content: toOpenAPIEventIteratorContent(
+          this.converter.convert(eventIteratorSchemaDetails.yields, { strategy: "output" }),
+          this.converter.convert(eventIteratorSchemaDetails.returns, { strategy: "output" })
+        )
+      };
+      return;
+    }
+    const [_, json] = this.converter.convert(outputSchema, { strategy: "output" });
+    ref.responses ??= {};
+    ref.responses[status] = {
+      description
+    };
+    if (outputStructure === "compact") {
+      ref.responses[status].content = toOpenAPIContent(json);
+      return;
+    }
+    const error = new OpenAPIGeneratorError(
+      'When output structure is "detailed", output schema must satisfy: { headers?: Record<string, unknown>, body?: unknown }'
+    );
+    if (!isObjectSchema(json)) {
+      throw error;
+    }
+    if (json.properties?.headers !== void 0) {
+      if (!isObjectSchema(json.properties.headers)) {
+        throw error;
+      }
+      for (const key in json.properties.headers.properties) {
+        ref.responses[status].headers ??= {};
+        ref.responses[status].headers[key] = {
+          schema: toOpenAPISchema(json.properties.headers.properties[key]),
+          required: json.properties.headers.required?.includes(key)
+        };
+      }
+    }
+    if (json.properties?.body !== void 0) {
+      ref.responses[status].content = toOpenAPIContent(json.properties.body);
+    }
+  }
+  #errorResponse(ref, def) {
+    const errorMap = def.errorMap;
+    const errors = {};
+    for (const code in errorMap) {
+      const config = errorMap[code];
+      if (!config) {
+        continue;
+      }
+      const status = fallbackORPCErrorStatus(code, config.status);
+      const message = fallbackORPCErrorMessage(code, config.message);
+      const [dataRequired, dataSchema] = this.converter.convert(config.data, { strategy: "output" });
+      errors[status] ??= [];
+      errors[status].push({
+        type: "object",
+        properties: {
+          defined: { const: true },
+          code: { const: code },
+          status: { const: status },
+          message: { type: "string", default: message },
+          data: dataSchema
+        },
+        required: dataRequired ? ["defined", "code", "status", "message", "data"] : ["defined", "code", "status", "message"]
+      });
+    }
+    ref.responses ??= {};
+    for (const status in errors) {
+      const schemas = errors[status];
+      ref.responses[status] = {
+        description: status,
+        content: toOpenAPIContent({
+          oneOf: [
+            ...schemas,
+            {
+              type: "object",
+              properties: {
+                defined: { const: false },
+                code: { type: "string" },
+                status: { type: "number" },
+                message: { type: "string" },
+                data: {}
+              },
+              required: ["defined", "code", "status", "message"]
+            }
+          ]
+        })
+      };
+    }
+  }
+}
+
+const oo = {
+  spec: customOpenAPIOperation
+};
+
+export { CompositeSchemaConverter, OpenAPIGenerator, applyCustomOpenAPIOperation, checkParamsSchema, customOpenAPIOperation, getCustomOpenAPIOperation, getDynamicParams, isAnySchema, isObjectSchema, oo, separateObjectSchema, toOpenAPIContent, toOpenAPIEventIteratorContent, toOpenAPIMethod, toOpenAPIParameters, toOpenAPIPath, toOpenAPISchema };

package/dist/shared/openapi.BNHmrMe2.mjs

@@ -0,0 +1,145 @@
+import { fallbackContractConfig } from '@orpc/contract';
+import { isObject } from '@orpc/shared';
+import { traverseContractProcedures, toHttpPath, isProcedure, getLazyMeta, unlazy, getRouter, createContractedProcedure } from '@orpc/server';
+import { createRouter, addRoute, findRoute } from 'rou3';
+import { s as standardizeHTTPPath } from './openapi.DZzpQAb-.mjs';
+
+class StandardOpenAPICodec {
+  constructor(serializer) {
+    this.serializer = serializer;
+  }
+  async decode(request, params, procedure) {
+    const inputStructure = fallbackContractConfig("defaultInputStructure", procedure["~orpc"].route.inputStructure);
+    if (inputStructure === "compact") {
+      const data = request.method === "GET" ? this.serializer.deserialize(request.url.searchParams) : this.serializer.deserialize(await request.body());
+      if (data === void 0) {
+        return params;
+      }
+      if (isObject(data)) {
+        return {
+          ...params,
+          ...data
+        };
+      }
+      return data;
+    }
+    const deserializeSearchParams = () => {
+      return this.serializer.deserialize(request.url.searchParams);
+    };
+    return {
+      params,
+      get query() {
+        const value = deserializeSearchParams();
+        Object.defineProperty(this, "query", { value, writable: true });
+        return value;
+      },
+      set query(value) {
+        Object.defineProperty(this, "query", { value, writable: true });
+      },
+      headers: request.headers,
+      body: this.serializer.deserialize(await request.body())
+    };
+  }
+  encode(output, procedure) {
+    const successStatus = fallbackContractConfig("defaultSuccessStatus", procedure["~orpc"].route.successStatus);
+    const outputStructure = fallbackContractConfig("defaultOutputStructure", procedure["~orpc"].route.outputStructure);
+    if (outputStructure === "compact") {
+      return {
+        status: successStatus,
+        headers: {},
+        body: this.serializer.serialize(output)
+      };
+    }
+    if (!isObject(output)) {
+      throw new Error(
+        'Invalid output structure for "detailed" output. Expected format: { body: any, headers?: Record<string, string | string[] | undefined> }'
+      );
+    }
+    return {
+      status: successStatus,
+      headers: output.headers ?? {},
+      body: this.serializer.serialize(output.body)
+    };
+  }
+  encodeError(error) {
+    return {
+      status: error.status,
+      headers: {},
+      body: this.serializer.serialize(error.toJSON())
+    };
+  }
+}
+
+function toRou3Pattern(path) {
+  return standardizeHTTPPath(path).replace(/\/\{\+([^}]+)\}/g, "/**:$1").replace(/\/\{([^}]+)\}/g, "/:$1");
+}
+function decodeParams(params) {
+  return Object.fromEntries(Object.entries(params).map(([key, value]) => [key, decodeURIComponent(value)]));
+}
+
+class StandardOpenAPIMatcher {
+  tree = createRouter();
+  pendingRouters = [];
+  init(router, path = []) {
+    const laziedOptions = traverseContractProcedures({ router, path }, ({ path: path2, contract }) => {
+      const method = fallbackContractConfig("defaultMethod", contract["~orpc"].route.method);
+      const httpPath = toRou3Pattern(contract["~orpc"].route.path ?? toHttpPath(path2));
+      if (isProcedure(contract)) {
+        addRoute(this.tree, method, httpPath, {
+          path: path2,
+          contract,
+          procedure: contract,
+          // this mean dev not used contract-first so we can used contract as procedure directly
+          router
+        });
+      } else {
+        addRoute(this.tree, method, httpPath, {
+          path: path2,
+          contract,
+          procedure: void 0,
+          router
+        });
+      }
+    });
+    this.pendingRouters.push(...laziedOptions.map((option) => ({
+      ...option,
+      httpPathPrefix: toHttpPath(option.path),
+      laziedPrefix: getLazyMeta(option.router).prefix
+    })));
+  }
+  async match(method, pathname) {
+    if (this.pendingRouters.length) {
+      const newPendingRouters = [];
+      for (const pendingRouter of this.pendingRouters) {
+        if (!pendingRouter.laziedPrefix || pathname.startsWith(pendingRouter.laziedPrefix) || pathname.startsWith(pendingRouter.httpPathPrefix)) {
+          const { default: router } = await unlazy(pendingRouter.router);
+          this.init(router, pendingRouter.path);
+        } else {
+          newPendingRouters.push(pendingRouter);
+        }
+      }
+      this.pendingRouters = newPendingRouters;
+    }
+    const match = findRoute(this.tree, method, pathname);
+    if (!match) {
+      return void 0;
+    }
+    if (!match.data.procedure) {
+      const { default: maybeProcedure } = await unlazy(getRouter(match.data.router, match.data.path));
+      if (!isProcedure(maybeProcedure)) {
+        throw new Error(`
+          [Contract-First] Missing or invalid implementation for procedure at path: ${toHttpPath(match.data.path)}.
+          Ensure that the procedure is correctly defined and matches the expected contract.
+        `);
+      }
+      match.data.procedure = createContractedProcedure(maybeProcedure, match.data.contract);
+    }
+    return {
+      path: match.data.path,
+      procedure: match.data.procedure,
+      params: match.params ? decodeParams(match.params) : void 0
+    };
+  }
+}
+
+export { StandardOpenAPICodec as S, StandardOpenAPIMatcher as a, decodeParams as d, toRou3Pattern as t };

package/dist/shared/openapi.DZzpQAb-.mjs

@@ -0,0 +1,231 @@
+import { isObject, findDeepMatches } from '@orpc/shared';
+import 'json-schema-typed/draft-2020-12';
+
+const LOGIC_KEYWORDS = [
+  "$dynamicRef",
+  "$ref",
+  "additionalItems",
+  "additionalProperties",
+  "allOf",
+  "anyOf",
+  "const",
+  "contains",
+  "contentEncoding",
+  "contentMediaType",
+  "contentSchema",
+  "dependencies",
+  "dependentRequired",
+  "dependentSchemas",
+  "else",
+  "enum",
+  "exclusiveMaximum",
+  "exclusiveMinimum",
+  "format",
+  "if",
+  "items",
+  "maxContains",
+  "maximum",
+  "maxItems",
+  "maxLength",
+  "maxProperties",
+  "minContains",
+  "minimum",
+  "minItems",
+  "minLength",
+  "minProperties",
+  "multipleOf",
+  "not",
+  "oneOf",
+  "pattern",
+  "patternProperties",
+  "prefixItems",
+  "properties",
+  "propertyNames",
+  "required",
+  "then",
+  "type",
+  "unevaluatedItems",
+  "unevaluatedProperties",
+  "uniqueItems"
+];
+
+function isFileSchema(schema) {
+  return isObject(schema) && schema.type === "string" && typeof schema.contentMediaType === "string";
+}
+function isObjectSchema(schema) {
+  return isObject(schema) && schema.type === "object";
+}
+function isAnySchema(schema) {
+  if (schema === true) {
+    return true;
+  }
+  if (Object.keys(schema).every((k) => !LOGIC_KEYWORDS.includes(k))) {
+    return true;
+  }
+  return false;
+}
+function separateObjectSchema(schema, separatedProperties) {
+  if (Object.keys(schema).some((k) => k !== "type" && k !== "properties" && k !== "required" && LOGIC_KEYWORDS.includes(k))) {
+    return [{ type: "object" }, schema];
+  }
+  const matched = { ...schema };
+  const rest = { ...schema };
+  matched.properties = schema.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 (!isObject(example)) {
+      return example;
+    }
+    return Object.entries(example).reduce((acc, [key, value]) => {
+      if (separatedProperties.includes(key)) {
+        acc[key] = value;
+      }
+      return acc;
+    }, {});
+  });
+  rest.properties = schema.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 (!isObject(example)) {
+      return example;
+    }
+    return Object.entries(example).reduce((acc, [key, value]) => {
+      if (!separatedProperties.includes(key)) {
+        acc[key] = value;
+      }
+      return acc;
+    }, {});
+  });
+  return [matched, rest];
+}
+function filterSchemaBranches(schema, check, matches = []) {
+  if (check(schema)) {
+    matches.push(schema);
+    return [matches, void 0];
+  }
+  if (isObject(schema)) {
+    for (const keyword of ["anyOf", "oneOf"]) {
+      if (schema[keyword] && Object.keys(schema).every(
+        (k) => k === keyword || !LOGIC_KEYWORDS.includes(k)
+      )) {
+        const rest = schema[keyword].map((s) => filterSchemaBranches(s, check, matches)[1]).filter((v) => !!v);
+        if (rest.length === 1 && typeof rest[0] === "object") {
+          return [matches, { ...schema, [keyword]: void 0, ...rest[0] }];
+        }
+        return [matches, { ...schema, [keyword]: rest }];
+      }
+    }
+  }
+  return [matches, schema];
+}
+
+function standardizeHTTPPath(path) {
+  return `/${path.replace(/\/{2,}/g, "/").replace(/^\/|\/$/g, "")}`;
+}
+function toOpenAPIPath(path) {
+  return standardizeHTTPPath(path).replace(/\/\{\+([^}]+)\}/g, "/{$1}");
+}
+function toOpenAPIMethod(method) {
+  return method.toLocaleLowerCase();
+}
+function getDynamicParams(path) {
+  return path ? standardizeHTTPPath(path).match(/\/\{([^}]+)\}/g)?.map((v) => v.match(/\{\+?([^}]+)\}/)[1]) : void 0;
+}
+function toOpenAPIContent(schema) {
+  const content = {};
+  const [matches, restSchema] = filterSchemaBranches(schema, isFileSchema);
+  for (const file of matches) {
+    content[file.contentMediaType] = {
+      schema: toOpenAPISchema(file)
+    };
+  }
+  if (restSchema !== void 0) {
+    content["application/json"] = {
+      schema: toOpenAPISchema(restSchema)
+    };
+    const isStillHasFileSchema = findDeepMatches((v) => isObject(v) && isFileSchema(v), restSchema).values.length > 0;
+    if (isStillHasFileSchema) {
+      content["multipart/form-data"] = {
+        schema: toOpenAPISchema(restSchema)
+      };
+    }
+  }
+  return content;
+}
+function toOpenAPIEventIteratorContent([yieldsRequired, yieldsSchema], [returnsRequired, returnsSchema]) {
+  return {
+    "text/event-stream": {
+      schema: toOpenAPISchema({
+        oneOf: [
+          {
+            type: "object",
+            properties: {
+              event: { const: "message" },
+              data: yieldsSchema,
+              id: { type: "string" },
+              retry: { type: "number" }
+            },
+            required: yieldsRequired ? ["event", "data"] : ["event"]
+          },
+          {
+            type: "object",
+            properties: {
+              event: { const: "done" },
+              data: returnsSchema,
+              id: { type: "string" },
+              retry: { type: "number" }
+            },
+            required: returnsRequired ? ["event", "data"] : ["event"]
+          },
+          {
+            type: "object",
+            properties: {
+              event: { const: "error" },
+              data: {},
+              id: { type: "string" },
+              retry: { type: "number" }
+            },
+            required: ["event"]
+          }
+        ]
+      })
+    }
+  };
+}
+function toOpenAPIParameters(schema, parameterIn) {
+  const parameters = [];
+  for (const key in schema.properties) {
+    const keySchema = schema.properties[key];
+    parameters.push({
+      name: key,
+      in: parameterIn,
+      required: schema.required?.includes(key),
+      style: parameterIn === "query" ? "deepObject" : void 0,
+      explode: parameterIn === "query" ? true : void 0,
+      schema: toOpenAPISchema(keySchema)
+    });
+  }
+  return parameters;
+}
+function checkParamsSchema(schema, params) {
+  const properties = Object.keys(schema.properties ?? {});
+  const required = schema.required ?? [];
+  if (properties.length !== params.length || properties.some((v) => !params.includes(v))) {
+    return false;
+  }
+  if (required.length !== params.length || required.some((v) => !params.includes(v))) {
+    return false;
+  }
+  return true;
+}
+function toOpenAPISchema(schema) {
+  return schema === true ? {} : schema === false ? { not: {} } : schema;
+}
+
+export { LOGIC_KEYWORDS as L, toOpenAPIPath as a, toOpenAPIEventIteratorContent as b, isObjectSchema as c, separateObjectSchema as d, checkParamsSchema as e, toOpenAPIParameters as f, getDynamicParams as g, toOpenAPIContent as h, isAnySchema as i, toOpenAPISchema as j, isFileSchema as k, filterSchemaBranches as l, standardizeHTTPPath as s, toOpenAPIMethod as t };