fumadocs-openapi 11.4.3 → 12.0.1

package/dist/packages/shared-api/dist/i18n.js

@@ -0,0 +1,7 @@
+import keys_default from "./.translations/keys.js";
+//#region ../shared-api/dist/i18n.js
+function apiDocsTranslations() {
+	return { keys: keys_default };
+}
+//#endregion
+export { apiDocsTranslations };

package/dist/packages/shared-api/dist/utils/cn.js

@@ -0,0 +1,2 @@
+import { cn } from "cn";
+export { cn };

package/dist/packages/shared-api/dist/utils/id-to-title.js

@@ -0,0 +1,12 @@
+//#region ../shared-api/dist/utils/id-to-title.js
+function idToTitle(id) {
+	let result = [];
+	for (const c of id) if (result.length === 0) result.push(c.toLocaleUpperCase());
+	else if (c === ".") result = [];
+	else if (/^[A-Z]$/.test(c) && result.at(-1) !== " ") result.push(" ", c);
+	else if (c === "-") result.push(" ");
+	else result.push(c);
+	return result.join("");
+}
+//#endregion
+export { idToTitle };

package/dist/packages/shared-api/dist/utils/is-plain-object.js

@@ -0,0 +1,8 @@
+//#region ../shared-api/dist/utils/is-plain-object.js
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null;
+}
+//#endregion
+export { isPlainObject };

package/dist/packages/shared-api/dist/utils/merge-refs.js

@@ -0,0 +1,11 @@
+//#region ../shared-api/dist/utils/merge-refs.js
+function mergeRefs(...refs) {
+	return (value) => {
+		refs.forEach((ref) => {
+			if (typeof ref === "function") ref(value);
+			else if (ref != null) ref.current = value;
+		});
+	};
+}
+//#endregion
+export { mergeRefs };

package/dist/packages/shared-api/dist/utils/url.js

@@ -0,0 +1,13 @@
+//#region ../shared-api/dist/utils/url.js
+function joinURL(base, pathname) {
+	if (pathname.startsWith("/")) pathname = pathname.slice(1);
+	if (base.endsWith("/")) base = base.slice(0, -1);
+	if (pathname.length > 0) return base + "/" + pathname;
+	else return base;
+}
+function resolveServerUrl(template, variables) {
+	for (const [key, value] of Object.entries(variables)) template = template.replaceAll(`{${key}}`, value);
+	return template;
+}
+//#endregion
+export { joinURL, resolveServerUrl };

package/dist/{utils → packages/shared-api/dist/utils}/use-query.js

@@ -1,5 +1,6 @@
+"use client";
 import { useMemo, useRef, useState } from "react";
-//#region src/utils/use-query.ts
+//#region ../shared-api/dist/utils/use-query.js
 function useQuery(fn) {
 	const [loading, setLoading] = useState(false);
 	const [data, setData] = useState();

package/dist/packages/shared-api/dist/utils/use-server-store.js

@@ -0,0 +1,56 @@
+"use client";
+import { isPlainObject } from "./is-plain-object.js";
+import { useEffect, useMemo, useRef, useState } from "react";
+//#region ../shared-api/dist/utils/use-server-store.js
+/**
+* The selected server of an API page, persisted in `localStorage`.
+*/
+function useServerStore({ storageKey, keyOf, resolve, defaultKey }) {
+	const [server, setServer] = useState(() => defaultKey !== void 0 ? resolve(defaultKey) : null);
+	const restored = useRef(void 0);
+	useEffect(() => {
+		if (restored.current === storageKey) return;
+		restored.current = storageKey;
+		const cached = localStorage.getItem(storageKey);
+		if (!cached) return;
+		try {
+			const value = JSON.parse(cached);
+			if (!isPlainObject(value) || !isPlainObject(value.variables)) return;
+			const server = resolve(keyOf(value));
+			if (server) setServer({
+				...server,
+				variables: value.variables
+			});
+		} catch {}
+	}, [
+		storageKey,
+		keyOf,
+		resolve
+	]);
+	return useMemo(() => ({
+		server,
+		setServer(key) {
+			const next = resolve(key);
+			if (!next) return;
+			localStorage.setItem(storageKey, JSON.stringify(next));
+			setServer(next);
+		},
+		setServerVariables(variables) {
+			setServer((prev) => {
+				if (!prev) return null;
+				const next = {
+					...prev,
+					variables
+				};
+				localStorage.setItem(storageKey, JSON.stringify(next));
+				return next;
+			});
+		}
+	}), [
+		server,
+		resolve,
+		storageKey
+	]);
+}
+//#endregion
+export { useServerStore };

package/dist/playground/auth.d.ts

@@ -0,0 +1,85 @@
+import { OAuth2SecurityScheme, OperationObject, SecuritySchemeObject } from "../types.js";
+import { ReactNode } from "react";
+import { DataEngine, FieldKey } from "@fumari/stf";
+//#region src/playground/auth.d.ts
+export type OAuthFlowType = keyof NonNullable<OAuth2SecurityScheme['flows']>;
+export interface OAuthFlowInput {
+  /** name of the security scheme */
+  schemeId: string;
+  scopes: string[];
+  clientId: string;
+  clientSecret: string;
+  username: string;
+  password: string;
+  /** where the password flow sends the client credentials */
+  clientAuth: 'body' | 'header';
+}
+/**
+ * Run an OAuth flow and resolve its token.
+ *
+ * `implicit` and `authorizationCode` leave the page instead: the token is picked up on return,
+ * in `usePlaygroundAuth().store`.
+ */
+export declare function requestOAuthToken(scheme: OAuth2SecurityScheme, type: OAuthFlowType, { schemeId, scopes, clientId, clientSecret, username, password, clientAuth }: OAuthFlowInput): Promise<string | undefined>;
+/** scheme name -> token info */
+type TokenStore = Record<string, TokenInfo | undefined>;
+type TokenInfo = {
+  type: 'authorization_code';
+  redirect_uri: string;
+  client_id: string;
+  client_secret: string;
+  token: string;
+} | {
+  type: 'implicit';
+  client_id: string;
+  token: string;
+};
+interface AuthContextType {
+  store: TokenStore;
+  updatedSchemeId: string | null;
+  isLoading: boolean;
+  error?: unknown;
+}
+export declare function usePlaygroundAuth(): AuthContextType;
+export interface AuthRequirement {
+  /** id of the security scheme */
+  id: string;
+  scopes: string[];
+  scheme: SecuritySchemeObject;
+}
+export interface AuthField {
+  schemeId: string;
+  scheme: SecuritySchemeObject;
+  scopes: string[];
+  /** the form field holding its value */
+  fieldName: FieldKey;
+  /** `localStorage` key of its persisted value */
+  storageKey: string;
+  defaultValue: unknown;
+  /** encode the value into request data, like the header of Basic auth */
+  mapOutput?: (value: unknown) => unknown;
+}
+export interface AuthFields {
+  /** the security requirements of the operation, one of them authorizes the request */
+  requirements: AuthRequirement[][];
+  /** index of the selected requirement, `-1` when the operation needs no authorization */
+  selected: number;
+  select: (index: number) => void;
+  /** the fields of the selected requirement */
+  fields: AuthField[];
+  /** encode the auth fields of form values into request data */
+  mapValues: <T>(values: T) => T;
+  /** write the persisted values into the form, returns a cleanup removing them */
+  init: () => () => void;
+}
+export interface AuthFieldsOptions {
+  /** the operation to authorize, defaults to the security of the document */
+  operation?: OperationObject;
+  /** customise the generated fields, like their default values */
+  transform?: (fields: AuthField[]) => AuthField[];
+}
+/**
+ * The auth fields of an API playground: the values it persists, and the request data they encode into.
+ */
+export declare function useAuthFields(engine: DataEngine, { operation, transform }?: AuthFieldsOptions): AuthFields;
+//#endregion

package/dist/playground/auth.js

@@ -1,17 +1,86 @@
 "use client";
-import { useRenderContext } from "../ui/contexts/api.js";
-import { useQuery } from "../utils/use-query.js";
-import { createContext, use, useEffect, useMemo, useState } from "react";
+import { useQuery } from "../packages/shared-api/dist/utils/use-query.js";
+import { useOpenAPI } from "../utils/create-page.js";
+import { createContext, use, useCallback, useEffect, useMemo, useState } from "react";
 import { jsx } from "react/jsx-runtime";
+import { useListener } from "@fumari/stf";
+import { arrayStartsWith, objectGet, objectSet } from "@fumari/stf/lib/utils";
+import { useOnChange } from "fumadocs-core/utils/use-on-change";
 //#region src/playground/auth.tsx
+/**
+* Run an OAuth flow and resolve its token.
+*
+* `implicit` and `authorizationCode` leave the page instead: the token is picked up on return,
+* in `usePlaygroundAuth().store`.
+*/
+async function requestOAuthToken(scheme, type, { schemeId, scopes, clientId, clientSecret, username, password, clientAuth }) {
+	const flows = scheme.flows ?? {};
+	const scope = scopes.join("+");
+	const redirect_uri = window.location.href;
+	if (type === "implicit" || type === "authorizationCode") {
+		const flow = flows[type];
+		if (!flow) return;
+		const params = new URLSearchParams({
+			response_type: type === "implicit" ? "token" : "code",
+			client_id: clientId,
+			redirect_uri,
+			scope,
+			state: JSON.stringify(type === "implicit" ? {
+				scheme: schemeId,
+				client_id: clientId,
+				redirect_uri
+			} : {
+				scheme: schemeId,
+				client_id: clientId,
+				client_secret: clientSecret,
+				redirect_uri
+			})
+		});
+		window.location.replace(`${flow.authorizationUrl}?${params}`);
+		return;
+	}
+	if (type !== "password" && type !== "clientCredentials") return;
+	const flow = flows[type];
+	if (!flow) return;
+	const headers = {};
+	const body = new URLSearchParams({ scope });
+	if (type === "password") {
+		body.set("grant_type", "password");
+		body.set("username", username);
+		body.set("password", password);
+		if (clientAuth === "header") headers.Authorization = `Basic ${btoa(`${clientId}:${clientSecret}`)}`;
+		else {
+			if (clientId) body.set("client_id", clientId);
+			if (clientSecret) body.set("client_secret", clientSecret);
+		}
+	} else {
+		body.set("grant_type", "client_credentials");
+		body.set("client_id", clientId);
+		body.set("client_secret", clientSecret);
+	}
+	return fetchToken(flow.tokenUrl, body, headers);
+}
+async function fetchToken(tokenUrl, body, headers = {}) {
+	const res = await fetch(tokenUrl, {
+		method: "POST",
+		headers: {
+			...headers,
+			"Content-Type": "application/x-www-form-urlencoded"
+		},
+		body
+	});
+	if (!res.ok) throw new Error(await res.text());
+	const { access_token, token_type = "Bearer" } = await res.json();
+	return `${token_type} ${access_token}`;
+}
 const AuthContext = createContext(null);
-function useAuth() {
+function usePlaygroundAuth() {
 	const ctx = use(AuthContext);
-	if (!ctx) throw new Error("must use this component under <AuthProvider />");
+	if (!ctx) throw new Error("Component must be used under <OpenAPIProvider />");
 	return ctx;
 }
 function AuthProvider({ children }) {
-	const { dereferenced, resolve } = useRenderContext().schema;
+	const { dereferenced, resolve } = useOpenAPI().doc;
 	const schemes = dereferenced.components?.securitySchemes;
 	const [store, setStore] = useState({});
 	const authCodeQuery = useQuery(async (code, state) => {
@@ -19,23 +88,16 @@ function AuthProvider({ children }) {
 		if (!scheme || scheme.type !== "oauth2") return;
 		const value = scheme.flows?.authorizationCode;
 		if (!value) return;
-		const res = await fetch(value.tokenUrl, {
-			method: "POST",
-			headers: { "Content-Type": "application/x-www-form-urlencoded" },
-			body: new URLSearchParams({
+		const info = {
+			type: "authorization_code",
+			...state,
+			token: await fetchToken(value.tokenUrl, new URLSearchParams({
 				grant_type: "authorization_code",
 				code,
 				redirect_uri: state.redirect_uri,
 				client_id: state.client_id,
 				client_secret: state.client_secret
-			})
-		});
-		if (!res.ok) throw new Error(await res.text());
-		const { access_token, token_type = "Bearer" } = await res.json();
-		const info = {
-			type: "authorization_code",
-			...state,
-			token: `${token_type} ${access_token}`
+			}))
 		};
 		setStore((s) => ({
 			...s,
@@ -72,8 +134,10 @@ function AuthProvider({ children }) {
 			}));
 			window.history.replaceState(null, "", window.location.pathname);
 		}
-		if (window.location.search.length > 0) onQuery();
-		if (window.location.hash.length > 1) onHash();
+		try {
+			if (window.location.search.length > 0) onQuery();
+			if (window.location.hash.length > 1) onHash();
+		} catch {}
 	}, []);
 	return /* @__PURE__ */ jsx(AuthContext, {
 		value: useMemo(() => ({
@@ -89,5 +153,136 @@ function AuthProvider({ children }) {
 		children
 	});
 }
+/**
+* The auth fields of an API playground: the values it persists, and the request data they encode into.
+*/
+function useAuthFields(engine, { operation, transform } = {}) {
+	const auth = usePlaygroundAuth();
+	const { storageKeyPrefix, doc } = useOpenAPI();
+	const { dereferenced, resolve } = doc;
+	const schemes = dereferenced.components?.securitySchemes;
+	const requirements = useMemo(() => {
+		const out = [];
+		if (!schemes) return out;
+		for (const map of operation?.security ?? dereferenced.security ?? []) {
+			const list = [];
+			for (const [id, scopes] of Object.entries(map)) {
+				const scheme = resolve(schemes[id]);
+				if (scheme) list.push({
+					id,
+					scopes,
+					scheme
+				});
+			}
+			if (list.length > 0) out.push(list);
+		}
+		return out;
+	}, [
+		dereferenced.security,
+		operation?.security,
+		resolve,
+		schemes
+	]);
+	const [selected, select] = useState(() => {
+		if (requirements.length === 0) return -1;
+		const idx = requirements.findIndex((req) => req.every((item) => !item.scheme.deprecated));
+		return idx !== -1 ? idx : 0;
+	});
+	const requirement = selected === -1 ? null : requirements[selected];
+	const fields = useMemo(() => {
+		if (!requirement) return [];
+		const out = requirement.map(({ id, scheme, scopes }) => {
+			const shared = {
+				schemeId: id,
+				scheme,
+				scopes,
+				storageKey: `${storageKeyPrefix}auth-${id}`
+			};
+			if (scheme.type === "http" && scheme.scheme === "basic") return {
+				...shared,
+				fieldName: ["header", "Authorization"],
+				defaultValue: {
+					username: "",
+					password: ""
+				},
+				mapOutput(value) {
+					if (!value || typeof value !== "object") return value;
+					const { username = "", password = "" } = value;
+					return `Basic ${btoa(`${username}:${password}`)}`;
+				}
+			};
+			if (scheme.type === "apiKey") return {
+				...shared,
+				fieldName: [scheme.in, scheme.name],
+				defaultValue: ""
+			};
+			return {
+				...shared,
+				fieldName: ["header", "Authorization"],
+				defaultValue: scheme.type === "http" || scheme.type === "oauth2" ? "Bearer " : ""
+			};
+		});
+		return transform ? transform(out) : out;
+	}, [
+		requirement,
+		storageKeyPrefix,
+		transform
+	]);
+	useListener({
+		stf: engine,
+		onUpdate(key) {
+			for (const field of fields) {
+				if (!arrayStartsWith(field.fieldName, key)) continue;
+				const value = engine.get(field.fieldName);
+				if (value != null) localStorage.setItem(field.storageKey, JSON.stringify(value));
+			}
+		}
+	});
+	useOnChange(auth.updatedSchemeId, () => {
+		const { updatedSchemeId } = auth;
+		if (!updatedSchemeId) return;
+		const { token } = auth.store[updatedSchemeId];
+		const field = fields.find((field) => field.schemeId === updatedSchemeId);
+		if (field) {
+			engine.update(field.fieldName, token);
+			return;
+		}
+		const idx = requirements.findIndex((req) => req.some((item) => item.id === updatedSchemeId));
+		if (idx !== -1) {
+			localStorage.setItem(`${storageKeyPrefix}auth-${updatedSchemeId}`, JSON.stringify(token));
+			select(idx);
+		}
+	});
+	return {
+		requirements,
+		selected,
+		select,
+		fields,
+		mapValues: useCallback((values) => {
+			const cloned = structuredClone(values);
+			for (const field of fields) {
+				if (!field.mapOutput) continue;
+				objectSet(cloned, field.fieldName, field.mapOutput(objectGet(cloned, field.fieldName)));
+			}
+			return cloned;
+		}, [fields]),
+		init: useCallback(() => {
+			for (const field of fields) {
+				const stored = localStorage.getItem(field.storageKey);
+				if (stored) {
+					const parsed = JSON.parse(stored);
+					if (typeof parsed === typeof field.defaultValue) {
+						engine.init(field.fieldName, parsed);
+						continue;
+					}
+				}
+				engine.init(field.fieldName, field.defaultValue);
+			}
+			return () => {
+				for (const field of fields) engine.delete(field.fieldName);
+			};
+		}, [engine, fields])
+	};
+}
 //#endregion
-export { AuthProvider, useAuth };
+export { AuthProvider, requestOAuthToken, useAuthFields, usePlaygroundAuth };

package/dist/playground/fetcher.d.ts

@@ -1,4 +1,5 @@
-import "../requests/types.js";
+import { MediaAdapter } from "../requests/media/adapter.js";
+import { RequestData } from "../requests/types.js";
 import { Awaitable } from "../types.js";
 //#region src/playground/fetcher.d.ts
 export type FetchResult = FetchResponseResult | FetchErrorResult;
@@ -14,6 +15,14 @@ export interface FetchResponseResult {
   headers: Headers;
   body: ArrayBuffer;
 }
+export interface Fetcher {
+  /**
+   * This method will not apply the path & search parameters from `options` to given `url`.
+   *
+   * @param url - The full URL of request.
+   */
+  fetch: (url: string, data: RequestData) => Promise<FetchResult>;
+}
 export interface BrowserFetcherOptions {
   /**
    * Request timeout in seconds (default: 10s)
@@ -31,4 +40,5 @@ export interface BrowserFetcherOptions {
    */
   onRequestInit?: (requestInit: RequestInit) => Awaitable<RequestInit>;
 }
+export declare function createBrowserFetcher(adapters: Record<string, MediaAdapter>, { proxyUrl, proxyForwardCookie, requestTimeout, onRequestInit }?: BrowserFetcherOptions): Fetcher;
 //#endregion

package/dist/playground/index.d.ts

@@ -0,0 +1,3 @@
+import { BrowserFetcherOptions, FetchErrorResult, FetchResponseResult, FetchResult, Fetcher, createBrowserFetcher } from "./fetcher.js";
+import { AuthField, AuthRequirement, OAuthFlowType, requestOAuthToken, useAuthFields, usePlaygroundAuth } from "./auth.js";
+export { type AuthField, type AuthRequirement, type BrowserFetcherOptions, type FetchErrorResult, type FetchResponseResult, type FetchResult, type Fetcher, type OAuthFlowType, createBrowserFetcher, requestOAuthToken, useAuthFields, usePlaygroundAuth };

package/dist/playground/index.js

@@ -0,0 +1,3 @@
+import { requestOAuthToken, useAuthFields, usePlaygroundAuth } from "./auth.js";
+import { createBrowserFetcher } from "./fetcher.js";
+export { createBrowserFetcher, requestOAuthToken, useAuthFields, usePlaygroundAuth };

package/dist/requests/generators/index.d.ts

@@ -1,9 +1,9 @@
 import { MediaAdapter } from "../media/adapter.js";
 import { RequestData } from "../types.js";
-import * as Shared from "@fumadocs/api-docs/codegen";
+import { CodeUsageGenerator as CodeUsageGenerator$1, CodeUsageGeneratorRegistry as CodeUsageGeneratorRegistry$1, InlineCodeUsageGenerator as InlineCodeUsageGenerator$1, codegen_d_exports } from "../../packages/shared-api/dist/codegen.js";
 //#region src/requests/generators/index.d.ts
 export declare function pathnameFromRequest(pathname: string, { path, query }: RequestData): string;
-export type CodeUsageGeneratorRegistry = Shared.CodeUsageGeneratorRegistry<RequestData & {
+export type CodeUsageGeneratorRegistry = CodeUsageGeneratorRegistry$1<RequestData & {
   url: string;
 }, {
   mediaAdapters: Record<string, MediaAdapter>;
@@ -12,7 +12,7 @@ export type CodeUsageGeneratorRegistry = Shared.CodeUsageGeneratorRegistry<Reque
 /**
  * Generate code example for given programming language
  */
-export type CodeUsageGenerator = Shared.CodeUsageGenerator<RequestData & {
+export type CodeUsageGenerator = CodeUsageGenerator$1<RequestData & {
   url: string;
 }, {
   mediaAdapters: Record<string, MediaAdapter>;
@@ -21,7 +21,7 @@ export type CodeUsageGenerator = Shared.CodeUsageGenerator<RequestData & {
 /**
  * Generate code example for given programming language
  */
-export type InlineCodeUsageGenerator<T = unknown> = Shared.InlineCodeUsageGenerator<RequestData & {
+export type InlineCodeUsageGenerator<T = unknown> = InlineCodeUsageGenerator$1<RequestData & {
   url: string;
 }, {
   mediaAdapters: Record<string, MediaAdapter>;

package/dist/requests/generators/index.js

@@ -1,4 +1,4 @@
-import * as Shared from "@fumadocs/api-docs/codegen";
+import { createCodeUsageGeneratorRegistry as createCodeUsageGeneratorRegistry$1 } from "../../packages/shared-api/dist/codegen.js";
 //#region src/requests/generators/index.ts
 function pathnameFromRequest(pathname, { path, query }) {
 	for (const key in path) {
@@ -16,7 +16,7 @@ function pathnameFromRequest(pathname, { path, query }) {
 	return searchParams.size > 0 ? `${pathPart}?${searchParams}` : pathPart;
 }
 function createCodeUsageGeneratorRegistry(inherit) {
-	return Shared.createCodeUsageGeneratorRegistry(inherit);
+	return createCodeUsageGeneratorRegistry$1(inherit);
 }
 //#endregion
 export { createCodeUsageGeneratorRegistry, pathnameFromRequest };

package/dist/requests/index.d.ts

@@ -0,0 +1,4 @@
+import { isMediaTypeSupported, resolveMediaAdapter } from "./media/resolve-adapter.js";
+import { EncodedParameter, EncodedParameterMultiple, encodeRequestData } from "./media/encode.js";
+import { RawRequestData, RequestData } from "./types.js";
+export { type EncodedParameter, type EncodedParameterMultiple, type RawRequestData, type RequestData, encodeRequestData, isMediaTypeSupported, resolveMediaAdapter };

package/dist/requests/index.js

@@ -0,0 +1,3 @@
+import { isMediaTypeSupported, resolveMediaAdapter } from "./media/resolve-adapter.js";
+import { encodeRequestData } from "./media/encode.js";
+export { encodeRequestData, isMediaTypeSupported, resolveMediaAdapter };

package/dist/requests/media/adapter.d.ts

@@ -1,3 +1,4 @@
+import { isMediaTypeSupported, resolveMediaAdapter } from "./resolve-adapter.js";
 //#region src/requests/media/adapter.d.ts
 interface BaseContext {
   /**

package/dist/requests/media/encode.d.ts

@@ -1,5 +1,6 @@
-import "../types.js";
-import "../../types.js";
+import { MediaAdapter } from "./adapter.js";
+import { RawRequestData, RequestData } from "../types.js";
+import { ParameterObject } from "../../types.js";
 //#region src/requests/media/encode.d.ts
 export interface EncodedParameter {
   readonly value: string;
@@ -7,4 +8,8 @@ export interface EncodedParameter {
 export interface EncodedParameterMultiple {
   readonly values: string[];
 }
+/**
+ * serialize parameters, see https://swagger.io/docs/specification/v3_0/serialization.
+ */
+export declare function encodeRequestData(from: RawRequestData, adapters: Record<string, MediaAdapter>, parameters?: ParameterObject[]): RequestData;
 //#endregion

package/dist/requests/media/resolve-adapter.d.ts

@@ -0,0 +1,20 @@
+import { MediaAdapter } from "./adapter.js";
+//#region src/requests/media/resolve-adapter.d.ts
+/**
+ * Resolve a media adapter for a given media type.
+ * Supports exact matches and pattern matching (e.g., +json suffix).
+ *
+ * @param mediaType - The media type to resolve (e.g., "application/json", "application/json-patch+json")
+ * @param adapters - Record of media adapters
+ * @returns The resolved adapter or undefined if not found
+ */
+export declare function resolveMediaAdapter(mediaType: string, adapters: Record<string, MediaAdapter>): MediaAdapter | undefined;
+/**
+ * Check if a media type is supported by the given adapters.
+ *
+ * @param mediaType - The media type to check
+ * @param adapters - Record of media adapters
+ * @returns true if the media type is supported
+ */
+export declare function isMediaTypeSupported(mediaType: string, adapters: Record<string, MediaAdapter>): boolean;
+//#endregion

package/dist/server/index.d.ts

@@ -1,7 +1,8 @@
-import { CreateProxyOptions, Proxy, createProxy } from "./proxy.js";
-import { OpenAPIPageProps_Preloaded, OpenAPIPageProps_Spec } from "../ui/index.js";
-import { SchemaToPagesOptions } from "../utils/pages/preset-auto.js";
 import { Awaitable, Document } from "../types.js";
+import { OpenAPIPageProps_Preloaded, OpenAPIPageProps_Spec } from "../utils/pages/builder.js";
+import { SchemaToPagesOptions } from "../utils/pages/preset-auto.js";
+import { CreateProxyOptions, Proxy, createProxy } from "./proxy.js";
+import "../ui/index.js";
 import { DynamicSource, LoaderPlugin, MetaData, Page, PageData, Source } from "fumadocs-core/source";
 import { StructuredData } from "fumadocs-core/mdx-plugins/remark-structure";
 import { TOCItemType } from "fumadocs-core/toc";
@@ -63,10 +64,6 @@ export interface OpenAPIPageData extends PageData {
   structuredData: StructuredData;
   toc: TOCItemType[];
   _openapi: InternalOpenAPIMeta;
-  /** @deprecated use `getOpenAPIPageProps()` instead */
-  getAPIPageProps: () => OpenAPIPageProps_Spec;
-  /** @deprecated use `getOpenAPIPageProps()` instead */
-  getClientAPIPageProps: () => OpenAPIPageProps_Spec;
 }
 export type OpenAPISourceOptions = SchemaToPagesOptions & {
   baseDir?: string;