redoc 2.5.4 → 3.0.0-rc.1

package/typings/services/code-samples/language-availability.d.ts

@@ -0,0 +1,4 @@
+/** Community edition: only the payload tab and languages with spec-provided `x-codeSamples` are offered. */
+export declare function filterAvailableLanguages<L extends {
+    key: string;
+}>(languages: L[], definitionSampleKeys: Set<string>): L[];

package/typings/services/code-samples/normalize-servers.d.ts

@@ -0,0 +1,3 @@
+import type { OpenAPIServer } from '../../types/openapi.js';
+export declare function resolveServerUrl(url: string, specUrl?: string): string;
+export declare function normalizeServers(specUrl: string | undefined, servers: OpenAPIServer[]): OpenAPIServer[];

package/typings/services/code-samples/server-env.d.ts

@@ -0,0 +1,3 @@
+import type { OpenAPIServer } from '../../types/openapi.js';
+/** Seeds one environment per global server so a saved environment name can resolve to a server in a fresh session. */
+export declare function buildServerEnvValues(servers: OpenAPIServer[]): Record<string, Record<string, string>>;

package/typings/services/code-samples/server-variables.d.ts

@@ -0,0 +1,11 @@
+type ServerWithVariables = {
+    url: string;
+    variables?: Record<string, {
+        default?: string;
+    }>;
+};
+/** Substitutes `{variable}` placeholders in a server URL with the variables' default values. */
+export declare function replaceServerVariables(server: ServerWithVariables): string;
+/** The environment may hold either the raw (templated) or the substituted server URL — match both. */
+export declare function serverMatchesUrl(server: ServerWithVariables, url: string | undefined): boolean;
+export {};

package/typings/services/code-samples/source.d.ts

@@ -0,0 +1,104 @@
+import type { OpenAPIParameterLocation } from '../../types/openapi.js';
+import type { SecuritySchemeIn, SecuritySchemeType, securitySchemeType, panelKind } from '../../types/common.js';
+import type { OAuthFlowsData, SecuritySchemeCredentials } from '../../types/store.js';
+export type { OAuthFlowsData, SecuritySchemeCredentials };
+export type ServerVariable = {
+    default?: string;
+    enum?: string[];
+    description?: string;
+};
+export type ServerEntry = {
+    url: string;
+    name?: string;
+    description?: string;
+    variables?: Record<string, ServerVariable>;
+    /** Set on entries injected by `mergeInMockServer` (never present in specs). */
+    isMockServer?: boolean;
+};
+export type ParameterEntry = {
+    name: string;
+    in: OpenAPIParameterLocation;
+    required?: boolean;
+    deprecated?: boolean;
+    example?: unknown;
+    schemaId?: string;
+    serializationMime?: string;
+    style?: string;
+    explode?: boolean;
+    allowReserved?: boolean;
+    /** Per-server example overrides: serverUrl → example value */
+    serverValues?: Record<string, {
+        example?: unknown;
+    }>;
+};
+export type SecuritySchemeEntry = {
+    id: string;
+    type: Exclude<SecuritySchemeType, typeof securitySchemeType.MUTUAL_TLS>;
+    name?: string;
+    in?: SecuritySchemeIn;
+    scheme?: string;
+    bearerFormat?: string;
+    openIdConnectUrl?: string;
+    flows?: OAuthFlowsData;
+    'x-defaultAccessToken'?: string;
+    'x-defaultTokenType'?: string;
+    'x-defaultClientId'?: string;
+    'x-defaultClientSecret'?: string;
+    'x-defaultUsername'?: string;
+    'x-defaultPassword'?: string;
+    /** Per-server auth overrides */
+    serverValues?: Record<string, SecuritySchemeCredentials>;
+};
+/** One AND-group: all schemes in the array must be satisfied together */
+export type SecurityRequirement = {
+    schemes: SecuritySchemeEntry[];
+    scopes: string[];
+};
+export type MediaTypeEntry = {
+    schemaId?: string;
+    exampleIds?: string[];
+};
+export type DefinitionCodeSample = {
+    lang: string;
+    label?: string;
+    source: string;
+};
+export type CodeSampleRequestValues = {
+    security?: Record<string, unknown>;
+    envVariables?: Record<string, string>;
+    serverEnvVariables?: Record<string, Record<string, string>>;
+    body?: unknown;
+    serverBody?: Record<string, unknown>;
+};
+export type CodeSampleSource = {
+    kind: typeof panelKind.CODE_SAMPLE;
+    operationType: 'http' | 'webhook' | 'callback';
+    method: string;
+    path: string;
+    servers: ServerEntry[];
+    parameters: {
+        path: ParameterEntry[];
+        query: ParameterEntry[];
+        querystring: ParameterEntry[];
+        header: ParameterEntry[];
+        cookie: ParameterEntry[];
+    };
+    security: SecurityRequirement[];
+    /** mediaType name → { schemaId, exampleIds } */
+    requestBody?: Record<string, MediaTypeEntry>;
+    /** Pre-authored code samples from the spec (x-codeSamples) */
+    definitionSamples?: DefinitionCodeSample[];
+    /** Response status codes (for generators that include expected status) */
+    responseCodes?: string[];
+    /** Configure request values (security credentials, env vars, per-server env vars) */
+    requestValues?: CodeSampleRequestValues;
+    /** Raw pointer into the spec (for deep linking) */
+    pointer?: string;
+    /** Docs route slug of the operation page, relative to the routing base path
+     * (e.g. `operations/getmuseumhours`) — lets hosts link back to the description */
+    href?: string;
+    /** OpenAPI `operationId` — should match the loaded spec so hosts can resolve the operation */
+    openApiOperationId?: string;
+    /** OpenAPI operation `summary` — the human-readable operation name */
+    summary?: string;
+};

package/typings/services/schema/dialects/graphqlSchema.d.ts

@@ -0,0 +1 @@
+export declare const GraphqlSchemaDialectId: 'graphql-schema';

package/typings/services/schema/dialects/jsonSchema.d.ts

@@ -0,0 +1,7 @@
+import type { SchemaProcessorDialect, Document } from '../../../types/schema.js';
+export declare function getImplicitDiscriminatorChildren(document: Document): Record<string, Array<{
+    ref: string;
+    value: string;
+}>>;
+export declare const JsonSchemaDialectId: "json-schema";
+export declare const jsonSchemaDialect: SchemaProcessorDialect;

package/typings/services/schema/index.d.ts

@@ -0,0 +1 @@
+export { schemaProcessor as processSchema } from './schemaProcessor.js';

package/typings/services/schema/propertyBuilder.d.ts

@@ -0,0 +1,32 @@
+import type { SchemaNode, DiscriminatorObject, PropertyType, AccessMode } from '../../types/schema.js';
+export declare function detectJsonSchemaType(schema: SchemaNode): string;
+export declare function schemaHasType(type: string | string[], target: string): boolean;
+export declare function isArrayTypedSchema(schema: SchemaNode): boolean;
+export declare function isStructuredArrayItems(items: SchemaNode): boolean;
+export declare function isPrimitiveLikeSchema(schema: SchemaNode, type: string | string[]): boolean;
+/**
+ * Primitive items that carry their own documentation are rendered as a nested
+ * `[i]` row, so the array row keeps only the array-level info; trivial primitive
+ * items stay flattened into the array row with their metadata promoted onto it.
+ */
+export declare function primitiveArrayItemsHaveOwnInfo(items: SchemaNode): boolean;
+export declare function humanizeConstraints(schema: SchemaNode): string[];
+export declare function buildDisplayType(schema: SchemaNode, type: string | string[]): {
+    typePrefix: string;
+    displayType: string;
+    displayFormat: string;
+};
+export declare function getDocumentedPrimitiveArrayItems(schema: SchemaNode, type: string | string[]): SchemaNode | undefined;
+export declare function stringifyValue(value: unknown): string;
+export declare function toPropertyExample(value: unknown, exampleSerializer?: (value: unknown) => string): PropertyType['example'];
+export declare function getAccessMode(schema: SchemaNode): AccessMode;
+export declare function getEnum(schema: SchemaNode): PropertyType['enum'];
+export declare function getDiscriminatorObject(schema: SchemaNode): DiscriminatorObject | undefined;
+export type PropertyShellOptions = {
+    isRequired?: boolean;
+    isAdditionalProperty?: boolean;
+    isPatternProperty?: boolean;
+    exampleSerializer?: (value: unknown) => string;
+};
+export declare function buildPropertyShell(schema: SchemaNode, options?: PropertyShellOptions): PropertyType;
+export declare function promotePrimitiveArrayMetadata(property: PropertyType, schema: SchemaNode, type: string | string[], exampleSerializer?: (value: unknown) => string): void;

package/typings/services/schema/propertyTreeBuilder.d.ts

@@ -0,0 +1,21 @@
+import type { SchemaNode, PropertyType } from '../../types/schema.js';
+export type SchemaTreeContext = {
+    prepareVariant(ref: SchemaNode): SchemaNode;
+    propertyRefCache: Map<string, PropertyType>;
+    variantResolutionCache: Map<string, SchemaNode>;
+    isChild?: boolean;
+    implicitDiscriminatorChildren?: Record<string, ImplicitDiscriminatorChild[]>;
+    exampleSerializer?: (value: unknown) => string;
+    sortRequiredPropsFirst?: boolean;
+    /** Refs open on the current DFS path; reaching one again is a cycle. */
+    activeRefs: Set<string>;
+    depth: number;
+    /** Refs on a reference cycle; memoized by ref alone so a cyclic component expands once. */
+    recursiveRefs: ReadonlySet<string>;
+};
+type ImplicitDiscriminatorChild = {
+    ref: string;
+    value: string;
+};
+export declare function buildPropertyTree(preparedRoot: SchemaNode, ctx: SchemaTreeContext, rootJsonPointer: string): PropertyType;
+export {};

package/typings/services/schema/schemaProcessor.d.ts

@@ -0,0 +1,2 @@
+import type { PropertyType, SchemaNode, Document, SchemaProcessorOptions } from '../../types/schema.js';
+export declare function schemaProcessor(schema: SchemaNode, document: Document, options?: SchemaProcessorOptions): PropertyType;

package/typings/services/schema/variant-label.d.ts

@@ -0,0 +1,6 @@
+import type { SchemaNode } from '../../types/schema.js';
+export type VariantLabel = {
+    label: string;
+    typeLabel: string;
+};
+export declare function deriveVariantLabel(variant: SchemaNode, parentSchema: SchemaNode): VariantLabel;

package/typings/services/search/engine/collapse.d.ts

@@ -0,0 +1,5 @@
+import type { SearchDocument } from '../types.js';
+import type { LowerDocument } from './lowered.js';
+import type { Candidate, ParsedQuery } from './types.js';
+export type LoweredLookup = (document: SearchDocument) => LowerDocument;
+export declare function collapseSharedFields(candidates: Candidate[], query: ParsedQuery, lowered: LoweredLookup): Candidate[];

package/typings/services/search/engine/constants.d.ts

@@ -0,0 +1,22 @@
+export declare const SEARCH_LIMIT = 100;
+export declare const SHARED_FIELD_COPIES = 3;
+export declare const SEARCH_CANDIDATE_LIMIT = 500;
+export { HIGHLIGHTED_TEXT_MAX_LENGTH } from '../highlight.js';
+export declare const SEARCH_INDEX_FIELDS: string[];
+export declare const SEARCH_SCORE: {
+    readonly titleExact: 2000;
+    readonly titlePrefix: 800;
+    readonly titleAllWords: 400;
+    readonly titlePartial: 150;
+    readonly paramNameExact: 250;
+    readonly paramNamePartial: 120;
+    readonly sectionTitleExact: 180;
+    readonly sectionTitlePartial: 90;
+    readonly paramValue: 40;
+    readonly paramPlace: 5;
+    readonly titleCoverage: 100;
+    readonly httpPath: 60;
+    readonly httpMethod: 50;
+    readonly text: 10;
+    readonly deprecated: -40;
+};

package/typings/services/search/engine/flexsearch.d.ts

@@ -0,0 +1,6 @@
+import { type Document, type Id, type DocumentData } from 'flexsearch';
+import type { SearchDocument } from '../types.js';
+export declare function createSearchIndex(): Document;
+/** Joins the values the index needs. The copy is temporary — the engine keeps the original. */
+export declare function toIndexedDocument(document: SearchDocument): DocumentData;
+export declare function candidateIds(index: Document, query: string): Promise<Set<Id>>;

package/typings/services/search/engine/index.d.ts

@@ -0,0 +1,11 @@
+import type { SearchDocument, SearchItemData } from '../types.js';
+export declare class SearchEngine {
+    private _index;
+    private _documents;
+    private _lowerDocuments;
+    addDocument(document: SearchDocument): void;
+    search(query: string): Promise<SearchItemData[]>;
+    private rankCandidates;
+    private appendCandidates;
+    private lowered;
+}

package/typings/services/search/engine/lowered.d.ts

@@ -0,0 +1,34 @@
+import type { SearchDocument } from '../types.js';
+import type { ParsedQuery } from './types.js';
+/**
+ * Lowercased copy of a document for substring matching. `parameters` holds every parameter's
+ * fields (name, description, path, example, enum, place) joined by newlines; `bounds` holds
+ * `PARAMETER_STRIDE` offsets per parameter — the start of each field, then the end of the last.
+ */
+export type LowerDocument = {
+    title: string;
+    text: string;
+    httpMethod: string;
+    httpPath: string;
+    path: string;
+    parameters: string;
+    bounds: Uint32Array;
+};
+export declare enum ParameterField {
+    Name = 0,
+    Description = 1,
+    Path = 2,
+    Example = 3,
+    Enum = 4,
+    Place = 5
+}
+/** Matching is substring-based, so every value is lowered once here rather than per query. */
+export declare function lowerDocument(document: SearchDocument): LowerDocument;
+/** One lowered field of parameter `index`, as a slice of the document blob. */
+export declare function field(page: LowerDocument, index: number, kind: ParameterField): string;
+/**
+ * Parameters whose text holds at least one query word, in definition order. Found by
+ * scanning the joined blob once per word, so parameters that cannot score are never
+ * visited — on large operations that is most of them.
+ */
+export declare function parametersMentioning(page: LowerDocument, count: number, query: ParsedQuery): number[];

package/typings/services/search/engine/match.d.ts

@@ -0,0 +1,12 @@
+import type { SearchDocument } from '../types.js';
+import type { LowerDocument } from './lowered.js';
+import type { DocumentMatch, ParameterHit, ParsedQuery } from './types.js';
+/**
+ * FlexSearch reports the index field, but the UI reads `title`, `text`, `httpPath`,
+ * `path` and `parameters`. So the hit fields come from the document, not from the index.
+ */
+export declare function resolveMatch(page: LowerDocument, document: SearchDocument, query: ParsedQuery): DocumentMatch;
+/** One value holds every query word, like the index intersects its terms per field. */
+export declare function coversInOneValue(page: LowerDocument, document: SearchDocument, query: ParsedQuery): boolean;
+/** Best matching parameter of every message other than the primary match's. */
+export declare function otherMessageMatches(page: LowerDocument, document: SearchDocument, match: DocumentMatch, query: ParsedQuery): ParameterHit[];

package/typings/services/search/engine/present.d.ts

@@ -0,0 +1,5 @@
+import type { SearchDocument, SearchItemData } from '../types.js';
+import type { LowerDocument } from './lowered.js';
+import type { DocumentMatch, ParsedQuery } from './types.js';
+export declare function resolveDeepLink(page: LowerDocument, document: SearchDocument, match: DocumentMatch, query: ParsedQuery): SearchDocument;
+export declare function prepareHighlight(document: SearchDocument, query: string, match: DocumentMatch): SearchItemData['highlight'];

package/typings/services/search/engine/query.d.ts

@@ -0,0 +1,6 @@
+import type { ParsedQuery } from './types.js';
+export declare function parseQuery(query: string): ParsedQuery;
+export declare function coverage(query: ParsedQuery, lowered: string): number;
+export declare function bestCoverage(query: ParsedQuery, values: string[]): number;
+export declare function coversQuery(query: ParsedQuery, lowered: string): boolean;
+export declare function matchesWords(query: ParsedQuery, lowered: string): boolean;

package/typings/services/search/engine/score.d.ts

@@ -0,0 +1,7 @@
+import type { SearchDocument } from '../types.js';
+import type { LowerDocument } from './lowered.js';
+import type { DocumentMatch, ParsedQuery } from './types.js';
+/** A page whose title is the query wins; a page that only mentions it in prose loses. */
+export declare function scoreMatch(page: LowerDocument, document: SearchDocument, match: DocumentMatch, query: ParsedQuery): number;
+/** How well the query matched one parameter; the value is also its ranking bonus. */
+export declare function scoreParameter(page: LowerDocument, document: SearchDocument, index: number, query: ParsedQuery): number;

package/typings/services/search/engine/text.d.ts

@@ -0,0 +1,3 @@
+export declare function toText(value: string | string[] | undefined): string;
+/** Lowercased text; array items are joined by newlines so a query word never spans two. */
+export declare function lowerText(value: unknown): string;

package/typings/services/search/engine/types.d.ts

@@ -0,0 +1,19 @@
+import type { OperationParameter, SearchDocument } from '../types.js';
+export type ParsedQuery = {
+    text: string;
+    words: string[];
+};
+export type DocumentMatch = {
+    fields: string[];
+    parameter: OperationParameter | undefined;
+    parameterScore: number;
+};
+export type Candidate = {
+    document: SearchDocument;
+    match: DocumentMatch;
+    score: number;
+};
+export type ParameterHit = {
+    parameter: OperationParameter;
+    score: number;
+};

package/typings/services/search/highlight.d.ts

@@ -0,0 +1,3 @@
+export declare const HIGHLIGHTED_TEXT_MAX_LENGTH = 150;
+export declare function highlightTextForSearch(query: string, text: string): string;
+export declare function markMatchedValue(query: string, value: string): string | undefined;

package/typings/services/search/index.d.ts

@@ -0,0 +1,4 @@
+export { ApiDocsSearchIndexer, type SearchIndexerOptions } from './indexer/index.js';
+export { highlightTextForSearch, markMatchedValue } from './highlight.js';
+export { matchableQueryWords, containsQueryWord } from './text-match.js';
+export type { SearchDocument, SearchItemData } from './types.js';

package/typings/services/search/indexer/context.d.ts

@@ -0,0 +1,8 @@
+import type { Node } from '@markdoc/markdoc';
+export type AsyncMessageSubsection = 'payload' | 'headers' | 'bindings';
+export type DescriptionFormatter = (desc: string | Node | Node[]) => string;
+export type WalkScope = {
+    callbackId?: string;
+    messageKey?: string;
+    pathOnly?: boolean;
+};

package/typings/services/search/indexer/deep-links.d.ts

@@ -0,0 +1,12 @@
+import type { AsyncMessageSubsection, WalkScope } from './context.js';
+export type FieldDeepLink = {
+    slug: string;
+    type: string;
+    in?: string;
+    contentType?: string;
+    responseCode?: string;
+    fieldPath: string[];
+    scope: WalkScope;
+};
+export declare function buildFieldDeepLink({ slug, type, in: inValue, contentType, responseCode, fieldPath, scope }: FieldDeepLink): string;
+export declare function buildAsyncMessageDeepLink(slug: string, messageKey: string | undefined, subsection: AsyncMessageSubsection, fieldPath: string[]): string;

package/typings/services/search/indexer/extractors/asyncapi.d.ts

@@ -0,0 +1,8 @@
+import type { ContainerNode, ContentNode } from '../../../../types/content.js';
+import type { ExtractContext, Extractor } from './context.js';
+export declare const messagesExtractor: Extractor;
+export declare function extractMessageBindingFields(container: ContainerNode, ctx: ExtractContext): void;
+/** The channel address, rendered under the channel title; sits inside the page container. */
+export declare function extractChannelAddress(children: ContentNode[]): string | undefined;
+/** One row per server (broker) the page lists: name, host, title, summary and description. */
+export declare function extractServerFields(container: ContainerNode, ctx: ExtractContext): void;

package/typings/services/search/indexer/extractors/body.d.ts

@@ -0,0 +1,2 @@
+import type { Extractor } from './context.js';
+export declare const bodyExtractor: Extractor;

package/typings/services/search/indexer/extractors/callbacks.d.ts

@@ -0,0 +1,4 @@
+import type { ContentNode, ItemContentNode } from '../../../../types/content.js';
+import type { ExtractContext } from './context.js';
+export type VisitNodes = (nodes: ContentNode[], ctx: ExtractContext) => void;
+export declare function extractCallback(callback: NonNullable<ItemContentNode['callback']>, ctx: ExtractContext, visit: VisitNodes): void;

package/typings/services/search/indexer/extractors/context.d.ts

@@ -0,0 +1,25 @@
+import type { OperationParameter } from '@redocly/theme/core/openapi';
+import type { Node } from '@markdoc/markdoc';
+import type { ItemContentNode } from '../../../../types/content.js';
+import type { ExampleEntry } from '../../../../types/store.js';
+import type { SchemaWalker } from '../schema-walker.js';
+import type { DescriptionFormatter, WalkScope } from '../context.js';
+export type ExtractContext = {
+    slug: string;
+    scope: WalkScope;
+    paramsMap: Record<string, OperationParameter>;
+    visited: Set<string>;
+    walker: SchemaWalker;
+    formatDescription: DescriptionFormatter;
+    hasSchemas: boolean;
+    exampleStore?: Record<string, ExampleEntry>;
+    /** True on the API overview page; parts that should lead there only are gated on it. */
+    isOverview: boolean;
+};
+export type Extractor = {
+    matches(node: ItemContentNode): boolean;
+    extract(node: ItemContentNode, ctx: ExtractContext): void;
+};
+export declare function addRow(ctx: ExtractContext, param: OperationParameter): void;
+export declare function describe(ctx: ExtractContext, desc: string | Node | Node[] | undefined): string;
+export declare function withScope(ctx: ExtractContext, scope: Partial<WalkScope>): ExtractContext;

package/typings/services/search/indexer/extractors/examples.d.ts

@@ -0,0 +1,3 @@
+import type { Extractor } from './context.js';
+/** Rows for the example selector labels of a request body, each response, and each message. */
+export declare const examplesExtractor: Extractor;

package/typings/services/search/indexer/extractors/graphql.d.ts

@@ -0,0 +1,2 @@
+import type { Extractor } from './context.js';
+export declare const graphqlExtractor: Extractor;

package/typings/services/search/indexer/extractors/heading-sections.d.ts

@@ -0,0 +1,3 @@
+import type { Node } from '@markdoc/markdoc';
+import type { ExtractContext } from './context.js';
+export declare function extractHeadingSections(content: string | Node | Node[] | undefined, ctx: ExtractContext): void;

package/typings/services/search/indexer/extractors/index.d.ts

@@ -0,0 +1,12 @@
+import type { ItemContentNode } from '../../../../types/content.js';
+import type { Extractor } from './context.js';
+export declare const extractors: readonly Extractor[];
+export declare function extractorsFor(node: ItemContentNode): Extractor[];
+export type { ExtractContext, Extractor } from './context.js';
+export { extractCallback } from './callbacks.js';
+export { extractHeadingSections } from './heading-sections.js';
+export { extractChannelAddress, extractMessageBindingFields, extractServerFields, } from './asyncapi.js';
+export { extractMcpFields } from './mcp.js';
+export { extractInfoMetadataRows, extractPanelRows } from './panels.js';
+export { extractSecurityRows } from './security.js';
+export { extractSchemaPageFields } from './schema-page.js';

package/typings/services/search/indexer/extractors/mcp.d.ts

@@ -0,0 +1,9 @@
+import type { OperationParameter } from '@redocly/theme/core/openapi';
+import type { ApiItem } from '../../../../types/store.js';
+import type { ExtractContext } from './context.js';
+type McpFields = {
+    text: string;
+    parameters: OperationParameter[];
+};
+export declare function extractMcpFields(item: ApiItem, document: Record<string, unknown> | undefined, ctx: ExtractContext): McpFields | undefined;
+export {};

package/typings/services/search/indexer/extractors/named-rows.d.ts

@@ -0,0 +1,9 @@
+import type { Node } from '@markdoc/markdoc';
+import type { ExtractContext, Extractor } from './context.js';
+export type NamedRow = {
+    name: string;
+    description?: string | Node | Node[];
+    type?: string;
+};
+export declare const namedRowsExtractor: Extractor;
+export declare function addNamedRows(rows: NamedRow[], place: string, suffix: string, ctx: ExtractContext): void;

package/typings/services/search/indexer/extractors/panels.d.ts

@@ -0,0 +1,10 @@
+import type { ContainerNode, InfoMetadataNode, ServersPanelItem } from '../../../../types/content.js';
+import type { ExtractContext } from './context.js';
+type ServerVariables = ServersPanelItem['servers'][number]['variables'];
+/** One row per server variable, on the overview page only, so a variable leads to the servers panel there. */
+export declare function extractServerVariableRows(variables: ServerVariables, ctx: ExtractContext): void;
+/** Rows for the side panels of a page: servers, and the info attributes (contact, license, terms). */
+export declare function extractPanelRows(container: ContainerNode, ctx: ExtractContext): void;
+/** One row per key/value of the overview's `x-metadata` table. */
+export declare function extractInfoMetadataRows(node: InfoMetadataNode, ctx: ExtractContext): void;
+export {};

package/typings/services/search/indexer/extractors/parameters.d.ts

@@ -0,0 +1,2 @@
+import type { Extractor } from './context.js';
+export declare const parametersExtractor: Extractor;

package/typings/services/search/indexer/extractors/responses.d.ts

@@ -0,0 +1,2 @@
+import type { Extractor } from './context.js';
+export declare const responsesExtractor: Extractor;

package/typings/services/search/indexer/extractors/schema-page.d.ts

@@ -0,0 +1,9 @@
+import type { OperationParameter } from '@redocly/theme/core/openapi';
+import type { SchemaEntry } from '../../../../types/store.js';
+import type { ExtractContext } from './context.js';
+type SchemaPageFields = {
+    parameters: OperationParameter[];
+    description: string;
+};
+export declare function extractSchemaPageFields(schemaName: string, schemaStore: Record<string, SchemaEntry> | undefined, ctx: ExtractContext): SchemaPageFields;
+export {};

package/typings/services/search/indexer/extractors/security.d.ts

@@ -0,0 +1,4 @@
+import type { SecurityNode } from '../../../../types/content.js';
+import type { ExtractContext } from './context.js';
+/** One row per security scheme the operation accepts: name plus the short type line and scopes. */
+export declare function extractSecurityRows(node: SecurityNode, ctx: ExtractContext): void;

package/typings/services/search/indexer/index.d.ts

@@ -0,0 +1,14 @@
+import type { ApiItem, ExampleEntry, SchemaEntry } from '../../../types/store.js';
+import type { SearchDocument } from '../types.js';
+import type { DescriptionFormatter } from './context.js';
+export type SearchIndexerOptions = {
+    formatDescription?: DescriptionFormatter;
+    /** Enables example rows (the example selector labels); without it they are skipped. */
+    exampleStore?: Record<string, ExampleEntry>;
+};
+export declare class ApiDocsSearchIndexer {
+    #private;
+    constructor(basePath: string, schemaStore?: Record<string, SchemaEntry>, document?: Record<string, unknown>, options?: SearchIndexerOptions);
+    addItem(item: ApiItem, ancestors?: string[]): void;
+    getResult(): SearchDocument[];
+}

package/typings/services/search/indexer/param.d.ts

@@ -0,0 +1,7 @@
+import type { OperationParameter } from '@redocly/theme/core/openapi';
+export declare function makeParam(fields: Partial<OperationParameter> & {
+    name: string | string[];
+    place: string;
+}): OperationParameter;
+export declare function truncateIndexedExample(example: string): string;
+export declare function getParameterId(param: OperationParameter, callbackId?: string, messageKey?: string): string;

package/typings/services/search/indexer/places.d.ts

@@ -0,0 +1,42 @@
+import type { AsyncMessageSubsection } from './context.js';
+/**
+ * The `place` grammar — every label the indexer stamps on a row. A place is shown in the
+ * result row, keyed into the dedup id, and parsed back (`responseCodeOf`,
+ * `asyncSubsectionOf`, `isDescriptionPlace`), so every literal lives here.
+ */
+export declare const REQUEST_FIELDS_PLACE = "request fields";
+export declare const REQUEST_BODY_PLACE = "request body";
+export declare const SCHEMA_FIELDS_PLACE = "schema fields";
+export declare const DESCRIPTION_PLACE = "description";
+export declare const CALLBACK_PLACE = "callback";
+export declare const MESSAGE_PLACE = "message";
+export declare const MESSAGE_PAYLOAD_PLACE = "message payload";
+export declare const MESSAGE_HEADERS_PLACE = "message headers";
+export declare const MESSAGE_BINDINGS_PLACE = "message bindings";
+export declare const SERVER_PLACE = "server";
+export declare const SERVER_VARIABLES_PLACE = "server variables";
+export declare const OVERVIEW_PLACE = "overview";
+export declare const METADATA_PLACE = "metadata";
+export declare const SECURITY_PLACE = "security";
+export declare const REQUEST_EXAMPLES_PLACE = "request examples";
+export declare const MESSAGE_EXAMPLES_PLACE = "message examples";
+export declare const GRAPHQL_ARGUMENTS_PLACE = "arguments";
+export declare const MCP_INPUT_SCHEMA_PLACE = "input schema";
+export declare const MCP_OUTPUT_SCHEMA_PLACE = "output schema";
+export declare const MCP_PROMPT_ARGUMENTS_PLACE = "arguments";
+/** Place of a top-level parameter, by its content-node variant. */
+export declare function parameterPlaceOf(variant: string | undefined): string;
+/** Place of schema/graphql field rows, by their content-node variant. */
+export declare function fieldsPlaceOf(variant: string | undefined): string;
+export declare function responseSectionPlace(code: string): string;
+export declare function responseFieldsPlace(code: string): string;
+export declare function responseHeadersPlace(code: string): string;
+export declare function responseExamplesPlace(code: string): string;
+/** Prefixes places produced inside a callback so search entries read as the callback's. */
+export declare function scopedPlace(place: string, callbackId?: string): string;
+export declare function responseCodeOf(place: string): string | undefined;
+export declare function asyncSubsectionOf(place: string): AsyncMessageSubsection | undefined;
+/** Markdown-heading rows: `description`, or `callback description` inside a callback. */
+export declare function isDescriptionPlace(place: string): boolean;
+/** Example selector labels: `request examples`, `response 201 examples`, `message examples`. */
+export declare function isExamplesPlace(place: string): boolean;