@scalar/workspace-store 0.3.2 → 0.4.0

package/dist/navigation/helpers/traverse-schemas.d.ts

@@ -0,0 +1,16 @@
+import type { TagsMap, TraversedSchema, TraverseSpecOptions } from '../../navigation/types.js';
+import type { OpenAPIV3_1 } from '@scalar/openapi-types';
+/** Traverses the schemas in an OpenAPI document to build an array of model entries.
+ *
+ * This function processes each schema in components.schemas to:
+ * - Filter out internal schemas (marked with x-internal) and schemas to ignore (marked with x-scalar-ignore)
+ * - Create model entries with unique references and IDs
+ * - Store model IDs and titles for mobile header navigation
+ *
+ * @param content - The OpenAPI document to traverse
+ * @param titlesMap - Map to store schema IDs and titles for mobile header navigation
+ * @param getModelId - Function to generate unique IDs for schemas
+ * @returns Array of traversed schema entries
+ */
+export declare const traverseSchemas: (content: OpenAPIV3_1.Document, tagsMap: TagsMap, titlesMap: Map<string, string>, getModelId: TraverseSpecOptions["getModelId"]) => TraversedSchema[];
+//# sourceMappingURL=traverse-schemas.d.ts.map

package/dist/navigation/helpers/traverse-schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"traverse-schemas.d.ts","sourceRoot":"","sources":["../../../src/navigation/helpers/traverse-schemas.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,eAAe,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAA;AACvF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AA6BxD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,eAAe,YACjB,WAAW,CAAC,QAAQ,WAEpB,OAAO,aAEL,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,cAClB,mBAAmB,CAAC,YAAY,CAAC,KAC5C,eAAe,EAyBjB,CAAA"}

package/dist/navigation/helpers/traverse-schemas.js

@@ -0,0 +1,35 @@
+import { getTag } from "../../navigation/helpers/get-tag.js";
+const createModelEntry = (ref, name = "Unknown", titlesMap, getModelId, tag) => {
+  const id = getModelId({ name }, tag);
+  titlesMap.set(id, name);
+  return {
+    id,
+    title: name,
+    name,
+    ref,
+    type: "model"
+  };
+};
+const traverseSchemas = (content, tagsMap, titlesMap, getModelId) => {
+  const schemas = content.components?.schemas ?? {};
+  const untagged = [];
+  for (const name in schemas) {
+    if (schemas[name]["x-internal"] || schemas[name]["x-scalar-ignore"] || !Object.hasOwn(schemas, name)) {
+      continue;
+    }
+    const ref = `#/content/components/schemas/${name}`;
+    if (schemas[name]["x-tags"]?.length) {
+      schemas[name]["x-tags"].forEach((tagName) => {
+        const { tag } = getTag(tagsMap, tagName);
+        tagsMap.get(tagName)?.entries.push(createModelEntry(ref, name, titlesMap, getModelId, tag));
+      });
+    } else {
+      untagged.push(createModelEntry(ref, name, titlesMap, getModelId));
+    }
+  }
+  return untagged;
+};
+export {
+  traverseSchemas
+};
+//# sourceMappingURL=traverse-schemas.js.map

package/dist/navigation/helpers/traverse-schemas.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/navigation/helpers/traverse-schemas.ts"],
+  "sourcesContent": ["import { getTag } from '@/navigation/helpers/get-tag'\nimport type { TagsMap, TraversedSchema, TraverseSpecOptions } from '@/navigation/types'\nimport type { OpenAPIV3_1 } from '@scalar/openapi-types'\n\n/** Creates a traversed schema entry from an OpenAPI schema object.\n *\n * @param ref - JSON pointer reference to the schema in the OpenAPI document\n * @param name - Name of the schema, defaults to 'Unknown'\n * @param titlesMap - Map to store schema IDs and titles for mobile header navigation\n * @param getModelId - Function to generate unique IDs for schemas\n * @returns A traversed schema entry with ID, title, name and reference\n */\nconst createModelEntry = (\n  ref: string,\n  name = 'Unknown',\n  titlesMap: Map<string, string>,\n  getModelId: TraverseSpecOptions['getModelId'],\n  tag?: OpenAPIV3_1.TagObject,\n): TraversedSchema => {\n  const id = getModelId({ name }, tag)\n  titlesMap.set(id, name)\n\n  return {\n    id,\n    title: name,\n    name,\n    ref,\n    type: 'model',\n  }\n}\n\n/** Traverses the schemas in an OpenAPI document to build an array of model entries.\n *\n * This function processes each schema in components.schemas to:\n * - Filter out internal schemas (marked with x-internal) and schemas to ignore (marked with x-scalar-ignore)\n * - Create model entries with unique references and IDs\n * - Store model IDs and titles for mobile header navigation\n *\n * @param content - The OpenAPI document to traverse\n * @param titlesMap - Map to store schema IDs and titles for mobile header navigation\n * @param getModelId - Function to generate unique IDs for schemas\n * @returns Array of traversed schema entries\n */\nexport const traverseSchemas = (\n  content: OpenAPIV3_1.Document,\n  /** Map of tagNames and their entries */\n  tagsMap: TagsMap,\n  /** Map of titles for the mobile header */\n  titlesMap: Map<string, string>,\n  getModelId: TraverseSpecOptions['getModelId'],\n): TraversedSchema[] => {\n  const schemas = content.components?.schemas ?? {}\n  const untagged: TraversedSchema[] = []\n\n  for (const name in schemas) {\n    if (schemas[name]['x-internal'] || schemas[name]['x-scalar-ignore'] || !Object.hasOwn(schemas, name)) {\n      continue\n    }\n\n    const ref = `#/content/components/schemas/${name}`\n\n    // Add to tags\n    if (schemas[name]['x-tags']?.length) {\n      schemas[name]['x-tags'].forEach((tagName: string) => {\n        const { tag } = getTag(tagsMap, tagName)\n        tagsMap.get(tagName)?.entries.push(createModelEntry(ref, name, titlesMap, getModelId, tag))\n      })\n    }\n    // Add to untagged\n    else {\n      untagged.push(createModelEntry(ref, name, titlesMap, getModelId))\n    }\n  }\n\n  return untagged\n}\n"],
+  "mappings": "AAAA,SAAS,cAAc;AAYvB,MAAM,mBAAmB,CACvB,KACA,OAAO,WACP,WACA,YACA,QACoB;AACpB,QAAM,KAAK,WAAW,EAAE,KAAK,GAAG,GAAG;AACnC,YAAU,IAAI,IAAI,IAAI;AAEtB,SAAO;AAAA,IACL;AAAA,IACA,OAAO;AAAA,IACP;AAAA,IACA;AAAA,IACA,MAAM;AAAA,EACR;AACF;AAcO,MAAM,kBAAkB,CAC7B,SAEA,SAEA,WACA,eACsB;AACtB,QAAM,UAAU,QAAQ,YAAY,WAAW,CAAC;AAChD,QAAM,WAA8B,CAAC;AAErC,aAAW,QAAQ,SAAS;AAC1B,QAAI,QAAQ,IAAI,EAAE,YAAY,KAAK,QAAQ,IAAI,EAAE,iBAAiB,KAAK,CAAC,OAAO,OAAO,SAAS,IAAI,GAAG;AACpG;AAAA,IACF;AAEA,UAAM,MAAM,gCAAgC,IAAI;AAGhD,QAAI,QAAQ,IAAI,EAAE,QAAQ,GAAG,QAAQ;AACnC,cAAQ,IAAI,EAAE,QAAQ,EAAE,QAAQ,CAAC,YAAoB;AACnD,cAAM,EAAE,IAAI,IAAI,OAAO,SAAS,OAAO;AACvC,gBAAQ,IAAI,OAAO,GAAG,QAAQ,KAAK,iBAAiB,KAAK,MAAM,WAAW,YAAY,GAAG,CAAC;AAAA,MAC5F,CAAC;AAAA,IACH,OAEK;AACH,eAAS,KAAK,iBAAiB,KAAK,MAAM,WAAW,UAAU,CAAC;AAAA,IAClE;AAAA,EACF;AAEA,SAAO;AACT;",
+  "names": []
+}

package/dist/navigation/helpers/traverse-tags.d.ts

@@ -0,0 +1,15 @@
+import type { OpenAPIV3_1 } from '@scalar/openapi-types';
+import type { TagsMap, TraversedEntry, TraverseSpecOptions } from '../../navigation/types.js';
+type Options = Pick<TraverseSpecOptions, 'getTagId' | 'tagsSorter' | 'operationsSorter'>;
+/**
+ * Traverses the tags map to create navigation entries, handling both grouped and ungrouped tags.
+ *
+ * This function processes the OpenAPI document's tags to:
+ * - Handle tag groups if specified via x-tagGroups
+ * - Sort tags and their operations according to provided sorters
+ * - Create navigation entries for each tag or tag group
+ * - Flatten default tag entries if it's the only tag present
+ */
+export declare const traverseTags: (content: OpenAPIV3_1.Document, tagsMap: TagsMap, titlesMap: Map<string, string>, { getTagId, tagsSorter, operationsSorter }: Options) => TraversedEntry[];
+export {};
+//# sourceMappingURL=traverse-tags.d.ts.map

package/dist/navigation/helpers/traverse-tags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"traverse-tags.d.ts","sourceRoot":"","sources":["../../../src/navigation/helpers/traverse-tags.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAGxD,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAgB,mBAAmB,EAAE,MAAM,oBAAoB,CAAA;AAEpG,KAAK,OAAO,GAAG,IAAI,CAAC,mBAAmB,EAAE,UAAU,GAAG,YAAY,GAAG,kBAAkB,CAAC,CAAA;AA2HxF;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY,YACd,WAAW,CAAC,QAAQ,WAEpB,OAAO,aAEL,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,8CACc,OAAO,KAClD,cAAc,EAyBhB,CAAA"}

package/dist/navigation/helpers/traverse-tags.js

@@ -0,0 +1,77 @@
+import { getTag } from "./get-tag.js";
+const createTagEntry = (tag, titlesMap, getTagId, children, isGroup = false) => {
+  const id = getTagId(tag);
+  const title = tag["x-displayName"] || tag.name || "Untitled Tag";
+  titlesMap.set(id, title);
+  return {
+    id,
+    title,
+    name: tag.name || title,
+    children,
+    isGroup,
+    type: "tag"
+  };
+};
+const getSortedTagEntries = (_keys, tagsMap, titlesMap, { getTagId, tagsSorter, operationsSorter }) => {
+  const hasDefault = _keys.includes("default");
+  const keys = hasDefault ? _keys.filter((key) => key !== "default") : _keys;
+  if (tagsSorter === "alpha") {
+    keys.sort((a, b) => {
+      const nameA = getTag(tagsMap, a).tag["x-displayName"] || a || "Untitle Tag";
+      const nameB = getTag(tagsMap, b).tag["x-displayName"] || b || "Untitled Tag";
+      return nameA.localeCompare(nameB);
+    });
+  } else if (typeof tagsSorter === "function") {
+    keys.sort((a, b) => tagsSorter(getTag(tagsMap, a).tag, getTag(tagsMap, b).tag));
+  }
+  if (hasDefault) {
+    keys.push("default");
+  }
+  return keys.flatMap((key) => {
+    const { tag, entries } = getTag(tagsMap, key);
+    if (tag["x-internal"] || tag["x-scalar-ignore"]) {
+      return [];
+    }
+    if (operationsSorter === "alpha") {
+      entries.sort((a, b) => "method" in a && "method" in b ? a.title.localeCompare(b.title) : 0);
+    } else if (operationsSorter === "method") {
+      entries.sort((a, b) => "method" in a && "method" in b ? a.method.localeCompare(b.method) : 0);
+    } else if (typeof operationsSorter === "function") {
+      entries.sort((a, b) => {
+        if (a.type !== "operation" && a.type !== "webhook" || b.type !== "operation" && b.type !== "webhook") {
+          return 0;
+        }
+        const pathA = a.type === "operation" ? a.path : a.name;
+        const pathB = b.type === "operation" ? b.path : b.name;
+        return operationsSorter(
+          { method: a.method, path: pathA, ref: a.ref },
+          { method: b.method, path: pathB, ref: b.ref }
+        );
+      });
+    }
+    return entries.length ? createTagEntry(tag, titlesMap, getTagId, entries) : [];
+  });
+};
+const traverseTags = (content, tagsMap, titlesMap, { getTagId, tagsSorter, operationsSorter }) => {
+  if (content["x-tagGroups"]) {
+    const tagGroups = content["x-tagGroups"];
+    return tagGroups.flatMap((tagGroup) => {
+      const entries = getSortedTagEntries(tagGroup.tags ?? [], tagsMap, titlesMap, {
+        getTagId,
+        tagsSorter,
+        operationsSorter
+      });
+      return entries.length ? createTagEntry(tagGroup, titlesMap, getTagId, entries, true) : [];
+    });
+  }
+  const keys = Array.from(tagsMap.keys());
+  const tags = getSortedTagEntries(keys, tagsMap, titlesMap, { getTagId, tagsSorter, operationsSorter });
+  if (tags.length === 1 && tags[0].title === "default") {
+    return tags[0].children ?? [];
+  }
+  return tags;
+};
+export {
+  traverseTags
+};
+//# sourceMappingURL=traverse-tags.js.map

package/dist/navigation/helpers/traverse-tags.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/navigation/helpers/traverse-tags.ts"],
+  "sourcesContent": ["import type { OpenAPIV3_1 } from '@scalar/openapi-types'\n\nimport { getTag } from './get-tag'\nimport type { TagsMap, TraversedEntry, TraversedTag, TraverseSpecOptions } from '@/navigation/types'\n\ntype Options = Pick<TraverseSpecOptions, 'getTagId' | 'tagsSorter' | 'operationsSorter'>\n\n/** Creates a traversed tag entry from an OpenAPI tag object.\n *\n * @param tag - The OpenAPI tag object\n * @param titlesMap - Map to store tag IDs and titles for mobile header navigation\n * @param getTagId - Function to generate unique IDs for tags\n * @param children - Array of child entries (operations, webhooks, etc.)\n * @param isGroup - Whether this tag represents a group of tags\n * @returns A traversed tag entry with ID, title, name and children\n */\nconst createTagEntry = (\n  tag: OpenAPIV3_1.TagObject,\n  titlesMap: Map<string, string>,\n  getTagId: TraverseSpecOptions['getTagId'],\n  children: TraversedEntry[],\n  isGroup = false,\n): TraversedTag => {\n  const id = getTagId(tag)\n  const title = tag['x-displayName'] || tag.name || 'Untitled Tag'\n  titlesMap.set(id, title)\n\n  return {\n    id,\n    title,\n    name: tag.name || title,\n    children,\n    isGroup,\n    type: 'tag',\n  }\n}\n\n/** Sorts and processes tags to create a hierarchical structure of tag entries.\n *\n * This function handles:\n * - Sorting tags alphabetically or using a custom sort function\n * - Ensuring the default tag appears last\n * - Sorting operations within tags by title, method, or custom function\n * - Filtering out internal and ignored tags\n * - Creating tag entries with their associated operations\n *\n * @param _keys - Array of tag keys to process\n * @param tagsMap - Map of tags and their entries\n * @param tagsDict - Dictionary of OpenAPI tags by name\n * @param titlesMap - Map of titles for the mobile header\n * @param options - Sorting and ID generation options\n * @returns Array of processed and sorted tag entries\n */\n/** Sorts tags and returns entries */\nconst getSortedTagEntries = (\n  _keys: string[],\n  /** Map of tags and their entries */\n  tagsMap: TagsMap,\n  /** Map of titles for the mobile header */\n  titlesMap: Map<string, string>,\n  { getTagId, tagsSorter, operationsSorter }: Options,\n) => {\n  // Ensure that default is last if it exists\n  const hasDefault = _keys.includes('default')\n  const keys = hasDefault ? _keys.filter((key) => key !== 'default') : _keys\n\n  // Alpha sort\n  if (tagsSorter === 'alpha') {\n    keys.sort((a, b) => {\n      const nameA = getTag(tagsMap, a).tag['x-displayName'] || a || 'Untitle Tag'\n      const nameB = getTag(tagsMap, b).tag['x-displayName'] || b || 'Untitled Tag'\n      return nameA.localeCompare(nameB)\n    })\n  }\n  // Custom sort\n  else if (typeof tagsSorter === 'function') {\n    keys.sort((a, b) => tagsSorter(getTag(tagsMap, a).tag, getTag(tagsMap, b).tag))\n  }\n\n  if (hasDefault) {\n    keys.push('default')\n  }\n\n  /**\n   * Process each tag and its entries:\n   * - Skip internal and ignored tags\n   * - Sort operations within tags\n   * - Create tag entries with sorted operations\n   */\n  return keys.flatMap((key) => {\n    const { tag, entries } = getTag(tagsMap, key)\n\n    // Skip if the tag is internal or scalar-ignore\n    if (tag['x-internal'] || tag['x-scalar-ignore']) {\n      return []\n    }\n\n    // Alpha sort\n    if (operationsSorter === 'alpha') {\n      entries.sort((a, b) => ('method' in a && 'method' in b ? a.title.localeCompare(b.title) : 0))\n    }\n    // Method sort\n    else if (operationsSorter === 'method') {\n      entries.sort((a, b) => ('method' in a && 'method' in b ? a.method.localeCompare(b.method) : 0))\n    }\n    // Custom sort\n    else if (typeof operationsSorter === 'function') {\n      entries.sort((a, b) => {\n        // Guard against tags\n        if ((a.type !== 'operation' && a.type !== 'webhook') || (b.type !== 'operation' && b.type !== 'webhook')) {\n          return 0\n        }\n\n        // Handle webhooks as well as operations\n        const pathA = a.type === 'operation' ? a.path : a.name\n        const pathB = b.type === 'operation' ? b.path : b.name\n\n        return operationsSorter(\n          { method: a.method, path: pathA, ref: a.ref },\n          { method: b.method, path: pathB, ref: b.ref },\n        )\n      })\n    }\n\n    return entries.length ? createTagEntry(tag, titlesMap, getTagId, entries) : []\n  })\n}\n\n/**\n * Traverses the tags map to create navigation entries, handling both grouped and ungrouped tags.\n *\n * This function processes the OpenAPI document's tags to:\n * - Handle tag groups if specified via x-tagGroups\n * - Sort tags and their operations according to provided sorters\n * - Create navigation entries for each tag or tag group\n * - Flatten default tag entries if it's the only tag present\n */\nexport const traverseTags = (\n  content: OpenAPIV3_1.Document,\n  /** Map of tags and their entries */\n  tagsMap: TagsMap,\n  /** Map of titles for the mobile title */\n  titlesMap: Map<string, string>,\n  { getTagId, tagsSorter, operationsSorter }: Options,\n): TraversedEntry[] => {\n  // x-tagGroups\n  if (content['x-tagGroups']) {\n    const tagGroups = content['x-tagGroups'] as { tags: string[] }[]\n\n    return tagGroups.flatMap((tagGroup) => {\n      const entries = getSortedTagEntries(tagGroup.tags ?? [], tagsMap, titlesMap, {\n        getTagId,\n        tagsSorter,\n        operationsSorter,\n      })\n      return entries.length ? createTagEntry(tagGroup, titlesMap, getTagId, entries, true) : []\n    })\n  }\n\n  // Ungrouped regular tags\n  const keys = Array.from(tagsMap.keys())\n  const tags = getSortedTagEntries(keys, tagsMap, titlesMap, { getTagId, tagsSorter, operationsSorter })\n\n  // Flatten if we only have default tag\n  if (tags.length === 1 && tags[0].title === 'default') {\n    return tags[0].children ?? []\n  }\n\n  return tags\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/navigation/helpers/traverse-webhooks.d.ts

@@ -0,0 +1,19 @@
+import type { OpenAPIV3_1 } from '@scalar/openapi-types';
+import type { TagsMap, TraversedWebhook, TraverseSpecOptions } from '../../navigation/types.js';
+/** Traverses the webhooks in an OpenAPI document to build an array of webhook entries.
+ *
+ * This function processes each webhook in the document to:
+ * - Filter out internal webhooks (marked with x-internal) and webhooks to ignore (marked with x-scalar-ignore)
+ * - Group webhooks by their tags
+ * - Create webhook entries with unique references and IDs
+ * - Store webhook IDs and titles for mobile header navigation
+ *
+ * @param content - The OpenAPI document to traverse
+ * @param tagsMap - Map of tag names to arrays of traversed entries from operations
+ * @param tagsDict - Dictionary mapping tag names to their OpenAPI tag objects
+ * @param titlesMap - Map to store webhook IDs and titles for mobile header navigation
+ * @param getWebhookId - Function to generate unique IDs for webhooks
+ * @returns Array of untagged webhook entries
+ */
+export declare const traverseWebhooks: (content: OpenAPIV3_1.Document, tagsMap: TagsMap, titlesMap: Map<string, string>, getWebhookId: TraverseSpecOptions["getWebhookId"]) => TraversedWebhook[];
+//# sourceMappingURL=traverse-webhooks.d.ts.map

package/dist/navigation/helpers/traverse-webhooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"traverse-webhooks.d.ts","sourceRoot":"","sources":["../../../src/navigation/helpers/traverse-webhooks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAGxD,OAAO,KAAK,EAAE,OAAO,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAA;AAmCxF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB,YAClB,WAAW,CAAC,QAAQ,WAEpB,OAAO,aAEL,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,gBAChB,mBAAmB,CAAC,cAAc,CAAC,KAChD,gBAAgB,EAiClB,CAAA"}

package/dist/navigation/helpers/traverse-webhooks.js

@@ -0,0 +1,40 @@
+import { getTag } from "./get-tag.js";
+const createWebhookEntry = (ref, method, name = "Unknown", title = "Unknown", titlesMap, getWebhookId, tag) => {
+  const id = getWebhookId({ name, method }, tag);
+  titlesMap.set(id, title);
+  return {
+    id,
+    title,
+    name,
+    ref,
+    method,
+    type: "webhook"
+  };
+};
+const traverseWebhooks = (content, tagsMap, titlesMap, getWebhookId) => {
+  const untagged = [];
+  Object.entries(content.webhooks ?? {}).forEach(([name, pathItemObject]) => {
+    const pathEntries = Object.entries(pathItemObject ?? {});
+    pathEntries.forEach(([method, operation]) => {
+      const ref = `#/webhooks/${name}/${method}`;
+      if (operation["x-internal"] || operation["x-scalar-ignore"]) {
+        return;
+      }
+      if (operation.tags?.length) {
+        operation.tags.forEach((tagName) => {
+          const { tag } = getTag(tagsMap, tagName);
+          tagsMap.get(tagName)?.entries.push(
+            createWebhookEntry(ref, method, name, operation.summary ?? name, titlesMap, getWebhookId, tag)
+          );
+        });
+      } else {
+        untagged.push(createWebhookEntry(ref, method, name, operation.summary ?? name, titlesMap, getWebhookId));
+      }
+    });
+  });
+  return untagged;
+};
+export {
+  traverseWebhooks
+};
+//# sourceMappingURL=traverse-webhooks.js.map

package/dist/navigation/helpers/traverse-webhooks.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/navigation/helpers/traverse-webhooks.ts"],
+  "sourcesContent": ["import type { OpenAPIV3_1 } from '@scalar/openapi-types'\n\nimport { getTag } from './get-tag'\nimport type { TagsMap, TraversedWebhook, TraverseSpecOptions } from '@/navigation/types'\n\n/** Creates a traversed webhook entry from an OpenAPI webhook object.\n *\n * @param ref - JSON pointer reference to the webhook in the OpenAPI document\n * @param method - HTTP method of the webhook\n * @param name - Name of the webhook, defaults to 'Unknown'\n * @param title - Title of the webhook, defaults to 'Unknown'\n * @param titlesMap - Map to store webhook IDs and titles for mobile header navigation\n * @param getWebhookId - Function to generate unique IDs for webhooks\n * @param tag - Optional tag object associated with the webhook\n * @returns A traversed webhook entry with ID, title, name, method and reference\n */\nconst createWebhookEntry = (\n  ref: string,\n  method: OpenAPIV3_1.HttpMethods,\n  name = 'Unknown',\n  title = 'Unknown',\n  titlesMap: Map<string, string>,\n  getWebhookId: TraverseSpecOptions['getWebhookId'],\n  tag?: OpenAPIV3_1.TagObject,\n): TraversedWebhook => {\n  const id = getWebhookId({ name, method }, tag)\n  titlesMap.set(id, title)\n\n  return {\n    id,\n    title,\n    name,\n    ref,\n    method: method,\n    type: 'webhook',\n  }\n}\n\n/** Traverses the webhooks in an OpenAPI document to build an array of webhook entries.\n *\n * This function processes each webhook in the document to:\n * - Filter out internal webhooks (marked with x-internal) and webhooks to ignore (marked with x-scalar-ignore)\n * - Group webhooks by their tags\n * - Create webhook entries with unique references and IDs\n * - Store webhook IDs and titles for mobile header navigation\n *\n * @param content - The OpenAPI document to traverse\n * @param tagsMap - Map of tag names to arrays of traversed entries from operations\n * @param tagsDict - Dictionary mapping tag names to their OpenAPI tag objects\n * @param titlesMap - Map to store webhook IDs and titles for mobile header navigation\n * @param getWebhookId - Function to generate unique IDs for webhooks\n * @returns Array of untagged webhook entries\n */\nexport const traverseWebhooks = (\n  content: OpenAPIV3_1.Document,\n  /** The tag map from from traversing paths */\n  tagsMap: TagsMap,\n  /** Map of titles for the mobile title */\n  titlesMap: Map<string, string>,\n  getWebhookId: TraverseSpecOptions['getWebhookId'],\n): TraversedWebhook[] => {\n  const untagged: TraversedWebhook[] = []\n\n  // Traverse webhooks\n  Object.entries(content.webhooks ?? {}).forEach(([name, pathItemObject]) => {\n    const pathEntries = Object.entries(pathItemObject ?? {}) as [OpenAPIV3_1.HttpMethods, OpenAPIV3_1.OperationObject][]\n\n    pathEntries.forEach(([method, operation]) => {\n      const ref = `#/webhooks/${name}/${method}`\n\n      // Skip if the operation is internal or scalar-ignore\n      if (operation['x-internal'] || operation['x-scalar-ignore']) {\n        return\n      }\n\n      if (operation.tags?.length) {\n        operation.tags.forEach((tagName: string) => {\n          const { tag } = getTag(tagsMap, tagName)\n          tagsMap\n            .get(tagName)\n            ?.entries.push(\n              createWebhookEntry(ref, method, name, operation.summary ?? name, titlesMap, getWebhookId, tag),\n            )\n        })\n      }\n      // Add to untagged\n      else {\n        untagged.push(createWebhookEntry(ref, method, name, operation.summary ?? name, titlesMap, getWebhookId))\n      }\n    })\n  })\n\n  return untagged\n}\n"],
+  "mappings": "AAEA,SAAS,cAAc;AAcvB,MAAM,qBAAqB,CACzB,KACA,QACA,OAAO,WACP,QAAQ,WACR,WACA,cACA,QACqB;AACrB,QAAM,KAAK,aAAa,EAAE,MAAM,OAAO,GAAG,GAAG;AAC7C,YAAU,IAAI,IAAI,KAAK;AAEvB,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,MAAM;AAAA,EACR;AACF;AAiBO,MAAM,mBAAmB,CAC9B,SAEA,SAEA,WACA,iBACuB;AACvB,QAAM,WAA+B,CAAC;AAGtC,SAAO,QAAQ,QAAQ,YAAY,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,MAAM,cAAc,MAAM;AACzE,UAAM,cAAc,OAAO,QAAQ,kBAAkB,CAAC,CAAC;AAEvD,gBAAY,QAAQ,CAAC,CAAC,QAAQ,SAAS,MAAM;AAC3C,YAAM,MAAM,cAAc,IAAI,IAAI,MAAM;AAGxC,UAAI,UAAU,YAAY,KAAK,UAAU,iBAAiB,GAAG;AAC3D;AAAA,MACF;AAEA,UAAI,UAAU,MAAM,QAAQ;AAC1B,kBAAU,KAAK,QAAQ,CAAC,YAAoB;AAC1C,gBAAM,EAAE,IAAI,IAAI,OAAO,SAAS,OAAO;AACvC,kBACG,IAAI,OAAO,GACV,QAAQ;AAAA,YACR,mBAAmB,KAAK,QAAQ,MAAM,UAAU,WAAW,MAAM,WAAW,cAAc,GAAG;AAAA,UAC/F;AAAA,QACJ,CAAC;AAAA,MACH,OAEK;AACH,iBAAS,KAAK,mBAAmB,KAAK,QAAQ,MAAM,UAAU,WAAW,MAAM,WAAW,YAAY,CAAC;AAAA,MACzG;AAAA,IACF,CAAC;AAAA,EACH,CAAC;AAED,SAAO;AACT;",
+  "names": []
+}

package/dist/navigation/helpers/utils.d.ts

@@ -0,0 +1,39 @@
+import type { Heading } from '../../navigation/types.js';
+/**
+ * Extracts all headings from a Markdown string and adds URL-friendly slugs to each heading.
+ * Uses GithubSlugger to generate consistent slugs that match GitHub's heading anchor format.
+ *
+ * @param input - The Markdown string to extract headings from
+ * @returns Array of heading objects containing value, depth, and slug
+ *
+ * @example
+ * const markdown = `
+ * # Getting Started
+ * ## Installation
+ * ### Requirements
+ * `
+ * const headings = getHeadingsFromMarkdown(markdown)
+ * // Returns:
+ * // [
+ * //   { value: 'Getting Started', depth: 1, slug: 'getting-started' },
+ * //   { value: 'Installation', depth: 2, slug: 'installation' },
+ * //   { value: 'Requirements', depth: 3, slug: 'requirements' }
+ * // ]
+ */
+export declare function getHeadingsFromMarkdown(input: string): Heading[];
+export type HeadingLevels = 1 | 2 | 3 | 4 | 5 | 6;
+/**
+ * Returns the lowest heading level from a list of headings.
+ *
+ * @param headings - Array of heading objects containing depth property
+ * @returns The lowest heading level (1-6) or 1 if no valid headings found
+ *
+ * @example
+ * const headings = [
+ *   { value: 'Getting Started', depth: 1 },
+ *   { value: 'Installation', depth: 2 }
+ * ]
+ * getLowestHeadingLevel(headings) // Returns: 1
+ */
+export declare const getLowestHeadingLevel: (headings: Heading[]) => HeadingLevels;
+//# sourceMappingURL=utils.d.ts.map

package/dist/navigation/helpers/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/navigation/helpers/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAA;AAiCjD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,EAAE,CAMhE;AAED,MAAM,MAAM,aAAa,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;AAEjD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,qBAAqB,aAAc,OAAO,EAAE,KAAG,aAQ3D,CAAA"}

package/dist/navigation/helpers/utils.js

@@ -0,0 +1,25 @@
+import { getHeadings } from "@scalar/code-highlight/markdown";
+import GithubSlugger from "github-slugger";
+const withSlugs = (headings, slugger) => headings.map((heading) => {
+  return {
+    ...heading,
+    slug: slugger.slug(heading.value)
+  };
+});
+function getHeadingsFromMarkdown(input) {
+  const slugger = new GithubSlugger();
+  const headings = getHeadings(input);
+  return withSlugs(headings, slugger);
+}
+const getLowestHeadingLevel = (headings) => {
+  const lowestLevel = Math.min(...headings.map((heading) => heading.depth));
+  if (lowestLevel >= 1 && lowestLevel <= 6) {
+    return lowestLevel;
+  }
+  return 1;
+};
+export {
+  getHeadingsFromMarkdown,
+  getLowestHeadingLevel
+};
+//# sourceMappingURL=utils.js.map

package/dist/navigation/helpers/utils.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/navigation/helpers/utils.ts"],
+  "sourcesContent": ["import type { Heading } from '@/navigation/types'\nimport { getHeadings } from '@scalar/code-highlight/markdown'\nimport GithubSlugger from 'github-slugger'\n\n/**\n * Adds URL-friendly slugs to each heading in the array.\n * Uses GithubSlugger to generate consistent slugs that match GitHub's heading anchor format.\n *\n * @param headings - Array of heading objects containing value and depth\n * @param slugger - GithubSlugger instance for generating consistent slugs\n * @returns Array of headings with added slug property\n *\n * @example\n * const headings = [\n *   { value: 'Getting Started', depth: 1 },\n *   { value: 'Installation', depth: 2 }\n * ]\n * const slugger = new GithubSlugger()\n * withSlugs(headings, slugger)\n * // Returns:\n * // [\n * //   { value: 'Getting Started', depth: 1, slug: 'getting-started' },\n * //   { value: 'Installation', depth: 2, slug: 'installation' }\n * // ]\n */\nconst withSlugs = (headings: Heading[], slugger: GithubSlugger): Heading[] =>\n  headings.map((heading) => {\n    return {\n      ...heading,\n      slug: slugger.slug(heading.value),\n    }\n  })\n\n/**\n * Extracts all headings from a Markdown string and adds URL-friendly slugs to each heading.\n * Uses GithubSlugger to generate consistent slugs that match GitHub's heading anchor format.\n *\n * @param input - The Markdown string to extract headings from\n * @returns Array of heading objects containing value, depth, and slug\n *\n * @example\n * const markdown = `\n * # Getting Started\n * ## Installation\n * ### Requirements\n * `\n * const headings = getHeadingsFromMarkdown(markdown)\n * // Returns:\n * // [\n * //   { value: 'Getting Started', depth: 1, slug: 'getting-started' },\n * //   { value: 'Installation', depth: 2, slug: 'installation' },\n * //   { value: 'Requirements', depth: 3, slug: 'requirements' }\n * // ]\n */\nexport function getHeadingsFromMarkdown(input: string): Heading[] {\n  const slugger = new GithubSlugger()\n\n  const headings = getHeadings(input)\n\n  return withSlugs(headings as Heading[], slugger)\n}\n\nexport type HeadingLevels = 1 | 2 | 3 | 4 | 5 | 6\n\n/**\n * Returns the lowest heading level from a list of headings.\n *\n * @param headings - Array of heading objects containing depth property\n * @returns The lowest heading level (1-6) or 1 if no valid headings found\n *\n * @example\n * const headings = [\n *   { value: 'Getting Started', depth: 1 },\n *   { value: 'Installation', depth: 2 }\n * ]\n * getLowestHeadingLevel(headings) // Returns: 1\n */\nexport const getLowestHeadingLevel = (headings: Heading[]): HeadingLevels => {\n  const lowestLevel = Math.min(...headings.map((heading) => heading.depth))\n\n  if (lowestLevel >= 1 && lowestLevel <= 6) {\n    return lowestLevel as HeadingLevels\n  }\n\n  return 1\n}\n"],
+  "mappings": "AACA,SAAS,mBAAmB;AAC5B,OAAO,mBAAmB;AAuB1B,MAAM,YAAY,CAAC,UAAqB,YACtC,SAAS,IAAI,CAAC,YAAY;AACxB,SAAO;AAAA,IACL,GAAG;AAAA,IACH,MAAM,QAAQ,KAAK,QAAQ,KAAK;AAAA,EAClC;AACF,CAAC;AAuBI,SAAS,wBAAwB,OAA0B;AAChE,QAAM,UAAU,IAAI,cAAc;AAElC,QAAM,WAAW,YAAY,KAAK;AAElC,SAAO,UAAU,UAAuB,OAAO;AACjD;AAiBO,MAAM,wBAAwB,CAAC,aAAuC;AAC3E,QAAM,cAAc,KAAK,IAAI,GAAG,SAAS,IAAI,CAAC,YAAY,QAAQ,KAAK,CAAC;AAExE,MAAI,eAAe,KAAK,eAAe,GAAG;AACxC,WAAO;AAAA,EACT;AAEA,SAAO;AACT;",
+  "names": []
+}

package/dist/navigation/index.d.ts

@@ -0,0 +1,3 @@
+export type { TraverseSpecOptions as createNavigationOptions } from './types.js';
+export { traverseDocument as createNavigation } from './helpers/traverse-document.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/navigation/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/navigation/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,mBAAmB,IAAI,uBAAuB,EAAE,MAAM,SAAS,CAAA;AAG7E,OAAO,EAAE,gBAAgB,IAAI,gBAAgB,EAAE,MAAM,6BAA6B,CAAA"}

package/dist/navigation/index.js

@@ -0,0 +1,5 @@
+import { traverseDocument } from "./helpers/traverse-document.js";
+export {
+  traverseDocument as createNavigation
+};
+//# sourceMappingURL=index.js.map

package/dist/navigation/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/navigation/index.ts"],
+  "sourcesContent": ["export type { TraverseSpecOptions as createNavigationOptions } from './types'\n\n// biome-ignore lint/performance/noBarrelFile: <explanation>\nexport { traverseDocument as createNavigation } from './helpers/traverse-document'\n"],
+  "mappings": "AAGA,SAA6B,wBAAwB;",
+  "names": []
+}

package/dist/navigation/types.d.ts

@@ -0,0 +1,94 @@
+import type { OpenAPIV3_1 } from '@scalar/openapi-types';
+/** Map of tagNames and their entries */
+export type TagsMap = Map<string, {
+    tag: OpenAPIV3_1.TagObject;
+    entries: TraversedEntry[];
+}>;
+type TraverseEntryBase = {
+    type: 'text' | 'operation' | 'model' | 'tag' | 'webhook';
+    id: string;
+    title: string;
+};
+/** Description entry returned form traversing the document */
+export type TraversedDescription = TraverseEntryBase & {
+    type: 'text';
+    children?: TraverseEntryBase[];
+};
+/** Operation entry returned form traversing the document */
+export type TraversedOperation = TraverseEntryBase & {
+    type: 'operation';
+    ref: string;
+    method: OpenAPIV3_1.HttpMethods;
+    path: string;
+};
+/** Model entry returned form traversing the document */
+export type TraversedSchema = TraverseEntryBase & {
+    type: 'model';
+    ref: string;
+    name: string;
+};
+/** Tag entry returned form traversing the document, includes tagGroups */
+export type TraversedTag = TraverseEntryBase & {
+    type: 'tag';
+    name: string;
+    children?: TraversedEntry[];
+    isGroup: boolean;
+};
+/** Webhook entry returned form traversing the document, basically the same as an operation but with name instead of path */
+export type TraversedWebhook = TraverseEntryBase & {
+    type: 'webhook';
+    ref: string;
+    method: OpenAPIV3_1.HttpMethods;
+    name: string;
+};
+/** Entries returned form traversing the document */
+export type TraversedEntry = TraversedDescription | TraversedOperation | TraversedSchema | TraversedTag | TraversedWebhook;
+type OperationSortValue = {
+    method: string;
+    path: string;
+    ref: string;
+};
+/** Configuration options for traversing an OpenAPI specification document.
+ *
+ * These options control how the document is processed and organized, including:
+ * - Sorting of tags and operations
+ * - Visibility of models
+ * - ID generation for various elements (headings, operations, webhooks, models, tags)
+ */
+export type TraverseSpecOptions = {
+    /** Controls how tags are sorted - either alphabetically or using a custom sort function */
+    tagsSorter: 'alpha' | ((a: OpenAPIV3_1.TagObject, b: OpenAPIV3_1.TagObject) => number);
+    /** Controls how operations are sorted - alphabetically, by method, or using a custom sort function */
+    operationsSorter: 'alpha' | 'method' | ((a: OperationSortValue, b: OperationSortValue) => number);
+    /** Whether to hide model schemas from the navigation */
+    hideModels: boolean;
+    /** Function to generate unique IDs for markdown headings */
+    getHeadingId: (heading: {
+        depth: number;
+        value: string;
+        slug?: string;
+    }) => string;
+    /** Function to generate unique IDs for operations */
+    getOperationId: (operation: {
+        path: string;
+        method: OpenAPIV3_1.HttpMethods;
+    } & OpenAPIV3_1.OperationObject, parentTag: OpenAPIV3_1.TagObject) => string;
+    /** Function to generate unique IDs for webhooks */
+    getWebhookId: (webhook?: {
+        name: string;
+        method?: string;
+    }, parentTag?: OpenAPIV3_1.TagObject) => string;
+    /** Function to generate unique IDs for models/schemas */
+    getModelId: (model?: {
+        name: string;
+    }, parentTag?: OpenAPIV3_1.TagObject) => string;
+    /** Function to generate unique IDs for tags */
+    getTagId: (tag: OpenAPIV3_1.TagObject) => string;
+};
+export type Heading = {
+    depth: number;
+    value: string;
+    slug?: string;
+};
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/navigation/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/navigation/types.ts"],"names":[],"mappings":"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"}

package/dist/navigation/types.js

@@ -0,0 +1 @@
+//# sourceMappingURL=types.js.map

package/dist/navigation/types.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/schemas/extensions.d.ts

@@ -0,0 +1,14 @@
+export declare const extensions: {
+    readonly document: {
+        readonly navigation: "x-scalar-navigation";
+        readonly activeAuth: "x-scalar-active-auth";
+        readonly activeServer: "x-scalar-active-server";
+    };
+    readonly workspace: {
+        readonly darkMode: "x-scalar-dark-mode";
+        readonly defaultClient: "x-scalar-default-client";
+        readonly activeDocument: "x-scalar-active-document";
+        readonly theme: "x-scalar-theme";
+    };
+};
+//# sourceMappingURL=extensions.d.ts.map

package/dist/schemas/extensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extensions.d.ts","sourceRoot":"","sources":["../../src/schemas/extensions.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,UAAU;;;;;;;;;;;;CAYb,CAAA"}

package/dist/schemas/extensions.js

@@ -0,0 +1,17 @@
+const extensions = {
+  document: {
+    navigation: "x-scalar-navigation",
+    activeAuth: "x-scalar-active-auth",
+    activeServer: "x-scalar-active-server"
+  },
+  workspace: {
+    darkMode: "x-scalar-dark-mode",
+    defaultClient: "x-scalar-default-client",
+    activeDocument: "x-scalar-active-document",
+    theme: "x-scalar-theme"
+  }
+};
+export {
+  extensions
+};
+//# sourceMappingURL=extensions.js.map

package/dist/schemas/extensions.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/schemas/extensions.ts"],
+  "sourcesContent": ["export const extensions = {\n  document: {\n    navigation: 'x-scalar-navigation',\n    activeAuth: 'x-scalar-active-auth',\n    activeServer: 'x-scalar-active-server',\n  },\n  workspace: {\n    darkMode: 'x-scalar-dark-mode',\n    defaultClient: 'x-scalar-default-client',\n    activeDocument: 'x-scalar-active-document',\n    theme: 'x-scalar-theme',\n  },\n} as const\n"],
+  "mappings": "AAAO,MAAM,aAAa;AAAA,EACxB,UAAU;AAAA,IACR,YAAY;AAAA,IACZ,YAAY;AAAA,IACZ,cAAc;AAAA,EAChB;AAAA,EACA,WAAW;AAAA,IACT,UAAU;AAAA,IACV,eAAe;AAAA,IACf,gBAAgB;AAAA,IAChB,OAAO;AAAA,EACT;AACF;",
+  "names": []
+}

package/dist/schemas/{callback.d.ts.map → openapi-v3/callback.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"callback.d.ts","sourceRoot":"","sources":["../../src/schemas/callback.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAI1B,CAAA"}
+{"version":3,"file":"callback.d.ts","sourceRoot":"","sources":["../../../src/schemas/openapi-v3/callback.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAI1B,CAAA"}

package/dist/schemas/{callback.js.map → openapi-v3/callback.js.map}

@@ -1,6 +1,6 @@
 {
   "version": 3,
-  "sources": ["../../src/schemas/callback.ts"],
+  "sources": ["../../../src/schemas/openapi-v3/callback.ts"],
   "sourcesContent": ["import { Type } from '@sinclair/typebox'\nimport { PathItemObject } from './path-item'\n\n/**\n * A map of possible out-of band callbacks related to the parent operation. Each value in the map is a Path Item Object that describes a set of requests that may be initiated by the API provider and the expected responses. The key value used to identify the Path Item Object is an expression, evaluated at runtime, that identifies a URL to use for the callback operation.\n *\n * To describe incoming requests from the API provider independent from another API call, use the webhooks field.\n */\nexport const CallbackObject = Type.Record(\n  Type.String(),\n  /** A Path Item Object used to define a callback request and expected responses. A complete example is available. */\n  PathItemObject,\n)\n"],
   "mappings": "AAAA,SAAS,YAAY;AACrB,SAAS,sBAAsB;AAOxB,MAAM,iBAAiB,KAAK;AAAA,EACjC,KAAK,OAAO;AAAA;AAAA,EAEZ;AACF;",
   "names": []

package/dist/schemas/{components.d.ts.map → openapi-v3/components.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"components.d.ts","sourceRoot":"","sources":["../../src/schemas/components.ts"],"names":[],"mappings":"AAaA,kOAAkO;AAClO,eAAO,MAAM,gBAAgB;IAC3B,iDAAiD;;;;;;;;;;;;;;;;;;;IAEjD,mDAAmD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEnD,oDAAoD;;;;;;;;;;;;;;;IAEpD,kDAAkD;;;;;;;;;;;;;IAElD,uDAAuD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEvD,iDAAiD;;;;;;;;;;;;IAEjD,0DAA0D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAE1D,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;IAE/C,mDAAmD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEnD,oDAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEpD,CAAA"}
+{"version":3,"file":"components.d.ts","sourceRoot":"","sources":["../../../src/schemas/openapi-v3/components.ts"],"names":[],"mappings":"AAaA,kOAAkO;AAClO,eAAO,MAAM,gBAAgB;IAC3B,iDAAiD;;;;;;;;;;;;;;;;;;;IAEjD,mDAAmD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEnD,oDAAoD;;;;;;;;;;;;;;;IAEpD,kDAAkD;;;;;;;;;;;;;IAElD,uDAAuD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEvD,iDAAiD;;;;;;;;;;;;IAEjD,0DAA0D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAE1D,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;IAE/C,mDAAmD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEnD,oDAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEpD,CAAA"}

package/dist/schemas/{components.js.map → openapi-v3/components.js.map}

@@ -1,6 +1,6 @@
 {
   "version": 3,
-  "sources": ["../../src/schemas/components.ts"],
+  "sources": ["../../../src/schemas/openapi-v3/components.ts"],
   "sourcesContent": ["import { Type } from '@sinclair/typebox'\nimport { SchemaObject } from './schema'\nimport { ResponseObject } from './response'\nimport { ReferenceObject } from './reference'\nimport { ParameterObject } from './parameter'\nimport { ExampleObject } from './example'\nimport { RequestBodyObject } from './request-body'\nimport { SecuritySchemeObject } from './security-scheme'\nimport { LinkObject } from './link'\nimport { CallbackObject } from './callback'\nimport { PathItemObject } from './path-item'\nimport { HeaderObject } from './header'\n\n/** Holds a set of reusable objects for different aspects of the OAS. All objects defined within the Components Object will have no effect on the API unless they are explicitly referenced from outside the Components Object. */\nexport const ComponentsObject = Type.Object({\n  /** An object to hold reusable Schema Objects. */\n  schemas: Type.Optional(Type.Record(Type.String(), SchemaObject)),\n  /** An object to hold reusable Response Objects. */\n  responses: Type.Optional(Type.Record(Type.String(), Type.Union([ResponseObject, ReferenceObject]))),\n  /** An object to hold reusable Parameter Objects. */\n  parameters: Type.Optional(Type.Record(Type.String(), Type.Union([ParameterObject, ReferenceObject]))),\n  /** An object to hold reusable Example Objects. */\n  examples: Type.Optional(Type.Record(Type.String(), Type.Union([ExampleObject, ReferenceObject]))),\n  /** An object to hold reusable Request Body Objects. */\n  requestBodies: Type.Optional(Type.Record(Type.String(), Type.Union([RequestBodyObject, ReferenceObject]))),\n  /** An object to hold reusable Header Objects. */\n  headers: Type.Optional(Type.Record(Type.String(), Type.Union([HeaderObject, ReferenceObject]))),\n  /** An object to hold reusable Security Scheme Objects. */\n  securitySchemes: Type.Optional(Type.Record(Type.String(), Type.Union([SecuritySchemeObject, ReferenceObject]))),\n  /** An object to hold reusable Link Objects. */\n  links: Type.Optional(Type.Record(Type.String(), Type.Union([LinkObject, ReferenceObject]))),\n  /** An object to hold reusable Callback Objects. */\n  callbacks: Type.Optional(Type.Record(Type.String(), Type.Union([CallbackObject, ReferenceObject]))),\n  /** An object to hold reusable Path Item Objects. */\n  pathItems: Type.Optional(Type.Record(Type.String(), PathItemObject)),\n})\n"],
   "mappings": "AAAA,SAAS,YAAY;AACrB,SAAS,oBAAoB;AAC7B,SAAS,sBAAsB;AAC/B,SAAS,uBAAuB;AAChC,SAAS,uBAAuB;AAChC,SAAS,qBAAqB;AAC9B,SAAS,yBAAyB;AAClC,SAAS,4BAA4B;AACrC,SAAS,kBAAkB;AAC3B,SAAS,sBAAsB;AAC/B,SAAS,sBAAsB;AAC/B,SAAS,oBAAoB;AAGtB,MAAM,mBAAmB,KAAK,OAAO;AAAA;AAAA,EAE1C,SAAS,KAAK,SAAS,KAAK,OAAO,KAAK,OAAO,GAAG,YAAY,CAAC;AAAA;AAAA,EAE/D,WAAW,KAAK,SAAS,KAAK,OAAO,KAAK,OAAO,GAAG,KAAK,MAAM,CAAC,gBAAgB,eAAe,CAAC,CAAC,CAAC;AAAA;AAAA,EAElG,YAAY,KAAK,SAAS,KAAK,OAAO,KAAK,OAAO,GAAG,KAAK,MAAM,CAAC,iBAAiB,eAAe,CAAC,CAAC,CAAC;AAAA;AAAA,EAEpG,UAAU,KAAK,SAAS,KAAK,OAAO,KAAK,OAAO,GAAG,KAAK,MAAM,CAAC,eAAe,eAAe,CAAC,CAAC,CAAC;AAAA;AAAA,EAEhG,eAAe,KAAK,SAAS,KAAK,OAAO,KAAK,OAAO,GAAG,KAAK,MAAM,CAAC,mBAAmB,eAAe,CAAC,CAAC,CAAC;AAAA;AAAA,EAEzG,SAAS,KAAK,SAAS,KAAK,OAAO,KAAK,OAAO,GAAG,KAAK,MAAM,CAAC,cAAc,eAAe,CAAC,CAAC,CAAC;AAAA;AAAA,EAE9F,iBAAiB,KAAK,SAAS,KAAK,OAAO,KAAK,OAAO,GAAG,KAAK,MAAM,CAAC,sBAAsB,eAAe,CAAC,CAAC,CAAC;AAAA;AAAA,EAE9G,OAAO,KAAK,SAAS,KAAK,OAAO,KAAK,OAAO,GAAG,KAAK,MAAM,CAAC,YAAY,eAAe,CAAC,CAAC,CAAC;AAAA;AAAA,EAE1F,WAAW,KAAK,SAAS,KAAK,OAAO,KAAK,OAAO,GAAG,KAAK,MAAM,CAAC,gBAAgB,eAAe,CAAC,CAAC,CAAC;AAAA;AAAA,EAElG,WAAW,KAAK,SAAS,KAAK,OAAO,KAAK,OAAO,GAAG,cAAc,CAAC;AACrE,CAAC;",
   "names": []

package/dist/schemas/openapi-v3/contact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contact.d.ts","sourceRoot":"","sources":["../../../src/schemas/openapi-v3/contact.ts"],"names":[],"mappings":"AAEA,+CAA+C;AAC/C,eAAO,MAAM,aAAa;IACxB,+DAA+D;;IAE/D,8EAA8E;;IAE9E,0GAA0G;;EAE1G,CAAA"}

package/dist/schemas/{contact.js.map → openapi-v3/contact.js.map}

@@ -1,6 +1,6 @@
 {
   "version": 3,
-  "sources": ["../../src/schemas/contact.ts"],
+  "sources": ["../../../src/schemas/openapi-v3/contact.ts"],
   "sourcesContent": ["import { Type } from '@sinclair/typebox'\n\n/** Contact information for the exposed API. */\nexport const ContactObject = Type.Object({\n  /** The identifying name of the contact person/organization. */\n  name: Type.Optional(Type.String()),\n  /** The URI for the contact information. This MUST be in the form of a URI. */\n  url: Type.Optional(Type.String()),\n  /** The email address of the contact person/organization. This MUST be in the form of an email address. */\n  email: Type.Optional(Type.String()),\n})\n"],
   "mappings": "AAAA,SAAS,YAAY;AAGd,MAAM,gBAAgB,KAAK,OAAO;AAAA;AAAA,EAEvC,MAAM,KAAK,SAAS,KAAK,OAAO,CAAC;AAAA;AAAA,EAEjC,KAAK,KAAK,SAAS,KAAK,OAAO,CAAC;AAAA;AAAA,EAEhC,OAAO,KAAK,SAAS,KAAK,OAAO,CAAC;AACpC,CAAC;",
   "names": []

package/dist/schemas/openapi-v3/discriminator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discriminator.d.ts","sourceRoot":"","sources":["../../../src/schemas/openapi-v3/discriminator.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,eAAO,MAAM,mBAAmB;IAC9B,mNAAmN;;IAEnN,4FAA4F;;EAE5F,CAAA"}