@scalar/api-client 3.6.1 → 3.8.0

package/dist/v2/helpers/safe-run.d.ts

@@ -1,34 +0,0 @@
-/**
- * Run a function and capture any thrown error as a tagged result so callers
- * never have to write `try/catch` themselves.
- *
- * Resolves to `{ ok: true, data }` when `fn` returns (or its promise
- * resolves) and to `{ ok: false, error }` when it throws synchronously or
- * the returned promise rejects. The error is also logged via `console.error`
- * so unexpected failures still surface in the devtools console while the
- * caller decides how to present them to the user.
- *
- * Useful for guarding `await`s where a rejection would otherwise leave UI
- * state inconsistent (e.g. a loading flag that is reset only on the success
- * path). Because `safeRun` itself never rejects, the post-await cleanup can
- * run on the next line without a `try/finally` block.
- *
- * @example
- * const outcome = await safeRun(() => fetcher())
- * isLoading.value = false
- * if (!outcome.ok) {
- *   toast(outcome.error, 'error')
- *   return
- * }
- * useData(outcome.data)
- */
-export declare const safeRun: <T>(fn: () => Promise<T> | T) => Promise<{
-    readonly ok: true;
-    readonly data: Awaited<T>;
-    readonly error?: undefined;
-} | {
-    readonly ok: false;
-    readonly error: string;
-    readonly data?: undefined;
-}>;
-//# sourceMappingURL=safe-run.d.ts.map

package/dist/v2/helpers/safe-run.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"safe-run.d.ts","sourceRoot":"","sources":["../../../src/v2/helpers/safe-run.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,OAAO,GAAU,CAAC,EAAE,IAAI,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC;;;;;;;;EAaxD,CAAA"}

package/dist/v2/helpers/safe-run.js

@@ -1,43 +0,0 @@
-//#region src/v2/helpers/safe-run.ts
-/**
-* Run a function and capture any thrown error as a tagged result so callers
-* never have to write `try/catch` themselves.
-*
-* Resolves to `{ ok: true, data }` when `fn` returns (or its promise
-* resolves) and to `{ ok: false, error }` when it throws synchronously or
-* the returned promise rejects. The error is also logged via `console.error`
-* so unexpected failures still surface in the devtools console while the
-* caller decides how to present them to the user.
-*
-* Useful for guarding `await`s where a rejection would otherwise leave UI
-* state inconsistent (e.g. a loading flag that is reset only on the success
-* path). Because `safeRun` itself never rejects, the post-await cleanup can
-* run on the next line without a `try/finally` block.
-*
-* @example
-* const outcome = await safeRun(() => fetcher())
-* isLoading.value = false
-* if (!outcome.ok) {
-*   toast(outcome.error, 'error')
-*   return
-* }
-* useData(outcome.data)
-*/
-var safeRun = async (fn) => {
-	try {
-		return {
-			ok: true,
-			data: await fn()
-		};
-	} catch (error) {
-		console.error(error);
-		return {
-			ok: false,
-			error: error instanceof Error ? error.message : String(error)
-		};
-	}
-};
-//#endregion
-export { safeRun };
-
-//# sourceMappingURL=safe-run.js.map

package/dist/v2/helpers/safe-run.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"safe-run.js","names":[],"sources":["../../../src/v2/helpers/safe-run.ts"],"sourcesContent":["/**\n * Run a function and capture any thrown error as a tagged result so callers\n * never have to write `try/catch` themselves.\n *\n * Resolves to `{ ok: true, data }` when `fn` returns (or its promise\n * resolves) and to `{ ok: false, error }` when it throws synchronously or\n * the returned promise rejects. The error is also logged via `console.error`\n * so unexpected failures still surface in the devtools console while the\n * caller decides how to present them to the user.\n *\n * Useful for guarding `await`s where a rejection would otherwise leave UI\n * state inconsistent (e.g. a loading flag that is reset only on the success\n * path). Because `safeRun` itself never rejects, the post-await cleanup can\n * run on the next line without a `try/finally` block.\n *\n * @example\n * const outcome = await safeRun(() => fetcher())\n * isLoading.value = false\n * if (!outcome.ok) {\n *   toast(outcome.error, 'error')\n *   return\n * }\n * useData(outcome.data)\n */\nexport const safeRun = async <T>(fn: () => Promise<T> | T) => {\n  try {\n    return {\n      ok: true,\n      data: await fn(),\n    } as const\n  } catch (error) {\n    console.error(error)\n    return {\n      ok: false,\n      error: error instanceof Error ? error.message : String(error),\n    } as const\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,IAAa,UAAU,OAAU,OAA6B;AAC5D,KAAI;AACF,SAAO;GACL,IAAI;GACJ,MAAM,MAAM,IAAI;GACjB;UACM,OAAO;AACd,UAAQ,MAAM,MAAM;AACpB,SAAO;GACL,IAAI;GACJ,OAAO,iBAAiB,QAAQ,MAAM,UAAU,OAAO,MAAM;GAC9D"}

package/dist/v2/helpers/storage.d.ts

@@ -1,31 +0,0 @@
-/**
- * Handles persistence of the active workspace ID in localStorage.
- *
- * Usage example:
- * ```ts
- * // Set the active workspace id
- * workspaceStorage.setActiveWorkspaceId('workspace-1');
- *
- * // Get the currently active workspace id
- * const id = workspaceStorage.getActiveWorkspaceId();
- * ```
- */
-export declare const workspaceStorage: {
-    /**
-     * We keep the currently active path so we can reload it if needed
-     */
-    readonly setCurrentPath: (path: string) => void;
-    /**
-     * Retrieve the last active path
-     */
-    readonly getLastPath: () => string | null;
-    /**
-     * Persist the telemetry enabled state
-     */
-    readonly setTelemetry: (enabled: boolean) => void;
-    /**
-     * Retrieve the persisted telemetry enabled state. Returns null if never set.
-     */
-    readonly getTelemetry: () => boolean | null;
-};
-//# sourceMappingURL=storage.d.ts.map

package/dist/v2/helpers/storage.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../../../src/v2/helpers/storage.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,gBAAgB;IAC3B;;OAEG;oCACoB,MAAM,KAAG,IAAI;IAQpC;;OAEG;gCACc,MAAM,GAAG,IAAI;IAI9B;;OAEG;qCACqB,OAAO,KAAG,IAAI;IAItC;;OAEG;iCACe,OAAO,GAAG,IAAI;CAOxB,CAAA"}

package/dist/v2/helpers/storage.js

@@ -1,37 +0,0 @@
-import { safeLocalStorage } from "@scalar/helpers/object/local-storage";
-//#region src/v2/helpers/storage.ts
-var CURRENT_PATH_KEY = "scalar.currentPath";
-var TELEMETRY_KEY = "scalar.telemetry";
-/**
-* Handles persistence of the active workspace ID in localStorage.
-*
-* Usage example:
-* ```ts
-* // Set the active workspace id
-* workspaceStorage.setActiveWorkspaceId('workspace-1');
-*
-* // Get the currently active workspace id
-* const id = workspaceStorage.getActiveWorkspaceId();
-* ```
-*/
-var workspaceStorage = {
-	setCurrentPath: (path) => {
-		if (path === "/") return;
-		safeLocalStorage().setItem(CURRENT_PATH_KEY, path);
-	},
-	getLastPath: () => {
-		return safeLocalStorage().getItem(CURRENT_PATH_KEY);
-	},
-	setTelemetry: (enabled) => {
-		safeLocalStorage().setItem(TELEMETRY_KEY, String(enabled));
-	},
-	getTelemetry: () => {
-		const value = safeLocalStorage().getItem(TELEMETRY_KEY);
-		if (value === null) return null;
-		return value === "true";
-	}
-};
-//#endregion
-export { workspaceStorage };
-
-//# sourceMappingURL=storage.js.map

package/dist/v2/helpers/storage.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"storage.js","names":[],"sources":["../../../src/v2/helpers/storage.ts"],"sourcesContent":["import { safeLocalStorage } from '@scalar/helpers/object/local-storage'\n\nconst CURRENT_PATH_KEY = 'scalar.currentPath' as const\nconst TELEMETRY_KEY = 'scalar.telemetry' as const\n\n/**\n * Handles persistence of the active workspace ID in localStorage.\n *\n * Usage example:\n * ```ts\n * // Set the active workspace id\n * workspaceStorage.setActiveWorkspaceId('workspace-1');\n *\n * // Get the currently active workspace id\n * const id = workspaceStorage.getActiveWorkspaceId();\n * ```\n */\nexport const workspaceStorage = {\n  /**\n   * We keep the currently active path so we can reload it if needed\n   */\n  setCurrentPath: (path: string): void => {\n    // We have an infinite redirect loop if we set the current path to the root path\n    if (path === '/') {\n      return\n    }\n    safeLocalStorage().setItem(CURRENT_PATH_KEY, path)\n  },\n\n  /**\n   * Retrieve the last active path\n   */\n  getLastPath: (): string | null => {\n    return safeLocalStorage().getItem(CURRENT_PATH_KEY)\n  },\n\n  /**\n   * Persist the telemetry enabled state\n   */\n  setTelemetry: (enabled: boolean): void => {\n    safeLocalStorage().setItem(TELEMETRY_KEY, String(enabled))\n  },\n\n  /**\n   * Retrieve the persisted telemetry enabled state. Returns null if never set.\n   */\n  getTelemetry: (): boolean | null => {\n    const value = safeLocalStorage().getItem(TELEMETRY_KEY)\n    if (value === null) {\n      return null\n    }\n    return value === 'true'\n  },\n} as const\n"],"mappings":";;AAEA,IAAM,mBAAmB;AACzB,IAAM,gBAAgB;;;;;;;;;;;;;AActB,IAAa,mBAAmB;CAI9B,iBAAiB,SAAuB;AAEtC,MAAI,SAAS,IACX;AAEF,oBAAkB,CAAC,QAAQ,kBAAkB,KAAK;;CAMpD,mBAAkC;AAChC,SAAO,kBAAkB,CAAC,QAAQ,iBAAiB;;CAMrD,eAAe,YAA2B;AACxC,oBAAkB,CAAC,QAAQ,eAAe,OAAO,QAAQ,CAAC;;CAM5D,oBAAoC;EAClC,MAAM,QAAQ,kBAAkB,CAAC,QAAQ,cAAc;AACvD,MAAI,UAAU,KACZ,QAAO;AAET,SAAO,UAAU;;CAEpB"}

package/dist/v2/hooks/use-color-mode.d.ts

@@ -1,20 +0,0 @@
-import type { WorkspaceStore } from '@scalar/workspace-store/client';
-import type { ColorMode } from '@scalar/workspace-store/schemas/workspace';
-import { type MaybeRefOrGetter } from 'vue';
-/**
- * Composable hook that manages color mode (dark/light/system) based on workspace store configuration.
- * Automatically listens to system preference changes when mode is set to 'system'.
- *
- * @param options - Configuration options for the color mode hook.
- * @param options.workspaceStore - The workspace store instance that contains the color mode preference.
- * @returns Reactive color mode state and computed properties.
- */
-export declare const useColorMode: ({ workspaceStore }: {
-    workspaceStore: MaybeRefOrGetter<WorkspaceStore | null>;
-}) => {
-    /** The current color mode from the workspace store (reactive). */
-    colorMode: import("vue").ComputedRef<ColorMode>;
-    /** Whether the current effective color mode is dark (reactive). */
-    isDarkMode: import("vue").ComputedRef<boolean>;
-};
-//# sourceMappingURL=use-color-mode.d.ts.map

package/dist/v2/hooks/use-color-mode.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"use-color-mode.d.ts","sourceRoot":"","sources":["../../../src/v2/hooks/use-color-mode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAA;AACpE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2CAA2C,CAAA;AAC1E,OAAO,EAAE,KAAK,gBAAgB,EAAyD,MAAM,KAAK,CAAA;AA+ClG;;;;;;;GAOG;AACH,eAAO,MAAM,YAAY,GAAI,oBAAoB;IAAE,cAAc,EAAE,gBAAgB,CAAC,cAAc,GAAG,IAAI,CAAC,CAAA;CAAE;IAiCxG,kEAAkE;;IAElE,mEAAmE;;CAGtE,CAAA"}

package/dist/v2/hooks/use-color-mode.js

@@ -1,72 +0,0 @@
-import { computed, onMounted, onUnmounted, ref, toValue, watch } from "vue";
-//#region src/v2/hooks/use-color-mode.ts
-/**
-* Gets the system color mode preference from the browser.
-* Falls back to 'light' if running in a non-browser environment.
-*
-* @returns The system preference for dark or light mode.
-*/
-var getSystemModePreference = () => {
-	if (typeof window === "undefined" || typeof window?.matchMedia !== "function") return "light";
-	return window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
-};
-/**
-* Converts a ColorMode to a DarkLightMode by resolving 'system' to the actual system preference.
-*
-* @param mode - The color mode to convert.
-* @returns The resolved dark or light mode.
-*/
-var getDarkLightMode = (mode) => {
-	return mode === "system" ? getSystemModePreference() : mode;
-};
-/**
-* Applies the color mode by adding/removing the appropriate CSS classes on the document body.
-* This function is safe to call in non-browser environments (no-op).
-*
-* @param mode - The dark or light mode to apply.
-*/
-var applyColorMode = (mode) => {
-	if (typeof document === "undefined") return;
-	const isDark = mode === "dark";
-	document.body.classList.toggle("dark-mode", isDark);
-	document.body.classList.toggle("light-mode", !isDark);
-};
-/**
-* Composable hook that manages color mode (dark/light/system) based on workspace store configuration.
-* Automatically listens to system preference changes when mode is set to 'system'.
-*
-* @param options - Configuration options for the color mode hook.
-* @param options.workspaceStore - The workspace store instance that contains the color mode preference.
-* @returns Reactive color mode state and computed properties.
-*/
-var useColorMode = ({ workspaceStore }) => {
-	const colorMode = computed(() => toValue(workspaceStore)?.workspace["x-scalar-color-mode"] ?? "system");
-	const darkLightMode = computed(() => getDarkLightMode(colorMode.value));
-	const isDarkMode = computed(() => darkLightMode.value === "dark");
-	const mediaQuery = ref(null);
-	/**
-	* Handles system preference changes.
-	* Only updates the color mode if the current mode is set to 'system'.
-	*/
-	const handleSystemPreferenceChange = () => {
-		if (colorMode.value === "system") applyColorMode(getSystemModePreference());
-	};
-	watch(colorMode, (mode) => applyColorMode(getDarkLightMode(mode)), { immediate: true });
-	onMounted(() => {
-		if (typeof window !== "undefined" && typeof window?.matchMedia === "function") {
-			mediaQuery.value = window.matchMedia("(prefers-color-scheme: dark)");
-			mediaQuery.value.addEventListener("change", handleSystemPreferenceChange);
-		}
-	});
-	onUnmounted(() => {
-		mediaQuery.value?.removeEventListener("change", handleSystemPreferenceChange);
-	});
-	return {
-		colorMode,
-		isDarkMode
-	};
-};
-//#endregion
-export { useColorMode };
-
-//# sourceMappingURL=use-color-mode.js.map

package/dist/v2/hooks/use-color-mode.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"use-color-mode.js","names":[],"sources":["../../../src/v2/hooks/use-color-mode.ts"],"sourcesContent":["import type { WorkspaceStore } from '@scalar/workspace-store/client'\nimport type { ColorMode } from '@scalar/workspace-store/schemas/workspace'\nimport { type MaybeRefOrGetter, computed, onMounted, onUnmounted, ref, toValue, watch } from 'vue'\n\n/**\n * Specific dark or light mode, excluding the 'system' option.\n */\ntype DarkLightMode = Exclude<ColorMode, 'system'>\n\n/**\n * Gets the system color mode preference from the browser.\n * Falls back to 'light' if running in a non-browser environment.\n *\n * @returns The system preference for dark or light mode.\n */\nconst getSystemModePreference = (): DarkLightMode => {\n  if (typeof window === 'undefined' || typeof window?.matchMedia !== 'function') {\n    return 'light'\n  }\n\n  return window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light'\n}\n\n/**\n * Converts a ColorMode to a DarkLightMode by resolving 'system' to the actual system preference.\n *\n * @param mode - The color mode to convert.\n * @returns The resolved dark or light mode.\n */\nconst getDarkLightMode = (mode: ColorMode): DarkLightMode => {\n  return mode === 'system' ? getSystemModePreference() : mode\n}\n\n/**\n * Applies the color mode by adding/removing the appropriate CSS classes on the document body.\n * This function is safe to call in non-browser environments (no-op).\n *\n * @param mode - The dark or light mode to apply.\n */\nconst applyColorMode = (mode: DarkLightMode): void => {\n  if (typeof document === 'undefined') {\n    return\n  }\n\n  const isDark = mode === 'dark'\n  document.body.classList.toggle('dark-mode', isDark)\n  document.body.classList.toggle('light-mode', !isDark)\n}\n\n/**\n * Composable hook that manages color mode (dark/light/system) based on workspace store configuration.\n * Automatically listens to system preference changes when mode is set to 'system'.\n *\n * @param options - Configuration options for the color mode hook.\n * @param options.workspaceStore - The workspace store instance that contains the color mode preference.\n * @returns Reactive color mode state and computed properties.\n */\nexport const useColorMode = ({ workspaceStore }: { workspaceStore: MaybeRefOrGetter<WorkspaceStore | null> }) => {\n  const colorMode = computed(() => toValue(workspaceStore)?.workspace['x-scalar-color-mode'] ?? 'system')\n  const darkLightMode = computed(() => getDarkLightMode(colorMode.value))\n  const isDarkMode = computed(() => darkLightMode.value === 'dark')\n\n  const mediaQuery = ref<MediaQueryList | null>(null)\n\n  /**\n   * Handles system preference changes.\n   * Only updates the color mode if the current mode is set to 'system'.\n   */\n  const handleSystemPreferenceChange = (): void => {\n    if (colorMode.value === 'system') {\n      applyColorMode(getSystemModePreference())\n    }\n  }\n\n  // Watch for colorMode changes and apply them immediately\n  watch(colorMode, (mode) => applyColorMode(getDarkLightMode(mode)), { immediate: true })\n\n  onMounted(() => {\n    // Listen to system preference changes when mode is 'system'\n    if (typeof window !== 'undefined' && typeof window?.matchMedia === 'function') {\n      mediaQuery.value = window.matchMedia('(prefers-color-scheme: dark)')\n      mediaQuery.value.addEventListener('change', handleSystemPreferenceChange)\n    }\n  })\n\n  onUnmounted(() => {\n    mediaQuery.value?.removeEventListener('change', handleSystemPreferenceChange)\n  })\n\n  return {\n    /** The current color mode from the workspace store (reactive). */\n    colorMode,\n    /** Whether the current effective color mode is dark (reactive). */\n    isDarkMode,\n  }\n}\n"],"mappings":";;;;;;;;AAeA,IAAM,gCAA+C;AACnD,KAAI,OAAO,WAAW,eAAe,OAAO,QAAQ,eAAe,WACjE,QAAO;AAGT,QAAO,OAAO,WAAW,+BAA+B,CAAC,UAAU,SAAS;;;;;;;;AAS9E,IAAM,oBAAoB,SAAmC;AAC3D,QAAO,SAAS,WAAW,yBAAyB,GAAG;;;;;;;;AASzD,IAAM,kBAAkB,SAA8B;AACpD,KAAI,OAAO,aAAa,YACtB;CAGF,MAAM,SAAS,SAAS;AACxB,UAAS,KAAK,UAAU,OAAO,aAAa,OAAO;AACnD,UAAS,KAAK,UAAU,OAAO,cAAc,CAAC,OAAO;;;;;;;;;;AAWvD,IAAa,gBAAgB,EAAE,qBAAkF;CAC/G,MAAM,YAAY,eAAe,QAAQ,eAAe,EAAE,UAAU,0BAA0B,SAAS;CACvG,MAAM,gBAAgB,eAAe,iBAAiB,UAAU,MAAM,CAAC;CACvE,MAAM,aAAa,eAAe,cAAc,UAAU,OAAO;CAEjE,MAAM,aAAa,IAA2B,KAAK;;;;;CAMnD,MAAM,qCAA2C;AAC/C,MAAI,UAAU,UAAU,SACtB,gBAAe,yBAAyB,CAAC;;AAK7C,OAAM,YAAY,SAAS,eAAe,iBAAiB,KAAK,CAAC,EAAE,EAAE,WAAW,MAAM,CAAC;AAEvF,iBAAgB;AAEd,MAAI,OAAO,WAAW,eAAe,OAAO,QAAQ,eAAe,YAAY;AAC7E,cAAW,QAAQ,OAAO,WAAW,+BAA+B;AACpE,cAAW,MAAM,iBAAiB,UAAU,6BAA6B;;GAE3E;AAEF,mBAAkB;AAChB,aAAW,OAAO,oBAAoB,UAAU,6BAA6B;GAC7E;AAEF,QAAO;EAEL;EAEA;EACD"}

package/dist/v2/types/configuration.d.ts

@@ -1,278 +0,0 @@
-import type { Result } from '@scalar/helpers/types/result';
-/**
- * Coordinates that uniquely identify a registry-backed document. Both the
- * fetch and publish APIs operate on these so callers can compose a single
- * meta object once and pass it around.
- */
-export type RegistryDocumentMeta = {
-    namespace: string;
-    slug: string;
-    version?: string;
-};
-/**
- * Error codes surfaced by `fetchDocument`. Errors are returned as a
- * discriminated union so callers can react to each failure mode without
- * having to parse free-form strings:
- *
- * - `NOT_FOUND`: the registry has no document at the requested
- *   namespace / slug / version. Usually a sign that the version was
- *   removed upstream or the caller is asking for a draft that does not
- *   exist yet.
- * - `FETCH_FAILED`: a network or server error prevented the fetch from
- *   completing. The request can usually be retried.
- * - `UNAUTHORIZED`: the caller is not signed in / not allowed to read
- *   from this namespace. The host application is expected to surface a
- *   sign-in flow.
- * - `UNKNOWN`: a catch-all for failure modes the adapter cannot map
- *   onto one of the dedicated codes above. Callers surface a generic
- *   error message and, when present, the human-readable `message`
- *   field returned alongside the code.
- */
-export type FetchRegistryDocumentError = 'NOT_FOUND' | 'FETCH_FAILED' | 'UNAUTHORIZED' | 'UNKNOWN';
-/**
- * Fetches the full document from the registry by meta. When a `registry`
- * adapter is wired up, registry meta takes priority over
- * `x-scalar-original-source-url` when syncing. Returns the document as a
- * plain object on success, or a discriminated `FetchRegistryDocumentError`
- * code (with an optional human-readable `message`) on failure.
- */
-export type ImportDocumentFromRegistry = (meta: RegistryDocumentMeta) => Promise<Result<{
-    document: Record<string, unknown>;
-    versionSha?: string;
-}, FetchRegistryDocumentError>>;
-/**
- * Error codes surfaced by `publishDocument`. Errors are returned as a
- * discriminated union so callers can react to each failure mode without
- * having to parse free-form strings:
- *
- * - `CONFLICT`: the namespace/slug is already taken on the registry.
- *   Resolve by picking a new slug or pulling the upstream version.
- * - `FETCH_FAILED`: a network or server error prevented the publish from
- *   completing. The request can usually be retried.
- * - `UNAUTHORIZED`: the caller is not signed in / not allowed to publish
- *   to this namespace. The host application is expected to surface a
- *   sign-in flow.
- * - `UNKNOWN`: a catch-all for failure modes the adapter cannot map
- *   onto one of the dedicated codes above. Callers surface a generic
- *   error message and, when present, the human-readable `message`
- *   field returned alongside the code.
- */
-export type PublishRegistryDocumentError = 'CONFLICT' | 'FETCH_FAILED' | 'UNAUTHORIZED' | 'UNKNOWN';
-/**
- * Discriminated outcome of a `publishDocument` call.
- */
-export type PublishRegistryDocumentResult = Result<RegistryDocumentMeta & {
-    /** Commit hash advertised by the registry for the published version. */
-    commitHash?: string;
-}, PublishRegistryDocumentError>;
-/**
- * Publishes a brand-new document to the registry under the given
- * namespace and slug. Used for team-workspace documents that do not yet
- * have a registry entry - subsequent sync flows then go through the
- * Pull / Push pair once the registry has assigned a commit hash.
- *
- * The caller also chooses the document's initial `version` and passes
- * the full document body. The local workspace mirrors the same string
- * on `info.version` after a successful publish so the document and the
- * registry stay in sync without a follow-up edit.
- */
-export type PublishRegistryDocument = (input: {
-    namespace: string;
-    slug: string;
-    /** Initial version the document is published under (e.g. `1.0.0`). */
-    version: string;
-    /**
-     * Full OpenAPI document body to seed the registry entry with. The
-     * caller is expected to apply the chosen `version` to `info.version`
-     * before passing the document so the registry stores a consistent
-     * snapshot.
-     */
-    document: Record<string, unknown>;
-}) => Promise<PublishRegistryDocumentResult>;
-/**
- * Error codes surfaced by `publishVersion`. Errors are returned as a
- * discriminated union so callers can react to each failure mode without
- * having to parse free-form strings:
- *
- * - `CONFLICT`: the registry's current commit hash for this version no
- *   longer matches the one the caller passed in. Somebody pushed in the
- *   meantime - the caller is expected to pull the upstream changes,
- *   resolve any merge conflicts and try again.
- * - `NOT_FOUND`: the registry has no document at this namespace / slug
- *   to publish a new version against. Use `publishDocument` instead to
- *   create the document group first.
- * - `FETCH_FAILED`: a network or server error prevented the publish
- *   from completing. The request can usually be retried.
- * - `UNAUTHORIZED`: the caller is not signed in / not allowed to
- *   publish to this namespace. The host application is expected to
- *   surface a sign-in flow.
- * - `UNKNOWN`: a catch-all for failure modes the adapter cannot map
- *   onto one of the dedicated codes above. Callers surface a generic
- *   error message and, when present, the human-readable `message`
- *   field returned alongside the code.
- */
-export type PublishRegistryVersionError = 'CONFLICT' | 'NOT_FOUND' | 'FETCH_FAILED' | 'UNAUTHORIZED' | 'UNKNOWN';
-/**
- * Discriminated outcome of a `publishVersion` call. On success the
- * registry returns the new commit hash so the caller can persist it on
- * `x-scalar-registry-meta` and detect upstream drift on subsequent
- * refreshes.
- */
-export type PublishRegistryVersionResult = Result<RegistryDocumentMeta & {
-    /** Commit hash advertised by the registry for the published version. */
-    commitHash?: string;
-}, PublishRegistryVersionError>;
-/**
- * Publishes a new version of an existing registry document. Pairs with
- * `publishDocument` (which creates the document group itself) and is
- * what the team-workspace "Push" flow ultimately calls once the user
- * has saved local edits.
- *
- * The caller passes the `commitHash` it currently has locally so the
- * registry can do optimistic concurrency: if the upstream hash has
- * moved on, the publish is rejected with `CONFLICT` and the caller is
- * expected to pull the latest version before retrying.
- */
-export type PublishRegistryVersion = (input: {
-    namespace: string;
-    slug: string;
-    /** Version identifier the caller is publishing (e.g. `1.2.0`). */
-    version: string;
-    /**
-     * Full OpenAPI document body that should become the new state on the
-     * registry for this `version`. Mirrors the input shape of
-     * `publishDocument` so adapters can share the same upload helper.
-     */
-    document: Record<string, unknown>;
-    /**
-     * Commit hash the caller currently believes is the latest one for
-     * this `version`. The registry compares this against its own current
-     * hash and rejects the publish with `CONFLICT` when they no longer
-     * match, preventing accidental overwrites of upstream changes.
-     */
-    commitHash?: string;
-}) => Promise<PublishRegistryVersionResult>;
-/**
- * A single version that the registry advertises for a document group.
- *
- * Mirrors the minimum surface the sidebar needs to render a version row
- * (the version label and an optional commit hash). Loaded vs unloaded
- * state is derived later by matching against workspace-store documents.
- */
-export type RegistryDocumentVersion = {
-    version: string;
-    commitHash?: string;
-};
-/**
- * A document group as advertised by the registry, before it is merged
- * with locally loaded workspace documents. Lives at the configuration
- * layer so consumers can produce these without depending on internal
- * sidebar hooks.
- */
-export type RegistryDocument = {
-    namespace: string;
-    slug: string;
-    title: string;
-    versions: RegistryDocumentVersion[];
-};
-/**
- * Loading-aware wrapper for the list of registry documents.
- *
- * The sidebar uses the `status` to decide whether to render skeleton
- * placeholders while the registry is being fetched. `documents` is
- * optional during loading so callers can either render nothing or stream
- * in cached results while a refresh is still in flight.
- */
-export type RegistryDocumentsState = {
-    status: 'loading';
-    documents?: RegistryDocument[];
-} | {
-    status: 'success';
-    documents: RegistryDocument[];
-};
-/**
- * A namespace under which the user is allowed to publish documents.
- *
- * The publish modal renders one entry per namespace - as a static label
- * when there is only one, or as a dropdown otherwise - so callers can
- * surface the personal account, organisations, teams, etc. the user
- * has access to.
- */
-export type RegistryNamespace = {
-    /** Stable namespace identifier passed back to publish callbacks. */
-    namespace: string;
-    /** Optional human-readable label. Falls back to `namespace` when omitted. */
-    title?: string;
-};
-/**
- * Loading-aware wrapper for the list of namespaces the user can publish
- * to. Mirrors {@link RegistryDocumentsState} so the publish modal can
- * render a skeleton row while the host application is still resolving
- * the user's memberships.
- */
-export type RegistryNamespacesState = {
-    status: 'loading';
-    namespaces?: RegistryNamespace[];
-} | {
-    status: 'success';
-    namespaces: RegistryNamespace[];
-};
-/**
- * Bundles every interaction the API client needs with an external
- * registry. Consumers (Scalar Cloud, custom self-hosted setups) provide
- * a single adapter object instead of wiring each callback up
- * individually. The adapter itself is optional at the top level of the
- * client - omit it to opt out of registry features entirely - but every
- * field inside the adapter is required when it is provided.
- */
-export type RegistryAdapter = {
-    /**
-     * Reactive list of all available registry documents with a loading
-     * status, used by the sidebar to render skeleton placeholders until
-     * the real list is ready.
-     */
-    documents: RegistryDocumentsState;
-    /**
-     * Reactive list of namespaces the user can publish into. The publish
-     * modal uses it to show a single-line label (one namespace) or a
-     * dropdown (multiple namespaces) and falls back to a skeleton while
-     * the listing is still loading.
-     */
-    namespaces: RegistryNamespacesState;
-    /**
-     * Fetches the full document from the registry by meta. When provided,
-     * registry meta takes priority over `x-scalar-original-source-url`
-     * when syncing.
-     */
-    fetchDocument: ImportDocumentFromRegistry;
-    /**
-     * Publishes a brand-new document to the registry under the given
-     * namespace and slug. Returns a discriminated `Result` so callers can
-     * branch on `CONFLICT` / `FETCH_FAILED` / `UNAUTHORIZED` without
-     * string-matching error messages.
-     */
-    publishDocument: PublishRegistryDocument;
-    /**
-     * Publishes a new version of an existing registry document. The
-     * caller passes the `commitHash` it currently has locally so the
-     * registry can do optimistic concurrency and reject the publish with
-     * `CONFLICT` when the upstream hash has moved on.
-     */
-    publishVersion: PublishRegistryVersion;
-    /**
-     * Forces the host application to refetch `documents` and resolves once
-     * the new listing is in hand.
-     *
-     * Used by the sync flow to invalidate the host's listing cache after a
-     * `CONFLICT` push: the rejection means the registry has a newer
-     * commit hash than our local listing knows about, so refreshing the
-     * listing lets `computeVersionStatus` notice the mismatch and flip the
-     * Pull button on naturally - without the hook having to track its own
-     * "needs pull" overlay state.
-     *
-     * Optional so existing adapters keep type-checking; the sync flow
-     * silently no-ops when it is missing.
-     */
-    refreshDocuments?: () => Promise<void>;
-};
-//# sourceMappingURL=configuration.d.ts.map

package/dist/v2/types/configuration.d.ts.map

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