blume 1.7.3 → 2.0.1

package/dist/types/openapi/model.d.ts

@@ -0,0 +1,158 @@
+import type { Document, OperationObject } from "@scalar/openapi-types/3.1";
+import type { AsyncApiAction, AsyncApiDocument } from "./asyncapi.ts";
+import type { GraphqlDocument, GraphqlMember } from "./graphql.ts";
+import type { ReferenceKind } from "./references.ts";
+export { slugify } from "./references.ts";
+/**
+ * Blume's own API reference model, shared by both spec kinds. OpenAPI specs
+ * are parsed and upgraded to 3.1, AsyncAPI specs normalized to 3.x (see
+ * `parse.ts`), with internal `$ref`s left intact — the document stays
+ * JSON-serializable (a fully dereferenced graph can be circular), and the schema
+ * components resolve refs against `document.components.schemas` at render time.
+ * Each operation is flattened into an {@link ApiOperationRef} with a real,
+ * per-operation route so it becomes a first-class Blume page.
+ */
+/** A normalized OpenAPI 3.1 document, internal `$ref`s intact. */
+export type ApiDocument = Document;
+/** The HTTP methods an OpenAPI path item may declare, in spec order. */
+export declare const HTTP_METHODS: readonly ["get", "put", "post", "delete", "options", "head", "patch", "trace"];
+export type HttpMethod = (typeof HTTP_METHODS)[number];
+/** A stable, URL-safe key for an operation: its `operationId`, else method+path. */
+export declare const operationKey: (method: string, path: string, operationId?: string) => string;
+/** One operation, flattened out of its document and mapped to a route. */
+export interface ApiOperationRef {
+    /** Stable key, unique within a spec; matches the MDX `<Operation id>`. */
+    key: string;
+    /**
+     * HTTP method (OpenAPI), `send`/`receive` action (AsyncAPI), or the member
+     * kind — a root-field operation kind or a named-type kind (GraphQL).
+     */
+    method: HttpMethod | AsyncApiAction | GraphqlMember;
+    /**
+     * Templated path, e.g. `/pets/{id}` — the channel address (AsyncAPI), or
+     * the root field / type name (GraphQL).
+     */
+    path: string;
+    /** Full site route for this operation's page, e.g. `/reference/pet/add-pet`. */
+    route: string;
+    /** Display tag name (first tag; `Operations` or the channel address when untagged). */
+    tag: string;
+    tagSlug: string;
+    summary: string;
+    description: string;
+    /** The `operationId` (OpenAPI) or the `operations` map key (AsyncAPI). */
+    operationId?: string;
+    deprecated: boolean;
+    /** The channel the operation acts on (AsyncAPI only). */
+    channelId?: string;
+}
+/** A tag/section, in first-seen order. */
+export interface ApiTagRef {
+    slug: string;
+    name: string;
+    description: string;
+}
+/** Everything the runtime needs for one spec, serialized into `blume:openapi`. */
+export interface ApiSpecData {
+    /** Which front-end parsed the spec (and which components render it). */
+    kind: ReferenceKind;
+    /** Unique token used as the `<Operation source>` and the data-module key. */
+    slug: string;
+    /** Base route the spec's operations hang off, e.g. `/reference`. */
+    route: string;
+    label: string;
+    title: string;
+    version: string;
+    description: string;
+    document: ApiDocument | AsyncApiDocument | GraphqlDocument;
+    /**
+     * URL of the live GraphQL endpoint the playground and code samples target
+     * (GraphQL only; OpenAPI documents carry their servers in the document).
+     */
+    endpoint?: string;
+    /** Operations keyed by {@link ApiOperationRef.key}. */
+    operations: Record<string, ApiOperationRef>;
+    tags: ApiTagRef[];
+    /** Code-sample languages to render per operation. */
+    codeSamples: string[];
+    /** Whether nested schema rows start expanded. */
+    expandSchemas: boolean;
+    /**
+     * The "Try it" playground: whether operation pages render it, and the
+     * resolved proxy the Send button targets — `false` for direct requests, a
+     * URL string otherwise (the built-in `/_api-proxy` route already carries
+     * the site `basePath`).
+     */
+    playground: {
+        enabled: boolean;
+        proxy: string | false;
+    };
+}
+/** The generated `blume:openapi` module: specs keyed by {@link ApiSpecData.slug}. */
+export type OpenApiData = Record<string, ApiSpecData>;
+/**
+ * The spec a `<Operation source>` / `<ApiOverview source>` names, or nothing.
+ * `blume:openapi` crosses a JSON boundary as a plain object, so a lookup must
+ * be an own-property one: `source="toString"` would otherwise resolve to the
+ * inherited function, which is truthy and carries no `operations`, and every
+ * consumer would throw where it means to decline. Shared by the components
+ * and the agent-surface serializers so they miss the same way.
+ */
+export declare const specOf: (specs: OpenApiData, source: string) => ApiSpecData | undefined;
+/** The operation an `<Operation id>` names within its spec, or nothing. */
+export declare const operationOf: (spec: ApiSpecData, id: string) => ApiOperationRef | undefined;
+/** The addresses an API overview lists, and what to call them. */
+export interface SpecAddresses {
+    /** `Base URL` (OpenAPI), `Servers` (AsyncAPI) or `Endpoint` (GraphQL). */
+    label: string;
+    addresses: string[];
+}
+/**
+ * Where the API lives, flattened into one list for the overview page. OpenAPI
+ * declares `servers` as an array of URLs; AsyncAPI as a named map of
+ * host/protocol/pathname; a GraphQL schema names no server, so its configured
+ * live endpoint stands in.
+ */
+export declare const specAddresses: (spec: ApiSpecData) => SpecAddresses;
+/**
+ * Assign each distinct tag name a unique slug. `slugify` can collapse
+ * different names onto one value — any two punctuation-only tags (`!!!`,
+ * `???`) both fall through to the `operations` fallback — and a shared slug
+ * silently merges the tags' routes, sidebar groups, and overview sections.
+ * Collisions gain `-2`, `-3`, … in first-seen order. Shared with the AsyncAPI
+ * extractor (`asyncapi.ts`), whose untagged fallback groups are channel
+ * addresses.
+ */
+export declare const tagSlugger: () => ((name: string) => string);
+/** An operation before the collector assigns its unique key and route. */
+type CollectedOperation = Omit<ApiOperationRef, "route" | "tagSlug">;
+/** The flattened output both extractors produce. */
+export interface CollectedOperations {
+    operations: ApiOperationRef[];
+    tags: ApiTagRef[];
+}
+/** The collector handle: feed operations in, read the flattened output out. */
+export interface OperationCollector {
+    add: (entry: CollectedOperation) => void;
+    finish: () => CollectedOperations;
+}
+/** {@link CollectedOperations} plus anything the extractor had to skip. */
+export interface ExtractedOperations extends CollectedOperations {
+    warnings: string[];
+}
+/**
+ * The collector behind both extractors (OpenAPI here, AsyncAPI in
+ * `asyncapi.ts`): first-seen tag ordering, key de-duplication (a repeated key
+ * gains its method/action as a suffix), and the shared route template — so
+ * URL shape and slug rules can never drift between the two spec kinds.
+ */
+export declare const operationCollector: (baseRoute: string, tagMeta: ReadonlyMap<string, string>) => OperationCollector;
+/**
+ * Flatten a 3.1 document into a route-mapped operation list and its ordered
+ * tags. Operations inherit the first tag they declare; keys are de-duplicated so
+ * a repeated `operationId` still yields distinct routes. `warnings` reports
+ * anything skipped (a `$ref` path item), so missing operations aren't silent.
+ */
+export declare const extractOperations: (document: ApiDocument, baseRoute: string) => ExtractedOperations;
+/** Resolve the operation object for a ref out of its (OpenAPI) document. */
+export declare const operationObject: (spec: ApiSpecData, ref: ApiOperationRef) => OperationObject | undefined;

package/dist/types/openapi/parse.d.ts

@@ -0,0 +1,57 @@
+import type { AsyncApiDocument } from "./asyncapi.ts";
+import type { GraphqlDocument } from "./graphql.ts";
+import type { ApiDocument } from "./model.ts";
+export interface ParsedSpec {
+    document: ApiDocument;
+    warnings: string[];
+}
+/**
+ * The spec was read successfully but its contents aren't an OpenAPI document
+ * (an empty file, or YAML that parses to a scalar or list — say, a README
+ * pointed at by mistake). Kept distinct from read/fetch failures so callers
+ * can suggest fixing the file instead of checking reachability.
+ */
+export declare class InvalidSpecError extends Error {
+    constructor(message: string);
+}
+/** Where and whether to cache a remote spec's text between runs. */
+export interface SpecFetchOptions {
+    /** Dir for a last-good on-disk copy of a remote spec (offline fallback). */
+    cacheDir?: string;
+    /**
+     * Re-fetch even when a cached copy exists. Builds/sync refresh; dev is
+     * cache-first for fast, offline-tolerant restarts (see `SourceContext`).
+     */
+    refresh?: boolean;
+}
+export declare const parseSpec: (spec: string, root: string, options?: SpecFetchOptions) => Promise<ParsedSpec>;
+export interface ParsedAsyncApiSpec {
+    document: AsyncApiDocument;
+    warnings: string[];
+}
+/**
+ * Read and normalize a spec to an AsyncAPI 3.x document — the AsyncAPI mirror
+ * of {@link parseSpec}. 1.x/2.x documents are lifted to 3.0 with the official
+ * `@asyncapi/converter` (channels + operations with `send`/`receive` actions),
+ * so the extractor and components only ever handle one shape; `$ref`s stay
+ * intact, matching the OpenAPI path. Error semantics match `parseSpec`: an
+ * unreadable spec throws, a readable non-AsyncAPI document throws
+ * {@link InvalidSpecError}, a pre-3.0 document without the converter installed
+ * throws {@link SpecDependencyError}, and callers lower all three into source
+ * diagnostics.
+ */
+export declare const parseAsyncApiSpec: (spec: string, root: string, options?: SpecFetchOptions) => Promise<ParsedAsyncApiSpec>;
+export interface ParsedGraphqlSpec {
+    document: GraphqlDocument;
+    warnings: string[];
+}
+/**
+ * Read and lower a GraphQL schema — SDL text or an introspection JSON result —
+ * to the serializable document the reference renders from; the GraphQL mirror
+ * of {@link parseSpec}. Error semantics match the other kinds: an unreadable
+ * spec throws the read/fetch error, while readable-but-invalid schema text
+ * (SDL syntax errors, validation failures, JSON that isn't an introspection
+ * result) throws {@link InvalidSpecError} so callers suggest fixing the file
+ * rather than checking reachability.
+ */
+export declare const parseGraphqlSpec: (spec: string, root: string, options?: SpecFetchOptions) => Promise<ParsedGraphqlSpec>;

package/dist/types/openapi/references.d.ts

@@ -1,16 +1,23 @@
 import type { ResolvedConfig } from "../core/schema.ts";
+import type { ScalarOptions } from "../reference/scalar.ts";
+import type { ResolvedReferenceAdapter } from "../reference/schema.ts";
 export { normalizeRoute } from "../core/base-path.ts";
 /**
- * Pure resolution of the configured API reference blocks into concrete routes,
- * labels, and a renderer choice — no file IO, so the content source, the
+ * Pure resolution of the configured `reference` adapters into concrete routes
+ * and labels — no file IO, so the content source, the
  * nav-target validation, the Scalar page generator, and the `blume:openapi`
  * data module all share one source of truth. Kept free of any Astro/template
  * imports so `core` can depend on it without a cycle.
  */
-export type ReferenceKind = "openapi" | "asyncapi" | "graphql";
-/** Who renders a reference: Blume's own UI, or the embedded Scalar SPA. */
-export type ReferenceRenderer = "blume" | "scalar";
-/** Per-block display options for the Blume renderer. */
+/**
+ * Which adapter a reference came from. `openapi`, `asyncapi`, and `graphql`
+ * are rendered by Blume into real pages; `scalar` is the embedded Scalar SPA
+ * on a single route.
+ */
+export type ReferenceKind = ResolvedReferenceAdapter["kind"];
+/** The kinds Blume renders into pages itself — everything but the Scalar embed. */
+export type BlumeReferenceKind = Exclude<ReferenceKind, "scalar">;
+/** Per-adapter display options for the Blume renderer. */
 export interface ReferenceDisplay {
     /** Code-sample languages shown per operation. */
     codeSamples: string[];
@@ -26,10 +33,9 @@ export interface ReferenceDisplay {
         proxy: string | boolean;
     };
 }
-/** A spec source resolved to a concrete route, label, and renderer. */
+/** A spec source resolved to a concrete route and label. */
 export interface ReferenceSource {
     kind: ReferenceKind;
-    renderer: ReferenceRenderer;
     /** Unique token derived from the route; the `<Operation source>` / data key. */
     slug: string;
     /** Normalized route the reference mounts at, e.g. `/reference`. */
@@ -59,14 +65,12 @@ export interface ReferenceSource {
      * (GraphQL only — a schema, unlike an OpenAPI document, names no server).
      */
     endpoint?: string;
-    /** Per-block Scalar theme name override, if any (Scalar renderer only). */
-    theme?: string;
     /**
-     * Arbitrary Scalar config forwarded to `<ScalarComponent>` (Scalar renderer
-     * only). Takes precedence over Blume's derived spec/theme config. Typed off
-     * the config schema so the two can never drift.
+     * The `scalar()` adapter's own options (`scalar` kind only): `theme` plus
+     * any Scalar config forwarded verbatim to `<ScalarComponent>`, which takes
+     * precedence over Blume's derived spec/theme config.
      */
-    scalar?: ResolvedConfig["openapi"]["scalar"];
+    scalar?: ScalarOptions;
     /** Display options carried through to the Blume renderer. */
     display: ReferenceDisplay;
     /**
@@ -75,6 +79,10 @@ export interface ReferenceSource {
      */
     collisions?: string[];
 }
+/** A reference Blume renders itself: one the content pipeline stages pages for. */
+export type BlumeReferenceSource = ReferenceSource & {
+    kind: BlumeReferenceKind;
+};
 /**
  * Lowercase, hyphen-separated slug: `Add a Pet!` -> `add-a-pet`. Unicode
  * letters are kept (`Größe` -> `größe`), NFC-normalized so canonically
@@ -84,33 +92,37 @@ export interface ReferenceSource {
  */
 export declare const slugify: (text: string) => string;
 /**
- * Resolve every enabled reference. Both blocks honor their `renderer` —
- * Blume's own UI by default, with the embedded Scalar SPA as the opt-out.
+ * Resolve every configured reference, in `reference` order: Blume's own pages
+ * for `openapi()`, `asyncapi()`, and `graphql()`, and one embedded Scalar page
+ * per `scalar()` source.
  */
 export declare const resolveReferences: (config: ResolvedConfig) => ReferenceSource[];
 /**
- * Mounted route for every reference, regardless of renderer. References no
+ * Mounted route for every reference, regardless of kind. References no
  * longer add a header tab automatically — authors point a `navigation.tabs`
  * entry at one of these routes to surface it (and, for Blume-rendered specs, to
  * scope its operations sidebar). These routes are whitelisted as valid nav
  * targets so such a tab doesn't read as a broken link.
  */
 export declare const referenceRoutes: (config: ResolvedConfig) => string[];
-/** Blume-rendered references (both kinds), deduped by route (first wins). */
-export declare const blumeReferences: (config: ResolvedConfig) => ReferenceSource[];
-/** Whether any reference is Scalar-rendered (gates the `@scalar/astro` dep + pages). */
+/** Blume-rendered references (every kind but Scalar), deduped by route (first wins). */
+export declare const blumeReferences: (config: ResolvedConfig) => BlumeReferenceSource[];
+/** Whether any reference is Scalar-rendered (gates the Scalar pages). */
 export declare const hasScalarReferences: (config: ResolvedConfig) => boolean;
 /**
- * The reference kinds whose enabled, Blume-rendered playground opted into the
+ * The Blume-rendered references whose enabled playground opted into the
  * built-in CORS proxy with `proxy: true`. A proxy URL string points at an
  * external service, and `false` sends requests directly — neither routes
- * through the endpoint. The generator's per-spec allowlist diagnostics key on
- * this, so it shares one definition with {@link needsPlaygroundProxy}.
+ * through the endpoint. AsyncAPI never does: an event composer's WebSocket
+ * connect is direct, so its `proxy` has nothing to forward. Drawn from the
+ * deduped set so the slugs match the `blume:openapi` data keys; the
+ * generator's per-spec allowlist diagnostics key on this, so it shares one
+ * definition with {@link needsPlaygroundProxy}.
  */
-export declare const builtinProxyKinds: (config: ResolvedConfig) => ReferenceKind[];
+export declare const builtinProxyReferences: (config: ResolvedConfig) => BlumeReferenceSource[];
 /**
  * Whether the built-in playground CORS proxy endpoint (`/_api-proxy`) must be
- * generated: some enabled Blume-rendered block's playground opted into it with
+ * generated: some Blume-rendered reference's playground opted into it with
  * `proxy: true`. Shared by the server feature gate and the generator so the
  * two can never disagree.
  */

package/dist/types/openapi/render-mdx.d.ts

@@ -0,0 +1,33 @@
+import type { ApiOperationRef, ApiSpecData } from "./model.ts";
+import type { ReferenceSource } from "./references.ts";
+/**
+ * Frontmatter emitted for one operation or overview page. Boolean flags are
+ * assigned only when set, so absent keys stay absent in the staged MDX.
+ */
+export interface RenderedPageData {
+    ai?: {
+        exclude: boolean;
+    };
+    deprecated?: boolean;
+    search?: {
+        exclude?: boolean;
+        tags?: string[];
+    };
+    seo: {
+        description: string;
+        noindex?: boolean;
+    };
+    sidebar: {
+        badge?: string;
+        label: string;
+    };
+    title: string;
+    type?: string;
+}
+/** Frontmatter + body for one operation or overview page. */
+export interface RenderedPage {
+    data: RenderedPageData;
+    body: string;
+}
+export declare const operationMdx: (spec: ApiSpecData, operation: ApiOperationRef, reference?: Pick<ReferenceSource, "includeInLlms" | "includeInSearch" | "noindex" | "seoDescriptionSuffix">) => RenderedPage;
+export declare const overviewMdx: (spec: ApiSpecData, reference?: Pick<ReferenceSource, "includeInLlms" | "includeInSearch" | "noindex">) => RenderedPage;

package/dist/types/openapi/sentence.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Close a fragment of spec prose as a sentence. OpenAPI `summary` values are
+ * usually title-like ("Get a flag", no period), so prose that runs straight
+ * into the next generated sentence ("Get a flag Reference for …") needs one.
+ * Empty text stays empty.
+ */
+export declare const asSentence: (text: string) => string;

package/dist/types/openapi/signature.d.ts

@@ -0,0 +1,10 @@
+import type { ApiOperationRef, ApiSpecData } from "./model.ts";
+/**
+ * The one-line name of what an operation page documents, in the notation of
+ * its spec kind: `GET /pets/{id}` for an HTTP endpoint, `SEND user/signup`
+ * for an AsyncAPI channel action, `query pets` or `type Pet` for a GraphQL
+ * member. The page titles an untitled operation with it and the agent
+ * surfaces (`<route>.md`, llms-full.txt, MCP `get_page`) downlevel
+ * `<Operation>` to it, so the two can never disagree about the endpoint.
+ */
+export declare const operationSignature: (spec: Pick<ApiSpecData, "kind">, operation: Pick<ApiOperationRef, "method" | "path">) => string;

package/dist/types/openapi/source.d.ts

@@ -0,0 +1,22 @@
+import type { ContentSource, SourceContext } from "../core/sources/types.ts";
+import type { OpenApiData } from "./model.ts";
+import type { BlumeReferenceSource } from "./references.ts";
+/**
+ * The staged content source behind Blume's own API reference renderer (OpenAPI
+ * and AsyncAPI alike). Each configured spec is parsed once here, then lowered
+ * into one MDX page per operation plus an overview page — so operations become
+ * first-class Blume pages (real routes, sidebar, search, i18n, OG) and the
+ * parsed documents are handed to the generated `blume:openapi` module for the
+ * UI components to render. The source keeps its historical `openapi` name for
+ * both kinds — downstream consumers (`agents.llmsTxt.openapi`, the llms noindex
+ * exemption) key on it as "the generated API reference source".
+ */
+/** A content source that also exposes the specs it parsed during `load()`. */
+export interface OpenApiContentSource extends ContentSource {
+    readonly kind: "openapi-source";
+    /** Parsed spec data, populated by `load()`; `{}` before the first load. */
+    openApiData: () => OpenApiData;
+}
+/** Narrow a content source to the OpenAPI source (to read its parsed specs). */
+export declare const isOpenApiSource: (source: ContentSource) => source is OpenApiContentSource;
+export declare const openApiSource: (references: BlumeReferenceSource[], ctx: SourceContext) => OpenApiContentSource;

package/dist/types/openapi/spec-dependency-error.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Reading a spec needs an optional package the project hasn't installed (the
+ * AsyncAPI converter, for a pre-3.0 document). Carries its own suggestion —
+ * the install command — because neither of the other spec failures fits: the
+ * file is fine and so is the network.
+ */
+export declare class SpecDependencyError extends Error {
+    readonly suggestion: string;
+    constructor(message: string, suggestion: string);
+}

package/dist/types/reference/asyncapi.d.ts

@@ -0,0 +1,166 @@
+import { z } from "zod";
+import type { AdapterDescriptor } from "../core/adapter.ts";
+import type { PlaygroundOptions, ReferenceSourceOptions } from "./options.ts";
+/** Options for {@link asyncapi}. */
+export interface AsyncApiOptions {
+    /**
+     * Code-sample tools shown per operation (Blume renderer). Defaults to every
+     * tool appropriate to the operation's protocol binding.
+     */
+    codeSamples?: string[];
+    /** Start nested schema rows expanded rather than collapsed (Blume renderer). Defaults to `false`. */
+    expandSchemas?: boolean;
+    /**
+     * The "Try it" message composer (Blume renderer). On by default; `false`
+     * hides it. `proxy` is accepted for parity but doesn't apply to event
+     * operations — a WebSocket connect goes straight from the browser.
+     */
+    playground?: PlaygroundOptions;
+    /** Where the reference mounts. Defaults to `/events`. */
+    route?: string;
+    /** One or more specs; each renders on its own route by default. */
+    sources?: ReferenceSourceOptions[];
+    /** Shorthand for a single source: `sources: [{ spec }]`. */
+    spec?: string;
+}
+export declare const asyncapiOptionsSchema: z.ZodPipe<z.ZodObject<{
+    expandSchemas: z.ZodDefault<z.ZodBoolean>;
+    sources: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        includeInLlms: z.ZodDefault<z.ZodBoolean>;
+        includeInSearch: z.ZodDefault<z.ZodBoolean>;
+        label: z.ZodOptional<z.ZodString>;
+        noindex: z.ZodDefault<z.ZodBoolean>;
+        route: z.ZodOptional<z.ZodString>;
+        seoDescriptionSuffix: z.ZodDefault<z.ZodBoolean>;
+        spec: z.ZodString;
+    }, z.core.$strict>>>;
+    codeSamples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    playground: z.ZodPipe<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        proxy: z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+    }, z.core.$strict>]>>, z.ZodTransform<{
+        enabled: boolean;
+        proxy: string | boolean;
+    }, boolean | {
+        enabled: boolean;
+        proxy: string | boolean;
+    }>>;
+    route: z.ZodDefault<z.ZodString>;
+    spec: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodTransform<Omit<{
+    expandSchemas: boolean;
+    sources: {
+        includeInLlms: boolean;
+        includeInSearch: boolean;
+        noindex: boolean;
+        seoDescriptionSuffix: boolean;
+        spec: string;
+        label?: string | undefined;
+        route?: string | undefined;
+    }[];
+    codeSamples: string[];
+    playground: {
+        enabled: boolean;
+        proxy: string | boolean;
+    };
+    route: string;
+    spec?: string | undefined;
+}, "spec">, {
+    expandSchemas: boolean;
+    sources: {
+        includeInLlms: boolean;
+        includeInSearch: boolean;
+        noindex: boolean;
+        seoDescriptionSuffix: boolean;
+        spec: string;
+        label?: string | undefined;
+        route?: string | undefined;
+    }[];
+    codeSamples: string[];
+    playground: {
+        enabled: boolean;
+        proxy: string | boolean;
+    };
+    route: string;
+    spec?: string | undefined;
+}>>;
+/** `asyncapi()` options with every default applied and `spec` folded into `sources`. */
+export type ResolvedAsyncApiOptions = z.output<typeof asyncapiOptionsSchema>;
+export type AsyncApiAdapter = AdapterDescriptor<"asyncapi", AsyncApiOptions>;
+/** An `asyncapi()` descriptor as the config schema resolves it. */
+export type ResolvedAsyncApiAdapter = AdapterDescriptor<"asyncapi", ResolvedAsyncApiOptions>;
+export declare const asyncapiAdapterSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"asyncapi">;
+    options: z.ZodPipe<z.ZodObject<{
+        expandSchemas: z.ZodDefault<z.ZodBoolean>;
+        sources: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            includeInLlms: z.ZodDefault<z.ZodBoolean>;
+            includeInSearch: z.ZodDefault<z.ZodBoolean>;
+            label: z.ZodOptional<z.ZodString>;
+            noindex: z.ZodDefault<z.ZodBoolean>;
+            route: z.ZodOptional<z.ZodString>;
+            seoDescriptionSuffix: z.ZodDefault<z.ZodBoolean>;
+            spec: z.ZodString;
+        }, z.core.$strict>>>;
+        codeSamples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        playground: z.ZodPipe<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            proxy: z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+        }, z.core.$strict>]>>, z.ZodTransform<{
+            enabled: boolean;
+            proxy: string | boolean;
+        }, boolean | {
+            enabled: boolean;
+            proxy: string | boolean;
+        }>>;
+        route: z.ZodDefault<z.ZodString>;
+        spec: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodTransform<Omit<{
+        expandSchemas: boolean;
+        sources: {
+            includeInLlms: boolean;
+            includeInSearch: boolean;
+            noindex: boolean;
+            seoDescriptionSuffix: boolean;
+            spec: string;
+            label?: string | undefined;
+            route?: string | undefined;
+        }[];
+        codeSamples: string[];
+        playground: {
+            enabled: boolean;
+            proxy: string | boolean;
+        };
+        route: string;
+        spec?: string | undefined;
+    }, "spec">, {
+        expandSchemas: boolean;
+        sources: {
+            includeInLlms: boolean;
+            includeInSearch: boolean;
+            noindex: boolean;
+            seoDescriptionSuffix: boolean;
+            spec: string;
+            label?: string | undefined;
+            route?: string | undefined;
+        }[];
+        codeSamples: string[];
+        playground: {
+            enabled: boolean;
+            proxy: string | boolean;
+        };
+        route: string;
+        spec?: string | undefined;
+    }>>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * An AsyncAPI reference. Blume normalizes the spec to AsyncAPI 3.x and renders
+ * its own UI — one real page per operation, in the sidebar, search, llms.txt,
+ * and OG; a `scalar()` adapter is the embedded-SPA alternative. Only the
+ * defaults differ from `openapi()`: the reference mounts at `/events`, and
+ * empty `codeSamples` means every tool the operation's protocol binding
+ * suggests.
+ */
+export declare const asyncapi: (options: AsyncApiOptions) => AsyncApiAdapter;