@scalar/api-client 2.38.1 → 2.38.2

package/dist/views/Request/RequestSection/index.js

@@ -1,6 +1,43 @@
-import { filterSecurityRequirements as r } from "./helpers/filter-security-requirements.js";
-import { default as f } from "./RequestSection.vue.js";
-export {
-  f as RequestSection,
-  r as filterSecurityRequirements
+import "../../../CodeInput-C-igR77V.js";
+import "../../../DataTableInput-yaU5g-kP.js";
+import "../../../SectionFilter-hrtoRLwj.js";
+import { t as RequestSection_default } from "../../../RequestSection-HhdJj9hW.js";
+import "../../../RequestAuth-BzBfIysT.js";
+//#region src/views/Request/RequestSection/helpers/filter-security-requirements.ts
+/**
+* Takes in selected security and filters it with the requirements
+*/
+var filterSecurityRequirements = (securityRequirements, selectedSecuritySchemeUids = [], securitySchemes = {}) => {
+	if (!securityRequirements || securityRequirements.length === 0) return [];
+	const nonOptionalRequirements = securityRequirements.filter((requirement) => Object.keys(requirement).length > 0);
+	if (nonOptionalRequirements.length === 0) return [];
+	if (selectedSecuritySchemeUids.length === 0) {
+		const firstRequirement = nonOptionalRequirements[0];
+		const firstSchemeNameKey = firstRequirement ? Object.keys(firstRequirement)[0] : void 0;
+		const matchingScheme = Object.values(securitySchemes).find((scheme) => scheme.nameKey === firstSchemeNameKey);
+		return matchingScheme ? [matchingScheme] : [];
+	}
+	const requiredCombinations = new Set(nonOptionalRequirements.map((requirement) => Object.keys(requirement).sort().join(",")));
+	const result = [];
+	for (const uids of selectedSecuritySchemeUids) {
+		const schemeUids = Array.isArray(uids) ? uids : [uids];
+		const validSchemes = [];
+		const nameKeys = [];
+		for (const uid of schemeUids) {
+			const scheme = securitySchemes[uid];
+			if (scheme?.nameKey) {
+				validSchemes.push(scheme);
+				nameKeys.push(scheme.nameKey);
+			}
+		}
+		if (nameKeys.length > 0) {
+			const key = nameKeys.sort().join(",");
+			if (requiredCombinations.has(key)) result.push(...validSchemes);
+		}
+	}
+	return result;
 };
+//#endregion
+export { RequestSection_default as RequestSection, filterSecurityRequirements };
+
+//# sourceMappingURL=index.js.map

package/dist/views/Request/RequestSection/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../../src/views/Request/RequestSection/helpers/filter-security-requirements.ts"],"sourcesContent":["import type { Collection, SecurityScheme } from '@scalar/oas-utils/entities/spec'\n\n/**\n * Takes in selected security and filters it with the requirements\n */\nexport const filterSecurityRequirements = (\n  securityRequirements: Collection['security'],\n  selectedSecuritySchemeUids: Collection['selectedSecuritySchemeUids'] = [],\n  securitySchemes: Record<string, SecurityScheme> = {},\n): SecurityScheme[] => {\n  // Return empty array if no security requirements exist\n  if (!securityRequirements || securityRequirements.length === 0) {\n    return []\n  }\n\n  // Filter out optional security requirements (empty objects)\n  const nonOptionalRequirements = securityRequirements.filter((requirement) => Object.keys(requirement).length > 0)\n\n  // Return empty array if only optional security requirements exist\n  if (nonOptionalRequirements.length === 0) {\n    return []\n  }\n\n  // If no security schemes are selected, return the first available security scheme\n  if (selectedSecuritySchemeUids.length === 0) {\n    const firstRequirement = nonOptionalRequirements[0]\n    const firstSchemeNameKey = firstRequirement ? Object.keys(firstRequirement)[0] : undefined\n\n    // Find the security scheme that matches the first requirement\n    const matchingScheme = Object.values(securitySchemes).find((scheme) => scheme.nameKey === firstSchemeNameKey)\n\n    return matchingScheme ? [matchingScheme] : []\n  }\n\n  // Create a Set of required security combinations for fast lookup\n  const requiredCombinations = new Set(\n    nonOptionalRequirements.map((requirement) => Object.keys(requirement).sort().join(',')),\n  )\n\n  const result: SecurityScheme[] = []\n\n  for (const uids of selectedSecuritySchemeUids) {\n    // Handle both single uid and array of uids\n    const schemeUids = Array.isArray(uids) ? uids : [uids]\n\n    // Get valid schemes and their name keys in one pass\n    const validSchemes: SecurityScheme[] = []\n    const nameKeys: string[] = []\n\n    for (const uid of schemeUids) {\n      const scheme = securitySchemes[uid]\n      if (scheme?.nameKey) {\n        validSchemes.push(scheme)\n        nameKeys.push(scheme.nameKey)\n      }\n    }\n\n    // Check if this combination is required\n    if (nameKeys.length > 0) {\n      const key = nameKeys.sort().join(',')\n      if (requiredCombinations.has(key)) {\n        result.push(...validSchemes)\n      }\n    }\n  }\n\n  return result\n}\n"],"mappings":";;;;;;;;;AAKA,IAAa,8BACX,sBACA,6BAAuE,EAAE,EACzE,kBAAkD,EAAE,KAC/B;AAErB,KAAI,CAAC,wBAAwB,qBAAqB,WAAW,EAC3D,QAAO,EAAE;CAIX,MAAM,0BAA0B,qBAAqB,QAAQ,gBAAgB,OAAO,KAAK,YAAY,CAAC,SAAS,EAAE;AAGjH,KAAI,wBAAwB,WAAW,EACrC,QAAO,EAAE;AAIX,KAAI,2BAA2B,WAAW,GAAG;EAC3C,MAAM,mBAAmB,wBAAwB;EACjD,MAAM,qBAAqB,mBAAmB,OAAO,KAAK,iBAAiB,CAAC,KAAK,KAAA;EAGjF,MAAM,iBAAiB,OAAO,OAAO,gBAAgB,CAAC,MAAM,WAAW,OAAO,YAAY,mBAAmB;AAE7G,SAAO,iBAAiB,CAAC,eAAe,GAAG,EAAE;;CAI/C,MAAM,uBAAuB,IAAI,IAC/B,wBAAwB,KAAK,gBAAgB,OAAO,KAAK,YAAY,CAAC,MAAM,CAAC,KAAK,IAAI,CAAC,CACxF;CAED,MAAM,SAA2B,EAAE;AAEnC,MAAK,MAAM,QAAQ,4BAA4B;EAE7C,MAAM,aAAa,MAAM,QAAQ,KAAK,GAAG,OAAO,CAAC,KAAK;EAGtD,MAAM,eAAiC,EAAE;EACzC,MAAM,WAAqB,EAAE;AAE7B,OAAK,MAAM,OAAO,YAAY;GAC5B,MAAM,SAAS,gBAAgB;AAC/B,OAAI,QAAQ,SAAS;AACnB,iBAAa,KAAK,OAAO;AACzB,aAAS,KAAK,OAAO,QAAQ;;;AAKjC,MAAI,SAAS,SAAS,GAAG;GACvB,MAAM,MAAM,SAAS,MAAM,CAAC,KAAK,IAAI;AACrC,OAAI,qBAAqB,IAAI,IAAI,CAC/B,QAAO,KAAK,GAAG,aAAa;;;AAKlC,QAAO"}

package/dist/views/Request/RequestSidebarItem.vue.d.ts

@@ -1,5 +1,5 @@
 import { type DraggableProps, type DraggingItem, type HoveredItem } from '@scalar/draggable';
-import type { SidebarMenuItem } from '../../views/Request/types/index.js';
+import type { SidebarMenuItem } from '@/views/Request/types';
 type __VLS_Props = {
     /**
      * Toggle dragging on and off

package/dist/views/Request/RequestSidebarItemMenu.vue.d.ts

@@ -1,14 +1,14 @@
-import type { SidebarMenuItem } from '../../views/Request/types/index.js';
+import type { SidebarMenuItem } from '@/views/Request/types';
 type __VLS_Props = {
     menuItem: SidebarMenuItem;
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
     closeMenu: () => any;
-    toggleWatchMode: (item: import("../../views/Request/types/index.js").SidebarItem | undefined) => any;
+    toggleWatchMode: (item: import("@/views/Request/types").SidebarItem | undefined) => any;
     clearDrafts: () => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     onCloseMenu?: (() => any) | undefined;
-    onToggleWatchMode?: ((item: import("../../views/Request/types/index.js").SidebarItem | undefined) => any) | undefined;
+    onToggleWatchMode?: ((item: import("@/views/Request/types").SidebarItem | undefined) => any) | undefined;
     onClearDrafts?: (() => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;

package/dist/views/Request/RequestSubpageHeader.vue.d.ts

@@ -1,7 +1,7 @@
 import type { Environment } from '@scalar/oas-utils/entities/environment';
 import type { Collection, Operation, Server } from '@scalar/oas-utils/entities/spec';
 import type { Workspace } from '@scalar/oas-utils/entities/workspace';
-import type { EnvVariable } from '../../store/active-entities.js';
+import type { EnvVariable } from '@/store/active-entities';
 type __VLS_Props = {
     collection: Collection;
     operation: Operation;

package/dist/views/Request/ResponseSection/ResponseBodyPreview.vue.d.ts

@@ -1,4 +1,4 @@
-import type { MediaPreview } from '../../../views/Request/consts/index.js';
+import type { MediaPreview } from '@/views/Request/consts';
 type __VLS_Props = {
     src: string;
     type: string;

package/dist/views/Request/ResponseSection/ResponseSection.vue.d.ts

@@ -1,6 +1,6 @@
 import type { Collection, Operation, ResponseInstance } from '@scalar/oas-utils/entities/spec';
 import type { Workspace } from '@scalar/oas-utils/entities/workspace';
-import type { SendRequestResult } from '../../../libs/send-request/create-request-operation.js';
+import type { SendRequestResult } from '@/libs/send-request/create-request-operation';
 type __VLS_Props = {
     collection: Collection;
     operation: Operation;

package/dist/views/Request/ResponseSection/index.d.ts

@@ -1,3 +1,3 @@
-export { default as ResponseBody } from './ResponseBody.vue.js';
-export { default as ResponseSection } from './ResponseSection.vue.js';
+export { default as ResponseBody } from './ResponseBody.vue';
+export { default as ResponseSection } from './ResponseSection.vue';
 //# sourceMappingURL=index.d.ts.map

package/dist/views/Request/ResponseSection/index.js

@@ -1,6 +1,7 @@
-import { default as s } from "./ResponseBody.vue.js";
-import { default as a } from "./ResponseSection.vue.js";
-export {
-  s as ResponseBody,
-  a as ResponseSection
-};
+import "../../../CodeInput-C-igR77V.js";
+import "../../../DataTableInput-yaU5g-kP.js";
+import "../../../SectionFilter-hrtoRLwj.js";
+import "../../../ScalarAsciiArt-BjuSnj8e.js";
+import { n as ResponseBody_default, t as ResponseSection_default } from "../../../ResponseSection-DMJ0tw8E.js";
+import "../../../EmptyState-Cnm7hGW5.js";
+export { ResponseBody_default as ResponseBody, ResponseSection_default as ResponseSection };

package/dist/views/Request/components/index.d.ts

@@ -1,2 +1,2 @@
-export { default as WorkspaceDropdown } from './WorkspaceDropdown.vue.js';
+export { default as WorkspaceDropdown } from './WorkspaceDropdown.vue';
 //# sourceMappingURL=index.d.ts.map

package/dist/views/Request/components/index.js

@@ -1,4 +1,2 @@
-import { default as a } from "./WorkspaceDropdown.vue.js";
-export {
-  a as WorkspaceDropdown
-};
+import { t as WorkspaceDropdown_default } from "../../../components-CSxJTn6F.js";
+export { WorkspaceDropdown_default as WorkspaceDropdown };

package/dist/views/Request/consts/index.d.ts

@@ -1,3 +1,3 @@
-export { type MediaConfig, type MediaPreview, getMediaTypeConfig, isTextMediaType, mediaTypes, textMediaTypes, } from './mediaTypes.js';
-export { ADD_AUTH_DICT, ADD_AUTH_OPTIONS, type SecuritySchemeGroup, type SecuritySchemeOption, } from './new-auth-options.js';
+export { type MediaConfig, type MediaPreview, getMediaTypeConfig, isTextMediaType, mediaTypes, textMediaTypes, } from './mediaTypes';
+export { ADD_AUTH_DICT, ADD_AUTH_OPTIONS, type SecuritySchemeGroup, type SecuritySchemeOption, } from './new-auth-options';
 //# sourceMappingURL=index.d.ts.map

package/dist/views/Request/consts/index.js

@@ -1,10 +1,2 @@
-import { getMediaTypeConfig as i, isTextMediaType as p, mediaTypes as t, textMediaTypes as o } from "./mediaTypes.js";
-import { ADD_AUTH_DICT as a, ADD_AUTH_OPTIONS as d } from "./new-auth-options.js";
-export {
-  a as ADD_AUTH_DICT,
-  d as ADD_AUTH_OPTIONS,
-  i as getMediaTypeConfig,
-  p as isTextMediaType,
-  t as mediaTypes,
-  o as textMediaTypes
-};
+import { a as mediaTypes, i as isTextMediaType, n as ADD_AUTH_OPTIONS, o as textMediaTypes, r as getMediaTypeConfig, t as ADD_AUTH_DICT } from "../../../consts-CyGRb9dl.js";
+export { ADD_AUTH_DICT, ADD_AUTH_OPTIONS, getMediaTypeConfig, isTextMediaType, mediaTypes, textMediaTypes };

package/dist/views/Request/handle-drag.d.ts

@@ -1,6 +1,6 @@
 import type { DraggingItem, HoveredItem } from '@scalar/draggable';
-import type { WorkspaceStore } from '../../store/index.js';
-import type { ActiveEntitiesStore } from '../../store/active-entities.js';
+import type { WorkspaceStore } from '@/store';
+import type { ActiveEntitiesStore } from '@/store/active-entities';
 /** Create DnD handlers */
 export declare function dragHandlerFactory(activeWorkspace: ActiveEntitiesStore['activeWorkspace'], { collections, collectionMutators, tags, tagMutators, workspaceMutators }: WorkspaceStore): {
     handleDragEnd: (draggingItem: DraggingItem, hoveredItem: HoveredItem) => void;

package/dist/views/Request/libs/auth.d.ts

@@ -1,5 +1,5 @@
 import type { Collection, Operation, SecurityScheme } from '@scalar/oas-utils/entities/spec';
-import { type SecuritySchemeGroup, type SecuritySchemeOption } from '../../../views/Request/consts/index.js';
+import { type SecuritySchemeGroup, type SecuritySchemeOption } from '@/views/Request/consts';
 type DisplayScheme = {
     type: SecurityScheme['type'] | 'complex';
     nameKey: SecurityScheme['nameKey'];

package/dist/views/Request/libs/index.d.ts

@@ -1,4 +1,4 @@
-export { formatComplexScheme, formatScheme, getSchemeOptions, getSecurityRequirements } from './auth.js';
-export { authorizeOauth2, authorizeServers, generateCodeChallenge } from './oauth2.js';
-export { combineRenameDiffs, findResource, mutateCollectionDiff, mutateRequestDiff, mutateSecuritySchemeDiff, mutateServerDiff, mutateTagDiff, narrowUnionSchema, parseDiff, traverseZodSchema, } from './watch-mode.js';
+export { formatComplexScheme, formatScheme, getSchemeOptions, getSecurityRequirements } from './auth';
+export { authorizeOauth2, authorizeServers, generateCodeChallenge } from './oauth2';
+export { combineRenameDiffs, findResource, mutateCollectionDiff, mutateRequestDiff, mutateSecuritySchemeDiff, mutateServerDiff, mutateTagDiff, narrowUnionSchema, parseDiff, traverseZodSchema, } from './watch-mode';
 //# sourceMappingURL=index.d.ts.map

package/dist/views/Request/libs/index.js

@@ -1,22 +1,3 @@
-import { formatComplexScheme as r, formatScheme as f, getSchemeOptions as m, getSecurityRequirements as o } from "./auth.js";
-import { authorizeOauth2 as i, authorizeServers as u, generateCodeChallenge as c } from "./oauth2.js";
-import { combineRenameDiffs as h, findResource as S, mutateCollectionDiff as s, mutateRequestDiff as D, mutateSecuritySchemeDiff as p, mutateServerDiff as g, mutateTagDiff as l, narrowUnionSchema as x, parseDiff as C, traverseZodSchema as R } from "./watch-mode.js";
-export {
-  i as authorizeOauth2,
-  u as authorizeServers,
-  h as combineRenameDiffs,
-  S as findResource,
-  r as formatComplexScheme,
-  f as formatScheme,
-  c as generateCodeChallenge,
-  m as getSchemeOptions,
-  o as getSecurityRequirements,
-  s as mutateCollectionDiff,
-  D as mutateRequestDiff,
-  p as mutateSecuritySchemeDiff,
-  g as mutateServerDiff,
-  l as mutateTagDiff,
-  x as narrowUnionSchema,
-  C as parseDiff,
-  R as traverseZodSchema
-};
+import { a as formatScheme, i as formatComplexScheme, n as authorizeServers, o as getSchemeOptions, r as generateCodeChallenge, s as getSecurityRequirements, t as authorizeOauth2 } from "../../../libs-spbv4P0g.js";
+import { a as mutateSecuritySchemeDiff, c as narrowUnionSchema, i as mutateRequestDiff, l as parseDiff, n as findResource, o as mutateServerDiff, r as mutateCollectionDiff, s as mutateTagDiff, t as combineRenameDiffs, u as traverseZodSchema } from "../../../watch-mode-Dbaqd9bG.js";
+export { authorizeOauth2, authorizeServers, combineRenameDiffs, findResource, formatComplexScheme, formatScheme, generateCodeChallenge, getSchemeOptions, getSecurityRequirements, mutateCollectionDiff, mutateRequestDiff, mutateSecuritySchemeDiff, mutateServerDiff, mutateTagDiff, narrowUnionSchema, parseDiff, traverseZodSchema };

package/dist/views/Request/libs/oauth2.d.ts

@@ -1,5 +1,5 @@
 import type { Oauth2Flow, Server } from '@scalar/oas-utils/entities/spec';
-import type { ErrorResponse } from '../../../libs/errors.js';
+import type { ErrorResponse } from '@/libs/errors';
 /** Oauth2 security schemes which are not implicit */
 type NonImplicitFlow = Exclude<Oauth2Flow, {
     type: 'implicit';

package/dist/views/Request/libs/watch-mode.d.ts

@@ -1,8 +1,8 @@
 import { type Path, type PathValue } from '@scalar/object-utils/nested';
 import { type Difference } from 'microdiff';
 import { type ZodSchema } from 'zod';
-import type { WorkspaceStore } from '../../../store/index.js';
-import type { ActiveEntitiesStore } from '../../../store/active-entities.js';
+import type { WorkspaceStore } from '@/store';
+import type { ActiveEntitiesStore } from '@/store/active-entities';
 /**
  * Combine Rename Diffs
  * Rename diffs show up as a delete and an add.

package/dist/views/Request/types/index.js

@@ -1 +0,0 @@
-

package/dist/watch-mode-Dbaqd9bG.js

@@ -0,0 +1,375 @@
+import { isHttpMethod, schemaModel } from "@scalar/oas-utils/helpers";
+import { collectionSchema, createExampleFromRequest, requestSchema, securitySchemeSchema, serverSchema, tagSchema } from "@scalar/oas-utils/entities/spec";
+import { z } from "zod";
+import { getNestedValue } from "@scalar/object-utils/nested";
+import microdiff from "microdiff";
+//#region src/views/Request/libs/watch-mode.ts
+/**
+* Combine Rename Diffs
+* Rename diffs show up as a delete and an add.
+* This will go through the diff and combine any diff items which are next to each other which go from remove to add.
+*
+* - first we check if the payloads are the same then it was just a simple rename
+* - next we will add the rename and also handle any changes in the diff
+*/
+var combineRenameDiffs = (diff, pathPrefix = []) => {
+	const combined = [];
+	let skipNext = false;
+	for (let i = 0; i < diff.length; i++) {
+		if (skipNext) {
+			skipNext = false;
+			continue;
+		}
+		const current = diff[i];
+		const next = diff[i + 1];
+		if (!current) continue;
+		if (pathPrefix.length) {
+			current.path = [...pathPrefix, ...current.path];
+			if (next) next.path = [...pathPrefix, ...next.path];
+		} else if (current.path[0] !== "paths") {
+			combined.push(current);
+			continue;
+		}
+		if (current.type === "REMOVE" && next?.type === "CREATE") {
+			const [, currPath, currMethod] = current.path;
+			const [, nextPath, nextMethod] = next.path;
+			const nestedPrefix = ["paths", nextPath].filter((p) => typeof p === "string");
+			if (currPath !== nextPath) combined.push({
+				type: "CHANGE",
+				path: ["paths", "path"],
+				oldValue: currPath,
+				value: nextPath
+			});
+			if (currMethod && typeof nextMethod === "string" && currMethod !== nextMethod && nextPath) {
+				combined.push({
+					type: "CHANGE",
+					path: [
+						"paths",
+						nextPath,
+						"method"
+					],
+					oldValue: currMethod,
+					value: nextMethod
+				});
+				nestedPrefix.push(nextMethod);
+			}
+			if (pathPrefix.length === 0) {
+				const innerDiff = microdiff(current.oldValue, next.value);
+				if (innerDiff.length) {
+					const innerCombined = combineRenameDiffs(innerDiff, nestedPrefix);
+					combined.push(...innerCombined);
+				}
+			}
+			skipNext = true;
+		} else if (current.type === "CREATE" && current.path.length > 3 && typeof current.path.at(-1) !== "number") combined.push({
+			...current,
+			type: "CHANGE",
+			oldValue: void 0
+		});
+		else if (current.type === "REMOVE" && current.path.length > 3 && typeof current.path.at(-1) !== "number") combined.push({
+			...current,
+			type: "CHANGE",
+			value: void 0
+		});
+		else combined.push(current);
+	}
+	return combined;
+};
+/** Like array.find but returns the resource instead of the uid */
+var findResource = (arr, resources, condition) => {
+	for (const uid of arr) {
+		const resource = resources[uid];
+		if (resource && condition(resource)) return resource;
+	}
+	return null;
+};
+/** Helper function to unwrap optional and default schemas */
+var unwrapSchema = (schema) => {
+	if (schema instanceof z.ZodOptional) {
+		const unwrapped = schema.unwrap();
+		if (unwrapped instanceof z.ZodType) return unwrapSchema(unwrapped);
+	}
+	if (schema instanceof z.ZodDefault) {
+		const innerType = schema._zod.def.innerType;
+		if (innerType instanceof z.ZodType) return unwrapSchema(innerType);
+	}
+	if (schema instanceof z.ZodCatch) {
+		const innerType = schema._zod.def.innerType;
+		if (innerType instanceof z.ZodType) return unwrapSchema(innerType);
+	}
+	if (schema instanceof z.ZodPipe) {
+		const inType = schema._zod.def.in;
+		if (inType instanceof z.ZodType) return unwrapSchema(inType);
+	}
+	return schema;
+};
+/**
+* Traverses a zod schema based on the path and returns the schema at the end of the path
+* or null if the path doesn't exist. Handles optional unwrapping, records, and arrays
+*/
+var traverseZodSchema = (schema, path) => {
+	let currentSchema = schema;
+	for (const key of path) {
+		currentSchema = unwrapSchema(currentSchema);
+		if (currentSchema instanceof z.ZodAny) return currentSchema;
+		if (currentSchema instanceof z.ZodObject && typeof key === "string" && key in currentSchema.shape) {
+			const shapeValue = currentSchema.shape[key];
+			if (shapeValue instanceof z.ZodType) currentSchema = shapeValue;
+			else return null;
+		} else if (currentSchema instanceof z.ZodArray) if (typeof key === "number") if (currentSchema.element instanceof z.ZodType) currentSchema = currentSchema.element;
+		else return null;
+		else if (typeof key === "string") {
+			if (currentSchema.element instanceof z.ZodType) currentSchema = currentSchema.element;
+			else return null;
+			if (currentSchema instanceof z.ZodObject && key in currentSchema.shape) {
+				const shapeValue = currentSchema.shape[key];
+				if (shapeValue instanceof z.ZodType) currentSchema = shapeValue;
+				else return null;
+			} else return null;
+		} else return null;
+		else if (currentSchema instanceof z.ZodRecord) {
+			const valueSchema = currentSchema._zod.def.valueType;
+			if (!valueSchema || !(valueSchema instanceof z.ZodType)) return null;
+			if (typeof key === "string") {
+				currentSchema = valueSchema;
+				currentSchema = unwrapSchema(currentSchema);
+			} else if (typeof key === "number") {
+				currentSchema = valueSchema;
+				currentSchema = unwrapSchema(currentSchema);
+				if (currentSchema instanceof z.ZodArray) if (currentSchema.element instanceof z.ZodType) currentSchema = currentSchema.element;
+				else return null;
+			} else currentSchema = valueSchema;
+		} else return null;
+		currentSchema = unwrapSchema(currentSchema);
+	}
+	return currentSchema;
+};
+/**
+* Takes in diff, uses the path to get to the nested schema then parse the value
+* If there is a sub schema and it successfully parses, both the path and new value are valid and returned as such
+*
+* We return a tuple to make it easier to pass into the mutators
+*/
+var parseDiff = (schema, diff) => {
+	const parsedSchema = traverseZodSchema(schema, diff.path);
+	if (!parsedSchema) return null;
+	const path = diff.path.join(".");
+	const pathMinusOne = diff.path.slice(0, -1).join(".");
+	if (diff.type === "REMOVE") return {
+		path,
+		pathMinusOne,
+		value: void 0
+	};
+	const parsedValue = schemaModel(diff.value, parsedSchema, false);
+	if (typeof parsedValue === "undefined" || parsedValue === null) return null;
+	return {
+		path,
+		pathMinusOne,
+		value: parsedValue
+	};
+};
+/**
+* Transforms the diff into a payload for the collection mutator then executes that mutation
+*
+* @returns true if it succeeds, and false for a failure
+*/
+var mutateCollectionDiff = (diff, { activeCollection }, { collectionMutators }) => {
+	if (!activeCollection.value) return false;
+	if (typeof diff.path[diff.path.length - 1] === "number" && (diff.type === "CREATE" || diff.type === "REMOVE")) {
+		const parsed = parseDiff(collectionSchema, {
+			...diff,
+			path: diff.path
+		});
+		if (!parsed) return false;
+		const oldValue = [...getNestedValue(activeCollection.value, parsed.pathMinusOne)];
+		if (diff.type === "CREATE") oldValue.push(parsed.value);
+		else if (diff.type === "REMOVE") oldValue.pop();
+		collectionMutators.edit(activeCollection.value.uid, parsed.pathMinusOne, oldValue);
+	} else {
+		const parsed = parseDiff(collectionSchema, diff);
+		if (!parsed) return false;
+		collectionMutators.edit(activeCollection.value.uid, parsed.path, parsed.value);
+	}
+	return true;
+};
+/**
+* Currently we just generate new examples
+*
+* TODO: diff the changes in the examples and just update what we need to
+*/
+var updateRequestExamples = (requestUid, store) => {
+	const { requests, requestExamples, requestExampleMutators } = store;
+	const request = requests[requestUid];
+	request?.examples.forEach((exampleUid) => {
+		const newExample = createExampleFromRequest(request, requestExamples[exampleUid]?.name ?? "Default");
+		if (newExample) requestExampleMutators.set({
+			...newExample,
+			uid: exampleUid
+		});
+	});
+};
+/**
+* Generates an array of payloads for the request mutator from the request diff, also executes the mutation
+*/
+var mutateRequestDiff = (diff, { activeCollection }, store) => {
+	if (!activeCollection.value) return false;
+	const { requests, requestMutators } = store;
+	const [, path, method, ...keys] = diff.path;
+	if (path === "path" && diff.type === "CHANGE") activeCollection.value.requests.forEach((uid) => {
+		if (requests[uid]?.path === diff.oldValue) requestMutators.edit(uid, "path", diff.value);
+	});
+	else if (method === "method" && diff.type === "CHANGE") activeCollection.value.requests.forEach((uid) => {
+		if (requests[uid]?.method === diff.oldValue && requests[uid]?.path === path) requestMutators.edit(uid, "method", diff.value);
+	});
+	else if (diff.type !== "CHANGE" && typeof keys.at(-1) === "number") {
+		const request = findResource(activeCollection.value.requests, requests, (r) => r.path === path && r.method === method);
+		const parsed = parseDiff(requestSchema, {
+			...diff,
+			path: diff.path.slice(3)
+		});
+		if (!request || !parsed) return false;
+		const oldValue = [...getNestedValue(request, parsed.pathMinusOne)];
+		if (diff.type === "CREATE") oldValue.push(parsed.value);
+		else if (diff.type === "REMOVE") oldValue.pop();
+		requestMutators.edit(request.uid, parsed.pathMinusOne, oldValue);
+		if (diff.path[3] === "parameters" || diff.path[3] === "requestBody") updateRequestExamples(request.uid, store);
+	} else if (diff.type === "CREATE") {
+		const [firstEntry] = Object.entries(diff.value ?? {});
+		const [_method, _operation] = firstEntry ?? [];
+		const operation = method ? diff.value : _operation;
+		const newMethod = method || _method;
+		const operationServers = serverSchema.array().parse(operation.servers ?? []);
+		const { security: operationSecurity, ...operationWithoutSecurity } = operation;
+		const requestPayload = {
+			...operationWithoutSecurity,
+			method: isHttpMethod(newMethod) ? newMethod : "get",
+			path,
+			parameters: operation.parameters ?? [],
+			servers: operationServers.map((s) => s.uid)
+		};
+		if (operationSecurity?.length) requestPayload.security = operationSecurity.map((s) => {
+			if (Object.keys(s).length) {
+				const [key] = Object.keys(s);
+				if (!key) return s;
+				return { [key]: s[key] };
+			}
+			return s;
+		});
+		const request = schemaModel(requestPayload, requestSchema, false);
+		if (!request) return false;
+		requestMutators.add(request, activeCollection.value.uid);
+	} else if (diff.type === "REMOVE") {
+		const request = findResource(activeCollection.value.requests, requests, (_request) => _request.path === path && _request.method === method);
+		if (!request) return false;
+		requestMutators.delete(request, activeCollection.value.uid);
+	} else if (diff.type === "CHANGE") {
+		const request = findResource(activeCollection.value.requests, requests, (r) => r.path === path && r.method === method);
+		const parsed = parseDiff(requestSchema, {
+			...diff,
+			path: keys
+		});
+		if (!request || !parsed) return false;
+		requestMutators.edit(request.uid, parsed.path, parsed.value);
+		if (diff.path[3] === "parameters" || diff.path[3] === "requestBody") updateRequestExamples(request.uid, store);
+	}
+	return true;
+};
+/** Generates a payload for the server mutator from the server diff including the mutator method */
+var mutateServerDiff = (diff, { activeCollection }, { servers, serverMutators }) => {
+	if (!activeCollection.value) return false;
+	const [, index, ...keys] = diff.path;
+	if (keys?.length) {
+		const serverUid = activeCollection.value.servers[index];
+		if (!serverUid) return false;
+		const server = servers[serverUid];
+		const parsed = parseDiff(serverSchema, {
+			...diff,
+			path: keys
+		});
+		if (!server || !parsed) return false;
+		const value = diff.type === "REMOVE" && keys[keys.length - 1] === "variables" ? {} : parsed.value;
+		serverMutators.edit(serverUid, parsed.path, value);
+	} else if (diff.type === "REMOVE") {
+		if (!activeCollection.value.servers[index]) return false;
+		serverMutators.delete(activeCollection.value.servers[index], activeCollection.value.uid);
+	} else if (diff.type === "CREATE") {
+		const parsed = schemaModel(diff.value, serverSchema, false);
+		if (!parsed) return false;
+		serverMutators.add(parsed, activeCollection.value.uid);
+	}
+	return true;
+};
+/** Generates a payload for the tag mutator from the tag diff */
+var mutateTagDiff = (diff, { activeCollection }, { tags, tagMutators }) => {
+	if (!activeCollection.value) return false;
+	const [, index, ...keys] = diff.path;
+	if (keys?.length) {
+		const tagUid = activeCollection.value.tags[index];
+		if (!tagUid) return false;
+		const tag = tags[tagUid];
+		const parsed = parseDiff(tagSchema, {
+			...diff,
+			path: keys
+		});
+		if (!tag || !parsed) return false;
+		tagMutators.edit(tagUid, parsed.path, parsed.value);
+	} else if (diff.type === "REMOVE") {
+		const tagUid = activeCollection.value.tags[index];
+		if (!tagUid) return false;
+		const tag = tags[tagUid];
+		if (!tag) return false;
+		tagMutators.delete(tag, activeCollection.value.uid);
+	} else if (diff.type === "CREATE") {
+		const parsed = schemaModel(diff.value, tagSchema, false);
+		if (!parsed) return false;
+		tagMutators.add(parsed, activeCollection.value.uid);
+	}
+	return true;
+};
+/** Narrows down a zod union schema */
+var narrowUnionSchema = (schema, key, value) => {
+	const _schema = unwrapSchema(schema);
+	if (_schema instanceof z.ZodUnion || _schema instanceof z.ZodDiscriminatedUnion) for (const option of _schema.options) {
+		if (!(option instanceof z.ZodType)) continue;
+		const unwrappedOption = unwrapSchema(option);
+		if (unwrappedOption instanceof z.ZodObject && key in unwrappedOption.shape) {
+			const fieldSchema = unwrapSchema(unwrappedOption.shape[key]);
+			if (fieldSchema instanceof z.ZodLiteral && fieldSchema.value === value) return unwrappedOption;
+			if (fieldSchema instanceof z.ZodDefault && fieldSchema._zod.def.innerType instanceof z.ZodLiteral && fieldSchema._zod.def.innerType.value === value) return unwrappedOption;
+			if (fieldSchema instanceof z.ZodOptional && fieldSchema._zod.def.innerType instanceof z.ZodLiteral && fieldSchema._zod.def.innerType.value === value) return unwrappedOption;
+			if (fieldSchema instanceof z.ZodDefault && fieldSchema._zod.def.innerType instanceof z.ZodOptional && fieldSchema._zod.def.innerType._zod.def.innerType instanceof z.ZodLiteral && fieldSchema._zod.def.innerType._zod.def.innerType.value === value) return unwrappedOption;
+		}
+	}
+	return null;
+};
+/**
+* Generates a payload for the security scheme mutator from the security scheme diff, then executes that mutation
+*
+* Note: for edit we cannot use parseDiff here as it can't do unions, so we handle the unions first
+*
+* @returns true if it succeeds, and false for a failure
+*/
+var mutateSecuritySchemeDiff = (diff, { activeCollection }, { securitySchemes, securitySchemeMutators }) => {
+	if (!activeCollection.value) return false;
+	const [, , schemeName, ...keys] = diff.path;
+	const scheme = securitySchemes[schemeName] ?? findResource(activeCollection.value.securitySchemes, securitySchemes, (s) => s.nameKey === schemeName);
+	if (keys?.length) {
+		const schema = narrowUnionSchema(securitySchemeSchema, "type", scheme?.type ?? "");
+		if (!schema || !scheme) return false;
+		const parsed = parseDiff(schema, {
+			...diff,
+			path: keys
+		});
+		if (!parsed) return false;
+		const path = parsed.path;
+		securitySchemeMutators.edit(scheme.uid, path, parsed.value);
+	} else if (diff.type === "REMOVE") {
+		if (!scheme) return false;
+		securitySchemeMutators.delete(scheme.uid);
+	} else if (diff.type === "CREATE") securitySchemeMutators.add(securitySchemeSchema.parse(diff.value), activeCollection.value.uid);
+	return true;
+};
+//#endregion
+export { mutateSecuritySchemeDiff as a, narrowUnionSchema as c, mutateRequestDiff as i, parseDiff as l, findResource as n, mutateServerDiff as o, mutateCollectionDiff as r, mutateTagDiff as s, combineRenameDiffs as t, traverseZodSchema as u };
+
+//# sourceMappingURL=watch-mode-Dbaqd9bG.js.map