@scalar/oas-utils 0.2.61 → 0.2.63

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @scalar/oas-utils
 
+## 0.2.63
+
+### Patch Changes
+
+- ada8545: feat: add the sidebar button
+- Updated dependencies [ad12c56]
+  - @scalar/themes@0.9.44
+
+## 0.2.62
+
+### Patch Changes
+
+- 097ab40: fix: add mapping of header to headers for api client ingress
+- Updated dependencies [197e3ae]
+  - @scalar/themes@0.9.43
+
 ## 0.2.61
 
 ### Patch Changes

package/dist/entities/spec/collection.d.ts

@@ -107,13 +107,15 @@ export declare const extendedCollectionSchema: z.ZodObject<{
      *
      * @remarks Only effective when `documentUrl` is set
      */
-    watchForChanges: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    watchMode: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    /** Keeps track of which integration is associated with the specific collection */
+    integration: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     /**
      * Status of the watcher from above
      *
      * @defaults to idle for all collections, doesn't mean that it can watch for changes
      */
-    watchForChangesStatus: z.ZodDefault<z.ZodOptional<z.ZodEnum<["IDLE", "WATCHING", "ERROR"]>>>;
+    watchModeStatus: z.ZodDefault<z.ZodOptional<z.ZodEnum<["IDLE", "WATCHING", "ERROR"]>>>;
 }, "strip", z.ZodTypeAny, {
     uid: string;
     children: string[];
@@ -150,9 +152,10 @@ export declare const extendedCollectionSchema: z.ZodObject<{
         token: string;
         clientSecret: string;
     }>;
-    watchForChanges: boolean;
-    watchForChangesStatus: "IDLE" | "WATCHING" | "ERROR";
+    watchMode: boolean;
+    watchModeStatus: "IDLE" | "WATCHING" | "ERROR";
     documentUrl?: string | undefined;
+    integration?: string | null | undefined;
 }, {
     uid?: string | undefined;
     children?: (string | undefined)[] | undefined;
@@ -190,8 +193,9 @@ export declare const extendedCollectionSchema: z.ZodObject<{
         clientSecret?: string | undefined;
     }> | undefined;
     documentUrl?: string | undefined;
-    watchForChanges?: boolean | undefined;
-    watchForChangesStatus?: "IDLE" | "WATCHING" | "ERROR" | undefined;
+    watchMode?: boolean | undefined;
+    integration?: string | null | undefined;
+    watchModeStatus?: "IDLE" | "WATCHING" | "ERROR" | undefined;
 }>;
 export declare const collectionSchema: z.ZodObject<z.objectUtil.extendShape<{
     type: z.ZodDefault<z.ZodOptional<z.ZodLiteral<"collection">>>;
@@ -394,13 +398,15 @@ export declare const collectionSchema: z.ZodObject<z.objectUtil.extendShape<{
      *
      * @remarks Only effective when `documentUrl` is set
      */
-    watchForChanges: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    watchMode: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    /** Keeps track of which integration is associated with the specific collection */
+    integration: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     /**
      * Status of the watcher from above
      *
      * @defaults to idle for all collections, doesn't mean that it can watch for changes
      */
-    watchForChangesStatus: z.ZodDefault<z.ZodOptional<z.ZodEnum<["IDLE", "WATCHING", "ERROR"]>>>;
+    watchModeStatus: z.ZodDefault<z.ZodOptional<z.ZodEnum<["IDLE", "WATCHING", "ERROR"]>>>;
 }>, "strip", z.ZodTypeAny, {
     type: "collection";
     uid: string;
@@ -441,8 +447,8 @@ export declare const collectionSchema: z.ZodObject<z.objectUtil.extendShape<{
         token: string;
         clientSecret: string;
     }>;
-    watchForChanges: boolean;
-    watchForChangesStatus: "IDLE" | "WATCHING" | "ERROR";
+    watchMode: boolean;
+    watchModeStatus: "IDLE" | "WATCHING" | "ERROR";
     externalDocs?: {
         url: string;
         description?: string | undefined;
@@ -468,6 +474,7 @@ export declare const collectionSchema: z.ZodObject<z.objectUtil.extendShape<{
     components?: Record<string, unknown> | undefined;
     webhooks?: Record<string, unknown> | undefined;
     documentUrl?: string | undefined;
+    integration?: string | null | undefined;
 }, {
     type?: "collection" | undefined;
     uid?: string | undefined;
@@ -533,8 +540,9 @@ export declare const collectionSchema: z.ZodObject<z.objectUtil.extendShape<{
         clientSecret?: string | undefined;
     }> | undefined;
     documentUrl?: string | undefined;
-    watchForChanges?: boolean | undefined;
-    watchForChangesStatus?: "IDLE" | "WATCHING" | "ERROR" | undefined;
+    watchMode?: boolean | undefined;
+    integration?: string | null | undefined;
+    watchModeStatus?: "IDLE" | "WATCHING" | "ERROR" | undefined;
 }>;
 export type Collection = z.infer<typeof collectionSchema>;
 export type CollectionPayload = z.input<typeof collectionSchema>;

package/dist/entities/spec/collection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"collection.d.ts","sourceRoot":"","sources":["../../../src/entities/spec/collection.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAyCvB,eAAO,MAAM,wBAAwB;;IAEnC,qEAAqE;;IAErE,2FAA2F;;IAE3F,oCAAoC;;IAEpC,wDAAwD;;IAExD,gDAAgD;;IAEhD,8CAA8C;;IAE9C,gEAAgE;;IAEhE;;;;;OAKG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEH,wGAAwG;;IAExG;;;;OAIG;;IAEH;;;;OAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKH,CAAA;AAEF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAjE3B;;;;;;OAMG;;;;;;;;;;;;IAGH,uBAAuB;;IAEvB,uBAAuB;;IAEvB,gDAAgD;;;;IAYhD,qEAAqE;;IAErE,2FAA2F;;IAE3F,oCAAoC;;IAEpC,wDAAwD;;IAExD,gDAAgD;;IAEhD,8CAA8C;;IAE9C,gEAAgE;;IAEhE;;;;;OAKG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEH,wGAAwG;;IAExG;;;;OAIG;;IAEH;;;;OAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASJ,CAAA;AACD,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AACzD,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA"}
+{"version":3,"file":"collection.d.ts","sourceRoot":"","sources":["../../../src/entities/spec/collection.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAyCvB,eAAO,MAAM,wBAAwB;;IAEnC,qEAAqE;;IAErE,2FAA2F;;IAE3F,oCAAoC;;IAEpC,wDAAwD;;IAExD,gDAAgD;;IAEhD,8CAA8C;;IAE9C,gEAAgE;;IAEhE;;;;;OAKG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEH,wGAAwG;;IAExG;;;;OAIG;;IAEH,kFAAkF;;IAElF;;;;OAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKH,CAAA;AAEF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAnE3B;;;;;;OAMG;;;;;;;;;;;;IAGH,uBAAuB;;IAEvB,uBAAuB;;IAEvB,gDAAgD;;;;IAYhD,qEAAqE;;IAErE,2FAA2F;;IAE3F,oCAAoC;;IAEpC,wDAAwD;;IAExD,gDAAgD;;IAEhD,8CAA8C;;IAE9C,gEAAgE;;IAEhE;;;;;OAKG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEH,wGAAwG;;IAExG;;;;OAIG;;IAEH,kFAAkF;;IAElF;;;;OAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASJ,CAAA;AACD,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AACzD,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA"}

package/dist/entities/spec/collection.js

@@ -68,13 +68,15 @@ const extendedCollectionSchema = z.object({
      *
      * @remarks Only effective when `documentUrl` is set
      */
-    watchForChanges: z.boolean().optional().default(false),
+    watchMode: z.boolean().optional().default(false),
+    /** Keeps track of which integration is associated with the specific collection */
+    integration: z.string().nullable().optional(),
     /**
      * Status of the watcher from above
      *
      * @defaults to idle for all collections, doesn't mean that it can watch for changes
      */
-    watchForChangesStatus: z
+    watchModeStatus: z
         .enum(['IDLE', 'WATCHING', 'ERROR'])
         .optional()
         .default('IDLE'),

package/dist/entities/spec/request-examples.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"request-examples.d.ts","sourceRoot":"","sources":["../../../src/entities/spec/request-examples.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AACpD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAA;AACzC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AAEtC,eAAO,MAAM,8BAA8B;;;;;;IAMzC,kFAAkF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAUlF,CAAA;AAEF,kFAAkF;AAClF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAC3C,OAAO,8BAA8B,CACtC,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,0BAA0B,uEAQ7B,CAAA;AACV,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,0BAA0B,CAAC,CAAC,MAAM,CAAC,CAAA;AAEtE,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;YAjCnC,kFAAkF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoDlF,CAAA;AACF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAEzE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;gBAvD/B,kFAAkF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAAlF,kFAAkF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAAlF,kFAAkF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAAlF,kFAAkF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAAlF,kFAAkF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuElF,CAAA;AAEF,qDAAqD;AACrD,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AACjE,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAKxE,6DAA6D;AAC7D,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,gBAAgB;;;;;;;;;;;;;;;EA8B1D;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,MAAM,EACZ,MAAM,CAAC,EAAE,MAAM,GACd,cAAc,CAyFhB"}
+{"version":3,"file":"request-examples.d.ts","sourceRoot":"","sources":["../../../src/entities/spec/request-examples.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AACpD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAA;AACzC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AAEtC,eAAO,MAAM,8BAA8B;;;;;;IAMzC,kFAAkF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAUlF,CAAA;AAEF,kFAAkF;AAClF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAC3C,OAAO,8BAA8B,CACtC,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,0BAA0B,uEAQ7B,CAAA;AACV,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,0BAA0B,CAAC,CAAC,MAAM,CAAC,CAAA;AAEtE,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;YAjCnC,kFAAkF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoDlF,CAAA;AACF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAEzE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;gBAvD/B,kFAAkF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAAlF,kFAAkF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAAlF,kFAAkF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAAlF,kFAAkF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAAlF,kFAAkF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuElF,CAAA;AAEF,qDAAqD;AACrD,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AACjE,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAKxE,6DAA6D;AAC7D,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,gBAAgB;;;;;;;;;;;;;;;EA8B1D;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,MAAM,EACZ,MAAM,CAAC,EAAE,MAAM,GACd,cAAc,CAiGhB"}

package/dist/entities/spec/request-examples.js

@@ -112,10 +112,17 @@ function createExampleFromRequest(request, name, server) {
         path: [],
         query: [],
         cookie: [],
+        // deprecated TODO: add zod transform to remove
         header: [],
+        headers: [],
     };
     // Populated the separated params
     request.parameters?.forEach((p) => parameters[p.in].push(createParamInstance(p)));
+    // TODO: add zod transform to remove header and only support headers
+    if (parameters.header.length > 0) {
+        parameters.headers = parameters.header;
+        parameters.header = [];
+    }
     // ---------------------------------------------------------------------------
     // Handle request body defaulting for various content type encodings
     const body = {

package/dist/helpers/fetchSpecFromUrl.d.ts

@@ -1,5 +1,5 @@
 /**
- * Fetches an OpenAPI/Swagger specification from a given URL.
+ * Fetches an OpenAPI/Swagger document from a given URL.
  *
  * @throws an error if the fetch fails
  */

package/dist/helpers/fetchSpecFromUrl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fetchSpecFromUrl.d.ts","sourceRoot":"","sources":["../../src/helpers/fetchSpecFromUrl.ts"],"names":[],"mappings":"AASA;;;;GAIG;AACH,wBAAsB,gBAAgB,CACpC,GAAG,EAAE,MAAM,EACX,KAAK,CAAC,EAAE,MAAM,EACd,QAAQ,UAAO,GACd,OAAO,CAAC,MAAM,CAAC,CA8BjB"}
+{"version":3,"file":"fetchSpecFromUrl.d.ts","sourceRoot":"","sources":["../../src/helpers/fetchSpecFromUrl.ts"],"names":[],"mappings":"AAQA;;;;GAIG;AACH,wBAAsB,gBAAgB,CACpC,GAAG,EAAE,MAAM,EACX,KAAK,CAAC,EAAE,MAAM,EACd,QAAQ,UAAO,GACd,OAAO,CAAC,MAAM,CAAC,CAkCjB"}

package/dist/helpers/fetchSpecFromUrl.js

@@ -1,4 +1,4 @@
-import { redirectToProxy } from './redirectToProxy.js';
+import { fetchWithProxyFallback } from './fetchWithProxyFallback.js';
 import { formatJsonOrYamlString } from './parse.js';
 
 // Doesn’t work
@@ -6,7 +6,7 @@ const OLD_PROXY_URL = 'https://api.scalar.com/request-proxy';
 // Does work
 const NEW_PROXY_URL = 'https://proxy.scalar.com';
 /**
- * Fetches an OpenAPI/Swagger specification from a given URL.
+ * Fetches an OpenAPI/Swagger document from a given URL.
  *
  * @throws an error if the fetch fails
  */
@@ -16,21 +16,22 @@ async function fetchSpecFromUrl(url, proxy, beautify = true) {
         // eslint-disable-next-line no-param-reassign
         proxy = NEW_PROXY_URL;
     }
-    // To use a proxy or not to use a proxy
-    const response = await fetch(proxy ? redirectToProxy(proxy, url) : url);
-    // Looks like the request failed
-    if (response.status !== 200) {
-        console.error(`[fetchSpecFromUrl] Failed to fetch the specification at ${url} (Status: ${response.status})`);
+    try {
+        const response = await fetchWithProxyFallback(url, proxy);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch the OpenAPI document: ${url} (Status: ${response.status})`);
+        }
+        const text = await response.text();
+        // If it's JSON, make it pretty
+        return beautify ? formatJsonOrYamlString(text) : text;
+    }
+    catch (error) {
+        console.error(`[fetchSpecFromUrl] Failed to fetch the OpenAPI document at ${url}`, error);
         if (!proxy) {
-            console.warn(`[fetchSpecFromUrl] Tried to fetch the specification (url: ${url}) without a proxy. Are the CORS headers configured to allow cross-domain requests? https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS`);
+            console.warn(`[fetchSpecFromUrl] Tried to fetch the OpenAPI document (${url}) without a proxy. Are the CORS headers configured to allow cross-domain requests? https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS`);
         }
-        throw new Error(`Failed to fetch the specification (Status: ${response.status})`);
+        throw error;
     }
-    // If it’s JSON, make it pretty
-    if (beautify)
-        return formatJsonOrYamlString(await response.text());
-    else
-        return await response.text();
 }
 
 export { fetchSpecFromUrl };

package/dist/helpers/fetchWithProxyFallback.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Fetches an OpenAPI document with a proxy fallback mechanism.
+ *
+ * If a proxy is provided and the URL requires it, it will first attempt to fetch using the proxy.
+ * If the proxy fetch fails or is not used, it will fall back to a direct fetch.
+ *
+ * Also handles cases where the input is a JSON object instead of a URL.
+ */
+export declare function fetchWithProxyFallback(value: string, proxy?: string): Promise<Response>;
+//# sourceMappingURL=fetchWithProxyFallback.d.ts.map

package/dist/helpers/fetchWithProxyFallback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetchWithProxyFallback.d.ts","sourceRoot":"","sources":["../../src/helpers/fetchWithProxyFallback.ts"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AACH,wBAAsB,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,qBAsCzE"}

package/dist/helpers/fetchWithProxyFallback.js

@@ -0,0 +1,46 @@
+import { resolve } from '@scalar/import';
+import { shouldUseProxy, redirectToProxy } from './redirectToProxy.js';
+
+/**
+ * Fetches an OpenAPI document with a proxy fallback mechanism.
+ *
+ * If a proxy is provided and the URL requires it, it will first attempt to fetch using the proxy.
+ * If the proxy fetch fails or is not used, it will fall back to a direct fetch.
+ *
+ * Also handles cases where the input is a JSON object instead of a URL.
+ */
+async function fetchWithProxyFallback(value, proxy) {
+    // Maybe it’s not an OpenAPI document URL, but we can still find the actual URL
+    const url = await resolve(value);
+    // If the value is an object, mock a fetch response with beautified JSON
+    if (typeof value === 'object' && value !== null) {
+        const json = JSON.stringify(value, null, 2);
+        return {
+            ok: true,
+            status: 200,
+            text: async () => json,
+        };
+    }
+    if (typeof url !== 'string') {
+        throw new Error(`[fetchWithProxyFallback] Can’t fetch URL: ${url}`);
+    }
+    const shouldTryProxy = shouldUseProxy(proxy, url);
+    const initialUrl = shouldTryProxy ? redirectToProxy(proxy, url) : url;
+    try {
+        const result = await fetch(initialUrl, { cache: 'no-cache' });
+        if (result.ok || !shouldTryProxy) {
+            return result;
+        }
+        // Retry without proxy if the initial request failed
+        return await fetch(url, { cache: 'no-cache' });
+    }
+    catch (error) {
+        if (shouldTryProxy) {
+            // If proxy failed, try without it
+            return await fetch(url, { cache: 'no-cache' });
+        }
+        throw error;
+    }
+}
+
+export { fetchWithProxyFallback };

package/dist/helpers/index.d.ts

@@ -1,21 +1,24 @@
 export * from './concatenateUrlAndPath.js';
 export * from './createHash.js';
 export * from './fetchSpecFromUrl.js';
+export * from './fetchWithProxyFallback.js';
 export * from './findVariables.js';
 export * from './httpMethods.js';
 export * from './httpStatusCodes.js';
+export * from './isLocalUrl.js';
+export * from './isValidUrl.js';
 export * from './iterateTitle.js';
 export * from './local-storage.js';
+export * from './makeUrlAbsolute.js';
 export * from './normalizeMimeType.js';
 export * from './normalizeMimeTypeObject.js';
 export * from './object.js';
 export * from './parse.js';
 export * from './prettyPrintJson.js';
 export * from './redirectToProxy.js';
+export * from './regexHelpers.js';
 export * from './replaceVariables.js';
 export * from './schema-model.js';
 export * from './ssrState.js';
 export * from './string.js';
-export * from './isValidUrl.js';
-export * from './regexHelpers.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/helpers/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAA;AACvC,cAAc,cAAc,CAAA;AAC5B,cAAc,oBAAoB,CAAA;AAClC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,eAAe,CAAA;AAC7B,cAAc,mBAAmB,CAAA;AACjC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,qBAAqB,CAAA;AACnC,cAAc,2BAA2B,CAAA;AACzC,cAAc,UAAU,CAAA;AACxB,cAAc,SAAS,CAAA;AACvB,cAAc,mBAAmB,CAAA;AACjC,cAAc,mBAAmB,CAAA;AACjC,cAAc,oBAAoB,CAAA;AAClC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,YAAY,CAAA;AAC1B,cAAc,UAAU,CAAA;AACxB,cAAc,cAAc,CAAA;AAC5B,cAAc,gBAAgB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/helpers/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAA;AACvC,cAAc,cAAc,CAAA;AAC5B,cAAc,oBAAoB,CAAA;AAClC,cAAc,0BAA0B,CAAA;AACxC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,eAAe,CAAA;AAC7B,cAAc,mBAAmB,CAAA;AACjC,cAAc,cAAc,CAAA;AAC5B,cAAc,cAAc,CAAA;AAC5B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,mBAAmB,CAAA;AACjC,cAAc,qBAAqB,CAAA;AACnC,cAAc,2BAA2B,CAAA;AACzC,cAAc,UAAU,CAAA;AACxB,cAAc,SAAS,CAAA;AACvB,cAAc,mBAAmB,CAAA;AACjC,cAAc,mBAAmB,CAAA;AACjC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,oBAAoB,CAAA;AAClC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,YAAY,CAAA;AAC1B,cAAc,UAAU,CAAA"}

package/dist/helpers/index.js

@@ -1,20 +1,23 @@
 export { concatenateUrlAndPath } from './concatenateUrlAndPath.js';
 export { createHash } from './createHash.js';
 export { fetchSpecFromUrl } from './fetchSpecFromUrl.js';
+export { fetchWithProxyFallback } from './fetchWithProxyFallback.js';
 export { findVariables } from './findVariables.js';
 export { REQUEST_METHODS, canMethodHaveBody, getHttpMethodInfo } from './httpMethods.js';
 export { httpStatusCodes } from './httpStatusCodes.js';
+export { isLocalUrl } from './isLocalUrl.js';
+export { isValidUrl } from './isValidUrl.js';
 export { iterateTitle } from './iterateTitle.js';
 export { LS_KEYS } from './local-storage.js';
+export { makeUrlAbsolute } from './makeUrlAbsolute.js';
 export { normalizeMimeType } from './normalizeMimeType.js';
 export { normalizeMimeTypeObject } from './normalizeMimeTypeObject.js';
 export { getObjectKeys, objectMerge } from './object.js';
 export { formatJsonOrYamlString, isJsonString, json, parseJsonOrYaml, transformToJson, yaml } from './parse.js';
 export { prettyPrintJson, replaceCircularDependencies } from './prettyPrintJson.js';
-export { isRelativePath, isRequestToLocalhost, redirectToProxy, shouldUseProxy } from './redirectToProxy.js';
+export { isRelativePath, redirectToProxy, shouldUseProxy } from './redirectToProxy.js';
+export { pathRegex, variableRegex } from './regexHelpers.js';
 export { replaceVariables } from './replaceVariables.js';
 export { schemaModel } from './schema-model.js';
 export { defaultStateFactory, ssrState } from './ssrState.js';
 export { camelToTitleWords, capitalize } from './string.js';
-export { isValidUrl } from './isValidUrl.js';
-export { pathRegex, variableRegex } from './regexHelpers.js';

package/dist/helpers/isLocalUrl.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Detect requests to localhost
+ */
+export declare function isLocalUrl(url: string): boolean;
+//# sourceMappingURL=isLocalUrl.d.ts.map

package/dist/helpers/isLocalUrl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isLocalUrl.d.ts","sourceRoot":"","sources":["../../src/helpers/isLocalUrl.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,WAIrC"}

package/dist/helpers/isLocalUrl.js

@@ -0,0 +1,10 @@
+/**
+ * Detect requests to localhost
+ */
+function isLocalUrl(url) {
+    const { hostname } = new URL(url);
+    const listOfLocalUrls = ['localhost', '127.0.0.1', '[::1]', '0.0.0.0'];
+    return listOfLocalUrls.includes(hostname);
+}
+
+export { isLocalUrl };

package/dist/helpers/makeUrlAbsolute.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Pass an URL or a relative URL and get an absolute URL
+ */
+export declare const makeUrlAbsolute: (url?: string) => string | undefined;
+//# sourceMappingURL=makeUrlAbsolute.d.ts.map

package/dist/helpers/makeUrlAbsolute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"makeUrlAbsolute.d.ts","sourceRoot":"","sources":["../../src/helpers/makeUrlAbsolute.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,eAAe,SAAU,MAAM,uBAoB3C,CAAA"}

package/dist/helpers/makeUrlAbsolute.js

@@ -0,0 +1,20 @@
+/**
+ * Pass an URL or a relative URL and get an absolute URL
+ */
+const makeUrlAbsolute = (url) => {
+    if (!url ||
+        url.startsWith('http://') ||
+        url.startsWith('https://') ||
+        typeof window === 'undefined')
+        return url;
+    const baseUrl = window.location.href;
+    // Remove any query parameters or hash from the base URL
+    const cleanBaseUrl = baseUrl.split('?')[0].split('#')[0];
+    // Ensure the base URL ends with a slash if it doesn’t already
+    const normalizedBaseUrl = cleanBaseUrl.endsWith('/')
+        ? cleanBaseUrl
+        : cleanBaseUrl + '/';
+    return new URL(url, normalizedBaseUrl).toString();
+};
+
+export { makeUrlAbsolute };

package/dist/helpers/redirectToProxy.d.ts

@@ -4,6 +4,4 @@ export declare function redirectToProxy(proxy?: string, url?: string): string;
 export declare const isRelativePath: (url: string) => boolean;
 /** Returns false for requests to localhost, relative URLs, if no proxy is defined … */
 export declare function shouldUseProxy(proxy?: string, url?: string): boolean;
-/** Detect requests to localhost */
-export declare function isRequestToLocalhost(url: string): boolean;
 //# sourceMappingURL=redirectToProxy.d.ts.map

package/dist/helpers/redirectToProxy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"redirectToProxy.d.ts","sourceRoot":"","sources":["../../src/helpers/redirectToProxy.ts"],"names":[],"mappings":"AAAA,gEAAgE;AAChE,wBAAgB,eAAe,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAepE;AAED,mEAAmE;AACnE,eAAO,MAAM,cAAc,QAAS,MAAM,YAA8B,CAAA;AAExE,uFAAuF;AACvF,wBAAgB,cAAc,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,OAAO,CAWpE;AAED,mCAAmC;AACnC,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,WAI/C"}
+{"version":3,"file":"redirectToProxy.d.ts","sourceRoot":"","sources":["../../src/helpers/redirectToProxy.ts"],"names":[],"mappings":"AAEA,gEAAgE;AAChE,wBAAgB,eAAe,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAepE;AAED,mEAAmE;AACnE,eAAO,MAAM,cAAc,QAAS,MAAM,YAA8B,CAAA;AAExE,uFAAuF;AACvF,wBAAgB,cAAc,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,OAAO,CAWpE"}

package/dist/helpers/redirectToProxy.js

@@ -1,3 +1,5 @@
+import { isLocalUrl } from './isLocalUrl.js';
+
 /** Redirects the request to a proxy server with a given URL. */
 function redirectToProxy(proxy, url) {
     if (!shouldUseProxy(proxy, url)) {
@@ -22,15 +24,9 @@ function shouldUseProxy(proxy, url) {
     if (isRelativePath(url))
         return false;
     // Requests to localhost
-    if (isRequestToLocalhost(url))
+    if (isLocalUrl(url))
         return false;
     return true;
 }
-/** Detect requests to localhost */
-function isRequestToLocalhost(url) {
-    const { hostname } = new URL(url);
-    const listOfLocalUrls = ['localhost', '127.0.0.1', '[::1]'];
-    return listOfLocalUrls.includes(hostname);
-}
 
-export { isRelativePath, isRequestToLocalhost, redirectToProxy, shouldUseProxy };
+export { isRelativePath, redirectToProxy, shouldUseProxy };

package/dist/migrations/v-2.1.0/migration.d.ts

@@ -64,8 +64,8 @@ export declare const migrate_v_2_1_0: (data: Omit<v_0_0_0.Data, "folders">) => {
         }>;
         children: string[];
         'x-scalar-icon': string;
-        watchForChanges: false;
-        watchForChangesStatus: "IDLE";
+        watchMode: false;
+        watchModeStatus: "IDLE";
     }[];
     cookies: v_0_0_0.Cookie[];
     environments: {

package/dist/migrations/v-2.1.0/migration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"migration.d.ts","sourceRoot":"","sources":["../../../src/migrations/v-2.1.0/migration.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sCAAsC,CAAA;AAInE,mCAAmC;AACnC,eAAO,MAAM,eAAe,SAAU,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,SAAS,CAAC;;;;;;;;;;oBAG/C,CAAC;mBAIjB,CADJ;qBAA4C,CAAC;;;;0BAKlC,CAAC;mBACR,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAiDsD,CAAC;;;;oBASlD,CAAC;;;;;;wBAIF,CAAR;;;;;;sCAM2B,GAAG;oHAMoB,GAAsB;iCAGhE,GAAC;+BACS,GAAG;;+BAKb,CAAC;0BAED,CAAC;4BAIY,CAAA;wBAAoC,CAAC;wBAAqC,CAAC;0BACpF,CAAC;2BAAsC,CAAC;2BAGvC,CAAC;2BAAsC,CAAC;4BACxC,CAAC;;;kBACR,CAAD;;;;;;;;oBAQD,CAAC;2BAAqC,CAAC;sBAElB,CAAC;wBACA,CAAC;oBAAkC,CAAC;oBAG1D,CAAF;sBAAmC,CAAC;uBAE5B,CAAC;uBAAoC,CAAC;uBAChB,CAAC;wBACtB,CAAC;;;;;;oBAOS,CAAC;2BACR,CAAC;sBAAmC,CAAC;wBACtC,CAAC;oBACR,CAAC;oBAAmC,CAAC;sBAE7B,CAAC;uBACa,CAAC;uBACJ,CAAC;uBAAoC,CAAC;wBAC9C,CAAA;;;;;;oBAIS,CAAC;2BACA,CAAC;sBAChB,CAAC;wBACK,CAAC;oBACL,CAAC;oBAGN,CAAC;sBAEN,CAAJ;uBACS,CAAC;uBAEI,CAAC;uBACkB,CAAC;wBAAkC,CAAC;;;;;;oBAS/D,CAAC;2BAAqC,CAAC;sBACnC,CAAC;wBACW,CAAC;oBACjB,CAAJ;oBAAmC,CAAC;sBACf,CAAC;uBACf,CAAC;uBAAoC,CAAC;uBACjB,CAAC;wBACnB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAYP,CAAN;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBA0Iyd,CAAC;;6BAA4E,CAAC;;;;;;;;;;CADtiB,CAAA"}
+{"version":3,"file":"migration.d.ts","sourceRoot":"","sources":["../../../src/migrations/v-2.1.0/migration.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sCAAsC,CAAA;AAInE,mCAAmC;AACnC,eAAO,MAAM,eAAe,SAAU,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,SAAS,CAAC;;;;;;;;;;oBAG/C,CAAC;mBAIjB,CADJ;qBAA4C,CAAC;;;;0BAKlC,CAAC;mBACR,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAiDsD,CAAC;;;;oBASlD,CAAC;;;;;;wBAIF,CAAR;;;;;;sCAM2B,GAAG;oHAMoB,GAAsB;iCAGhE,GAAC;+BACS,GAAG;;+BAKb,CAAC;0BAED,CAAC;4BAIY,CAAA;wBAAoC,CAAC;wBAAqC,CAAC;0BACpF,CAAC;2BAAsC,CAAC;2BAGvC,CAAC;2BAAsC,CAAC;4BACxC,CAAC;;;kBACR,CAAD;;;;;;;;oBAQD,CAAC;2BAAqC,CAAC;sBAElB,CAAC;wBACA,CAAC;oBAAkC,CAAC;oBAG1D,CAAF;sBAAmC,CAAC;uBAE5B,CAAC;uBAAoC,CAAC;uBAChB,CAAC;wBACtB,CAAC;;;;;;oBAOS,CAAC;2BACR,CAAC;sBAAmC,CAAC;wBACtC,CAAC;oBACR,CAAC;oBAAmC,CAAC;sBAE7B,CAAC;uBACa,CAAC;uBACJ,CAAC;uBAAoC,CAAC;wBAC9C,CAAA;;;;;;oBAIS,CAAC;2BACA,CAAC;sBAChB,CAAC;wBACY,CAAA;oBACC,CAAC;oBAInB,CAAC;sBACE,CAAC;uBACS,CAAC;uBAGd,CAAC;uBAAoC,CAAC;wBAExC,CAAN;;;;;;oBAOmB,CAAA;2BAAqC,CAAC;sBACnC,CAAC;wBACW,CAAC;oBACtB,CAAC;oBACR,CAAN;sBAAmC,CAAC;uBACf,CAAC;uBAChB,CAAA;uBAAoC,CAAC;wBAIvC,CADH;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAUU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBA0Iyd,CAAC;;6BAA4E,CAAC;;;;;;;;;;CADljB,CAAA"}

package/dist/migrations/v-2.1.0/migration.js

@@ -118,8 +118,8 @@ const migrate_v_2_1_0 = (data) => {
             auth,
             'children': c.childUids || [],
             'x-scalar-icon': 'interface-content-folder',
-            'watchForChanges': false,
-            'watchForChangesStatus': 'IDLE',
+            'watchMode': false,
+            'watchModeStatus': 'IDLE',
         };
     });
     // Cookies

package/dist/transforms/export-spec.d.ts

@@ -42,8 +42,8 @@ export declare function exportSpecFromWorkspace({ collection, requests, }: {
         token: string;
         clientSecret: string;
     }>;
-    watchForChanges: boolean;
-    watchForChangesStatus: "IDLE" | "WATCHING" | "ERROR";
+    watchMode: boolean;
+    watchModeStatus: "IDLE" | "WATCHING" | "ERROR";
     externalDocs?: {
         url: string;
         description?: string | undefined;
@@ -69,5 +69,6 @@ export declare function exportSpecFromWorkspace({ collection, requests, }: {
     components?: Record<string, unknown> | undefined;
     webhooks?: Record<string, unknown> | undefined;
     documentUrl?: string | undefined;
+    integration?: string | null | undefined;
 };
 //# sourceMappingURL=export-spec.d.ts.map

package/dist/transforms/export-spec.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"export-spec.d.ts","sourceRoot":"","sources":["../../src/transforms/export-spec.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,UAAU,EACf,KAAK,OAAO,EAEb,MAAM,iBAAiB,CAAA;AAMxB,wBAAgB,uBAAuB,CAAC,EACtC,UAAU,EACV,QAAQ,GACT,EAAE;IACD,UAAU,EAAE,UAAU,CAAA;IACtB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAClC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEA"}
+{"version":3,"file":"export-spec.d.ts","sourceRoot":"","sources":["../../src/transforms/export-spec.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,UAAU,EACf,KAAK,OAAO,EAEb,MAAM,iBAAiB,CAAA;AAMxB,wBAAgB,uBAAuB,CAAC,EACtC,UAAU,EACV,QAAQ,GACT,EAAE;IACD,UAAU,EAAE,UAAU,CAAA;IACtB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAClC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEA"}

package/dist/transforms/import-spec.d.ts

@@ -8,7 +8,7 @@ export declare const parseSchema: (spec: string | UnknownObject) => Promise<{
     schema: OpenAPIV3.Document | OpenAPIV3_1.Document;
     errors: import("@scalar/openapi-parser").ErrorObject[];
 }>;
-export type ImportSpecToWorkspaceArgs = Pick<CollectionPayload, 'documentUrl' | 'watchForChanges'> & Pick<ReferenceConfiguration, 'authentication'> & {
+export type ImportSpecToWorkspaceArgs = Pick<CollectionPayload, 'documentUrl' | 'watchMode'> & Pick<ReferenceConfiguration, 'authentication'> & {
     /** Sets the preferred security scheme on the collection instead of the requests */
     setCollectionSecurity?: boolean;
 };
@@ -20,7 +20,7 @@ export type ImportSpecToWorkspaceArgs = Pick<CollectionPayload, 'documentUrl' |
  * created and used at various levels we will index via the uids to create
  * the relationships
  */
-export declare function importSpecToWorkspace(spec: string | UnknownObject, { authentication, documentUrl, setCollectionSecurity, watchForChanges, }?: ImportSpecToWorkspaceArgs): Promise<{
+export declare function importSpecToWorkspace(spec: string | UnknownObject, { authentication, documentUrl, setCollectionSecurity, watchMode, }?: ImportSpecToWorkspaceArgs): Promise<{
     error: false;
     collection: Collection;
     requests: Request[];

package/dist/transforms/import-spec.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"import-spec.d.ts","sourceRoot":"","sources":["../../src/transforms/import-spec.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,UAAU,EACf,KAAK,iBAAiB,EACtB,KAAK,OAAO,EACZ,KAAK,cAAc,EAGnB,KAAK,MAAM,EACX,KAAK,GAAG,EAOT,MAAM,iBAAiB,CAAA;AACxB,OAAO,EACL,KAAK,cAAc,EAKpB,MAAM,0BAA0B,CAAA;AAIjC,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AACnE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAA;AAClE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAkFxD,mFAAmF;AACnF,eAAO,MAAM,WAAW,SAAgB,MAAM,GAAG,aAAa;YAKjC,SAAS,CAAC,QAAQ,GAAG,WAAW,CAAC,QAAQ;;EACrE,CAAA;AAED,MAAM,MAAM,yBAAyB,GAAG,IAAI,CAC1C,iBAAiB,EACjB,aAAa,GAAG,iBAAiB,CAClC,GACC,IAAI,CAAC,sBAAsB,EAAE,gBAAgB,CAAC,GAAG;IAC/C,mFAAmF;IACnF,qBAAqB,CAAC,EAAE,OAAO,CAAA;CAChC,CAAA;AAEH;;;;;;;GAOG;AACH,wBAAsB,qBAAqB,CACzC,IAAI,EAAE,MAAM,GAAG,aAAa,EAC5B,EACE,cAAc,EACd,WAAW,EACX,qBAA6B,EAC7B,eAAuB,GACxB,GAAE,yBAA8B,GAChC,OAAO,CACN;IACE,KAAK,EAAE,KAAK,CAAA;IACZ,UAAU,EAAE,UAAU,CAAA;IACtB,QAAQ,EAAE,OAAO,EAAE,CAAA;IACnB,MAAM,EAAE,SAAS,CAAC,QAAQ,GAAG,WAAW,CAAC,QAAQ,CAAA;IACjD,QAAQ,EAAE,cAAc,EAAE,CAAA;IAC1B,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,IAAI,EAAE,GAAG,EAAE,CAAA;IACX,eAAe,EAAE,cAAc,EAAE,CAAA;CAClC,GACD;IAAE,KAAK,EAAE,IAAI,CAAC;IAAC,cAAc,EAAE,MAAM,EAAE,CAAA;CAAE,CAC5C,CA8QA"}
+{"version":3,"file":"import-spec.d.ts","sourceRoot":"","sources":["../../src/transforms/import-spec.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,UAAU,EACf,KAAK,iBAAiB,EACtB,KAAK,OAAO,EACZ,KAAK,cAAc,EAGnB,KAAK,MAAM,EACX,KAAK,GAAG,EAOT,MAAM,iBAAiB,CAAA;AACxB,OAAO,EACL,KAAK,cAAc,EAKpB,MAAM,0BAA0B,CAAA;AAIjC,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AACnE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAA;AAClE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAkFxD,mFAAmF;AACnF,eAAO,MAAM,WAAW,SAAgB,MAAM,GAAG,aAAa;YAKjC,SAAS,CAAC,QAAQ,GAAG,WAAW,CAAC,QAAQ;;EACrE,CAAA;AAED,MAAM,MAAM,yBAAyB,GAAG,IAAI,CAC1C,iBAAiB,EACjB,aAAa,GAAG,WAAW,CAC5B,GACC,IAAI,CAAC,sBAAsB,EAAE,gBAAgB,CAAC,GAAG;IAC/C,mFAAmF;IACnF,qBAAqB,CAAC,EAAE,OAAO,CAAA;CAChC,CAAA;AAEH;;;;;;;GAOG;AACH,wBAAsB,qBAAqB,CACzC,IAAI,EAAE,MAAM,GAAG,aAAa,EAC5B,EACE,cAAc,EACd,WAAW,EACX,qBAA6B,EAC7B,SAAiB,GAClB,GAAE,yBAA8B,GAChC,OAAO,CACN;IACE,KAAK,EAAE,KAAK,CAAA;IACZ,UAAU,EAAE,UAAU,CAAA;IACtB,QAAQ,EAAE,OAAO,EAAE,CAAA;IACnB,MAAM,EAAE,SAAS,CAAC,QAAQ,GAAG,WAAW,CAAC,QAAQ,CAAA;IACjD,QAAQ,EAAE,cAAc,EAAE,CAAA;IAC1B,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,IAAI,EAAE,GAAG,EAAE,CAAA;IACX,eAAe,EAAE,cAAc,EAAE,CAAA;CAClC,GACD;IAAE,KAAK,EAAE,IAAI,CAAC;IAAC,cAAc,EAAE,MAAM,EAAE,CAAA;CAAE,CAC5C,CA8QA"}

package/dist/transforms/import-spec.js

@@ -90,7 +90,7 @@ const parseSchema = async (spec) => {
  * created and used at various levels we will index via the uids to create
  * the relationships
  */
-async function importSpecToWorkspace(spec, { authentication, documentUrl, setCollectionSecurity = false, watchForChanges = false, } = {}) {
+async function importSpecToWorkspace(spec, { authentication, documentUrl, setCollectionSecurity = false, watchMode = false, } = {}) {
     const { schema, errors } = await parseSchema(spec);
     const importWarnings = [...errors.map((e) => e.message)];
     if (!schema)
@@ -276,7 +276,7 @@ async function importSpecToWorkspace(spec, { authentication, documentUrl, setCol
     }
     const collection = collectionSchema.parse({
         ...schema,
-        watchForChanges,
+        watchMode,
         documentUrl,
         auth,
         requests: requests.map((r) => r.uid),

package/package.json

@@ -16,7 +16,7 @@
     "specification",
     "yaml"
   ],
-  "version": "0.2.61",
+  "version": "0.2.63",
   "engines": {
     "node": ">=18"
   },
@@ -106,9 +106,10 @@
     "nanoid": "^5.0.7",
     "yaml": "^2.4.5",
     "zod": "^3.23.8",
+    "@scalar/import": "0.0.3",
     "@scalar/object-utils": "1.1.10",
+    "@scalar/themes": "0.9.44",
     "@scalar/types": "0.0.17",
-    "@scalar/themes": "0.9.42",
     "@scalar/openapi-types": "0.1.4"
   },
   "devDependencies": {