@sdk-it/spec 0.22.0 → 0.23.0

package/dist/index.js

@@ -1,2630 +1,20 @@
-// packages/spec/src/lib/find-polymorphic-varients.ts
-import { groupBy, uniqBy } from "lodash-es";
-import { camelcase, isEmpty as isEmpty2, isRef as isRef2, resolveRef as resolveRef2 } from "@sdk-it/core";
-
-// packages/spec/src/lib/tune.ts
-import { merge, uniq } from "lodash-es";
-import assert from "node:assert";
-import {
-  isEmpty,
-  isRef,
-  joinSkipDigits as joinSkipDigits2,
-  notRef,
-  pascalcase as pascalcase2,
-  resolveRef,
-  snakecase
-} from "@sdk-it/core";
-
-// packages/spec/src/lib/find-unique-schema-name.ts
-import { joinSkipDigits, pascalcase } from "@sdk-it/core";
-var reservedNames = /* @__PURE__ */ new Set(["Function", "Error"]);
-function findUniqueSchemaName(spec, initialName, potentialSuffixList, fallback) {
-  spec.components ??= {};
-  spec.components.schemas ??= {};
-  let name = pascalcase(initialName);
-  while (spec.components.schemas[name] || reservedNames.has(name)) {
-    const suffix = potentialSuffixList.shift();
-    name = pascalcase(joinSkipDigits([name, suffix || ""], " "));
-  }
-  return initialName === name ? fallback ?? name : name;
-}
-
-// packages/spec/src/lib/format-name.ts
-var reservedWords = /* @__PURE__ */ new Set([
-  "abstract",
-  "as",
-  "assert",
-  "async",
-  "await",
-  "break",
-  "case",
-  "catch",
-  "class",
-  "const",
-  "continue",
-  "default",
-  "deferred",
-  "do",
-  "dynamic",
-  "else",
-  "enum",
-  "export",
-  "extends",
-  "extension",
-  "external",
-  "factory",
-  "final",
-  "finally",
-  "for",
-  "Function",
-  "get",
-  "set",
-  "hide",
-  "if",
-  "default",
-  "new",
-  "implements",
-  "import",
-  "in",
-  "interface",
-  "is",
-  "library",
-  "mixin",
-  "new",
-  "null",
-  "on",
-  "operator",
-  "part",
-  "required",
-  "rethrow",
-  "return",
-  "hide",
-  "show"
-]);
-var STARTS_WITH_DIGITS_PATTERN = /^-?\d/;
-var FIRST_DASH = /^_/;
-var LAST_DASH = /_$/;
-var ONLY_ENGLISH = /(^\$)|(\+)|(-)|[^A-Za-z0-9]+/g;
-var formatName = (it) => {
-  if (reservedWords.has(it)) {
-    return `$${it}`;
-  }
-  if (typeof it === "number") {
-    if (Math.sign(it) === -1) {
-      return `$_${Math.abs(it)}`;
-    }
-    return `$${it}`;
-  }
-  if (typeof it === "string") {
-    if (STARTS_WITH_DIGITS_PATTERN.test(it)) {
-      if (Math.sign(parseInt(it, 10)) === -1) {
-        return `$_${Math.abs(parseInt(it, 10))}`;
-      }
-      return `$${it}`;
-    }
-    return it.replace(ONLY_ENGLISH, (match) => {
-      if (match === "-" && match === it[0])
-        return "desc_";
-      if (match === "+")
-        return "_plus_";
-      if (match === "$" && match === it[0])
-        return "$";
-      return "_";
-    }).replace(FIRST_DASH, "").replace(LAST_DASH, "");
-  }
-  return String(it);
-};
-
-// packages/spec/src/lib/tune.ts
-function fixSpec(spec, schemas, visited = /* @__PURE__ */ new Set()) {
-  for (const schema of schemas) {
-    if (isRef(schema))
-      continue;
-    if (!isEmpty(schema.properties)) {
-      schema.type = "object";
-      delete schema.oneOf;
-      delete schema.anyOf;
-      fixSpec(spec, Object.values(schema.properties), visited);
-    }
-    if (!isEmpty(schema["x-properties"])) {
-      fixSpec(spec, Object.values(schema["x-properties"]), visited);
-    }
-    if (!isEmpty(schema.items)) {
-      delete schema.oneOf;
-      delete schema.anyOf;
-      schema.type = "array";
-      fixSpec(spec, [schema.items], visited);
-      const items = resolveRef(spec, schema.items);
-      if (Array.isArray(items.default)) {
-        schema.default ??= structuredClone(items.default);
-      }
-      delete items.default;
-    }
-    if (!isEmpty(schema.anyOf) && !isEmpty(schema.oneOf)) {
-      delete schema.anyOf;
-    }
-    if (isEmpty(schema.enum)) {
-      delete schema.enum;
-    }
-    if (!isEmpty(schema.enum)) {
-      if (schema.enum.length === 1) {
-        schema.const = schema.enum[0];
-        delete schema.enum;
-      } else {
-        const valuesSet = /* @__PURE__ */ new Set();
-        const valuesList = [];
-        for (const it of schema.enum) {
-          const formattedValue = formatName(snakecase(formatName(it)));
-          if (!valuesSet.has(formattedValue)) {
-            valuesSet.add(formattedValue);
-            valuesList.push(it);
-          }
-        }
-        schema.enum = valuesList;
-      }
-      delete schema.allOf;
-    }
-    if (schema.const !== void 0) {
-      schema.default = schema.const;
-    }
-    if (!isEmpty(schema.allOf)) {
-      const schemas2 = schema.allOf;
-      const resolved = schemas2.map((it) => resolveRef(spec, it));
-      const hasObjects = resolved.some((it) => it.type === "object");
-      const hasOtherTypes = resolved.some(
-        (it) => it.type && it.type !== "object"
-      );
-      if (hasObjects && hasOtherTypes) {
-        assert(false, `allOf must be an object`);
-      }
-      merge(
-        schema,
-        ...resolved.map((it) => {
-          fixSpec(spec, [it], visited);
-          return it;
-        })
-      );
-      delete schema.allOf;
-    } else {
-      delete schema.allOf;
-    }
-    if (schema.type === "object" && isEmpty(schema.properties) && typeof schema.additionalProperties === "object" && !isEmpty(schema.additionalProperties) && notRef(schema.additionalProperties) && !isEmpty(schema.additionalProperties.properties)) {
-      fixSpec(
-        spec,
-        Object.values(schema.additionalProperties.properties),
-        visited
-      );
-      Object.assign(schema, schema.additionalProperties);
-      delete schema.additionalProperties;
-    }
-    for (const kind of ["oneOf", "anyOf"]) {
-      if (!isEmpty(schema[kind])) {
-        delete schema.type;
-        fixSpec(spec, schema[kind], visited);
-        if (isEmpty(schema[kind])) {
-          continue;
-        }
-        let enumSchemaIndex = -1;
-        const enumValues = [];
-        for (let idx = 0; idx < schema[kind].length; idx++) {
-          const item = schema[kind][idx];
-          if (notRef(item) && item.type === "string") {
-            if (item.enum && item.enum.length > 1) {
-              enumValues.push(...item.enum);
-              if (enumSchemaIndex === -1) {
-                enumSchemaIndex = idx;
-              }
-            }
-          }
-        }
-        if (enumSchemaIndex !== -1) {
-          const enumSchema = schema[kind][enumSchemaIndex];
-          if (notRef(enumSchema)) {
-            enumSchema.enum = uniq(enumValues);
-          }
-          schema[kind] = schema[kind].filter(
-            (it, idx) => idx === enumSchemaIndex || isRef(it)
-          );
-        }
-        const otherTypes = schema[kind].filter(
-          (it) => resolveRef(spec, it).type !== "null"
-        );
-        if (otherTypes.length === 1) {
-          Object.assign(schema, otherTypes[0]);
-          delete schema[kind];
-          continue;
-        }
-        schema["x-varients"] = findVarients(spec, schema[kind]);
-      } else {
-        delete schema[kind];
-      }
-    }
-  }
-}
-function expandSpec(spec, schemas, refs) {
-  for (const [name, schema] of Object.entries(schemas)) {
-    if (isRef(schema))
-      continue;
-    if (!isEmpty(schema.properties)) {
-      if (!isEmpty(schema.oneOf)) {
-        for (const oneOfIdx in schema.oneOf) {
-          const oneOf = schema.oneOf[oneOfIdx];
-          if (isRef(oneOf))
-            continue;
-          for (const key of ["properties", "x-properties"]) {
-            if (!isEmpty(oneOf.required) && schema[key]) {
-              schema.oneOf[oneOfIdx] = schema[key][oneOf.required[0]];
-            }
-          }
-        }
-        delete schema.type;
-        expandSpec(spec, schemas, refs);
-        continue;
-      }
-      if (schema.additionalProperties) {
-        continue;
-      }
-      spec.components.schemas[name] = schema;
-      const properties = schema.properties;
-      for (const [propName, value] of Object.entries(properties)) {
-        if (isRef(value))
-          continue;
-        const fixedPropName = propName.replace("[]", "");
-        const refName = pascalcase2(joinSkipDigits2([name, fixedPropName], " "));
-        if (!isEmpty(value.properties)) {
-          spec.components.schemas[refName] = value;
-          properties[propName] = { $ref: `#/components/schemas/${refName}` };
-          expandSpec(spec, { [refName]: value }, refs);
-        } else if (!isEmpty(value.oneOf)) {
-          expandOneOf(spec, name, value, refs, "oneOf");
-          spec.components.schemas[refName] = value;
-          properties[propName] = { $ref: `#/components/schemas/${refName}` };
-          expandSpec(spec, { [refName]: value }, refs);
-        } else if (!isEmpty(value.anyOf)) {
-          expandOneOf(spec, name, value, refs, "anyOf");
-          spec.components.schemas[refName] = value;
-          properties[propName] = { $ref: `#/components/schemas/${refName}` };
-          expandSpec(spec, { [refName]: value }, refs);
-        } else {
-          expandSpec(spec, { [refName]: value }, refs);
-        }
-      }
-      continue;
-    }
-    if (!isEmpty(schema["x-properties"])) {
-      spec.components.schemas[name] = schema;
-      const properties = schema["x-properties"];
-      for (const [propName, value] of Object.entries(properties)) {
-        if (isRef(value))
-          continue;
-        const fixedPropName = propName.replace("[]", "");
-        const refName = pascalcase2(joinSkipDigits2([name, fixedPropName], " "));
-        if (!isEmpty(value.properties)) {
-          spec.components.schemas[refName] = value;
-          properties[propName] = { $ref: `#/components/schemas/${refName}` };
-          expandSpec(spec, { [refName]: value }, refs);
-        } else if (!isEmpty(value.oneOf)) {
-          expandOneOf(spec, name, value, refs, "oneOf");
-          spec.components.schemas[refName] = value;
-          properties[propName] = { $ref: `#/components/schemas/${refName}` };
-          expandSpec(spec, { [refName]: value }, refs);
-        } else if (!isEmpty(value.anyOf)) {
-          expandOneOf(spec, name, value, refs, "anyOf");
-          spec.components.schemas[refName] = value;
-          properties[propName] = { $ref: `#/components/schemas/${refName}` };
-          expandSpec(spec, { [refName]: value }, refs);
-        } else {
-          expandSpec(spec, { [refName]: value }, refs);
-        }
-      }
-      continue;
-    }
-    if (schema.type === "array") {
-      if (isRef(schema.items))
-        continue;
-      if (isEmpty(schema.items))
-        continue;
-      const refName = findUniqueSchemaName(spec, name, ["Item", "Entry"]);
-      if (schema.items.type === "object") {
-        spec.components.schemas[refName] = schema.items;
-        expandSpec(spec, { [refName]: schema.items }, refs);
-        schema.items = { $ref: `#/components/schemas/${refName}` };
-        continue;
-      }
-      if (schema.items.type === "array") {
-        expandSpec(spec, { [refName]: schema.items }, refs);
-        continue;
-      }
-      if (!isEmpty(schema.items.oneOf)) {
-        expandOneOf(spec, refName, schema.items, refs, "oneOf");
-        continue;
-      }
-      if (!isEmpty(schema.items.anyOf)) {
-        expandOneOf(spec, refName, schema.items, refs, "anyOf");
-        continue;
-      }
-    }
-    if (!isEmpty(schema.oneOf)) {
-      expandOneOf(spec, name, schema, refs, "oneOf");
-      continue;
-    }
-    if (!isEmpty(schema.anyOf)) {
-      expandOneOf(spec, name, schema, refs, "anyOf");
-      continue;
-    }
-  }
-}
-function expandOneOf(spec, name, schema, refs, kind) {
-  const varients = schema["x-varients"];
-  if (!varients || varients.length === 0) {
-    console.warn(
-      `No varients found for ${name}. This might be an error in the OpenAPI spec.`
-    );
-  }
-  varients.forEach((varient) => {
-    const varientSchema = schema[kind][varient.position];
-    if (isRef(varientSchema))
-      return;
-    const refName = findUniqueSchemaName(
-      spec,
-      pascalcase2(`${name} ${varient.name}`),
-      ["Varient"]
-    );
-    if (varientSchema.type === "object") {
-      expandSpec(spec, { [refName]: varientSchema }, refs);
-      schema[kind][varient.position] = {
-        $ref: `#/components/schemas/${refName}`
-      };
-    } else {
-      expandSpec(spec, { [refName]: varientSchema }, refs);
-    }
-  });
-}
-function coerceTypes(schema, excludeNull = true) {
-  const types = Array.isArray(schema.type) ? schema.type : schema.type ? [schema.type] : [];
-  if (excludeNull) {
-    return types.filter((type) => type !== "null");
-  }
-  return types;
-}
-
-// packages/spec/src/lib/find-polymorphic-varients.ts
-var groupSchemasByType = (spec, schemas) => {
-  const groups = schemas.reduce((acc, schema, index) => {
-    if (isRef2(schema)) {
-      const referenced = resolveRef2(spec, schema);
-      const [type2] = coerceTypes(referenced, false);
-      acc[type2] ??= [];
-      acc[type2].push({ schema: referenced, position: index });
-      return acc;
-    }
-    if (isRef2(schema.items)) {
-      const referenced = resolveRef2(spec, schema.items);
-      acc.array ??= [];
-      acc.array.push({
-        schema: { ...schema, items: referenced },
-        position: index
-      });
-      return acc;
-    }
-    if (schema.oneOf) {
-      acc["oneOf"] ??= [];
-      acc["oneOf"].push({ schema: schema.oneOf, position: index });
-      return acc;
-    }
-    if (schema.anyOf) {
-      acc["oneOf"] ??= [];
-      acc["oneOf"].push({ schema: schema.anyOf, position: index });
-      return acc;
-    }
-    if (schema.const) {
-      switch (typeof schema.const) {
-        case "string":
-          acc.string ??= [];
-          acc.string.push({ schema, position: index });
-          return acc;
-        case "number":
-          acc.number ??= [];
-          acc.number.push({ schema, position: index });
-          return acc;
-        case "boolean":
-          acc.boolean ??= [];
-          acc.boolean.push({ schema, position: index });
-          return acc;
-        default:
-          throw new Error(
-            `Unsupported const type: ${typeof schema.const} for ${schema.const}`
-          );
-      }
-    }
-    const [type] = coerceTypes(schema, false);
-    acc[type] ??= [];
-    acc[type].push({ schema, position: index });
-    return acc;
-  }, {});
-  return groups;
-};
-function findVarients(spec, schemas) {
-  let varients = [];
-  const schemasByType = groupSchemasByType(spec, schemas);
-  if (!isEmpty2(schemasByType.string)) {
-    for (const { schema, position } of schemasByType.string) {
-      if (schema.const !== void 0) {
-        varients.push({
-          name: schema.const || "empty",
-          type: "string",
-          position,
-          priority: 100 - varients.length
-        });
-        continue;
-      }
-      if (schema.format) {
-        varients.push({
-          name: camelcase(schema.format),
-          type: "string",
-          position,
-          priority: 90 - varients.length
-        });
-        continue;
-      }
-      varients.push({ name: "textContent", type: "string", position });
-    }
-    varients = uniqBy(varients, (it) => it.name);
-  }
-  if (!isEmpty2(schemasByType.number) || !isEmpty2(schemasByType.integer)) {
-    const schemas2 = [
-      ...schemasByType.number ?? [],
-      ...schemasByType.integer ?? []
-    ];
-    for (const { schema, position } of schemas2) {
-      if (schema.format === "int64") {
-        varients.push({
-          name: "integer",
-          type: "number",
-          position,
-          priority: 90 - varients.length
-        });
-        continue;
-      }
-      if (schema.format === "float") {
-        varients.push({
-          name: "float",
-          type: "number",
-          position,
-          priority: 90 - varients.length
-        });
-        continue;
-      }
-      if (schema.format === "double") {
-        varients.push({
-          name: "double",
-          type: "number",
-          position,
-          priority: 90 - varients.length
-        });
-        continue;
-      }
-      varients.push({ name: "number", type: "number", position });
-    }
-  }
-  if (!isEmpty2(schemasByType.array)) {
-    for (const { schema, position } of schemasByType.array) {
-      const items = schema.items;
-      if (!items) {
-        varients.push({ name: "any", type: "array", position });
-        continue;
-      }
-      const [type] = coerceTypes(items);
-      if (type === "string") {
-        varients.push({
-          name: "textList",
-          type: "array",
-          subtype: "string",
-          position
-        });
-        continue;
-      }
-      if (type === "number") {
-        varients.push({
-          name: "numList",
-          type: "array",
-          subtype: "number",
-          position
-        });
-        continue;
-      }
-      if (type === "integer") {
-        varients.push({
-          name: "intList",
-          type: "array",
-          subtype: "integer",
-          position
-        });
-        continue;
-      }
-      if (type === "object") {
-        const subvarients = findVarients(spec, [items]);
-        for (const subvarient of subvarients) {
-          varients.push({
-            ...subvarient,
-            type: "array",
-            position
-          });
-        }
-        continue;
-      }
-      if (type === "array") {
-        const subvarients = findVarients(spec, [items]);
-        for (const subvarient of subvarients) {
-          varients.push({
-            ...subvarient,
-            name: `${subvarient.name}Matrix`,
-            type: "array",
-            position
-          });
-        }
-        continue;
-      }
-      varients.push({ name: "list", type: "array", position });
-    }
-  }
-  if (!isEmpty2(schemasByType.$ref)) {
-    const subvarients = findVarients(
-      spec,
-      schemasByType.$ref.map((it) => resolveRef2(spec, it.schema))
-    );
-    varients.push(
-      ...subvarients.map((it) => ({
-        ...it
-      }))
-    );
-  }
-  if (!isEmpty2(schemasByType.oneOf)) {
-    for (const { schema, position } of schemasByType.oneOf) {
-      const subvarients = findVarients(spec, schema);
-      varients.push(
-        ...subvarients.map((it) => ({
-          ...it,
-          position
-        }))
-      );
-    }
-  }
-  const matrix = [];
-  for (const { schema, position } of schemasByType.object ?? []) {
-    if (schema.additionalProperties || isEmpty2({ ...schema.properties, ...schema["x-properties"] })) {
-      continue;
-    }
-    for (const key of ["properties", "x-properties"]) {
-      if (!schema[key])
-        continue;
-      const list = Object.entries(schema[key]).map(([name, schemaOrRef]) => {
-        const schema2 = resolveRef2(spec, schemaOrRef);
-        name = schema2.const ?? schema2.enum?.[0] ?? name;
-        if (schema2.type === "string") {
-          return {
-            priority: schema2.const !== void 0 || schema2.enum?.[0] !== void 0 ? 100 - matrix.length : void 0,
-            static: true,
-            subtype: "string",
-            source: name,
-            name,
-            type: "object",
-            position
-          };
-        }
-        return {
-          subtype: "string",
-          source: name,
-          name,
-          type: "object",
-          position
-        };
-      });
-      matrix.push([...new Set(list)].sort((a) => a.static ? -1 : 1));
-    }
-    if (matrix.length === 0) {
-      throw new Error(
-        "No valid objects found. Please check your OpenAPI spec."
-      );
-    }
-    let discriminatorProp;
-    const firstRow = matrix[0];
-    for (const prop of firstRow) {
-      const existsCrossAllRows = matrix.every((row) => row.includes(prop));
-      if (existsCrossAllRows) {
-        discriminatorProp = prop;
-        break;
-      }
-    }
-  }
-  for (const row of matrix) {
-    for (const prop of row) {
-      const isUnique = matrix.every(
-        (it) => it === row ? true : !it.some((p) => p.name === prop.name)
-      );
-      if (isUnique) {
-        varients.push(prop);
-        break;
-      }
-    }
-  }
-  return varients.sort((a, b) => {
-    const aHasPriority = a.priority !== void 0;
-    const bHasPriority = b.priority !== void 0;
-    if (aHasPriority && bHasPriority) {
-      if (a.priority !== b.priority) {
-        return b.priority - a.priority;
-      }
-      return a.position - b.position;
-    } else if (aHasPriority) {
-      return -1;
-    } else if (bHasPriority) {
-      return 1;
-    } else {
-      return 0;
-    }
-  });
-}
-function findPolymorphicVarients(spec, schemas) {
-  const varients = findVarients(spec, schemas);
-  return Object.values(groupBy(varients, (it) => "-" + it.position)).map(
-    (group) => {
-      return (group ?? [])[0];
-    }
-  );
-}
-
-// packages/spec/src/lib/get-ref-usage.ts
-import { isEmpty as isEmpty5, isRef as isRef5, parseRef as parseRef2, pascalcase as pascalcase4 } from "@sdk-it/core";
-
-// packages/spec/src/lib/operation.ts
-import { camelcase as camelcase2 } from "stringcase";
-import { methods as methods2 } from "@sdk-it/core/paths.js";
-import { followRef, isRef as isRef4, parseRef, resolveRef as resolveRef4 } from "@sdk-it/core/ref.js";
-import { isEmpty as isEmpty4, pascalcase as pascalcase3, snakecase as snakecase2 } from "@sdk-it/core/utils.js";
-
-// packages/spec/src/lib/pagination/pagination.ts
-import { isRef as isRef3 } from "@sdk-it/core/ref.js";
-import { isEmpty as isEmpty3 } from "@sdk-it/core/utils.js";
-
-// packages/spec/src/lib/pagination/pagination-result.ts
-import pluralize from "pluralize";
-var PRIMARY_TOP_TIER_KEYWORDS = [
-  "data",
-  "items",
-  "results",
-  "value"
-];
-var PRIMARY_OTHER_KEYWORDS = [
-  "records",
-  "content",
-  "list",
-  "payload",
-  "entities",
-  "collection",
-  "users",
-  "products",
-  "orders",
-  "bookings",
-  "articles",
-  "posts",
-  "documents",
-  "events"
-];
-var SECONDARY_KEYWORDS = ["entries", "rows", "elements"];
-var PLURAL_DEPRIORITIZE_LIST = [
-  "status",
-  "success",
-  "address",
-  "details",
-  "properties",
-  "params",
-  "headers",
-  "cookies",
-  "series",
-  "links",
-  "meta",
-  "metadata",
-  "statistics",
-  "settings",
-  "options",
-  "permissions",
-  "credentials",
-  "diagnostics",
-  "warnings",
-  "errors",
-  "actions",
-  "attributes",
-  "categories",
-  "features",
-  "includes",
-  "tags"
-];
-var HAS_MORE_PRIMARY_POSITIVE_EXACT = [
-  "hasmore",
-  "hasnext",
-  "hasnextpage",
-  "moreitems",
-  "moreitemsavailable",
-  "nextpage",
-  "nextpageexists",
-  "nextpageavailable",
-  "hasadditionalresults",
-  "moreresultsavailable",
-  "canloadmore",
-  "hasadditional",
-  "additionalitems",
-  "fetchmore"
-];
-var HAS_MORE_SECONDARY_POSITIVE_EXACT = ["more", "next"];
-var HAS_MORE_PRIMARY_INVERTED_EXACT = [
-  "islast",
-  "lastpage",
-  "endofresults",
-  "endoflist",
-  "nomoreitems",
-  "nomoredata",
-  "allitemsloaded",
-  "iscomplete",
-  "completed"
-];
-var HAS_MORE_POSITIVE_REGEX_PATTERNS = [
-  "\\bhas_?more\\b",
-  "\\bhas_?next\\b",
-  // e.g., itemsHasNext, items_has_next
-  "\\bmore_?items\\b",
-  "\\bnext_?page\\b",
-  // e.g., userNextPageFlag
-  "\\badditional\\b",
-  // e.g., hasAdditionalData, additional_results_exist
-  "\\bcontinuation\\b",
-  // e.g., continuationAvailable, has_continuation_token
-  "\\bmore_?results\\b",
-  "\\bpage_?available\\b",
-  "\\bnext(?:_?(page|marker))?\\b"
-];
-var COMPILED_HAS_MORE_POSITIVE_REGEXES = HAS_MORE_POSITIVE_REGEX_PATTERNS.map((p) => new RegExp(p, "i"));
-var HAS_MORE_INVERTED_REGEX_PATTERNS = [
-  "\\bis_?last\\b",
-  // e.g., pageIsLast
-  "\\blast_?page\\b",
-  // e.g., resultsAreLastPage
-  "\\bend_?of_?(data|results|list|items|stream)\\b",
-  "\\bno_?more_?(items|data|results)?\\b",
-  "\\ball_?(items_?)?loaded\\b",
-  "\\bis_?complete\\b"
-];
-var COMPILED_HAS_MORE_INVERTED_REGEXES = HAS_MORE_INVERTED_REGEX_PATTERNS.map((p) => new RegExp(p, "i"));
-function getItemsName(properties) {
-  const arrayPropertyNames = [];
-  for (const propName in properties) {
-    if (propName in properties) {
-      const propSchema = properties[propName];
-      if (propSchema && propSchema.type === "array") {
-        arrayPropertyNames.push(propName);
-      }
-    }
-  }
-  if (arrayPropertyNames.length === 0) {
-    return null;
-  }
-  if (arrayPropertyNames.length === 1) {
-    return arrayPropertyNames[0];
-  }
-  let bestCandidate = null;
-  let candidateRank = Infinity;
-  const updateCandidate = (propName, rank) => {
-    if (rank < candidateRank) {
-      bestCandidate = propName;
-      candidateRank = rank;
-    }
-  };
-  for (const propName of arrayPropertyNames) {
-    const lowerPropName = propName.toLowerCase();
-    if (PRIMARY_TOP_TIER_KEYWORDS.includes(lowerPropName)) {
-      updateCandidate(propName, 2);
-      continue;
-    }
-    if (candidateRank > 3 && PRIMARY_OTHER_KEYWORDS.includes(lowerPropName)) {
-      updateCandidate(propName, 3);
-      continue;
-    }
-    if (candidateRank > 4 && SECONDARY_KEYWORDS.includes(lowerPropName)) {
-      updateCandidate(propName, 4);
-      continue;
-    }
-    if (candidateRank > 5 && pluralize.isPlural(propName) && !PLURAL_DEPRIORITIZE_LIST.includes(lowerPropName)) {
-      updateCandidate(propName, 5);
-      continue;
-    }
-    if (candidateRank > 6 && pluralize.isPlural(propName) && PLURAL_DEPRIORITIZE_LIST.includes(lowerPropName)) {
-      updateCandidate(propName, 6);
-      continue;
-    }
-  }
-  if (bestCandidate) {
-    return bestCandidate;
-  }
-  return arrayPropertyNames[0];
-}
-function guess(properties) {
-  const booleanPropertyNames = [];
-  for (const propName in properties) {
-    const propSchema = properties[propName];
-    if (propSchema.type === "boolean" || propSchema.type === "integer" || propSchema.type === "string") {
-      booleanPropertyNames.push(propName);
-    }
-  }
-  if (booleanPropertyNames.length === 0) {
-    return null;
-  }
-  if (booleanPropertyNames.length === 1) {
-    return booleanPropertyNames[0];
-  }
-  let bestCandidate = null;
-  let candidateRank = Infinity;
-  const updateCandidate = (propName, rank) => {
-    if (rank < candidateRank) {
-      bestCandidate = propName;
-      candidateRank = rank;
-    }
-  };
-  for (const propName of booleanPropertyNames) {
-    const normalizedForExactMatch = propName.toLowerCase().replace(/[-_]/g, "");
-    let currentPropRank = Infinity;
-    if (HAS_MORE_PRIMARY_POSITIVE_EXACT.includes(normalizedForExactMatch)) {
-      currentPropRank = 1;
-    } else if (HAS_MORE_SECONDARY_POSITIVE_EXACT.includes(normalizedForExactMatch)) {
-      currentPropRank = 2;
-    } else {
-      let foundPositiveRegex = false;
-      for (const regex of COMPILED_HAS_MORE_POSITIVE_REGEXES) {
-        if (regex.test(propName)) {
-          currentPropRank = 3;
-          foundPositiveRegex = true;
-          break;
-        }
-      }
-      if (!foundPositiveRegex) {
-        if (HAS_MORE_PRIMARY_INVERTED_EXACT.includes(normalizedForExactMatch)) {
-          currentPropRank = 4;
-        } else {
-          for (const regex of COMPILED_HAS_MORE_INVERTED_REGEXES) {
-            if (regex.test(propName)) {
-              currentPropRank = 5;
-              break;
-            }
-          }
-        }
-      }
-    }
-    updateCandidate(propName, currentPropRank);
-  }
-  return bestCandidate;
-}
-function getHasMoreName(properties) {
-  const rootGuess = guess(properties);
-  if (rootGuess) {
-    return rootGuess;
-  }
-  for (const propName in properties) {
-    const propSchema = properties[propName];
-    if (propSchema.type === "object" && propSchema.properties) {
-      const nested = getHasMoreName(propSchema.properties);
-      if (nested) {
-        return propName + "." + nested;
-      }
-    }
-  }
-  return null;
-}
-
-// packages/spec/src/lib/pagination/pagination.ts
-var OFFSET_PARAM_REGEXES = [
-  /\boffset\b/i,
-  /\bskip\b/i,
-  /\bstart(?:ing_at|_index)?\b/i,
-  // e.g., start, starting_at, start_index
-  /\bfrom\b/i
-];
-var GENERIC_LIMIT_PARAM_REGEXES = [
-  /\blimit\b/i,
-  /\bcount\b/i,
-  /\b(?:page_?)?size\b/i,
-  // e.g., size, page_size, pagesize
-  /\bmax_results\b/i,
-  /\bnum_results\b/i,
-  /\bshow\b/i,
-  // Can sometimes mean limit
-  /\bper_?page\b/i,
-  // e.g., per_page, perpage
-  /\bper-page\b/i,
-  /\btake\b/i
-];
-var PAGE_NUMBER_REGEXES = [
-  // /^(currentPage)?page$/i, // Exact match for "page"
-  // /^currentPage$/i, // Exact match for "currentPage"
-  /^p$/i,
-  // Exact match for "p" (common shorthand)
-  // /\bpage_?(?:number|no|num|idx|index)\b/i, // e.g., page_number, pageNumber, page_num, page_idx
-  /^(current)?_?page(_?)(?:number|no|num|idx|index)?\b/i
-];
-var PAGE_SIZE_REGEXES = [
-  /\bpage_?size\b/i,
-  // e.g., page_size, pagesize
-  /^size$/i,
-  // Exact "size"
-  // /\bsize\b/i, // Broader "size" - can be ambiguous, prefer more specific ones first
-  /\blimit\b/i,
-  // Limit is often used for page size
-  /\bcount\b/i,
-  // Count can also be used for page size
-  /\bper_?page\b/i,
-  // e.g., per_page, perpage
-  /\bper-page\b/i,
-  /\bnum_?(?:items|records|results)\b/i,
-  // e.g., num_items, numitems
-  /\bresults_?per_?page\b/i
-];
-var CURSOR_REGEXES = [
-  /\bmarker\b/i,
-  /\bcursor\b/i,
-  /\bafter(?:_?cursor)?\b/i,
-  // e.g., after, after_cursor
-  /\bbefore(?:_?cursor)?\b/i,
-  // e.g., before, before_cursor
-  /\b(next|prev|previous)_?(?:page_?)?token\b/i,
-  // e.g., next_page_token, nextPageToken, prev_token
-  /\b(next|prev|previous)_?cursor\b/i,
-  // e.g., next_cursor, previousCursor
-  /\bcontinuation(?:_?token)?\b/i,
-  // e.g., continuation, continuation_token
-  /\bpage(?:_?(token|id))?\b/i,
-  // e.g., after, after_cursor
-  /\bstart_?(?:key|cursor|token|after)\b/i
-  // e.g., start_key, startCursor, startToken, startAfter
-];
-var CURSOR_LIMIT_REGEXES = [
-  /\blimit\b/i,
-  /\bcount\b/i,
-  /\bsize\b/i,
-  // General size
-  /\bfirst\b/i,
-  // Common in Relay-style cursor pagination (forward pagination)
-  /\blast\b/i,
-  // Common in Relay-style cursor pagination (backward pagination)
-  /\bpage_?size\b/i,
-  // Sometimes page_size is used with cursors
-  /\bnum_?(?:items|records|results)\b/i,
-  // e.g., num_items
-  /\bmax_?items\b/i,
-  /\btake\b/i
-];
-function findParamAndKeyword(queryParams, regexes, excludeParamName) {
-  for (const param of queryParams) {
-    if (param.name === excludeParamName) {
-      continue;
-    }
-    for (const regex of regexes) {
-      const match = param.name.match(regex);
-      if (match) {
-        return { param, keyword: match[0] };
-      }
-    }
-  }
-  return null;
-}
-function coearceParameters(parameters) {
-  const cleanedParameters = [];
-  for (const param of parameters) {
-    if (!param.schema) {
-      continue;
-    }
-    if (isRef3(param.schema)) {
-      continue;
-    }
-    if (!param.schema.type) {
-      continue;
-    }
-    if (param.schema) {
-      cleanedParameters.push({
-        ...param,
-        schema: {
-          ...param.schema,
-          type: Array.isArray(param.schema.type) ? param.schema.type : [param.schema.type]
-        }
-      });
-    }
-  }
-  return cleanedParameters;
-}
-function isOffsetPagination(operation, parameters) {
-  const params = coearceParameters(parameters).filter(
-    (it) => it.schema.type.includes("integer") || it.schema.type.includes("number")
-  );
-  const offsetMatch = findParamAndKeyword(params, OFFSET_PARAM_REGEXES);
-  if (!offsetMatch)
-    return null;
-  const limitMatch = findParamAndKeyword(
-    params,
-    GENERIC_LIMIT_PARAM_REGEXES,
-    offsetMatch.param.name
-  );
-  if (!limitMatch)
-    return null;
-  return {
-    type: "offset",
-    offsetParamName: offsetMatch.param.name,
-    offsetKeyword: offsetMatch.keyword,
-    limitParamName: limitMatch.param.name,
-    limitKeyword: limitMatch.keyword
-  };
-}
-function isPagePagination(operation, parameters) {
-  const params = coearceParameters(parameters).filter(
-    (it) => it.schema.type.includes("integer") || it.schema.type.includes("number")
-  );
-  if (params.length < 2)
-    return null;
-  const pageNoMatch = findParamAndKeyword(params, PAGE_NUMBER_REGEXES);
-  if (!pageNoMatch)
-    return null;
-  const pageSizeMatch = findParamAndKeyword(
-    params,
-    PAGE_SIZE_REGEXES,
-    pageNoMatch.param.name
-  );
-  if (!pageSizeMatch)
-    return null;
-  return {
-    type: "page",
-    pageNumberParamName: pageNoMatch.param.name,
-    pageNumberKeyword: pageNoMatch.keyword,
-    pageSizeParamName: pageSizeMatch.param.name,
-    pageSizeKeyword: pageSizeMatch.keyword
-  };
-}
-function isCursorPagination(operation, parameters = []) {
-  const queryParams = parameters;
-  if (queryParams.length < 2)
-    return null;
-  const cursorMatch = findParamAndKeyword(queryParams, CURSOR_REGEXES);
-  if (!cursorMatch)
-    return null;
-  const limitMatch = findParamAndKeyword(
-    queryParams,
-    CURSOR_LIMIT_REGEXES,
-    cursorMatch.param.name
-  );
-  if (!limitMatch)
-    return null;
-  return {
-    type: "cursor",
-    cursorParamName: cursorMatch.param.name,
-    cursorKeyword: cursorMatch.keyword,
-    limitParamName: limitMatch.param.name,
-    limitKeyword: limitMatch.keyword
-  };
-}
-function guessPagination(operation, body, response) {
-  const bodyParameters = body && body.properties ? Object.entries(body.properties).map(([it, schema]) => ({
-    name: it,
-    schema
-  })) : [];
-  const parameters = operation.parameters;
-  if (isEmpty3(operation.parameters) && isEmpty3(bodyParameters)) {
-    return { type: "none", reason: "no parameters" };
-  }
-  if (!response) {
-    return { type: "none", reason: "no response" };
-  }
-  if (!response.properties) {
-    return { type: "none", reason: "empty response" };
-  }
-  const properties = response.properties;
-  const itemsKey = getItemsName(properties);
-  if (!itemsKey) {
-    return { type: "none", reason: "no items key" };
-  }
-  const hasMoreKey = getHasMoreName(excludeKey(properties, itemsKey));
-  if (!hasMoreKey) {
-    return { type: "none", reason: "no hasMore key" };
-  }
-  const pagination = isOffsetPagination(operation, [...parameters, ...bodyParameters]) || isPagePagination(operation, [...parameters, ...bodyParameters]) || isCursorPagination(operation, [...parameters, ...bodyParameters]);
-  return pagination ? { ...pagination, items: itemsKey, hasMore: hasMoreKey } : { type: "none", reason: "no pagination" };
-}
-function excludeKey(obj, key) {
-  const { [key]: _, ...rest } = obj;
-  return rest;
-}
-
-// packages/spec/src/lib/security.ts
-import { methods } from "@sdk-it/core/paths.js";
-import { resolveRef as resolveRef3 } from "@sdk-it/core/ref.js";
-function securityToOptions(spec, security2, securitySchemes, staticIn) {
-  const parameters = [];
-  for (const it of security2) {
-    const [name] = Object.keys(it);
-    if (!name) {
-      continue;
-    }
-    const schema = resolveRef3(
-      spec,
-      securitySchemes[name]
-    );
-    if (schema.type === "http") {
-      parameters.push({
-        in: staticIn ?? "header",
-        name: "authorization",
-        schema: { type: "string" },
-        example: schema.scheme === "bearer" ? '"<token>"' : `<${schema.scheme}> <token>`
-      });
-      continue;
-    }
-    if (schema.type === "apiKey") {
-      if (!schema.in) {
-        throw new Error(`apiKey security schema must have an "in" field`);
-      }
-      if (!schema.name) {
-        throw new Error(`apiKey security schema must have a "name" field`);
-      }
-      parameters.push({
-        in: staticIn ?? schema.in,
-        name: schema.name,
-        schema: { type: "string" },
-        example: `"proj-${crypto.randomUUID()}"`
-      });
-      continue;
-    }
-  }
-  return parameters;
-}
-function security(spec) {
-  const security2 = spec.security || [];
-  const paths = Object.values(spec.paths ?? {});
-  const options = securityToOptions(
-    spec,
-    security2,
-    spec.components.securitySchemes
-  );
-  for (const it of paths) {
-    for (const method of methods) {
-      const operation = it[method];
-      if (!operation) {
-        continue;
-      }
-      Object.assign(
-        options,
-        securityToOptions(
-          spec,
-          operation.security || [],
-          spec.components.securitySchemes,
-          "input"
-        )
-      );
-    }
-  }
-  return options;
-}
-
-// packages/spec/src/lib/operation.ts
-function findUniqueOperationId(usedOperationIds, initialId, choices, formatter) {
-  let counter = 1;
-  let uniqueOperationId = formatter(initialId);
-  while (usedOperationIds.has(uniqueOperationId)) {
-    const prependIndex = Math.min(counter - 1, choices.length - 1);
-    const prefix = choices[prependIndex];
-    if (prependIndex < choices.length - 1) {
-      uniqueOperationId = formatter(
-        `${prefix}${initialId.charAt(0).toUpperCase() + initialId.slice(1)}`
-      );
-    } else {
-      uniqueOperationId = formatter(
-        `${prefix}${initialId.charAt(0).toUpperCase() + initialId.slice(1)}${counter - choices.length + 1}`
-      );
-    }
-    counter++;
-  }
-  return uniqueOperationId;
-}
-function augmentSpec(config, verbose = false) {
-  if ("x-sdk-augmented" in config.spec) {
-    return config.spec;
-  }
-  const spec = {
-    ...config.spec,
-    components: {
-      ...config.spec.components,
-      schemas: config.spec.components?.schemas ?? {},
-      securitySchemes: config.spec.components?.securitySchemes ?? {}
-    },
-    paths: config.spec.paths ?? {}
-  };
-  const paths = {};
-  const usedOperationIds = /* @__PURE__ */ new Set();
-  for (const [path, pathItem] of Object.entries(spec.paths)) {
-    const fixedPath = path.replace(/:([^/]+)/g, "{$1}");
-    for (const [method, operation] of Object.entries(pathItem)) {
-      if (!methods2.includes(method)) {
-        continue;
-      }
-      const formatOperationId = config.operationId ?? defaults.operationId;
-      const formatTag = config.tag ?? defaults.tag;
-      const operationTag = formatTag(operation, fixedPath);
-      const operationId = findUniqueOperationId(
-        usedOperationIds,
-        formatOperationId(operation, fixedPath, method),
-        [operationTag, method, fixedPath.split("/").filter(Boolean).join("")],
-        (id) => formatOperationId(
-          { ...operation, operationId: id },
-          fixedPath,
-          method
-        )
-      );
-      usedOperationIds.add(operationId);
-      const parameters = [
-        ...pathItem.parameters ?? [],
-        ...operation.parameters ?? []
-      ].map((it) => resolveRef4(spec, it));
-      const tunedOperation = {
-        ...operation,
-        parameters,
-        tags: [snakecase2(operationTag)],
-        operationId,
-        responses: resolveResponses(
-          spec,
-          operationId,
-          operation,
-          config.responses
-        ),
-        requestBody: tuneRequestBody(
-          spec,
-          operationId,
-          operation,
-          parameters,
-          operation.security ?? []
-        )
-      };
-      tunedOperation["x-pagination"] = toPagination(spec, tunedOperation);
-      Object.assign(paths, {
-        [fixedPath]: {
-          ...paths[fixedPath],
-          [method]: tunedOperation
-        }
-      });
-    }
-  }
-  fixSpec(spec, Object.values(spec.components.schemas));
-  if (verbose) {
-    const newRefs = [];
-    expandSpec(spec, spec.components.schemas, newRefs);
-  }
-  return {
-    ...spec,
-    paths,
-    "x-sdk-augmented": true
-  };
-}
-function toPagination(spec, tunedOperation) {
-  if (tunedOperation["x-pagination"]) {
-    return tunedOperation["x-pagination"];
-  }
-  const schema = getResponseContentSchema(
-    spec,
-    tunedOperation.responses["200"],
-    "application/json"
-  );
-  const pagination = guessPagination(
-    tunedOperation,
-    tunedOperation.requestBody ? getRequestContentSchema(
-      spec,
-      tunedOperation.requestBody,
-      "application/json"
-    ) : void 0,
-    schema
-  );
-  if (pagination && pagination.type !== "none" && schema) {
-    return pagination;
-  }
-  return void 0;
-}
-function getResponseContentSchema(spec, response, type) {
-  if (!response) {
-    return void 0;
-  }
-  const content = response.content;
-  if (!content) {
-    return void 0;
-  }
-  for (const contentType in content) {
-    if (contentType.toLowerCase() === type.toLowerCase()) {
-      return isRef4(content[contentType].schema) ? followRef(spec, content[contentType].schema.$ref) : content[contentType].schema;
-    }
-  }
-  return void 0;
-}
-function getRequestContentSchema(spec, requestBody, type) {
-  const content = requestBody.content;
-  if (!content) {
-    return void 0;
-  }
-  for (const contentType in content) {
-    if (contentType.toLowerCase() === type.toLowerCase()) {
-      return isRef4(content[contentType].schema) ? followRef(spec, content[contentType].schema.$ref) : content[contentType].schema;
-    }
-  }
-  return void 0;
-}
-var defaults = {
-  operationId: (operation, path, method) => {
-    if (operation.operationId) {
-      return camelcase2(
-        operation.operationId.split("#").pop().replace(/-(?=\d)/g, "")
-      );
-    }
-    const metadata = operation["x-oaiMeta"];
-    if (metadata && metadata.name) {
-      return camelcase2(metadata.name);
-    }
-    return camelcase2(
-      [method, ...path.replace(/[\\/\\{\\}]/g, " ").split(" ")].filter(Boolean).join(" ").trim()
-    );
-  },
-  tag: (operation, path) => {
-    return operation.tags?.[0] ? sanitizeTag(operation.tags?.[0]) : determineGenericTag(path, operation);
-  }
-};
-function resolveResponses(spec, operationId, operation, responsesConfig) {
-  const responses = operation.responses ?? {};
-  operation.responses ??= {};
-  let foundSuccessResponse = false;
-  for (const status in responses) {
-    if (status === "default") {
-      delete responses[status];
-      continue;
-    }
-    operation.responses[status] = structuredClone(
-      resolveRef4(spec, responses[status])
-    );
-    if (isSuccessStatusCode(status)) {
-      foundSuccessResponse = true;
-    }
-  }
-  if (!foundSuccessResponse) {
-    operation.responses["200"] = {
-      description: "OK",
-      content: {
-        "application/json": {
-          schema: {}
-        }
-      }
-    };
-  }
-  for (const status in operation.responses) {
-    const response = operation.responses[status];
-    const statusCode = +status;
-    const outputName = statusCode !== 200 ? pascalcase3(operationId) + status : findUniqueSchemaName(spec, operationId, [
-      "output",
-      "payload",
-      "result"
-    ]);
-    if (!responsesConfig?.flattenErrorResponses) {
-      if (!isSuccessStatusCode(status)) {
-        continue;
-      }
-    }
-    if (isEmpty4(response.content)) {
-      response.content = {
-        "application/octet-stream": {}
-      };
-    }
-    response["x-response-name"] = outputName;
-    for (const [contentType, mediaType] of Object.entries(
-      response.content
-    )) {
-      if (isRef4(mediaType.schema)) {
-        const { model } = parseRef(mediaType.schema.$ref);
-        Object.assign(spec.components.schemas[model], {
-          "x-responsebody": true
-          // do not assign response ref to a group
-          // because they are supposed to be in a separate file only inlined
-          // schemas are grouped by operationId
-        });
-        response["x-response-name"] = model;
-        continue;
-      }
-      if (isSseContentType(contentType)) {
-        continue;
-      }
-      if (parseJsonContentType(contentType)) {
-        if (isEmpty4(mediaType.schema)) {
-          spec.components.schemas[outputName] = {
-            type: "object",
-            additionalProperties: true
-          };
-        }
-      } else {
-        spec.components.schemas[outputName] = {
-          ...spec.components.schemas[outputName],
-          "x-stream": !isTextContentType(contentType)
-        };
-      }
-      spec.components.schemas[outputName] = {
-        ...spec.components.schemas[outputName],
-        ...mediaType.schema,
-        "x-responsebody": true,
-        "x-response-group": operationId
-      };
-      operation.responses[status].content[contentType].schema = {
-        $ref: `#/components/schemas/${outputName}`
-      };
-    }
-  }
-  return operation.responses;
-}
-function forEachOperation(spec, callback) {
-  const result = [];
-  for (const [path, pathItem] of Object.entries(spec.paths)) {
-    for (const [method, operation] of Object.entries(pathItem)) {
-      if (!methods2.includes(method)) {
-        continue;
-      }
-      const metadata = operation["x-oaiMeta"] ?? {};
-      const operationTag = operation.tags?.[0];
-      result.push(
-        callback(
-          {
-            name: metadata.name,
-            method,
-            path,
-            groupName: operationTag,
-            tag: operationTag
-          },
-          operation
-        )
-      );
-    }
-  }
-  return result;
-}
-var reservedKeywords = /* @__PURE__ */ new Set([
-  "await",
-  // Reserved in async functions
-  "break",
-  "case",
-  "catch",
-  "class",
-  "const",
-  "continue",
-  "debugger",
-  "default",
-  "delete",
-  "do",
-  "else",
-  "enum",
-  "export",
-  "extends",
-  "false",
-  "finally",
-  "for",
-  "function",
-  "if",
-  "implements",
-  // Strict mode
-  "import",
-  "in",
-  "instanceof",
-  "interface",
-  // Strict mode
-  "let",
-  // Strict mode
-  "new",
-  "null",
-  "package",
-  // Strict mode
-  "private",
-  // Strict mode
-  "protected",
-  // Strict mode
-  "public",
-  // Strict mode
-  "return",
-  "static",
-  // Strict mode
-  "super",
-  "switch",
-  "this",
-  "throw",
-  "true",
-  "try",
-  "typeof",
-  "var",
-  "void",
-  "while",
-  "with",
-  "yield",
-  // Strict mode / Generator functions
-  // 'arguments' is not technically a reserved word, but it's a special identifier within functions
-  // and assigning to it or declaring it can cause issues or unexpected behavior.
-  "arguments"
-]);
-var reservedSdkKeywords = /* @__PURE__ */ new Set(["ClientError", "Error", "ConflictError"]);
-function sanitizeTag(tag) {
-  if (/^\d/.test(tag)) {
-    return `_${tag}`;
-  }
-  if (reservedKeywords.has(tag)) {
-    return `$${tag}`;
-  }
-  if (reservedSdkKeywords.has(tag)) {
-    return `$${tag}`;
-  }
-  return tag.replace(/[()]/g, "").replace(/--/g, "").split(/\s+/).filter(Boolean).join(" ");
-}
-function determineGenericTag(pathString, operation) {
-  const operationId = operation.operationId || "";
-  const VERSION_REGEX = /^[vV]\d+$/;
-  const commonVerbs = /* @__PURE__ */ new Set([
-    // Verbs to potentially strip from operationId prefix
-    "get",
-    "list",
-    "create",
-    "update",
-    "delete",
-    "post",
-    "put",
-    "patch",
-    "do",
-    "send",
-    "add",
-    "remove",
-    "set",
-    "find",
-    "search",
-    "check",
-    "make"
-  ]);
-  const segments = pathString.split("/").filter(Boolean);
-  const potentialCandidates = segments.filter(
-    (segment) => segment && !segment.startsWith("{") && !segment.endsWith("}") && !VERSION_REGEX.test(segment)
-  );
-  for (let i = potentialCandidates.length - 1; i >= 0; i--) {
-    const segment = potentialCandidates[i];
-    if (!segment.startsWith("@")) {
-      return sanitizeTag(camelcase2(segment));
-    }
-  }
-  const canFallbackToPathSegment = potentialCandidates.length > 0;
-  if (operationId) {
-    const lowerOpId = operationId.toLowerCase();
-    const parts = operationId.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/([A-Z])([A-Z][a-z])/g, "$1_$2").replace(/([a-zA-Z])(\d)/g, "$1_$2").replace(/(\d)([a-zA-Z])/g, "$1_$2").toLowerCase().split(/[_-\s]+/);
-    const validParts = parts.filter(Boolean);
-    if (commonVerbs.has(lowerOpId) && validParts.length === 1 && canFallbackToPathSegment) {
-    } else if (validParts.length > 0) {
-      const firstPart = validParts[0];
-      const isFirstPartVerb = commonVerbs.has(firstPart);
-      if (isFirstPartVerb && validParts.length > 1) {
-        const verbPrefixLength = firstPart.length;
-        let nextPartStartIndex = -1;
-        if (operationId.length > verbPrefixLength) {
-          const charAfterPrefix = operationId[verbPrefixLength];
-          if (charAfterPrefix >= "A" && charAfterPrefix <= "Z") {
-            nextPartStartIndex = verbPrefixLength;
-          } else if (charAfterPrefix >= "0" && charAfterPrefix <= "9") {
-            nextPartStartIndex = verbPrefixLength;
-          } else if (["_", "-"].includes(charAfterPrefix)) {
-            nextPartStartIndex = verbPrefixLength + 1;
-          } else {
-            const match = operationId.substring(verbPrefixLength).match(/[A-Z0-9]/);
-            if (match && match.index !== void 0) {
-              nextPartStartIndex = verbPrefixLength + match.index;
-            }
-            if (nextPartStartIndex === -1 && operationId.length > verbPrefixLength) {
-              nextPartStartIndex = verbPrefixLength;
-            }
-          }
-        }
-        if (nextPartStartIndex !== -1 && nextPartStartIndex < operationId.length) {
-          const remainingOriginalSubstring = operationId.substring(nextPartStartIndex);
-          const potentialTag = camelcase2(remainingOriginalSubstring);
-          if (potentialTag) {
-            return sanitizeTag(potentialTag);
-          }
-        }
-        const potentialTagJoined = camelcase2(validParts.slice(1).join("_"));
-        if (potentialTagJoined) {
-          return sanitizeTag(potentialTagJoined);
-        }
-      }
-      const potentialTagFull = camelcase2(operationId);
-      if (potentialTagFull) {
-        const isResultSingleVerb = validParts.length === 1 && isFirstPartVerb;
-        if (!(isResultSingleVerb && canFallbackToPathSegment)) {
-          if (potentialTagFull.length > 0) {
-            return sanitizeTag(potentialTagFull);
-          }
-        }
-      }
-      const firstPartCamel = camelcase2(firstPart);
-      if (firstPartCamel) {
-        const isFirstPartCamelVerb = commonVerbs.has(firstPartCamel);
-        if (!isFirstPartCamelVerb || validParts.length === 1 || !canFallbackToPathSegment) {
-          return sanitizeTag(firstPartCamel);
-        }
-      }
-      if (isFirstPartVerb && validParts.length > 1 && validParts[1] && canFallbackToPathSegment) {
-        const secondPartCamel = camelcase2(validParts[1]);
-        if (secondPartCamel) {
-          return sanitizeTag(secondPartCamel);
-        }
-      }
-    }
-  }
-  if (potentialCandidates.length > 0) {
-    let firstCandidate = potentialCandidates[0];
-    if (firstCandidate.startsWith("@")) {
-      firstCandidate = firstCandidate.substring(1);
-    }
-    if (firstCandidate) {
-      return sanitizeTag(camelcase2(firstCandidate));
-    }
-  }
-  console.warn(
-    `Could not determine a suitable tag for path: ${pathString}, operationId: ${operationId}. Using 'unknown'.`
-  );
-  return "unknown";
-}
-function parseJsonContentType(contentType) {
-  if (!contentType) {
-    return null;
-  }
-  let mainType = contentType.trim();
-  const semicolonIndex = mainType.indexOf(";");
-  if (semicolonIndex !== -1) {
-    mainType = mainType.substring(0, semicolonIndex).trim();
-  }
-  mainType = mainType.toLowerCase();
-  if (mainType.endsWith("/json")) {
-    return mainType.split("/")[1];
-  } else if (mainType.endsWith("+json")) {
-    return mainType.split("+")[1];
-  }
-  return null;
-}
-function isTextContentType(contentType) {
-  if (!contentType) {
-    return false;
-  }
-  let mainType = contentType.trim();
-  const semicolonIndex = mainType.indexOf(";");
-  if (semicolonIndex !== -1) {
-    mainType = mainType.substring(0, semicolonIndex).trim();
-  }
-  mainType = mainType.toLowerCase();
-  return mainType.startsWith("text/");
-}
-function isSseContentType(contentType) {
-  if (!contentType) {
-    return false;
-  }
-  let mainType = contentType.trim();
-  const semicolonIndex = mainType.indexOf(";");
-  if (semicolonIndex !== -1) {
-    mainType = mainType.substring(0, semicolonIndex).trim();
-  }
-  mainType = mainType.toLowerCase();
-  return mainType === "text/event-stream";
-}
-function isStreamingContentType(contentType) {
-  return contentType === "application/octet-stream";
-}
-function isSuccessStatusCode(statusCode) {
-  if (typeof statusCode === "string") {
-    const statusGroup = +statusCode.slice(0, 1);
-    const status = Number(statusCode);
-    return status >= 200 && status < 300 || status >= 2 && statusGroup <= 3;
-  }
-  statusCode = Number(statusCode);
-  return statusCode >= 200 && statusCode < 300;
-}
-function isErrorStatusCode(statusCode) {
-  if (typeof statusCode === "string") {
-    const statusGroup = +statusCode.slice(0, 1);
-    const status = Number(statusCode);
-    return status < 200 || status >= 300 || statusGroup >= 4 || statusGroup === 0 || statusGroup === 1;
-  }
-  statusCode = Number(statusCode);
-  return statusCode < 200 || statusCode >= 300;
-}
-function patchParameters(spec, schema, parameters, security2) {
-  const securitySchemes = spec.components?.securitySchemes ?? {};
-  const securityOptions = securityToOptions(spec, security2, securitySchemes);
-  let required = Array.isArray(schema.required) ? schema.required : [];
-  schema["x-properties"] ??= {};
-  for (const param of parameters) {
-    if (param.required) {
-      required.push(param.name);
-    }
-    schema["x-properties"][param.name] = {
-      "x-in": param.in,
-      ...isRef4(param.schema) ? followRef(spec, param.schema.$ref) : param.schema ?? { type: "string" }
-    };
-  }
-  for (const param of securityOptions) {
-    required = required.filter((name) => name !== param.name);
-    schema["x-properties"][param.name] = {
-      "x-in": "header",
-      ...isRef4(param.schema) ? followRef(spec, param.schema.$ref) : param.schema ?? { type: "string" }
-    };
-  }
-  schema["x-required"] = required;
-}
-function createOperation(options) {
-  const parameters = [];
-  if (!isEmpty4(options.parameters)) {
-    const locations = ["query", "path", "header", "cookie"];
-    for (const location of locations) {
-      const locationParams = options.parameters[location];
-      if (locationParams) {
-        for (const [name, param] of Object.entries(locationParams)) {
-          parameters.push({
-            name,
-            in: location,
-            required: param.required ?? false,
-            schema: param.schema
-          });
-        }
-      }
-    }
-  }
-  const responses = {};
-  for (const [key, schema] of Object.entries(options.response)) {
-    const [statusCode, contentType] = key.split(/-(.*)/);
-    if (!contentType) {
-      throw new Error(
-        `Response key "${key}" must be in the format "statusCode-contentType"`
-      );
-    }
-    responses[statusCode] ??= {
-      description: `Response for ${statusCode}`,
-      content: {}
-    };
-    if (contentType === "headers") {
-      responses[statusCode].headers = schema;
-    } else {
-      responses[statusCode].content[contentType] = {
-        schema
-      };
-    }
-  }
-  let requestBody = void 0;
-  if (options.request) {
-    requestBody = { description: "Request body", content: {} };
-    for (const [contentType, schema] of Object.entries(options.request)) {
-      requestBody.content[contentType] = { schema };
-    }
-  }
-  return {
-    security: (options.security ?? []).map((name) => ({
-      [name]: []
-    })),
-    operationId: options.name,
-    tags: [options.group],
-    parameters,
-    responses,
-    requestBody
-  };
-}
-function tuneRequestBody(spec, operationId, operation, parameters, security2) {
-  const inputName = findUniqueSchemaName(spec, operationId, [
-    "input",
-    "payload",
-    "request"
-  ]);
-  const requestBody = isRef4(operation.requestBody) ? followRef(spec, operation.requestBody.$ref) : operation.requestBody ?? {
-    content: {},
-    required: false
-  };
-  if (isEmpty4(requestBody.content)) {
-    const schema = {
-      "x-inputname": inputName,
-      "x-requestbody": true
-    };
-    patchParameters(spec, schema, parameters, security2);
-    const tuned = {
-      ...requestBody,
-      content: {
-        "application/empty": {
-          schema: { $ref: `#/components/schemas/${inputName}` }
-        }
-      }
-    };
-    spec.components.schemas[inputName] = schema;
-    return tuned;
-  }
-  for (const contentType in requestBody.content) {
-    const mediaType = requestBody.content[contentType];
-    let schema;
-    switch (true) {
-      case isRef4(mediaType.schema):
-        schema = followRef(spec, mediaType.schema.$ref);
-        break;
-      case isEmpty4(mediaType.schema):
-        schema ??= {};
-        console.warn(
-          `Request body schema for content type "${contentType}" is empty.`
-        );
-        break;
-      default:
-        schema = mediaType.schema;
-        break;
-    }
-    patchParameters(spec, schema, parameters, security2);
-    spec.components.schemas[inputName] = {
-      ...schema,
-      "x-requestbody": true,
-      "x-inputname": inputName
-    };
-    requestBody.content[contentType].schema = {
-      $ref: `#/components/schemas/${inputName}`
-    };
-  }
-  return requestBody;
-}
-
-// packages/spec/src/lib/get-ref-usage.ts
-function getRefUsage(spec, schemaName, list = []) {
-  const checkSchema = (schema, withRefCheck = false) => {
-    if (isRef5(schema)) {
-      if (!withRefCheck)
-        return false;
-      const { model } = parseRef2(schema.$ref);
-      return model === schemaName;
-    }
-    if (!isEmpty5(schema.oneOf)) {
-      return schema.oneOf.some((it) => checkSchema(it, true));
-    }
-    if (schema.type === "array" && schema.items) {
-      if (isRef5(schema.items)) {
-        return checkSchema(schema.items, withRefCheck);
-      }
-      if (schema.items.oneOf) {
-        return schema.items.oneOf.some((it) => checkSchema(it, true));
-      }
-      return checkSchema(schema.items, withRefCheck);
-    }
-    if (schema.type === "object") {
-      const properties = schema.properties;
-      if (!isEmpty5(properties)) {
-        let found = false;
-        let propertyName = "";
-        for (const [key, it] of Object.entries(properties)) {
-          found = checkSchema(it, false);
-          if (found) {
-            propertyName = key;
-          }
-        }
-        return propertyName;
-      }
-    }
-    return false;
-  };
-  for (const [key, value] of Object.entries(spec.components.schemas)) {
-    const thisWouldBeTheObjectPropertyKeyName = checkSchema(value);
-    if (thisWouldBeTheObjectPropertyKeyName) {
-      if (typeof thisWouldBeTheObjectPropertyKeyName === "string") {
-        list.push(pascalcase4(`${key} ${thisWouldBeTheObjectPropertyKeyName}`));
-      } else {
-        list.push(pascalcase4(key));
-      }
-    }
-  }
-  return list;
-}
-
-// packages/spec/src/lib/is-primitive-schema.ts
-function isPrimitiveSchema(schema) {
-  const types = coerceTypes(schema, false);
-  if (!types || types.length === 0) {
-    return false;
-  }
-  return types.includes("object") === false;
-}
-
-// packages/spec/src/lib/loaders/local-loader.ts
-import { readFile } from "node:fs/promises";
-import { extname } from "node:path";
-import { parse } from "yaml";
-async function loadLocal(location) {
-  const extName = extname(location);
-  const text = await readFile(location, "utf-8");
-  switch (extName) {
-    case ".json":
-      return JSON.parse(text);
-    case ".yaml":
-    case ".yml":
-      return parse(text);
-    default:
-      throw new Error(`Unsupported file extension: ${extName}`);
-  }
-}
-
-// packages/spec/src/lib/loaders/postman/postman-converter.ts
-import { parse as parse2 } from "fast-content-type-parse";
-function descriptionToText(description) {
-  if (!description) {
-    return void 0;
-  }
-  if (typeof description === "string") {
-    return description;
-  }
-  if (description.content) {
-    return description.content;
-  }
-  return void 0;
-}
-function isFolder(item) {
-  return "item" in item;
-}
-function isRequest(item) {
-  return !!item.request;
-}
-function processItems(items, parentTags, globalTags, paths, securitySchemes) {
-  for (const item of items) {
-    if (!isFolder(item) && !isRequest(item)) {
-      console.warn(
-        `Skipping item ${item.name} because it is not a folder or request`
-      );
-      continue;
-    }
-    if (isFolder(item)) {
-      if (item.auth) {
-        processAuthScheme(item.auth, securitySchemes);
-      }
-      if (!globalTags.some((tag) => tag.name === item.name)) {
-        globalTags.push({
-          name: item.name,
-          description: descriptionToText(item.description)
-        });
-      }
-      const currentTags = [...parentTags, item.name];
-      processItems(item.item, currentTags, globalTags, paths, securitySchemes);
-    } else if (isRequest(item)) {
-      let operation;
-      if (typeof item.request === "string") {
-        const url = new URL(item.request);
-        operation = requestToOperation(
-          {
-            name: url.pathname,
-            response: [{ code: 200 }],
-            request: {
-              method: "get",
-              url: {
-                path: url.pathname.split("/").slice(1)
-              }
-            }
-          },
-          securitySchemes
-        );
-      } else {
-        const auth = item.request.auth;
-        operation = requestToOperation(
-          {
-            name: item.name,
-            request: { ...item.request, auth },
-            response: item.response
-          },
-          securitySchemes
-        );
-      }
-      paths[operation.path] ??= {};
-      Object.assign(paths[operation.path], {
-        [operation.method]: {
-          tags: parentTags.length ? parentTags : void 0,
-          ...operation.operation
-        }
-      });
-    }
-  }
-}
-function coerceVariable(query) {
-  if (!query.key) {
-    throw new Error("Invalid query parameter format");
-  }
-  return {
-    key: query.key,
-    description: descriptionToText(query.description)
-  };
-}
-function coerceQuery(query) {
-  if (!query.key) {
-    throw new Error("Invalid query parameter format");
-  }
-  return {
-    key: query.key,
-    description: descriptionToText(query.description)
-  };
-}
-function coerceUrl(url) {
-  if (!url) {
-    throw new Error("Invalid URL format");
-  }
-  if (typeof url === "string") {
-    return {
-      path: url.split("/").slice(1),
-      query: [],
-      variable: []
-    };
-  }
-  if (typeof url.path === "string") {
-    return {
-      path: url.path.split("/").slice(1),
-      query: (url.query ?? []).map(coerceQuery),
-      variable: (url.variable ?? []).map(coerceVariable)
-    };
-  }
-  return {
-    path: (url.path ?? []).map((p) => {
-      if (typeof p === "string") {
-        return p;
-      }
-      throw new Error("Invalid URL path format");
-    }),
-    query: (url.query ?? []).map(coerceQuery),
-    variable: (url.variable ?? []).map(coerceVariable)
-  };
-}
-function coerceResponseHeader(header) {
-  if (!header) {
-    return [];
-  }
-  if (typeof header === "string") {
-    throw new Error(`Invalid header format: ${header}`);
-  }
-  return header.map((h) => {
-    if (typeof h === "string") {
-      return {
-        key: h,
-        value: null
-      };
-    }
-    return h;
-  });
-}
-function processAuthScheme(auth, securitySchemes) {
-  if (!auth || auth.type === "noauth")
-    return null;
-  const getAuthAttr = (key) => {
-    if (!auth || auth.type === "noauth")
-      return void 0;
-    const authType = auth[auth.type];
-    if (!authType)
-      return void 0;
-    const attr = authType.find((a) => a.key === key);
-    return attr ? String(attr.value) : void 0;
-  };
-  const schemeId = `${auth.type}Auth`;
-  switch (auth.type) {
-    case "apikey": {
-      const key = getAuthAttr("key") || "api_key";
-      const in_ = getAuthAttr("in") || "header";
-      securitySchemes[schemeId] = {
-        type: "apiKey",
-        name: key,
-        in: in_,
-        description: "API key authentication"
-      };
-      break;
-    }
-    case "basic":
-      securitySchemes[schemeId] = {
-        type: "http",
-        scheme: "basic",
-        description: "Basic HTTP authentication"
-      };
-      break;
-    case "bearer": {
-      const token = getAuthAttr("token");
-      securitySchemes[schemeId] = {
-        type: "http",
-        scheme: "bearer",
-        description: "Bearer token authentication",
-        ...token ? { bearerFormat: "JWT" } : {}
-      };
-      break;
-    }
-    case "oauth2": {
-      const flowType = getAuthAttr("grant_type") || "implicit";
-      securitySchemes[schemeId] = {
-        type: "oauth2",
-        description: "OAuth 2.0 authentication",
-        flows: {
-          [flowType === "authorization_code" ? "authorizationCode" : flowType]: {
-            authorizationUrl: getAuthAttr("authUrl") || "https://example.com/oauth/authorize",
-            tokenUrl: getAuthAttr("tokenUrl") || "https://example.com/oauth/token",
-            scopes: {}
-          }
-        }
-      };
-      break;
-    }
-    case "digest":
-      securitySchemes[schemeId] = {
-        type: "http",
-        scheme: "digest",
-        description: "Digest authentication"
-      };
-      break;
-    case "awsv4":
-      securitySchemes[schemeId] = {
-        type: "apiKey",
-        name: "Authorization",
-        in: "header",
-        description: "AWS Signature v4 authentication"
-      };
-      break;
-    default:
-      securitySchemes[schemeId] = {
-        type: "apiKey",
-        name: "Authorization",
-        in: "header",
-        description: `${auth.type} authentication`
-      };
-  }
-  return schemeId;
-}
-function generateSecurityRequirement(auth, securitySchemes) {
-  if (!auth || auth.type === "noauth")
-    return [];
-  const schemeId = `${auth.type}Auth`;
-  if (securitySchemes[schemeId]) {
-    return [{ [schemeId]: [] }];
-  }
-  return [];
-}
-function requestToOperation(item, securitySchemes) {
-  const url = coerceUrl(item.request.url);
-  const headers = Array.isArray(item.request.header) ? item.request.header : [];
-  const parameters = [
-    ...url.query.filter((param) => !param.disabled).map((param) => {
-      return {
-        in: "query",
-        name: param.key,
-        required: false,
-        description: param.description,
-        schema: {
-          ...param.value && !isNaN(Number(param.value)) ? { type: "number" } : param.value === "true" || param.value === "false" ? { type: "boolean" } : { type: "string" }
-        }
-      };
-    }),
-    ...url.variable.map((param) => {
-      return {
-        in: "path",
-        name: param.key,
-        required: true,
-        description: param.description,
-        schema: {
-          ...param.value && !isNaN(Number(param.value)) ? { type: "number" } : param.value === "true" || param.value === "false" ? { type: "boolean" } : { type: "string" }
-        }
-      };
-    }),
-    ...headers.filter(
-      (h) => !h.disabled && h.key.toLowerCase() !== "accept" && h.key.toLowerCase() !== "content-type"
-    ).map((header) => {
-      return {
-        in: "header",
-        name: header.key,
-        required: false,
-        description: descriptionToText(header.description),
-        schema: {
-          type: "string"
-        }
-      };
-    })
-  ];
-  const acceptHeaderIdx = headers.findIndex(
-    (h) => h.key.toLowerCase() === "accept"
-  );
-  const contentTypeIdx = headers.findIndex(
-    (h) => h.key.toLowerCase() === "content-type"
-  );
-  const [acceptHeaderValue] = acceptHeaderIdx !== -1 ? headers.splice(acceptHeaderIdx, 1).map((h) => h.value) : [];
-  const [contentTypeValue] = contentTypeIdx !== -1 ? headers.splice(contentTypeIdx, 1).map((h) => h.value) : [];
-  let security2;
-  if (item.request.auth) {
-    const schemeId = processAuthScheme(item.request.auth, securitySchemes);
-    if (schemeId) {
-      security2 = [{ [schemeId]: [] }];
-    }
-  }
-  return {
-    path: `/${url.path.join("/")}`.replace(/:([^/]+)/g, "{$1}"),
-    method: (item.request.method ?? "get").toLowerCase(),
-    operation: {
-      summary: item.name,
-      description: descriptionToText(item.request.description),
-      parameters,
-      security: security2,
-      responses: !item.response || item.response.length === 0 ? {
-        200: {
-          description: "Successful response"
-        }
-      } : item.response.reduce((acc, response) => {
-        const headers2 = coerceResponseHeader(response.header);
-        const contentTypeIdx2 = headers2.findIndex(
-          (h) => h.key.toLowerCase() === "content-type"
-        );
-        const [contentTypeValue2] = contentTypeIdx2 !== -1 ? headers2.splice(contentTypeIdx2).map((h) => h.value) : [];
-        let contentType = response.body ? parse2(contentTypeValue2 || "application/json")?.type : null;
-        contentType ??= "application/octet-stream";
-        return {
-          ...acc,
-          [response.code ?? 200]: {
-            description: response.name ? response.name : `Response for ${response.code}`,
-            content: {
-              [contentType]: {
-                schema: bodyToSchema(response.body)
-              }
-            }
-          }
-        };
-      }, {}),
-      requestBody: item.request.body ? requestBodyToOperationBody(
-        contentTypeValue || "application/json",
-        item.request.body
-      ) : void 0
-    }
-  };
-}
-function requestBodyToOperationBody(contentType, body) {
-  if (body.mode === "raw") {
-    return {
-      content: {
-        [contentType]: {
-          schema: bodyToSchema(body.raw)
-        }
-      }
-    };
-  } else if (body.mode === "urlencoded") {
-    const properties = {};
-    (body.urlencoded || []).filter((param) => !param.disabled).forEach((param) => {
-      properties[param.key] = {
-        type: "string",
-        description: descriptionToText(param.description)
-      };
-    });
-    return {
-      content: {
-        "application/x-www-form-urlencoded": {
-          schema: {
-            type: "object",
-            properties
-          }
-        }
-      }
-    };
-  } else if (body.mode === "formdata") {
-    const properties = {};
-    (body.formdata || []).filter((param) => !param.disabled).forEach((param) => {
-      if (param.type === "text") {
-        properties[param.key] = {
-          type: "string",
-          description: descriptionToText(param.description)
-        };
-      } else if (param.type === "file") {
-        properties[param.key] = {
-          type: "string",
-          format: "binary",
-          description: descriptionToText(param.description)
-        };
-      }
-    });
-    return {
-      content: {
-        "multipart/form-data": {
-          schema: {
-            type: "object",
-            properties
-          }
-        }
-      }
-    };
-  }
-  throw new Error(
-    `Unsupported request body mode: ${body.mode}. Supported modes are: raw, urlencoded, formdata`
-  );
-}
-function bodyToSchema(bodyString) {
-  if (!bodyString) {
-    return void 0;
-  }
-  let body;
-  try {
-    body = JSON.parse(bodyString.normalize("NFKD"));
-  } catch (error) {
-    console.warn(
-      `Failed to parse JSON body: ${bodyString}. Treating as plain string.`,
-      error
-    );
-    return { type: "string", example: bodyString };
-  }
-  return toSchema(body);
-}
-function toSchema(body) {
-  const typeMap = {
-    "<number>": "number",
-    "<string>": "string",
-    "<boolean>": "boolean",
-    false: "boolean",
-    true: "boolean"
-  };
-  if (Array.isArray(body)) {
-    return {
-      type: "array",
-      items: toSchema(body[0])
-    };
-  }
-  if (typeof body === "object" && body !== null) {
-    const properties = {};
-    for (const [key, value] of Object.entries(body)) {
-      properties[key] = toSchema(value);
-    }
-    return {
-      type: "object",
-      properties
-    };
-  }
-  if (typeof body === "string") {
-    return {
-      type: typeMap[body] ?? "string"
-    };
-  }
-  if (typeof body === "number") {
-    return {
-      type: "number"
-    };
-  }
-  if (typeof body === "boolean") {
-    return {
-      type: "boolean"
-    };
-  }
-  if (body === null) {
-    return {
-      type: "null"
-    };
-  }
-  console.warn(`Unknown type for body: ${body}. Defaulting to string.`, body);
-  return {
-    type: "string"
-  };
-}
-function convertPostmanToOpenAPI(collection) {
-  const tags = [];
-  const paths = {};
-  const securitySchemes = {};
-  if (collection.auth) {
-    processAuthScheme(collection.auth, securitySchemes);
-  }
-  processItems(collection.item, [], tags, paths, securitySchemes);
-  return {
-    openapi: "3.1.0",
-    info: {
-      title: collection.info.name,
-      version: "1.0.0",
-      description: descriptionToText(collection.info.description)
-    },
-    tags,
-    paths,
-    // Only add security at top level if there's collection auth
-    security: collection.auth ? generateSecurityRequirement(collection.auth, securitySchemes) : void 0,
-    components: Object.keys(securitySchemes).length > 0 ? {
-      securitySchemes
-    } : void 0
-  };
-}
-
-// packages/spec/src/lib/loaders/remote-loader.ts
-import { extname as extname2 } from "node:path";
-import { parse as parse3 } from "yaml";
-async function loadRemote(location) {
-  const extName = extname2(location);
-  const response = await fetch(location);
-  if (!response.ok) {
-    throw new Error(`Failed to fetch ${location}: ${response.statusText}`);
-  }
-  switch (extName) {
-    case ".json":
-      return response.json();
-    case ".yaml":
-    case ".yml": {
-      const text = await response.text();
-      return parse3(text);
-    }
-    default:
-      try {
-        return response.json();
-      } catch {
-        const text = await response.text();
-        return parse3(text);
-      }
-  }
-}
-
-// packages/spec/src/lib/loaders/load-spec.ts
-function isPostman(content) {
-  return typeof content === "object" && content !== null && "info" in content && typeof content.info === "object" && content.info !== null && "item" in content && Array.isArray(content.item) && "schema" in content.info && typeof content.info.schema === "string" && content.info.schema.includes("//schema.getpostman.com/");
-}
-async function loadSpec(location) {
-  let content = await loadFile(location);
-  if (isPostman(content)) {
-    content = convertPostmanToOpenAPI(content);
-  }
-  return content;
-}
-function loadFile(location) {
-  const [protocol] = location.split(":");
-  if (protocol === "http" || protocol === "https") {
-    return loadRemote(location);
-  }
-  return loadLocal(location);
-}
-
-// packages/spec/src/lib/metadata.ts
-import deubg from "debug";
-import { readFile as readFile2, unlink, writeFile } from "node:fs/promises";
-import { availableParallelism } from "node:os";
-import { join } from "node:path";
-import pLimit from "p-limit";
-import {
-  addLeadingSlash,
-  exist,
-  readFolder
-} from "@sdk-it/core/file-system.js";
-var log = deubg("sdk-it:metdata");
-async function readWriteJson(path) {
-  const content = await exist(path) ? JSON.parse(await readFile2(path, "utf-8")) : {};
-  return {
-    content,
-    write: (value = content) => writeFile(path, JSON.stringify(value, null, 2), "utf-8")
-  };
-}
-async function readWriteMetadata(output, files) {
-  const metadata = await readWriteJson(join(output, "metadata.json"));
-  metadata.content.generatedFiles = files;
-  metadata.content.userFiles ??= ["/dist/**", "/build/**", "/readme.md"];
-  await metadata.write(metadata.content);
-  return metadata;
-}
-async function cleanFiles(metadata, output, alwaysAvailableFiles = []) {
-  const { default: micromatch } = await import("micromatch");
-  const generated = metadata.generatedFiles ?? [];
-  const user = metadata.userFiles ?? [];
-  const keep = [...generated, ...user, ...alwaysAvailableFiles];
-  const actualFiles = (await readFolder(output, true)).map(addLeadingSlash);
-  const filesToDelete = actualFiles.filter(
-    (file) => !micromatch.isMatch(file, keep, { cwd: join(process.cwd(), output) })
-  );
-  const limit = pLimit(availableParallelism());
-  await Promise.all(
-    filesToDelete.map(
-      (file) => limit(async () => {
-        const filePath = join(output, file);
-        await unlink(filePath);
-        log(`Deleted file: ${filePath}`);
-      })
-    )
-  );
-}
-
-// packages/spec/src/lib/sidebar.ts
-import { camelcase as camelcase3 } from "stringcase";
-function createOAIMeta(spec) {
-  spec.paths ??= {};
-  const navigationGroups = {
-    default: { id: "default", title: "General" }
-  };
-  const groups = {};
-  forEachOperation(spec, (entry, operation) => {
-    const tag = entry.tag;
-    groups[tag] ??= {
-      id: tag,
-      title: tag,
-      description: spec.tags?.find((t) => t.name === tag)?.description,
-      navigationGroup: "default",
-      sections: []
-    };
-    groups[tag].sections.push({
-      type: "endpoint",
-      key: operation.operationId,
-      path: entry.path
-    });
-  });
-  return {
-    groups: Object.values(groups),
-    navigationGroups: Object.values(navigationGroups)
-  };
-}
-function getOperationById(spec, operationId) {
-  let operation;
-  forEachOperation(spec, (entry, op) => {
-    if (op.operationId === operationId) {
-      operation = op;
-    }
-  });
-  return operation;
-}
-function toSidebar(spec) {
-  const openapi = spec;
-  const sidebar = [];
-  const oaiMeta = openapi["x-oaiMeta"] ?? createOAIMeta(spec);
-  for (const navGroup of oaiMeta.navigationGroups) {
-    const group = oaiMeta.groups.filter(
-      (group2) => group2.navigationGroup === navGroup.id
-    );
-    if (group.length === 0)
-      continue;
-    const groupItems = [];
-    for (const item of group) {
-      const subitems = (item.sections ?? []).filter((it) => it.type === "endpoint").map((section) => {
-        const operation = getOperationById(spec, section.key);
-        const title = operation?.["x-oaiMeta"]?.name || operation?.summary || section.key;
-        return {
-          id: section.key,
-          title,
-          url: `${item.id}/${camelcase3(section.key)}`
-        };
-      });
-      if (subitems.length === 0)
-        continue;
-      groupItems.push({
-        id: item.id,
-        title: item.title,
-        url: `/${item.id}`,
-        description: item.description,
-        items: subitems
-      });
-    }
-    if (groupItems.length === 0)
-      continue;
-    sidebar.push({
-      category: navGroup.title,
-      items: groupItems
-    });
-  }
-  return sidebar;
-}
-export {
-  augmentSpec,
-  cleanFiles,
-  coerceTypes,
-  createOperation,
-  defaults,
-  determineGenericTag,
-  expandSpec,
-  findPolymorphicVarients,
-  findVarients,
-  fixSpec,
-  forEachOperation,
-  formatName,
-  getRefUsage,
-  isErrorStatusCode,
-  isPrimitiveSchema,
-  isSseContentType,
-  isStreamingContentType,
-  isSuccessStatusCode,
-  isTextContentType,
-  loadFile,
-  loadLocal,
-  loadRemote,
-  loadSpec,
-  parseJsonContentType,
-  patchParameters,
-  readWriteJson,
-  readWriteMetadata,
-  sanitizeTag,
-  security,
-  securityToOptions,
-  toSidebar
-};
+export * from "./lib/find-polymorphic-varients.js";
+export * from "./lib/find-unique-schema-name.js";
+export * from "./lib/for-each-operation.js";
+export * from "./lib/format-name.js";
+export * from "./lib/get-ref-usage.js";
+export * from "./lib/is-primitive-schema.js";
+export * from "./lib/is.js";
+export * from "./lib/loaders/load-spec.js";
+export * from "./lib/loaders/local-loader.js";
+export * from "./lib/loaders/remote-loader.js";
+export * from "./lib/metadata.js";
+export * from "./lib/operation.js";
+export * from "./lib/options.js";
+export * from "./lib/reserved-keywords.js";
+export * from "./lib/security.js";
+export * from "./lib/sidebar.js";
+export * from "./lib/tag.js";
+export * from "./lib/tune.js";
+export * from "./lib/types.js";
 //# sourceMappingURL=index.js.map