@sdk-it/spec 0.20.0 → 0.22.0

package/dist/index.js

@@ -1,3 +1,2630 @@
-export * from "./lib/loaders/load-spec.js";
-export * from "./lib/operation.js";
+// 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
+};
 //# sourceMappingURL=index.js.map