redoc 2.5.4 → 3.0.0-rc.1

package/typings/adapters/graphql/utils/createApiItem.d.ts

@@ -0,0 +1,15 @@
+import type { GraphqlItemVariant, TypeGroupFilter } from '../../../types/graphql.js';
+import type { ApiItem } from '../../../types/store.js';
+type CreateApiItemParams<T> = {
+    name: string;
+    variant: GraphqlItemVariant;
+    processedItems?: Set<string>;
+    filter?: TypeGroupFilter;
+    menuCommonFilter?: TypeGroupFilter;
+    label?: string;
+    deprecated?: boolean;
+    source: T;
+    parentPath?: string;
+};
+export declare function createApiItem<T>(params: CreateApiItemParams<T>): ApiItem | null;
+export {};

package/typings/adapters/graphql/utils/getBadges.d.ts

@@ -0,0 +1,4 @@
+import type { GraphQLSchema } from 'graphql';
+import type { Badge } from '../../../types/common.js';
+import type { GraphqlItemVariant } from '../../../types/graphql.js';
+export declare function getBadges(schema: GraphQLSchema, item: string, typeGroup?: GraphqlItemVariant): Badge[] | undefined;

package/typings/adapters/graphql/utils/ignoreInternalItems.d.ts

@@ -0,0 +1,3 @@
+export declare function ignoreInternalItems<T extends {
+    name: string;
+}>(items: T[]): T[];

package/typings/adapters/graphql/utils/isRootType.d.ts

@@ -0,0 +1,2 @@
+import type { GraphQLNamedType, GraphQLSchema } from 'graphql';
+export declare function isRootType(type: GraphQLNamedType, schema: GraphQLSchema): boolean;

package/typings/adapters/graphql/utils/menuSlashRegex.d.ts

@@ -0,0 +1 @@
+export declare const MENU_SLASH_DELIMITED_REGEX: RegExp;

package/typings/adapters/graphql/utils/normalizeMenu.d.ts

@@ -0,0 +1,3 @@
+import type { GraphQLSchema } from 'graphql';
+import type { MenuConfig } from '../../../types/graphql.js';
+export declare function normalizeMenuConfig(menu?: MenuConfig, schema?: GraphQLSchema): MenuConfig | undefined;

package/typings/adapters/graphql/utils/shouldIncludeItem.d.ts

@@ -0,0 +1,2 @@
+import type { TypeGroupFilter } from '../../../types/graphql.js';
+export declare function shouldIncludeItem(itemName: string, specific?: TypeGroupFilter, common?: TypeGroupFilter): boolean;

package/typings/adapters/graphql/utils/summary.d.ts

@@ -0,0 +1,4 @@
+import type { GraphQLSchema } from 'graphql';
+import type { GraphqlItemVariant } from '../../../types/graphql.js';
+import type { ParseMarkdownOptions } from '../../utils/parseMarkdown.js';
+export declare function getSummary(schema: GraphQLSchema, item: string, markdownOptions: ParseMarkdownOptions, typeGroup?: GraphqlItemVariant): string | undefined;

package/typings/adapters/graphql/utils/validateMenuConfig.d.ts

@@ -0,0 +1,3 @@
+import type { GraphQLSchema } from 'graphql';
+import type { MenuConfig } from '../../../types/graphql.js';
+export declare function validateGraphqlMenuConfig(schema: GraphQLSchema, menuConfig?: MenuConfig): void;

package/typings/adapters/helpers.d.ts

@@ -0,0 +1,40 @@
+import type { SchemaEntry, ExampleEntry, SecuritySchemeEntry, StoreContext } from '../types/store.js';
+import type { OpenAPIRef, Referenced } from '../types/common.js';
+import type { OpenAPIMediaType, OpenAPIExample } from '../types/openapi.js';
+import { isRecord } from '../utils/is-record.js';
+export { isRecord };
+export declare function resetStoreCounters(): void;
+export declare function stableStringify(data: unknown, seen?: Set<unknown>): string;
+export declare function registerSchema(schemaStore: Record<string, SchemaEntry>, hashIndex: Record<string, string>, entry: Omit<SchemaEntry, 'id'> & {
+    id?: string;
+}): string;
+/** Accepts a raw markdown string or a host-pre-parsed AST node; drops anything else. */
+export declare function pickRenderableDescription(value: unknown): ExampleEntry['description'];
+export declare function registerExample(exampleStore: Record<string, ExampleEntry>, entry: Omit<ExampleEntry, 'id'> & {
+    id?: string;
+}): string;
+export declare function registerSecurityScheme(securitySchemeStore: Record<string, SecuritySchemeEntry>, entry: SecuritySchemeEntry): string;
+export declare function createStoreContext(document: Record<string, unknown>): StoreContext;
+/**
+ * Safely coerce a value to Record<string, unknown>.
+ * Returns an empty object if the value is not a valid record.
+ */
+export declare function toRecord(value: unknown): Record<string, unknown>;
+export declare function resolveRef<T>(spec: Record<string, unknown>, value: Referenced<T>, ignoreNamedSchemas?: Set<string>): T | undefined;
+export type MediaTypesMap = {
+    [mime: string]: OpenAPIMediaType;
+};
+export declare function isOpenAPIRef(value: unknown): value is OpenAPIRef;
+type LegacyExampleHost = {
+    content?: Referenced<MediaTypesMap>;
+    'x-examples'?: {
+        [mime: string]: {
+            [name: string]: Referenced<OpenAPIExample>;
+        };
+    };
+    'x-example'?: {
+        [mime: string]: unknown;
+    };
+};
+export declare function resolveContent(spec: Record<string, unknown>, info: LegacyExampleHost | null | undefined, ignoreNamedSchemas?: Set<string>): MediaTypesMap | undefined;
+export declare function resolveJsonPointer(spec: Record<string, unknown>, ref: string): Record<string, unknown> | undefined;

package/typings/adapters/openapi/build/context.d.ts

@@ -0,0 +1,13 @@
+import type { OpenAPIDefinition, OpenAPICallback, OpenApiBuildContext as BuildContext, NormalizedCallback } from '../../../types/openapi.js';
+import type { Referenced } from '../../../types/common.js';
+import type { AdapterBuildContextInput, StoreContext } from '../../../types/store.js';
+type BuildContextWithDocument = AdapterBuildContextInput & {
+    document: OpenAPIDefinition;
+    storeCtx: StoreContext;
+    processContent?: boolean;
+};
+export declare function createBuildContext({ document, options, basePath, storeCtx, processContent }: BuildContextWithDocument): BuildContext;
+export declare function normalizeCallbacks(callbacks: {
+    [name: string]: Referenced<OpenAPICallback>;
+} | undefined, document: Record<string, unknown>, ignoreNamedSchemas?: Set<string>): NormalizedCallback[] | undefined;
+export {};

package/typings/adapters/openapi/build-code-sample-source.d.ts

@@ -0,0 +1,4 @@
+import type { OperationInfo } from '../../types/openapi.js';
+import type { StoreContext } from '../../types/store.js';
+import type { CodeSampleSource } from '../../services/code-samples/index.js';
+export declare function buildCodeSampleSource(operationInfo: OperationInfo, storeCtx: StoreContext, ignoreNamedSchemas?: Set<string>, isWebhook?: boolean, href?: string): CodeSampleSource;

package/typings/adapters/openapi/buildContext.d.ts

@@ -0,0 +1,2 @@
+import type { OpenApiBuildContext as BuildContext } from '../../types/openapi.js';
+export declare const openApiContext: import("../scopedContext.js").ScopedContext<BuildContext>;

package/typings/adapters/openapi/configure/apply-request-values.d.ts

@@ -0,0 +1,3 @@
+import type { ConfigureRequestValues, ConfigureServerRequestValues } from '@redocly/theme/ext/configure';
+import type { OperationInfo, OpenAPIServer } from '../../../types/openapi.js';
+export declare function applyRequestValuesToOperationInfo(operationInfo: OperationInfo, requestValues: ConfigureRequestValues | ConfigureServerRequestValues, mergedServers?: OpenAPIServer[]): void;

package/typings/adapters/openapi/configure/index.d.ts

@@ -0,0 +1,3 @@
+export { resolveRequestValues } from './resolve-request-values.js';
+export type { ResolveRequestValuesParams } from './resolve-request-values.js';
+export { applyRequestValuesToOperationInfo } from './apply-request-values.js';

package/typings/adapters/openapi/configure/merge-utils.d.ts

@@ -0,0 +1,30 @@
+import type { ConfigureRequestValues, ConfigureServerRequestValues, SecurityDetails } from '@redocly/theme/ext/configure';
+import type { OpenAPIParameterLocation, OpenAPIServer } from '../../../types/openapi.js';
+import type { SecuritySchemeCredentials } from '../../../services/code-samples/source.js';
+export declare function getParamValueMap(loc: OpenAPIParameterLocation, source: ConfigureRequestValues): Record<string, string> | undefined;
+export declare function mergeBodyValue(base: unknown, overlay: unknown): unknown;
+export type SchemeForCredentials = {
+    id: string;
+    type?: string;
+    scheme?: string;
+    scopes?: string[];
+    serverValues?: Record<string, SecuritySchemeCredentials>;
+};
+export declare function updateObjectProperties(original: unknown, updates: unknown): unknown;
+export declare function isDirectRequestValues(value: ConfigureRequestValues | ConfigureServerRequestValues | undefined | null): value is ConfigureRequestValues;
+export declare function getEffectiveRequestValues(requestValues: ConfigureRequestValues | ConfigureServerRequestValues | undefined, servers: readonly {
+    url: string;
+}[] | undefined): ConfigureRequestValues | undefined;
+export declare function createSecurityUpdates(scheme: SchemeForCredentials, securityValues: Record<string, SecurityDetails>): SecuritySchemeCredentials;
+export declare function mergeSecurityIntoScheme<S extends SchemeForCredentials>(scheme: S, securityValues: Record<string, SecurityDetails>): S & SecuritySchemeCredentials;
+export declare function mergeSecurityIntoScheme<S extends SchemeForCredentials>(scheme: S, securityValues: Record<string, SecurityDetails>, serverUrl: string): S & {
+    serverValues: Record<string, SecuritySchemeCredentials>;
+};
+export declare function applyServerVariableDefaults(servers: OpenAPIServer[] | undefined, serverVariables: Record<string, string> | undefined, targetServerUrl?: string): void;
+/** Immutable variant of {@link applyServerVariableDefaults} for runtime callers that must not mutate. */
+export declare function withServerVariableDefaults<T extends {
+    url: string;
+    variables?: Record<string, {
+        default?: string;
+    }>;
+}>(servers: readonly T[], serverVariables: Record<string, string> | undefined, targetServerUrl?: string): T[];

package/typings/adapters/openapi/configure/resolve-request-values.d.ts

@@ -0,0 +1,15 @@
+import { type ConfigureRequestValues, type ConfigureServerRequestValues } from '@redocly/theme/ext/configure';
+import type { OpenAPIServer } from '@redocly/theme/core/types';
+import type { OperationInfo } from '../../../types/openapi.js';
+export type ResolveRequestValuesParams = {
+    operationInfo: OperationInfo;
+    info: Record<string, unknown>;
+    servers: OpenAPIServer[];
+    basePath: string;
+    dynamicRequestValues?: ConfigureRequestValues | ConfigureServerRequestValues;
+};
+/**
+ * Builds configure context, calls the ejected configure() function, and returns
+ * merged request values: dynamicRequestValues ?? configResult.requestValues ?? {}.
+ */
+export declare function resolveRequestValues(params: ResolveRequestValuesParams): ConfigureRequestValues | ConfigureServerRequestValues;

package/typings/adapters/openapi/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const SUPPORTED_MCP_TYPES: readonly ['tools', 'resources', 'prompts'];
+export type McpCollectionType = (typeof SUPPORTED_MCP_TYPES)[number];
+export declare const MCP_SERVER_EXPERIMENTAL_CAPABILITIES = "experimental";
+export declare const PAGE_ACTIONS_MCP: ("mcp-cursor" | "mcp-vscode")[];

package/typings/adapters/openapi/group/content.d.ts

@@ -0,0 +1,25 @@
+import type { Node } from '@markdoc/markdoc';
+import type { ApiItemContent } from '../../../types/content.js';
+import type { BreadcrumbItem, GroupItem } from '../../../types/store.js';
+import type { OpenAPITagExtended, OperationInfo } from '../../../types/openapi.js';
+import type { ParseMarkdownOptions } from '../../utils/parseMarkdown.js';
+import type { McpGroupItems } from '../items/mcp/item.js';
+export type ChildTagInfo = {
+    displayName: string;
+    summary?: string;
+    slug: string;
+};
+export declare function buildGroupContent({ tag, tagName, headerLabel, description, operations, schemasItems, mcpItems, tagSlug, basePath, breadcrumbs, childTags, markdownOptions }: {
+    tag: OpenAPITagExtended;
+    tagName: string;
+    headerLabel?: string;
+    description?: string | Node[] | Node;
+    operations: OperationInfo[];
+    schemasItems?: GroupItem[];
+    mcpItems?: McpGroupItems;
+    tagSlug: string;
+    basePath: string;
+    breadcrumbs?: BreadcrumbItem[];
+    childTags?: ChildTagInfo[];
+    markdownOptions: ParseMarkdownOptions;
+}): ApiItemContent;

package/typings/adapters/openapi/group/item.d.ts

@@ -0,0 +1,8 @@
+import type { ApiItem } from '../../../types/store.js';
+import type { OpenAPIDefinition } from '../../../types/openapi.js';
+export declare function addTagItems(document: OpenAPIDefinition, result: ApiItem[]): void;
+export declare function processTagGroups(xTagGroups: Array<{
+    name: string;
+    tags: string[];
+}>, result: ApiItem[]): void;
+export declare function processRootTags(tagOrder: string[], childTagNames: Set<string>, result: ApiItem[]): void;

package/typings/adapters/openapi/index.d.ts

@@ -0,0 +1,13 @@
+import type { ApiDocAdapterProps, ApiItem, ApiStore } from '../../types/store.js';
+import type { OpenAPIDefinition } from '../../types/openapi.js';
+import type { ApiDocsOptions } from '../../types/options.js';
+export type { OpenApiBuildContext as BuildContext, TagData } from '../../types/openapi.js';
+export declare function processOpenApiDocument({ document, basePath, options, processContent }: ApiDocAdapterProps & {
+    document: OpenAPIDefinition;
+    options: ApiDocsOptions;
+    processContent?: boolean;
+}): Promise<{
+    items: ApiItem[];
+    store: ApiStore;
+}>;
+export declare function buildOpenApiItems(): ApiItem[];

package/typings/adapters/openapi/items/mcp/content.d.ts

@@ -0,0 +1,5 @@
+import type { ApiItemContent } from '../../../../types/content.js';
+import type { ApiDocsOptions } from '../../../../types/options.js';
+type McpItemType = 'tool' | 'rsrc' | 'prompt';
+export declare function buildMcpItemContent(mcpType: McpItemType, name: string, id: string, title: string, options: ApiDocsOptions): ApiItemContent;
+export {};

package/typings/adapters/openapi/items/mcp/item.d.ts

@@ -0,0 +1,9 @@
+import type { ApiItem, GroupItem } from '../../../../types/store.js';
+import { type McpCollectionType } from '../../constants.js';
+export declare function addMcpItems({ tagName, tagSlug, result, groupItems }: {
+    tagName: string;
+    tagSlug: string;
+    result: ApiItem[];
+    groupItems?: McpGroupItems;
+}): void;
+export type McpGroupItems = Record<McpCollectionType, GroupItem[]>;

package/typings/adapters/openapi/items/operation/content.d.ts

@@ -0,0 +1,12 @@
+import type { ApiItemContent } from '../../../../types/content.js';
+import type { OperationInfo } from '../../../../types/openapi.js';
+/**
+ * Callback ids in the legacy openapi-docs shape, `<name>/<verb>`, so links shared from it
+ * still resolve. One entry is emitted per url expression, so that pair can repeat within an
+ * operation — later duplicates take a `~<n>` suffix, which legacy lacked and collided on.
+ *
+ * The separator is deliberately not `/`: an id must never be a path-segment prefix of a
+ * sibling's, or hash matching would treat `<name>/<verb>` as also naming `<name>/<verb>~1`.
+ */
+export declare function createCallbackIdFactory(): (name: string, httpVerb: string) => string;
+export declare function buildItemContent(operationInfo: OperationInfo, pageSlug: string): ApiItemContent;

package/typings/adapters/openapi/items/operation/item.d.ts

@@ -0,0 +1,9 @@
+import type { ApiItem } from '../../../../types/store.js';
+import type { OperationInfo } from '../../../../types/openapi.js';
+import { type RbacScope } from '../../../rbac.js';
+export declare function addOperationItems({ operations, result, basePath: basePathOverride, parentRbac }: {
+    operations: OperationInfo[];
+    result: ApiItem[];
+    basePath?: string;
+    parentRbac?: RbacScope;
+}): void;

package/typings/adapters/openapi/items/overview/content.d.ts

@@ -0,0 +1,17 @@
+import type { Node } from '@markdoc/markdoc';
+import type { ContentNode, ApiItemContent } from '../../../../types/content.js';
+import type { OpenAPIDefinition } from '../../../../types/openapi.js';
+import type { ApiDocsOptions, NormalizedDownloadUrl } from '../../../../types/options.js';
+type OverviewContentOptions = {
+    downloadUrls?: NormalizedDownloadUrl[];
+    basePath: string;
+    sanitize: ApiDocsOptions['sanitize'];
+    markdownParser: ApiDocsOptions['markdownParser'];
+} & Partial<ApiDocsOptions>;
+export declare function buildOverviewContent({ document, description, sectionChildren, options }: {
+    document: OpenAPIDefinition;
+    description: string | Node[] | undefined;
+    sectionChildren: ContentNode[];
+    options: OverviewContentOptions;
+}): ApiItemContent;
+export {};

package/typings/adapters/openapi/items/overview/item.d.ts

@@ -0,0 +1,3 @@
+import type { ApiItem } from '../../../../types/store.js';
+import type { OpenAPIDefinition } from '../../../../types/openapi.js';
+export declare function buildOverviewItems(document: OpenAPIDefinition): ApiItem[];

package/typings/adapters/openapi/items/schema/content.d.ts

@@ -0,0 +1,3 @@
+import type { ApiItemContent } from '../../../../types/content.js';
+import type { ApiDocsOptions } from '../../../../types/options.js';
+export declare function buildSchemaDefinitionContent(schemaName: string, title: string | undefined, options: ApiDocsOptions): ApiItemContent;

package/typings/adapters/openapi/items/schema/item.d.ts

@@ -0,0 +1,9 @@
+import type { ApiItem, GroupItem } from '../../../../types/store.js';
+import type { OpenAPIDefinition } from '../../../../types/openapi.js';
+export declare function getSchemaNamesForTag(tagName: string, document: OpenAPIDefinition, schemaDefinitionsTagName: string | undefined): string[];
+export declare function addSchemaDefinitionItems({ tagName, tagSlug, result, groupItems }: {
+    tagName: string;
+    tagSlug: string;
+    result: ApiItem[];
+    groupItems?: GroupItem[];
+}): void;

package/typings/adapters/openapi/panels/download.d.ts

@@ -0,0 +1,3 @@
+import type { DownloadNode } from '../../../types/content.js';
+import type { NormalizedDownloadUrl } from '../../../types/options.js';
+export declare function buildDownloadPanelContent(downloadUrls: NormalizedDownloadUrl[]): DownloadNode;

package/typings/adapters/openapi/panels/mcp.d.ts

@@ -0,0 +1,3 @@
+import type { McpNode } from '../../../types/content.js';
+import type { OpenAPIDefinition } from '../../../types/openapi.js';
+export declare function buildMcpPanelContent(document: OpenAPIDefinition): McpNode | null;

package/typings/adapters/openapi/panels/overview.d.ts

@@ -0,0 +1,3 @@
+import type { OverviewNode } from '../../../types/content.js';
+import type { OpenAPIInfo } from '../../../types/openapi.js';
+export declare function buildOverviewPanelContent(info: OpenAPIInfo | undefined): OverviewNode;

package/typings/adapters/openapi/panels/servers.d.ts

@@ -0,0 +1,3 @@
+import type { ServerData } from '../../../types/common.js';
+import type { ServersNode } from '../../../types/content.js';
+export declare function buildServersPanelContent(servers: ServerData[]): ServersNode | null;

package/typings/adapters/openapi/resolve-openapi-example-value.d.ts

@@ -0,0 +1,3 @@
+import type { OpenAPIExample } from '../../types/openapi.js';
+export declare function resolveOpenApiExampleValue(example: OpenAPIExample | undefined): unknown;
+export declare function hasOpenApiExampleValue(example: OpenAPIExample | undefined): boolean;

package/typings/adapters/openapi/store.d.ts

@@ -0,0 +1,4 @@
+import type { ApiStore, StoreContext } from '../../types/store.js';
+import type { OpenAPIDefinition } from '../../types/openapi.js';
+import type { ApiDocsOptions } from '../../types/options.js';
+export declare function populateOpenApiStore(document: OpenAPIDefinition, storeCtx: StoreContext, options: ApiDocsOptions): ApiStore;

package/typings/{utils → adapters/openapi/utils}/JsonPointer.d.ts

@@ -11,7 +11,7 @@ export declare class JsonPointer {
      * // returns foo
      * JsonPointerHelper.baseName('/path/foo/subpath', 2)
      */
-    static baseName(pointer: any, level?: number): string;
+    static baseName(pointer?: string, level?: number): string;
     /**
      * returns dirname of pointer
      * if level > 1 returns corresponding dirname in the hierarchy
@@ -21,7 +21,7 @@ export declare class JsonPointer {
      * // returns /path
      * JsonPointerHelper.dirName('/path/foo/subpath', 2)
      */
-    static dirName(pointer: any, level?: number): string;
+    static dirName(pointer: string, level?: number): string;
     /**
      * returns relative path tokens
      * @example
@@ -30,12 +30,12 @@ export declare class JsonPointer {
      * // returns ['foo', 'subpath']
      * JsonPointerHelper.relative('/path', '/path/foo/subpath')
      */
-    static relative(from: any, to: any): string[];
+    static relative(from: string, to: string): string[];
     /**
      * overridden JsonPointer original parse to take care of prefixing '#' symbol
      * that is not valid JsonPointer
      */
-    static parse(pointer: any): string[];
+    static parse(pointer?: string): string[];
     /**
      * Creates a JSON pointer path, by joining one or more tokens to a base path.
      *
@@ -43,8 +43,8 @@ export declare class JsonPointer {
      * @param {string|string[]} tokens - The token(s) to append (e.g. ["name", "first"])
      * @returns {string}
      */
-    static join(base: any, tokens: any): string;
-    static get(object: object, pointer: string): any;
+    static join(base: string, tokens: string | string[]): string;
+    static get<T>(object: GenericObject, pointer: string): T;
     static compile(tokens: string[]): string;
     static escape(pointer: string): string;
 }

package/typings/adapters/openapi/utils/applyIgnoreNamedSchemasDeep.d.ts

@@ -0,0 +1 @@
+export declare function applyIgnoreNamedSchemasDeep(value: unknown, ignoreNamedSchemas?: Set<string>): unknown;

package/typings/adapters/openapi/utils/helpers.d.ts

@@ -0,0 +1,14 @@
+export declare function stripTrailingSlash(path: string): string;
+export declare function isNumeric(value: unknown): value is number;
+export declare function isAbsoluteUrl(url: string): boolean;
+/**
+ * simple resolve URL which doesn't break on strings with url fragments
+ * e.g. resolveUrl('http://test.com:{port}', 'path') results in http://test.com:{port}/path
+ */
+export declare function resolveUrl(url: string, to: string): string;
+export declare function titleize(text: string): string;
+export declare function removeQueryStringAndHash(serverUrl: string): string;
+export declare function escapeHTMLAttrChars(str: string): string;
+export declare function sanitizeItemId(id: string): string;
+export declare function get<T = unknown>(object: GenericObject | undefined, path: string | Array<string>, defval?: T): T | unknown;
+export declare function getDefinitionName(pointer?: string): string | undefined;

package/typings/adapters/openapi/utils/merge-mock-server.d.ts

@@ -0,0 +1,8 @@
+/** Operation servers win when non-empty; an empty array falls through to the
+ *  document servers (see the empty-array test — a `??` fallback would not). */
+export declare function pickOperationServers<T>(operationServers: T[] | undefined, documentServers: T[] | undefined): T[];
+/** Strips servers flagged as mock servers. Returns the same reference when
+ *  nothing is flagged. */
+export declare function excludeMockServers<T extends {
+    isMockServer?: boolean;
+}>(servers: T[]): T[];

package/typings/adapters/openapi/utils/operation.d.ts

@@ -0,0 +1,23 @@
+import type { OperationInfo, OpenAPIXBadges } from '../../../types/openapi.js';
+import type { SeoData } from '../../../types/common.js';
+import type { ParseMarkdownOptions } from '../../utils/parseMarkdown.js';
+type OperationData = {
+    slug: string;
+    label: string;
+    badges?: OpenAPIXBadges[];
+    deprecated: boolean;
+    isAdditionalOperation?: boolean;
+    httpVerb: string;
+    httpPath: string;
+    isWebhook: boolean;
+    seo?: SeoData;
+};
+export declare function getOperationData(operation: OperationInfo, basePath: string): OperationData;
+export declare function getOperationSummary(operation: OperationInfo, markdownOptions: ParseMarkdownOptions): string | undefined;
+type OperationColorProps = {
+    deprecated?: boolean;
+    isAdditionalOperation?: boolean;
+    httpVerb: string;
+};
+export declare function getOperationColor({ deprecated, isAdditionalOperation, httpVerb }: OperationColorProps): string;
+export {};

package/typings/adapters/openapi/utils/resolvePathItemRef.d.ts

@@ -0,0 +1,2 @@
+import type { OpenAPIPath } from '../../../types/openapi.js';
+export declare function resolvePathItemRef(document: Record<string, unknown>, pathItem: OpenAPIPath | undefined | null, openapi?: string): OpenAPIPath | undefined;

package/typings/adapters/openapi/utils/url.d.ts

@@ -0,0 +1,2 @@
+export declare function urlParse(url: string, slashesDenoteHost?: boolean): URL | null;
+export declare function getUrlDirname(urlLikeString: string): string | undefined;

package/typings/adapters/rbac.d.ts

@@ -0,0 +1,10 @@
+export type RbacScope = Record<string, string>;
+export declare function readRbacScope(_source: unknown): RbacScope | undefined;
+export declare function hasRbacScope(_source: unknown): boolean;
+export type RbacProp = Record<never, never>;
+export declare function rbacProp(_scope: RbacScope | undefined): RbacProp;
+export declare function isRbacKey(_key: string): boolean;
+export declare function splitRbacSection<T>(map: Record<string, T> | undefined): {
+    sectionRbac: RbacScope | undefined;
+    entries: [string, T][];
+};

package/typings/adapters/scopedContext.d.ts

@@ -0,0 +1,5 @@
+export type ScopedContext<T> = {
+    run<R>(ctx: T, fn: () => R): R;
+    get(): T;
+};
+export declare function createScopedContext<T>(name: string): ScopedContext<T>;

package/typings/adapters/utils/convertSwagger2OpenAPI.d.ts

@@ -0,0 +1,2 @@
+import type { OpenAPIDefinition } from '../../types/openapi.js';
+export declare function convertSwagger2OpenAPI(spec: GenericObject): Promise<OpenAPIDefinition>;

package/typings/adapters/utils/dompurify.d.ts

@@ -0,0 +1,5 @@
+type DOMPurifyInstance = {
+    sanitize(source: string): string;
+};
+export declare function getDOMPurify(): DOMPurifyInstance;
+export {};

package/typings/adapters/utils/isPlainText.d.ts

@@ -0,0 +1,6 @@
+/**
+ * True when a description string contains no markdown/markdoc/HTML syntax, so parsing it would
+ * only wrap it in a paragraph. Such strings can stay plain in the items/store JSON (an AST is
+ * ~10x the raw size) and render as-is on the client.
+ */
+export declare function isPlainText(value: string): boolean;

package/typings/adapters/utils/markdoc.d.ts

@@ -0,0 +1,55 @@
+import type { Node } from '@markdoc/markdoc';
+import type { ContentNode } from '../../types/content.js';
+import type { ApiItem } from '../../types/store.js';
+import type { ApiDocsOptions } from '../../types/options.js';
+import type { MarkdownHeading } from '../../types/openapi.js';
+import type { ParseMarkdownOptions } from './parseMarkdown.js';
+export type { MarkdownHeading };
+export type MarkdownSanitizeOptions = {
+    sanitize?: ApiDocsOptions['sanitize'];
+};
+export type DescriptionSegment = {
+    kind: 'markdoc';
+    node: ContentNode;
+} | {
+    kind: 'schemaDefinition';
+    node: ContentNode;
+};
+type ExtractDescriptionSegmentsOptions = {
+    sliceAtFirstHeading?: boolean;
+};
+export declare function extractContentUntilFirstHeading(ast: Node | Node[] | string | undefined, options?: ParseMarkdownOptions): Node[] | string | undefined;
+export declare function extractDescriptionSegments(ast: Node | Node[] | string | undefined, options?: ParseMarkdownOptions, { sliceAtFirstHeading }?: ExtractDescriptionSegmentsOptions): DescriptionSegment[];
+export declare function resolveMarkdocHeadingDeepSuffix(id: string, operationId: string, deepLinkSuffix?: string): string;
+export declare const HEADING_SCOPE_VARIABLE = "$$apiDocsHeadingScope";
+export type HeadingScope = {
+    operationId: string;
+    deepLinkSuffix?: string;
+};
+/** Scope of a partial outside any `#` section of the overview: the ids inline headings get. */
+export declare const OVERVIEW_ROOT_SCOPE: HeadingScope;
+export declare function scopedHeadingAttributes(relativeId: string, { operationId, deepLinkSuffix }: HeadingScope): {
+    id: string;
+    deepLinkHash: string;
+};
+export declare function resolveMarkdocHeadingIds(ast: Node | Node[] | string, operationId: string, deepLinkSuffix?: string): void;
+export declare function extractMarkdownSections(description: Node | Node[] | string | undefined, options?: ParseMarkdownOptions, operationId?: string, isTagContext?: boolean): MarkdownHeading[];
+export declare function buildMarkdownSectionItem({ heading, basePath }: {
+    heading: MarkdownHeading;
+    basePath: string;
+}): ApiItem;
+export declare function collectMarkdownSections(description: Node | Node[] | string | undefined, basePath: string, options: ParseMarkdownOptions): {
+    sectionItems: ApiItem[];
+    sectionChildren: ContentNode[];
+};
+export declare function stripMarkdown(text: string): string;
+export declare function extractFullText(ast: Node | Node[] | string): string;
+export declare function extractFirstParagraphText(ast: Node | Node[] | string, maxLength?: number): string | undefined;
+export declare function extractSummaryText(description: string | Node | Node[] | undefined | null, options?: ParseMarkdownOptions): string | undefined;
+export declare function extractSeoDescriptionText(description: string | Node | Node[] | undefined | null, options?: ParseMarkdownOptions): string | undefined;
+/** One Markdoc node, or a non-empty list of them. */
+export declare function isMarkdocAst(value: unknown): value is Node | Node[];
+export declare function collectTextContent(node: Node): string;
+export declare function collectMarkdownPlainText(ast: Node | Node[] | string): string;
+export declare function unescapeHTMLChars(str: string): string;
+export declare function sanitizeMarkdownSource(source: string, options?: MarkdownSanitizeOptions): string;

package/typings/adapters/utils/parseMarkdown.d.ts

@@ -0,0 +1,8 @@
+import type { Node } from '@markdoc/markdoc';
+import type { MarkdownParser } from '../../types/options.js';
+import type { MarkdownSanitizeOptions } from './markdoc.js';
+export type { MarkdownParser };
+export type ParseMarkdownOptions = MarkdownSanitizeOptions & {
+    markdownParser: MarkdownParser;
+};
+export declare function parseMarkdown(markdown: string | undefined | null | Node | Node[], options?: ParseMarkdownOptions): string | Node | Node[] | undefined;

package/typings/adapters/utils/seo.d.ts

@@ -0,0 +1,3 @@
+import type { SeoData } from '../../types/common.js';
+/** Drops keys whose value is undefined so the item defaults never blank a site-wide fallback. */
+export declare function resolveItemSeo(_node: object | null | undefined, fallback: SeoData): SeoData;

package/typings/adapters/utils/simplifyAstStructure.d.ts

@@ -0,0 +1,2 @@
+import type { Node } from '@markdoc/markdoc';
+export declare const simplifyAstStructure: (ast: Node) => Node | Node[];

package/typings/components/AdmonitionItem.d.ts

@@ -0,0 +1,6 @@
+import type { ReactElement } from 'react';
+import type { AdmonitionNode } from '../types/content.js';
+export type AdmonitionItemProps = {
+    node: AdmonitionNode;
+};
+export declare function AdmonitionItem({ node }: AdmonitionItemProps): ReactElement;

package/typings/components/ChannelAddressItem.d.ts

@@ -0,0 +1,7 @@
+import type { ReactElement } from 'react';
+import type { ChannelAddressNode } from '../types/content.js';
+declare function ChannelAddressItemComponent({ node }: {
+    node: ChannelAddressNode;
+}): ReactElement;
+export declare const ChannelAddressItem: import("react").MemoExoticComponent<typeof ChannelAddressItemComponent>;
+export {};

package/typings/components/ContainerItem.d.ts

@@ -0,0 +1,9 @@
+import type { ReactElement } from 'react';
+import type { ContainerNode } from '../types/content.js';
+declare function ContainerItemComponent({ node, itemPath, sectionId }: {
+    node: ContainerNode;
+    itemPath?: string;
+    sectionId?: string;
+}): ReactElement;
+export declare const ContainerItem: import("react").MemoExoticComponent<typeof ContainerItemComponent>;
+export {};

package/typings/components/EmptyMessageItem.d.ts

@@ -0,0 +1,6 @@
+import type { ReactElement } from 'react';
+import type { EmptyMessageNode } from '../types/content.js';
+export type EmptyMessageItemProps = {
+    node: EmptyMessageNode;
+};
+export declare function EmptyMessageItem({ node }: EmptyMessageItemProps): ReactElement;