apiuikit 0.3.0 → 1.0.0

package/dist/components/Navigation/AsyncAPINavigation.d.ts

@@ -0,0 +1,28 @@
+import { Operation } from '../../types/asyncapi/Operation';
+import { MessageObject } from '../../types/asyncapi/MessageObject';
+import { SideBarConfig } from '../../config/config';
+export type NavTab = "operations" | "messages" | "schemas";
+export type NavSectionId = NavTab | "servers" | "info";
+interface AsyncAPINavigationProps {
+    operations?: Record<string, Operation>;
+    messages?: Record<string, MessageObject>;
+    schemas?: Record<string, unknown>;
+    servers?: Record<string, unknown>;
+    /** Whether the Info panel is currently shown: controls only whether its tick appears here, mirroring the Layout's own `show.info` gate. */
+    hasInfo?: boolean;
+    /** Which section is currently the user's focus, for header highlighting:
+     * a single authoritative value covering all five sections (including
+     * Info and Servers) so at most one header is ever highlighted at once.
+     * Distinct from `onTabChange`, which only fires for the three switchable tabs. */
+    activeTab: NavSectionId | null;
+    onTabChange: (tab: NavTab) => void;
+    onItemSelect?: (tab: NavTab, key: string) => void;
+    onSelectServer?: (key: string) => void;
+    selectedItem?: {
+        tab: NavSectionId;
+        key: string;
+    } | null;
+    sidebarConfig?: SideBarConfig;
+}
+export default function AsyncAPINavigation({ operations, messages, schemas, servers, hasInfo, activeTab, onTabChange, onItemSelect, onSelectServer, selectedItem, sidebarConfig, }: AsyncAPINavigationProps): import("react").JSX.Element;
+export {};

package/dist/components/Navigation/Navigation.d.ts

@@ -0,0 +1,58 @@
+import { ComponentType, ReactNode } from 'react';
+export interface NavItemState {
+    isSelected: boolean;
+    isSectionActive: boolean;
+}
+export interface NavSectionDescriptor<T> {
+    id: string;
+    label: string;
+    icon: ComponentType<{
+        className?: string;
+    }>;
+    items: T[];
+    itemKey: (item: T) => string;
+    /** DOM id to scroll into view when this item is chosen, e.g. `operation-${key}`. */
+    targetId: (item: T) => string;
+    /** False for sections with no switchable tab of their own (e.g. Servers, which is always on screen) — only their items support scroll-to-select. Defaults to true. */
+    isTab?: boolean;
+    /** False to keep a section out of the expanded popover list while still tracking it for the spine's ticks and scroll-spy (e.g. Info: worth a tick, not worth a whole popover entry). Defaults to true. */
+    showInPopover?: boolean;
+    /** Content rendered for the item — just the badge/label, no button/list chrome, which this component owns so styling stays consistent across specs. */
+    renderItem: (item: T, state: NavItemState) => ReactNode;
+}
+/** A section whose item type has been erased, so sections with different item shapes (a server URL, a `FlatEndpoint`, a plain schema name, ...) can sit in one array. Build one from a concrete `NavSectionDescriptor<T>` via `defineNavSection`. */
+export type ErasedNavSection = NavSectionDescriptor<unknown>;
+/**
+ * The single cast that erases a section's item type. Safe because
+ * `Navigation` only ever feeds a section's own `items` back into that
+ * same section's `itemKey`/`targetId`/`renderItem` — it never mixes items
+ * across sections — so the erased `unknown` is always the original `T` by
+ * construction, even though the type system can't see that through the array.
+ */
+export declare function defineNavSection<T>(section: NavSectionDescriptor<T>): ErasedNavSection;
+interface NavigationProps {
+    sections: ErasedNavSection[];
+    activeSection: string | null;
+    onTabChange: (sectionId: string) => void;
+    onItemSelect: (sectionId: string, key: string) => void;
+    selectedItem?: {
+        section: string;
+        key: string;
+    } | null;
+}
+/**
+ * The sidebar navigation shared by AsyncAPI and OpenAPI, styled after Medium's
+ * table-of-contents. On wide layouts a bare tick "spine" (a parent tick per
+ * section plus a child tick per item, scroll-spy highlighted) sits fixed in
+ * the left gutter at the viewport's vertical center; hovering or clicking it
+ * opens a floating popover of sections (icon + label + count) with their
+ * items indented beneath. On narrow layouts (no gutter) the trigger is a
+ * floating bottom-right button that opens the same popover on click.
+ * Each spec supplies its own data as section descriptors (see
+ * `NavSectionDescriptor`) via a thin adapter — `AsyncAPINavigation` /
+ * `OpenAPINavigation`, both in this same directory — so spec-specific
+ * concerns (channel addresses, action badges, method badges, ...) stay in the
+ * adapter while the mechanics below are written once.
+ */
+export default function Navigation({ sections, activeSection, onTabChange, onItemSelect, selectedItem, }: NavigationProps): import("react").JSX.Element;
+export {};

package/dist/components/Navigation/OpenAPINavigation.d.ts

@@ -0,0 +1,22 @@
+import { OpenAPIPathItemData } from '../../types/openapi';
+export type OpenAPINavTab = "endpoints" | "webhooks" | "schemas";
+export type OpenAPINavSectionId = OpenAPINavTab | "servers" | "info";
+interface OpenAPINavigationProps {
+    paths?: Record<string, OpenAPIPathItemData | undefined>;
+    /** OpenAPI 3.1 `webhooks`, same Path Item shape as `paths`. */
+    webhooks?: Record<string, OpenAPIPathItemData | undefined>;
+    schemas?: Record<string, unknown>;
+    servers?: string[];
+    /** Whether the Info panel is currently shown: controls only whether its tick appears here, mirroring the Layout's own `show.info` gate. */
+    hasInfo?: boolean;
+    activeTab: OpenAPINavSectionId | null;
+    onTabChange: (tab: OpenAPINavTab) => void;
+    onItemSelect?: (tab: OpenAPINavTab, key: string) => void;
+    onSelectServer?: (key: string) => void;
+    selectedItem?: {
+        tab: OpenAPINavSectionId;
+        key: string;
+    } | null;
+}
+export default function OpenAPINavigation({ paths, webhooks, schemas, servers, hasInfo, activeTab, onTabChange, onItemSelect, onSelectServer, selectedItem, }: OpenAPINavigationProps): import("react").JSX.Element;
+export {};

package/dist/components/Navigation/SpecNavigation.d.ts

@@ -0,0 +1,25 @@
+import { ErasedNavSection } from './Navigation';
+export interface SpecNavigationProps<TabKey extends string> {
+    /**
+     * Section descriptors in page order. Memoize them in the calling adapter so
+     * Navigation's scroll-spy observer (keyed on `sections` identity) survives
+     * unrelated re-renders.
+     */
+    sections: ErasedNavSection[];
+    activeTab: TabKey | "servers" | "info" | null;
+    onTabChange: (tab: TabKey) => void;
+    onItemSelect?: (tab: TabKey, key: string) => void;
+    onSelectServer?: (key: string) => void;
+    selectedItem?: {
+        tab: TabKey | "servers" | "info";
+        key: string;
+    } | null;
+}
+/**
+ * Shared wiring between a spec's section descriptors and the Navigation
+ * mechanics, previously duplicated verbatim by the AsyncAPI and OpenAPI
+ * adapters: routes "servers" item clicks to their own handler, keeps Info
+ * clicks from being treated as a tab switch, and narrows Navigation's
+ * stringly-typed callbacks back to the spec's tab union.
+ */
+export default function SpecNavigation<TabKey extends string>({ sections, activeTab, onTabChange, onItemSelect, onSelectServer, selectedItem, }: SpecNavigationProps<TabKey>): import("react").JSX.Element;

package/dist/components/Navigation/index.d.ts

@@ -0,0 +1,4 @@
+export { default as AsyncAPINavigation } from './AsyncAPINavigation';
+export type { NavTab, NavSectionId } from './AsyncAPINavigation';
+export { default as OpenAPINavigation } from './OpenAPINavigation';
+export type { OpenAPINavTab, OpenAPINavSectionId } from './OpenAPINavigation';

package/dist/components/Navigation/sharedSections.d.ts

@@ -0,0 +1,10 @@
+import { ErasedNavSection } from './Navigation';
+/**
+ * Section descriptors that are identical for every spec, shared by the
+ * AsyncAPI and OpenAPI navigation adapters. Call these inside the adapter's
+ * `sections` memo, they build a fresh descriptor per call.
+ */
+/** One tick that jumps to the top of the Info panel. */
+export declare function infoNavSection(hasInfo: boolean): ErasedNavSection;
+/** A plain name list targeting the `schema-${name}` anchors both specs render. */
+export declare function schemasNavSection(schemas: Record<string, unknown>): ErasedNavSection;

package/dist/components/RenderExtensions.d.ts

@@ -0,0 +1,28 @@
+/**
+ * View of an object's x-* spec-extension fields. Values are `unknown` because
+ * extension payloads are arbitrary JSON, validated at runtime by the extension
+ * component that renders them. Spec object types declare no x-* keys (and no
+ * index signature), so they can't assign to this directly; extension readers
+ * accept `object` and narrow through `getExtension` / the key scan instead of
+ * making every caller cast.
+ */
+export type ExtensionSource = {
+    [key: `x-${string}`]: unknown;
+};
+/** Reads one x-* field off any spec object, e.g. `getExtension(info, "x-logo")`. */
+export declare const getExtension: (source: object | undefined, key: `x-${string}`) => unknown;
+interface RenderExtensionsProps {
+    /** The object to scan for x-* fields, e.g. the `info` object. */
+    source: object | undefined;
+    /** Prefix for each matched extension's `path` prop, e.g. "info". */
+    pathPrefix: string;
+}
+/**
+ * Scans `source`'s own keys for x-* spec-extension fields the `x-tensions`
+ * catalog knows how to render, and lazily loads + renders each match (via
+ * `React.lazy`, so an extension's code is only fetched when its key actually
+ * appears in a document). Unmatched x-* keys, and the library's own internal
+ * bookkeeping markers (`x-parser-*`, `x-lib-*`), render nothing.
+ */
+export declare function RenderExtensions({ source, pathPrefix }: RenderExtensionsProps): import("react").JSX.Element | null;
+export default RenderExtensions;

package/dist/components/Section.d.ts

@@ -6,6 +6,8 @@ interface SectionProps {
     stickySideContent: boolean;
     info?: boolean;
     reverseLayoutOnMobile?: boolean;
+    /** Rendered directly above the title, visible on small screens only (e.g. a logo that otherwise lives at the top of the desktop sidebar). */
+    mobileLeadContent?: ReactNode;
 }
-export default function Section({ title, content, sideContent, stickySideContent, info, reverseLayoutOnMobile, }: SectionProps): import("react").JSX.Element;
+export default function Section({ title, content, sideContent, stickySideContent, info, reverseLayoutOnMobile, mobileLeadContent, }: SectionProps): import("react").JSX.Element;
 export {};

package/dist/components/ServerAddressBanner.d.ts

@@ -0,0 +1,16 @@
+import { ReactNode } from 'react';
+export interface ServerAddressVariable {
+    description?: string;
+    enum?: string[];
+    default?: string;
+    examples?: string[];
+}
+interface ServerAddressBannerProps {
+    /** The server's host/url. The banner still renders without one, matching the previous per-spec behavior. */
+    address?: string;
+    variables?: Record<string, ServerAddressVariable>;
+    /** Extra rows rendered inside the banner below the address box (e.g. AsyncAPI's tag list). */
+    children?: ReactNode;
+}
+export default function ServerAddressBanner({ address, variables, children }: ServerAddressBannerProps): import("react").JSX.Element;
+export {};

package/dist/components/SidePanel.d.ts

@@ -4,6 +4,8 @@ export interface ISidePanelProps {
     side: SidePanelSide;
     onClose: () => void;
     title?: string | React.ReactNode;
+    /** Rendered in the header row between the title and the close button (e.g. a copy button). */
+    headerActions?: React.ReactNode;
     children?: React.ReactNode;
     width?: string;
 }

package/dist/components/Tabs.d.ts

@@ -12,6 +12,8 @@ interface TabsProps {
     onChange?: (id: string) => void;
     ariaLabel?: string;
     selectLabel?: string;
+    /** When set, the mobile `<select>` includes an empty option for no selection. */
+    placeholder?: string;
 }
-export default function Tabs({ tabs, current, onChange, ariaLabel, selectLabel, }: TabsProps): import("react").JSX.Element | null;
+export default function Tabs({ tabs, current, onChange, ariaLabel, selectLabel, placeholder, }: TabsProps): import("react").JSX.Element | null;
 export {};

package/dist/components/schema/SchemaTab.d.ts

@@ -1,11 +1,32 @@
-declare function SchemaTabs({ schema, label, description, schemaFormat, originalSchema, conversionError, pendingConversion, }: {
+import { ReactNode } from 'react';
+declare function SchemaTabs({ schema, label, rootName, description, schemaFormat, originalSchema, conversionError, pendingConversion, example, defaultView, }: {
+    /** JSON Schema to render in the Schema/Example tabs. */
     schema: unknown;
-    label: string;
+    /** Heading shown above the tab toggle, e.g. "Payload" or "Headers" — can embed interactive content, e.g. a media type selector. */
+    label: ReactNode;
+    /**
+     * Path prefix for schema tree rows. Defaults to `label`. Use when the heading
+     * should include extra context (e.g. media type) that must not appear in paths.
+     */
+    rootName?: string;
     description?: string;
+    /** Declared multi-format wrapper (e.g. Avro, Protobuf) this schema was converted from, if any. */
     schemaFormat?: string;
+    /** The pre-conversion schema, shown in the JSON tab instead of the converted `schema`. */
     originalSchema?: unknown;
+    /** When set, conversion from `schemaFormat` failed: shown as a warning and hides the Example tab. */
     conversionError?: string;
-    /** True while a Protobuf converter is still loading — see lazyProtoToJsonSchema.ts. */
+    /** True while a Protobuf converter is still loading, see lazyProtoToJsonSchema.ts. */
     pendingConversion?: boolean;
+    /** A real example value declared in the spec (OpenAPI media type `example`/`examples`, or an AsyncAPI message example) — shown as-is on the Example tab instead of auto-generating one. */
+    example?: unknown;
+    /**
+     * Which view opens first. Defaults to "example", the right call for a body
+     * or payload, where a sample value is the most useful thing to see. Pass
+     * "schema" for groups whose values are generated at runtime and so can only
+     * ever be faked here (request parameters, response headers), where the
+     * documented name/type/description is what the reader actually wants.
+     */
+    defaultView?: "schema" | "example";
 }): import("react").JSX.Element;
 export default SchemaTabs;

package/dist/components/tests/Authorization.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/tests/Bindings.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/tests/CodeBlock.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/tests/CodeSamples.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/tests/CopyMarkdownButton.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/tests/MarkdownExportMenu.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/tests/RenderExtensions.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/config/config.d.ts

@@ -17,6 +17,16 @@ export interface ShowConfig {
     messageExamples?: boolean;
     schemas?: boolean;
     errors?: boolean;
+    /** OpenAPI only: the Endpoints tab (paths/operations). */
+    endpoints?: boolean;
+    /** OpenAPI 3.1 only: the Webhooks tab. The tab appears only when the document declares `webhooks`. */
+    webhooks?: boolean;
+    /** Whether to render known x-* spec extensions (see the `x-tensions` catalog). Defaults to true. */
+    extensions?: boolean;
+    /** OpenAPI only: per-operation cURL/JavaScript/Python request examples. Defaults to true. */
+    codeSamples?: boolean;
+    /** The "Copy for LLM" / "View as Markdown" floating button. Defaults to true. */
+    copyMarkdown?: boolean;
 }
 export interface ExpandConfig {
     messageExamples?: boolean;

package/dist/containers/AsyncAPI/AsyncAPI.d.ts

@@ -1,12 +1,18 @@
 import { ConfigInterface } from '../../config';
 import { AsyncAPIDocumentData } from '../../types/schema';
-export type IAsyncAPIProps = {
+export interface IAsyncAPIProps {
+    /** A pre-resolved AsyncAPI 3.0 document object, or one that still contains `$ref`s. */
     asyncapi: AsyncAPIDocumentData;
+    /** UI configuration: theme, which sections to show, sidebar options, and more. */
     config?: ConfigInterface;
-} | {
-    kind: "resolved";
-    asyncapi: AsyncAPIDocumentData;
-    config?: ConfigInterface;
-};
+    /** Promise that `asyncapi` is already fully dereferenced upstream. Verified rather than trusted: `$ref`s left in place are still resolved either way, with a console warning that the promise was false. */
+    kind?: "resolved";
+}
+/**
+ * Renders a full AsyncAPI documentation page: sidebar navigation, search,
+ * servers, operations, messages, and schemas. Pass a pre-resolved (or
+ * `$ref`-carrying) document object; for raw YAML/JSON strings, use
+ * `AsyncAPIRenderer` instead, which parses first.
+ */
 declare const AsyncAPI: (props: IAsyncAPIProps) => import("react").JSX.Element;
 export default AsyncAPI;

package/dist/containers/AsyncAPI/AsyncAPIRenderer.d.ts

@@ -1,8 +1,17 @@
 import { ConfigInterface } from '../../config/config';
 interface AsyncAPIRendererProps {
+    /** Raw AsyncAPI document as a YAML or JSON string, parsed and validated internally via `@asyncapi/parser`. */
     raw: string;
+    /** UI configuration: theme, which sections to show, sidebar options, and more. */
     config?: ConfigInterface;
+    /** Called with the parser's diagnostics (errors/warnings) after each parse attempt. */
     onDiagnostics?: (diagnostics: unknown[]) => void;
 }
+/**
+ * Parses a raw AsyncAPI YAML/JSON string (via `@asyncapi/parser`) and renders
+ * the same full documentation page as `AsyncAPI`. Use this when you have a
+ * document as text rather than a pre-parsed object, e.g. user-entered or
+ * loaded from a file at runtime.
+ */
 export declare function AsyncAPIRenderer({ raw, config, onDiagnostics }: AsyncAPIRendererProps): import("react").JSX.Element | null;
 export {};

package/dist/containers/Information/InformationSection.d.ts

@@ -0,0 +1,22 @@
+interface InformationSectionProps {
+    title?: string;
+    description?: string;
+    license?: {
+        name?: string;
+        url?: string;
+    };
+    contact?: {
+        name?: string;
+        url?: string;
+        email?: string;
+    };
+    externalDocs?: {
+        description?: string;
+        url?: string;
+    };
+    tags?: unknown[];
+    /** The raw `info` object, scanned for x-* extensions (`x-logo` plus the x-tensions catalog). */
+    extensionsSource?: object;
+}
+export default function InformationSection({ title, description, license, contact, externalDocs, tags, extensionsSource, }: InformationSectionProps): import("react").JSX.Element;
+export {};

package/dist/containers/Information/OpenAPIInformation.d.ts

@@ -0,0 +1,9 @@
+import { OpenAPIExternalDocsData, OpenAPIInfoData, OpenAPITagData } from '../../types/openapi';
+interface OpenAPIInformationProps {
+    info: OpenAPIInfoData;
+    /** OpenAPI keeps tags/externalDocs at the document root, not on `info` (unlike AsyncAPI), so they are passed in separately. */
+    tags?: OpenAPITagData[];
+    externalDocs?: OpenAPIExternalDocsData;
+}
+export default function OpenAPIInformation({ info, tags, externalDocs }: OpenAPIInformationProps): import("react").JSX.Element;
+export {};

package/dist/containers/OpenAPI/Layout.d.ts

@@ -0,0 +1,7 @@
+import { ConfigInterface } from '../../config';
+import { OpenAPIDocumentData } from '../../types/openapi';
+export interface OpenAPILayoutProps {
+    openapi: OpenAPIDocumentData;
+    config: ConfigInterface;
+}
+export default function Layout({ openapi, config }: OpenAPILayoutProps): import("react").JSX.Element;

package/dist/containers/OpenAPI/OpenAPI.d.ts

@@ -0,0 +1,18 @@
+import { ConfigInterface } from '../../config';
+import { OpenAPIDocumentData } from '../../types/openapi';
+export interface IOpenAPIProps {
+    /** A pre-resolved OpenAPI 3.0/3.1 document object, or one that still contains `$ref`s. */
+    openapi: OpenAPIDocumentData;
+    /** UI configuration: theme, which sections to show, sidebar options, and more. */
+    config?: ConfigInterface;
+    /** Promise that `openapi` is already fully dereferenced upstream. Verified rather than trusted: `$ref`s left in place are still resolved either way, with a console warning that the promise was false. */
+    kind?: "resolved";
+}
+/**
+ * Renders a full OpenAPI documentation page: sidebar navigation, search,
+ * servers, endpoints, and schemas. Pass a pre-resolved (or `$ref`-carrying)
+ * document object; for raw YAML/JSON strings, use `OpenAPIRenderer` instead,
+ * which parses first.
+ */
+declare const OpenAPI: (props: IOpenAPIProps) => import("react").JSX.Element;
+export default OpenAPI;

package/dist/containers/OpenAPI/OpenAPIDocumentProvider.d.ts

@@ -0,0 +1,13 @@
+import { ReactNode } from 'react';
+import { ConfigInterface } from '../../config';
+import { OpenAPIDocumentData } from '../../types/openapi';
+export interface OpenAPIDocumentProviderProps {
+    document: OpenAPIDocumentData;
+    config?: ConfigInterface;
+    /** Extra classes merged onto the root surface (e.g. Layout's sidebar `pt-14`). */
+    className?: string;
+    children: ReactNode;
+}
+/** Mirrors AsyncAPIDocumentProvider, sharing the same DocumentContext shape. */
+export declare function OpenAPIDocumentProvider({ document: openapi, config, className, children, }: OpenAPIDocumentProviderProps): import("react").JSX.Element;
+export default OpenAPIDocumentProvider;

package/dist/containers/OpenAPI/OpenAPIRenderer.d.ts

@@ -0,0 +1,17 @@
+import { ConfigInterface } from '../../config/config';
+interface OpenAPIRendererProps {
+    /** Raw OpenAPI document as a YAML or JSON string, parsed and validated internally via `@readme/openapi-parser`. */
+    raw: string;
+    /** UI configuration: theme, which sections to show, sidebar options, and more. */
+    config?: ConfigInterface;
+    /** Called with the parser's diagnostics (errors/warnings) after each parse attempt. */
+    onDiagnostics?: (diagnostics: unknown[]) => void;
+}
+/**
+ * Parses a raw OpenAPI YAML/JSON string (via `@readme/openapi-parser`) and
+ * renders the same full documentation page as `OpenAPI`. Use this when you
+ * have a document as text rather than a pre-parsed object, e.g. user-entered
+ * or loaded from a file at runtime.
+ */
+export declare function OpenAPIRenderer({ raw, config, onDiagnostics }: OpenAPIRendererProps): import("react").JSX.Element | null;
+export {};

package/dist/containers/OpenAPI/tests/OpenAPI.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/containers/OpenAPI/tests/OpenAPIRenderer.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/containers/Operation/Operations.d.ts

@@ -5,6 +5,7 @@ interface OperationsProps {
     onSelectKey?: (key: string | null) => void;
     /** Which collapsed section of the selected operation search navigated to. */
     focusSection?: string | null;
+    showCopyMarkdown?: boolean;
 }
-export default function Operations({ operations, selectedKey, onSelectKey, focusSection }: OperationsProps): import("react").JSX.Element | null;
+export default function Operations({ operations, selectedKey, onSelectKey, focusSection, showCopyMarkdown }: OperationsProps): import("react").JSX.Element | null;
 export {};

package/dist/containers/Path/OperationCallbacks.d.ts

@@ -0,0 +1,37 @@
+import { ComponentType } from 'react';
+import { HttpMethod, OpenAPICallbackData } from '../../types/openapi';
+/**
+ * An operation's `callbacks`: requests the API sends back out to the caller
+ * after this operation runs. Each callback's leaf is an ordinary Operation
+ * Object, so it renders through PathOperation itself rather than a lesser
+ * parallel rendering that would drift from it.
+ *
+ * The direction is inverted from everything else in the panel, though. Here
+ * the API is the sender and the reader is the server, so the set is framed
+ * with who calls what before the reused operation view (whose own wording
+ * assumes the reader is the caller) appears.
+ *
+ * The spec nests these two deep (callback name, then URL expression, then
+ * method), but that hierarchy isn't worth making a reader navigate: it's
+ * flattened to one card per operation, each titled with all three parts, so
+ * every request body has its own labelled home.
+ */
+/** Injected to avoid an import cycle: PathOperation renders this file, and this file renders PathOperation back. */
+type OperationRenderer = ComponentType<{
+    method: HttpMethod;
+    path: string;
+    op: OpenAPICallbackData[string][HttpMethod] & object;
+    id: string | null;
+    idPrefix?: string;
+    depth?: number;
+}>;
+interface OperationCallbacksProps {
+    callbacks: Record<string, OpenAPICallbackData>;
+    /** Parent operation's anchor id, used to keep nested anchors unique. */
+    id: string | null;
+    renderOperation: OperationRenderer;
+    /** Nesting level of the parent operation, so a callback's own callbacks don't recurse without end. */
+    depth: number;
+}
+export default function OperationCallbacks({ callbacks, id, renderOperation: RenderOperation, depth, }: OperationCallbacksProps): import("react").JSX.Element | null;
+export {};

package/dist/containers/Path/PathOperation.d.ts

@@ -0,0 +1,21 @@
+import { HttpMethod, OpenAPIOperationData, OpenAPISecuritySchemeData } from '../../types/openapi';
+interface PathOperationProps {
+    method: HttpMethod;
+    path: string;
+    op: OpenAPIOperationData;
+    id: string | null;
+    /** Prefix for this operation's DOM anchor ids, so webhook anchors stay distinct from endpoint ones. */
+    idPrefix?: string;
+    /** Falls back to this when the operation doesn't declare its own `security`. */
+    globalSecurity?: Array<Record<string, string[]>>;
+    /** Scheme definitions (`components.securitySchemes`), resolved by name against `security`'s requirements to render the actual scheme details, not just their names. */
+    securitySchemes?: Record<string, OpenAPISecuritySchemeData>;
+    /** Opens the operation a response link points at, by its `operationId`. */
+    onFollowOperation?: (operationId: string) => void;
+    /** Whether an `operationId` resolves to an operation in the same list, so a response link can be navigable rather than plain text. */
+    isOperationKnown?: (operationId: string) => boolean;
+    /** Nesting level. A callback's operation may declare callbacks of its own, so past the first level they stop expanding rather than recursing without end. */
+    depth?: number;
+}
+export default function PathOperation({ method, path, op, id, idPrefix, globalSecurity, securitySchemes, onFollowOperation, isOperationKnown, depth, }: PathOperationProps): import("react").JSX.Element;
+export {};

package/dist/containers/Path/Paths.d.ts

@@ -0,0 +1,16 @@
+import { OpenAPIPathItemData, OpenAPISecuritySchemeData } from '../../types/openapi';
+interface PathsProps {
+    paths: Record<string, OpenAPIPathItemData | undefined>;
+    security?: Array<Record<string, string[]>>;
+    securitySchemes?: Record<string, OpenAPISecuritySchemeData>;
+    selectedKey?: string | null;
+    onSelectKey?: (key: string | null) => void;
+    focusSection?: string | null;
+    showCopyMarkdown?: boolean;
+    /** Heading for the identifier column. "Webhook" for OpenAPI 3.1 webhooks, whose keys are event names rather than URL paths. */
+    columnLabel?: string;
+    /** Prefix for this list's DOM anchor ids, keeping webhook anchors distinct from endpoint ones for search and sidebar navigation. */
+    idPrefix?: string;
+}
+export default function Paths({ paths, security, securitySchemes, selectedKey, onSelectKey, showCopyMarkdown, columnLabel, idPrefix, }: PathsProps): import("react").JSX.Element | null;
+export {};

package/dist/containers/Path/ResponseLinks.d.ts

@@ -0,0 +1,21 @@
+import { OpenAPILinkData } from '../../types/openapi';
+/**
+ * A response's `links`: which operation you can call next using values from
+ * this response. Rendered as a small annotated note rather than a tab or
+ * table, since a link is a design-time relationship worth pointing at, not a
+ * view of the response itself.
+ *
+ * The link's own `description` is the clickable part, so the sentence reads as
+ * documentation ("Fetch the newly created user using ...") rather than naming
+ * an operationId the reader has no other use for. It falls back to the target
+ * itself when a link declares no description.
+ */
+interface ResponseLinksProps {
+    links: Record<string, OpenAPILinkData>;
+    /** Opens the operation with this `operationId`. Omitted when nothing can navigate. */
+    onFollowOperation?: (operationId: string) => void;
+    /** Whether `operationId` resolves to an operation in the current list, so the target can be a link rather than plain text. */
+    isOperationKnown?: (operationId: string) => boolean;
+}
+export default function ResponseLinks({ links, onFollowOperation, isOperationKnown, }: ResponseLinksProps): import("react").JSX.Element;
+export {};

package/dist/containers/Path/tests/PathOperation.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/containers/Server/OpenAPIServer.d.ts

@@ -0,0 +1,4 @@
+import { OpenAPIServerData } from '../../types/openapi';
+type OpenAPIServerProps = OpenAPIServerData;
+export default function OpenAPIServer({ url, description, variables }: OpenAPIServerProps): import("react").JSX.Element;
+export {};

package/dist/containers/Server/OpenAPIServers.d.ts

@@ -0,0 +1,13 @@
+import { OpenAPIServerData } from '../../types/openapi';
+interface OpenAPIServersProps {
+    servers: OpenAPIServerData[];
+    selectedServer?: string | null;
+    onSelectServer?: (serverKey: string) => void;
+}
+/**
+ * OpenAPI's `servers` is an array (no name field), unlike AsyncAPI's keyed
+ * map — server keys here are stable positional indices ("server-0", ...),
+ * displayed via each server's own `url`.
+ */
+export default function OpenAPIServers({ servers, selectedServer, onSelectServer }: OpenAPIServersProps): import("react").JSX.Element;
+export {};

package/dist/contants.d.ts

@@ -1,3 +1,5 @@
+import { HttpMethod, OpenAPIParameterData } from './types/openapi';
+import { OperationAction } from './types/asyncapi/OperationAction';
 export declare const CONTACT_TEXT = "Contact";
 export declare const NAM_TEXT = "Name";
 export declare const URL_TEXT = "Url";
@@ -24,3 +26,8 @@ export declare const PROTOCOL_META: Record<string, {
     label: string;
     color: string;
 }>;
+export declare const PARAMETER_GROUPS: Array<{
+    location: OpenAPIParameterData["in"];
+    label: string;
+}>;
+export declare const METHOD_BADGE_COLOR_CLASSNAME: Record<HttpMethod | OperationAction, string>;