fumadocs-openapi/dist/ui/api-page.d.ts

Generate MDX docs for your OpenAPI spec

import { NoReference } from "../utils/schema.js";
import { MediaAdapter } from "../requests/media/adapter.js";
import { CodeUsageGenerator } from "./operation/usage-tabs/index.js";
import { OpenAPIServer } from "../server/create.js";
import { ExampleRequestItem } from "./operation/request-tabs.js";
import { APIPageClientOptions } from "./client/index.js";
import { SchemaUIOptions } from "./schema/index.js";
import { ResponseTab } from "./operation/response-tabs.js";
import "../server/index.js";
import { MethodInformation, RenderContext } from "../types.js";
import { ProcessedDocument } from "../utils/process-document.js";
import { FC, ReactNode } from "react";
import { HighlightOptionsCommon, HighlightOptionsThemes } from "fumadocs-core/highlight";
import { OpenAPIV3_1 } from "openapi-types";

//#region src/ui/api-page.d.ts
type Awaitable<T> = T | Promise<T>;
interface CreateAPIPageOptions {
  /**
   * Generate TypeScript definitions from response schema.
   *
   * Pass `false` to disable it.
   *
   * @param method - the operation object
   * @param statusCode - status code
   */
  generateTypeScriptSchema?: ((method: NoReference<MethodInformation>, statusCode: string) => Awaitable<string>) | false;
  /**
   * Generate example code usage for endpoints.
   */
  generateCodeSamples?: (method: MethodInformation) => Awaitable<CodeUsageGenerator[]>;
  shikiOptions?: Omit<HighlightOptionsCommon, 'lang' | 'components'> & HighlightOptionsThemes;
  /**
   * Show full response schema instead of only example response & Typescript definitions.
   *
   * @default true
   */
  showResponseSchema?: boolean;
  /**
   * Support other media types (for server-side generation).
   */
  mediaAdapters?: Record<string, MediaAdapter>;
  /**
   * Customise page content
   */
  content?: {
    renderResponseTabs?: (tabs: ResponseTab[], ctx: RenderContext) => Awaitable<ReactNode>;
    renderRequestTabs?: (items: ExampleRequestItem[], ctx: RenderContext & {
      route: string;
      operation: NoReference<MethodInformation>;
    }) => Awaitable<ReactNode>;
    renderAPIExampleLayout?: (slots: {
      selector: ReactNode;
      usageTabs: ReactNode;
      responseTabs: ReactNode;
    }, ctx: RenderContext) => Awaitable<ReactNode>;
    /**
     * @param generators - codegens for API example usages
     */
    renderAPIExampleUsageTabs?: (generators: CodeUsageGenerator[], ctx: RenderContext) => Awaitable<ReactNode>;
    /**
     * renderer of the entire page's layout (containing all operations & webhooks UI)
     */
    renderPageLayout?: (slots: {
      operations?: {
        item: OperationItem;
        children: ReactNode;
      }[];
      webhooks?: {
        item: WebhookItem;
        children: ReactNode;
      }[];
    }, ctx: RenderContext) => Awaitable<ReactNode>;
    renderOperationLayout?: (slots: {
      header: ReactNode;
      description: ReactNode;
      apiExample: ReactNode;
      apiPlayground: ReactNode;
      authSchemes: ReactNode;
      paremeters: ReactNode;
      body: ReactNode;
      responses: ReactNode;
      callbacks: ReactNode;
    }, ctx: RenderContext, method: NoReference<MethodInformation>) => Awaitable<ReactNode>;
    renderWebhookLayout?: (slots: {
      header: ReactNode;
      description: ReactNode;
      authSchemes: ReactNode;
      paremeters: ReactNode;
      body: ReactNode;
      requests: ReactNode;
      responses: ReactNode;
      callbacks: ReactNode;
    }) => Awaitable<ReactNode>;
  };
  /**
   * Info UI for JSON schemas
   */
  schemaUI?: {
    render?: (options: SchemaUIOptions, ctx: RenderContext) => Awaitable<ReactNode>;
    /**
     * Show examples under the generated content of JSON schemas.
     *
     * @defaultValue false
     */
    showExample?: boolean;
  };
  /**
   * Customise API playground
   */
  playground?: {
    /**
     * @defaultValue true
     */
    enabled?: boolean;
    /**
     * replace the server-side renderer
     */
    render?: (props: {
      path: string;
      method: MethodInformation;
      ctx: RenderContext;
    }) => Awaitable<ReactNode>;
  };
  client?: APIPageClientOptions;
}
interface ApiPageProps {
  document: Promise<ProcessedDocument> | string | ProcessedDocument;
  showTitle?: boolean;
  showDescription?: boolean;
  /**
   * An array of operations
   */
  operations?: OperationItem[];
  webhooks?: WebhookItem[];
}
interface WebhookItem {
  /**
   * webhook name in `webhooks`
   */
  name: string;
  method: OpenAPIV3_1.HttpMethods;
}
interface OperationItem {
  /**
   * the path of operation in `paths`
   */
  path: string;
  /**
   * the HTTP method of operation
   */
  method: OpenAPIV3_1.HttpMethods;
}
declare function createAPIPage(server: OpenAPIServer, options?: CreateAPIPageOptions): FC<ApiPageProps>;
//#endregion
export { ApiPageProps, CreateAPIPageOptions, OperationItem, WebhookItem, createAPIPage };
//# sourceMappingURL=api-page.d.ts.map