@pgcorp/ui-kit 0.13.0 → 0.15.0

package/dist/src/components/shared/data-display/_internal/richDocumentTypes.d.ts

@@ -0,0 +1,466 @@
+/** Closed semantic metadata; exact Unicode identities and ARIA references resolve inside one document. */
+export interface SRichSemanticMetadata {
+    /** Document-local target identity; neither a DOM id nor an inferred heading slug. */
+    readonly anchorId?: string;
+    readonly title?: string;
+    /** Well-formed BCP47 syntax, preserved without canonicalization or registry lookup. */
+    readonly lang?: string;
+    readonly direction?: 'ltr' | 'rtl' | 'auto';
+    /** Naming metadata is valid only for the native semantic owners which permit accessible names. */
+    readonly accessibleLabel?: string;
+    readonly labelledBy?: readonly string[];
+    readonly describedBy?: readonly string[];
+}
+/** Non-naming metadata for native owners whose implicit role prohibits accessible names. */
+export interface SRichPassiveMetadata extends Omit<SRichSemanticMetadata, 'accessibleLabel' | 'labelledBy'> {
+    readonly accessibleLabel?: never;
+    readonly labelledBy?: never;
+}
+/** Literal text content, including explicit empty text; markup is never interpreted. */
+export interface SRichTextNode {
+    readonly type: 'text';
+    readonly value: string;
+}
+/** Strong importance, rendered with native strong semantics. */
+export interface SRichStrongNode extends SRichPassiveMetadata {
+    readonly type: 'strong';
+    readonly children: readonly SRichInlineNode[];
+}
+/** Stress emphasis, distinct from idiomatic or visually differentiated phrasing. */
+export interface SRichEmphasisNode extends SRichPassiveMetadata {
+    readonly type: 'emphasis';
+    readonly children: readonly SRichInlineNode[];
+}
+/** Attention without added importance; native b semantics. */
+export interface SRichAttentionNode extends SRichPassiveMetadata {
+    readonly type: 'attention';
+    readonly children: readonly SRichInlineNode[];
+}
+/** Alternate voice or idiomatic phrasing; native i semantics. */
+export interface SRichIdiomaticNode extends SRichPassiveMetadata {
+    readonly type: 'idiomatic';
+    readonly children: readonly SRichInlineNode[];
+}
+/** No longer accurate or relevant content; native s semantics, not a document edit. */
+export interface SRichStrikethroughNode extends SRichPassiveMetadata {
+    readonly type: 'strikethrough';
+    readonly children: readonly SRichInlineNode[];
+}
+/** A deletion edit with optional safe citation and exact ISO date annotation. */
+export interface SRichDeletionNode extends SRichPassiveMetadata {
+    readonly type: 'deletion';
+    readonly cite?: string;
+    readonly dateTime?: string;
+    readonly children: readonly SRichInlineNode[];
+}
+/** Keyboard content is either the documented text form or an explicit rich sequence. */
+export type SRichKeyboardNode = SRichPassiveMetadata & {
+    readonly type: 'keyboard';
+} & ({
+    readonly value: string;
+    readonly children?: never;
+} | {
+    readonly children: readonly SRichInlineNode[];
+    readonly value?: never;
+});
+/** Superscript phrasing, retaining its child sequence rather than flattening text. */
+export interface SRichSuperscriptNode extends SRichPassiveMetadata {
+    readonly type: 'superscript';
+    readonly children: readonly SRichInlineNode[];
+}
+/** Subscript phrasing, retaining its child sequence rather than flattening text. */
+export interface SRichSubscriptNode extends SRichPassiveMetadata {
+    readonly type: 'subscript';
+    readonly children: readonly SRichInlineNode[];
+}
+/** One reference occurrence; occurrenceId defaults to id and is unique within that definition. */
+export interface SRichFootnoteReferenceNode extends SRichSemanticMetadata {
+    readonly type: 'footnoteReference';
+    readonly id: string;
+    readonly label: string;
+    readonly marker?: string;
+    readonly occurrenceId?: string;
+}
+/** Return link to the exact reference occurrence selected by id and optional occurrenceId. */
+export interface SRichFootnoteBacklinkNode extends SRichSemanticMetadata {
+    readonly type: 'footnoteBacklink';
+    readonly id: string;
+    readonly label: string;
+    readonly marker?: string;
+    readonly occurrenceId?: string;
+}
+/** Literal inline code; an empty code sequence is valid. */
+export interface SRichInlineCodeNode extends SRichPassiveMetadata {
+    readonly type: 'inlineCode';
+    readonly code: string;
+}
+/** Admitted external or relative URL with non-interactive inline descendants. */
+export interface SRichLinkNode extends SRichSemanticMetadata {
+    readonly type: 'link';
+    readonly href: string;
+    readonly title?: string;
+    readonly current?: boolean;
+    readonly children: readonly SRichInlineNode[];
+}
+/** Parser-free inline formula source passed to the isolated strict math owner. */
+export interface SRichMathInlineNode extends SRichPassiveMetadata {
+    readonly type: 'mathInline';
+    readonly source: string;
+}
+/** Native hard line break within phrasing content, not a paragraph delimiter. */
+export interface SRichHardBreakNode {
+    readonly type: 'hardBreak';
+}
+/** Image candidates use admitted resource identities and one descriptor family per set. */
+export type SRichImageCandidate = {
+    readonly resourceId: string;
+    readonly width: number;
+    readonly density?: never;
+} | {
+    readonly resourceId: string;
+    readonly density: number;
+    readonly width?: never;
+};
+/** One source element with a bounded media query and an admitted candidate set. */
+export interface SRichPictureSource {
+    readonly media?: string;
+    readonly candidates: readonly SRichImageCandidate[];
+}
+/** Responsive media configuration uses resource IDs; raw src and srcset are not accepted. */
+export interface SRichImagePresentation {
+    readonly resourceId: string;
+    readonly candidates?: readonly SRichImageCandidate[];
+    readonly pictureSources?: readonly SRichPictureSource[];
+}
+/** Image in phrasing content; metadata belongs to img even when picture sources are present. */
+export interface SRichInlineImageNode extends SRichSemanticMetadata, SRichImagePresentation {
+    readonly type: 'inlineImage';
+}
+/** Document-local navigation; anchorId references a declared target rather than declaring a target. */
+export interface SRichAnchorLinkNode extends Omit<SRichSemanticMetadata, 'anchorId'> {
+    readonly type: 'anchorLink';
+    readonly anchorId: string;
+    readonly children: readonly SRichInlineNode[];
+}
+/** Explicit passive target with optional phrasing content; never a descendant of another link. */
+export interface SRichAnchorTargetNode extends SRichPassiveMetadata {
+    readonly type: 'anchorTarget';
+    readonly anchorId: string;
+    readonly children?: readonly SRichInlineNode[];
+}
+/** An insertion edit; citation and date annotation do not enable interactive content. */
+export interface SRichInsertionNode extends SRichPassiveMetadata {
+    readonly type: 'insertion';
+    readonly cite?: string;
+    readonly dateTime?: string;
+    readonly children: readonly SRichInlineNode[];
+}
+/** Inline quotation with an optional admitted citation URL. */
+export interface SRichQuotationNode extends SRichPassiveMetadata {
+    readonly type: 'quotation';
+    readonly cite?: string;
+    readonly children: readonly SRichInlineNode[];
+}
+/** Sample output, preserving native samp semantics. */
+export interface SRichSampleNode extends SRichPassiveMetadata {
+    readonly type: 'sample';
+    readonly children: readonly SRichInlineNode[];
+}
+/** Explicit producer conversion of legacy monospace markup to native code semantics. */
+export interface SRichMonospaceNode extends SRichPassiveMetadata {
+    readonly type: 'monospace';
+    readonly children: readonly SRichInlineNode[];
+}
+/** Variable or placeholder expression, preserving native var semantics. */
+export interface SRichVariableNode extends SRichPassiveMetadata {
+    readonly type: 'variable';
+    readonly children: readonly SRichInlineNode[];
+}
+/** Passive phrasing group; no raw tag, styling or interactive channel. */
+export interface SRichInlineGroupNode extends SRichPassiveMetadata {
+    readonly type: 'inlineGroup';
+    readonly children: readonly SRichInlineNode[];
+}
+/** Ruby annotation content; valid only as a direct member of a ruby sequence. */
+export interface SRichRubyTextNode extends SRichPassiveMetadata {
+    readonly type: 'rubyText';
+    readonly children: readonly SRichInlineNode[];
+}
+/** Ruby fallback punctuation; valid only as a direct member of a ruby sequence. */
+export interface SRichRubyFallbackNode extends SRichPassiveMetadata {
+    readonly type: 'rubyFallback';
+    readonly children: readonly SRichInlineNode[];
+}
+/** Ordered base, annotation and fallback sequence preserving native ruby reading semantics. */
+export interface SRichRubyNode extends SRichSemanticMetadata {
+    readonly type: 'ruby';
+    readonly children: readonly (SRichInlineNode | SRichRubyTextNode | SRichRubyFallbackNode)[];
+}
+/** A readable checkbox in document content; it has no editable or event contract. */
+export interface SRichInlineCheckboxNode extends SRichPassiveMetadata {
+    readonly type: 'inlineCheckbox';
+    readonly checked: boolean;
+    readonly label: string;
+}
+/** Closed inline content union. Raw HTML, VNodes, callbacks, and trust flags are intentionally absent. */
+export type SRichInlineNode = SRichTextNode | SRichStrongNode | SRichAttentionNode | SRichEmphasisNode | SRichIdiomaticNode | SRichDeletionNode | SRichStrikethroughNode | SRichKeyboardNode | SRichSuperscriptNode | SRichSubscriptNode | SRichFootnoteReferenceNode | SRichFootnoteBacklinkNode | SRichInlineCodeNode | SRichLinkNode | SRichMathInlineNode | SRichHardBreakNode | SRichInlineImageNode | SRichAnchorLinkNode | SRichAnchorTargetNode | SRichInsertionNode | SRichQuotationNode | SRichSampleNode | SRichMonospaceNode | SRichVariableNode | SRichInlineGroupNode | SRichRubyNode | SRichInlineCheckboxNode;
+/** Paragraph phrasing; empty semantic paragraphs are preserved. */
+export interface SRichParagraphNode extends SRichPassiveMetadata {
+    readonly type: 'paragraph';
+    readonly children: readonly SRichInlineNode[];
+}
+/** Visible content or an accessible native heading outside normal layout flow. */
+export type SRichHeadingPresentation = 'visible' | 'assistive';
+/** Native heading level and explicit navigation identity; assistive content excludes interactive descendants. */
+export interface SRichHeadingNode extends SRichSemanticMetadata {
+    readonly type: 'heading';
+    readonly level: 1 | 2 | 3 | 4 | 5 | 6;
+    readonly presentation?: SRichHeadingPresentation;
+    readonly children: readonly SRichInlineNode[];
+}
+/** Block list item; task state is read-only and value is valid only in ordered lists. */
+export interface SRichListItemNode extends SRichSemanticMetadata {
+    readonly type: 'listItem';
+    readonly checked?: boolean;
+    readonly checkboxLabel?: string;
+    readonly value?: number;
+    readonly children: readonly SRichBlockNode[];
+}
+/** Native ordered or unordered list, including empty lists; start and item values are signed safe integers. */
+export interface SRichListNode extends SRichSemanticMetadata {
+    readonly type: 'list';
+    readonly ordered: boolean;
+    readonly start?: number;
+    readonly children: readonly SRichListItemNode[];
+}
+/** Block quotation with optional admitted citation and retained block descendants. */
+export interface SRichQuoteNode extends SRichSemanticMetadata {
+    readonly type: 'quote';
+    readonly cite?: string;
+    readonly children: readonly SRichBlockNode[];
+}
+/** Passive summaries use native details; interactive summaries use sibling toggle and rich content owners. */
+export interface SRichDisclosureNode extends SRichSemanticMetadata {
+    readonly type: 'disclosure';
+    readonly summary: string;
+    readonly summaryChildren?: readonly SRichInlineNode[];
+    readonly open?: boolean;
+    readonly children: readonly SRichBlockNode[];
+}
+/** Definition shared by reference occurrences; id and anchorId inhabit separate identity namespaces. */
+export interface SRichFootnoteDefinitionNode extends SRichSemanticMetadata {
+    readonly type: 'footnoteDefinition';
+    readonly id: string;
+    readonly label: string;
+    readonly children: readonly SRichBlockNode[];
+}
+/** Native thematic break with closed semantic metadata. */
+export interface SRichDividerNode extends SRichSemanticMetadata {
+    readonly type: 'divider';
+}
+/** Block figure with admitted responsive media and an optional rich caption. */
+export interface SRichImageNode extends SRichImagePresentation, SRichSemanticMetadata {
+    readonly type: 'image';
+    readonly resourceId: string;
+    readonly caption?: readonly SRichInlineNode[];
+}
+/** Resource action; its explicit label names the shared control and description is passive content. */
+export interface SRichResourceNode extends SRichPassiveMetadata {
+    readonly type: 'resource';
+    readonly resourceId: string;
+    readonly label: string;
+    readonly description?: string;
+}
+/** Literal code with explicit syntax language; lang metadata describes human content language separately. */
+export interface SRichCodeBlockNode extends SRichPassiveMetadata {
+    readonly type: 'codeBlock';
+    readonly code: string;
+    readonly language?: string;
+    readonly label?: string;
+    readonly showLineNumbers?: boolean;
+}
+/** Display formula source; label belongs to the shared math owner rather than its passive wrapper. */
+export interface SRichMathBlockNode extends SRichPassiveMetadata {
+    readonly type: 'mathBlock';
+    readonly source: string;
+    readonly label?: string;
+}
+export type SRichTableAlignment = 'left' | 'center' | 'right';
+export type SRichTableHeaderPresentation = 'visible' | 'assistive';
+/** Rectangular table column; header names the column and headerChildren preserves rich visible content. */
+export interface SRichTableColumn extends SRichSemanticMetadata {
+    readonly id: string;
+    readonly header: string;
+    readonly headerChildren?: readonly SRichInlineNode[];
+    readonly headerPresentation?: SRichTableHeaderPresentation;
+    readonly align?: SRichTableAlignment;
+}
+/** One rectangular table data cell with retained phrasing and semantic metadata. */
+export interface SRichTableCell extends SRichSemanticMetadata {
+    readonly children: readonly SRichInlineNode[];
+}
+/** Stable rectangular row; cell count must match the declared columns exactly. */
+export interface SRichTableRow extends SRichSemanticMetadata {
+    readonly id: string;
+    readonly cells: readonly SRichTableCell[];
+}
+/** Rectangular data table; row and column identities are unique inside this table. */
+export interface SRichTableNode extends SRichSemanticMetadata {
+    readonly type: 'table';
+    readonly label: string;
+    readonly columns: readonly SRichTableColumn[];
+    readonly rows: readonly SRichTableRow[];
+}
+/** Passive block grouping without an inferred landmark or role. */
+export interface SRichBlockGroupNode extends SRichPassiveMetadata {
+    readonly type: 'blockGroup';
+    readonly children: readonly SRichBlockNode[];
+}
+/** Native section; an explicit accessible name exposes its native region semantics. */
+export interface SRichSectionNode extends SRichSemanticMetadata {
+    readonly type: 'section';
+    readonly children: readonly SRichBlockNode[];
+}
+/** Definition term preserving native dt phrasing and metadata. */
+export interface SRichDefinitionTerm extends SRichSemanticMetadata {
+    readonly children: readonly SRichInlineNode[];
+}
+/** Definition description preserving native dd blocks and metadata. */
+export interface SRichDefinitionDescription extends SRichSemanticMetadata {
+    readonly children: readonly SRichBlockNode[];
+}
+/** Explicit term/description grouping; each side contains at least one semantic owner. */
+export interface SRichDefinitionEntry {
+    readonly terms: readonly SRichDefinitionTerm[];
+    readonly descriptions: readonly SRichDefinitionDescription[];
+}
+/** Native definition list with typed term/description groups. */
+export interface SRichDefinitionListNode extends SRichSemanticMetadata {
+    readonly type: 'definitionList';
+    readonly entries: readonly SRichDefinitionEntry[];
+}
+export type SRichSemanticTableScope = 'row' | 'col' | 'rowgroup' | 'colgroup';
+export type SRichSemanticTableCellContent = {
+    readonly content: 'inline';
+    readonly children: readonly SRichInlineNode[];
+} | {
+    readonly content: 'block';
+    readonly children: readonly SRichBlockNode[];
+};
+/** Native cell metadata; cellId and headers resolve only within the owning table. */
+export interface SRichSemanticTableCellMetadata extends SRichSemanticMetadata {
+    readonly cellId?: string;
+    readonly headers?: readonly string[];
+    /** Zero extends through the remaining rows of the current row group. */
+    readonly rowSpan?: number;
+    readonly colSpan?: number;
+    readonly align?: SRichTableAlignment;
+}
+/** Header cell; block content excludes heading and section descendants under native th rules. */
+export type SRichSemanticTableHeaderCell = SRichSemanticTableCellMetadata & SRichSemanticTableCellContent & {
+    readonly type: 'header';
+    readonly scope?: SRichSemanticTableScope;
+};
+/** Data cell; inline and block content remain distinct and scope is not a data-cell attribute. */
+export type SRichSemanticTableDataCell = SRichSemanticTableCellMetadata & SRichSemanticTableCellContent & {
+    readonly type: 'data';
+    readonly scope?: never;
+};
+export type SRichSemanticTableCell = SRichSemanticTableHeaderCell | SRichSemanticTableDataCell;
+/** Structural row validated against spans and the exact occupied table grid. */
+export interface SRichSemanticTableRow extends SRichSemanticMetadata {
+    readonly cells: readonly SRichSemanticTableCell[];
+}
+/** Explicit native column-group partition; spans cover the complete structural table width. */
+export interface SRichSemanticTableColumnGroup {
+    readonly span: number;
+}
+/** Structural table semantics; spans and header references are validated before rendering. */
+export interface SRichSemanticTableNode extends SRichSemanticMetadata {
+    readonly type: 'semanticTable';
+    readonly label: string;
+    readonly columnGroups?: readonly SRichSemanticTableColumnGroup[];
+    readonly caption?: readonly SRichInlineNode[];
+    readonly head?: readonly SRichSemanticTableRow[];
+    readonly body: readonly SRichSemanticTableRow[];
+    readonly foot?: readonly SRichSemanticTableRow[];
+    readonly headMetadata?: SRichSemanticMetadata;
+    readonly bodyMetadata?: SRichSemanticMetadata;
+    readonly footMetadata?: SRichSemanticMetadata;
+}
+export type SRichCalloutTone = 'neutral' | 'information' | 'success' | 'warning' | 'danger';
+/** Shared feedback composition; title is its declared heading and wrapper metadata cannot rename it. */
+export interface SRichCalloutNode extends SRichPassiveMetadata {
+    readonly type: 'callout';
+    readonly tone: SRichCalloutTone;
+    readonly title?: string;
+    readonly children: readonly SRichBlockNode[];
+}
+export type SRichActionAppearance = 'primary' | 'secondary' | 'danger';
+/** Consumer-resolved action intent; label names the shared control, not the passive document wrapper. */
+export interface SRichActionNode extends SRichPassiveMetadata {
+    readonly type: 'action';
+    readonly id: string;
+    readonly label: string;
+    readonly appearance?: SRichActionAppearance;
+    readonly disabled?: boolean;
+}
+/** Explicit native group of shared action controls. */
+export interface SRichActionGroupNode extends SRichSemanticMetadata {
+    readonly type: 'actionGroup';
+    readonly label?: string;
+    readonly actions: readonly SRichActionNode[];
+}
+/** Closed block content union accepted by the renderer. */
+export type SRichBlockNode = SRichParagraphNode | SRichHeadingNode | SRichListNode | SRichQuoteNode | SRichDisclosureNode | SRichFootnoteDefinitionNode | SRichDividerNode | SRichImageNode | SRichResourceNode | SRichCodeBlockNode | SRichMathBlockNode | SRichTableNode | SRichCalloutNode | SRichActionGroupNode | SRichBlockGroupNode | SRichSectionNode | SRichDefinitionListNode | SRichSemanticTableNode;
+export type SRichDocumentNode = SRichInlineNode | SRichBlockNode | SRichListItemNode | SRichActionNode | SRichRubyTextNode | SRichRubyFallbackNode;
+/** Versioned, serializable rich-document input. */
+export interface SRichDocumentV1 {
+    readonly version: 1;
+    readonly id: string;
+    readonly nodes: readonly SRichBlockNode[];
+}
+interface SRichDocumentResourceBase {
+    readonly id: string;
+    readonly url: string;
+    readonly title?: string;
+}
+/** Consumer-admitted image; data URLs additionally require exact raster MIME, base64 and signature. */
+export interface SRichDocumentImageResource extends SRichDocumentResourceBase {
+    readonly kind: 'image';
+    readonly alt: string;
+}
+/** Consumer-admitted file; data URLs are not a file-resource transport. */
+export interface SRichDocumentFileResource extends SRichDocumentResourceBase {
+    readonly kind: 'file';
+    readonly label: string;
+    readonly mediaType?: string;
+    readonly byteSize?: number;
+}
+/** Consumer-owned resource descriptor resolved independently from the document AST. */
+export type SRichDocumentResource = SRichDocumentImageResource | SRichDocumentFileResource;
+/** Fully validated renderer input with resource references resolved by stable IDs. */
+export interface SRichDocumentModel {
+    readonly document: SRichDocumentV1;
+    readonly resources: readonly SRichDocumentResource[];
+}
+/** Controlled external navigation intent with the exact document source coordinate. */
+export interface SRichDocumentLinkActivate {
+    readonly documentId: string;
+    readonly path: string;
+    readonly href: string;
+    readonly title?: string;
+}
+/** Resource intent identifying the admitted descriptor without exposing arbitrary render callbacks. */
+export interface SRichDocumentResourceActivate {
+    readonly documentId: string;
+    readonly path: string;
+    readonly resourceId: string;
+}
+/** Action intent resolved by the host using the declared stable action identity. */
+export interface SRichDocumentActionIntent {
+    readonly documentId: string;
+    readonly path: string;
+    readonly actionId: string;
+}
+export {};

package/dist/src/components/shared/data-display/_internal/richDocumentValidation.d.ts

@@ -0,0 +1,65 @@
+import { SRichSemanticMetadata } from './richDocumentTypes';
+export declare const S_RICH_DOCUMENT_VERSION: 1;
+export declare const S_RICH_DOCUMENT_MAX_NODES = 10000;
+export declare const S_RICH_DOCUMENT_MAX_DEPTH = 32;
+export declare const S_RICH_DOCUMENT_MAX_TEXT_LENGTH = 1048576;
+export type SRichDocumentContractErrorCode = 'cyclic_value' | 'duplicate_id' | 'invalid_structure' | 'invalid_type' | 'invalid_value' | 'limit_exceeded' | 'missing_resource' | 'unknown_field' | 'unknown_node_type' | 'unsafe_url' | 'unsupported_version';
+/** Typed contract failure with a stable machine code and exact source coordinate. */
+export declare class SRichDocumentContractError extends TypeError {
+    readonly code: SRichDocumentContractErrorCode;
+    readonly path: string;
+    constructor(code: SRichDocumentContractErrorCode, path: string, detail: string);
+}
+export type PlainRecord = Readonly<Record<string, unknown>>;
+export interface FootnoteOccurrence {
+    readonly id: string;
+    readonly occurrenceId: string;
+    readonly path: string;
+    readonly occurrencePath: string;
+}
+export interface ValidationContext {
+    readonly ancestors: Set<object>;
+    readonly actionIds: Set<string>;
+    readonly footnoteDefinitions: Map<string, string>;
+    readonly footnoteReferences: Map<string, FootnoteOccurrence>;
+    readonly footnoteBacklinks: Map<string, FootnoteOccurrence>;
+    readonly anchors: Map<string, string>;
+    readonly anchorReferences: Map<string, string>;
+    readonly accessibilityReferences: Map<string, string>;
+    nodeCount: number;
+}
+export declare function createValidationContext(): ValidationContext;
+/** Structural semantic owners share the document depth and total-node budget. */
+export declare function consumeRichNode(path: string, context: ValidationContext, depth: number): void;
+export declare function fail(code: SRichDocumentContractErrorCode, path: string, detail: string): never;
+export declare function enter(value: object, path: string, context: ValidationContext): void;
+export declare function readRecord(value: unknown, path: string, context: ValidationContext): PlainRecord;
+export declare function leave(value: object, context: ValidationContext): void;
+export declare function assertFields(record: PlainRecord, path: string, fields: ReadonlySet<string>): void;
+export declare function readArray(value: unknown, path: string, context: ValidationContext, bounds: {
+    readonly minimum: number;
+    readonly maximum: number;
+}): readonly unknown[];
+export declare function readString(value: unknown, path: string, options?: {
+    readonly allowEmpty?: boolean;
+    readonly stable?: boolean;
+    readonly maximum?: number;
+}): string;
+export declare function readOptionalString(value: unknown, path: string): string | undefined;
+export declare function readLabel(value: unknown, path: string): string;
+export declare function readOptionalLabel(value: unknown, path: string): string | undefined;
+export declare function readFootnoteId(value: unknown, path: string): string;
+export declare function readIdentity(value: unknown, path: string, maximum?: number): string;
+export declare const SEMANTIC_METADATA_FIELDS: readonly ["anchorId", "title", "lang", "direction", "accessibleLabel", "labelledBy", "describedBy"];
+export declare function readIdentityArray(value: unknown, path: string, context: ValidationContext): readonly string[];
+export declare function readSemanticMetadata(record: PlainRecord, path: string, context: ValidationContext, declareAnchor?: boolean): SRichSemanticMetadata;
+export declare function footnoteOccurrenceKey(id: string, occurrenceId: string): string;
+export declare function readFootnoteOccurrence(record: PlainRecord, path: string, context: ValidationContext, kind: 'footnoteReference' | 'footnoteBacklink'): {
+    readonly id: string;
+    readonly occurrenceId?: string;
+};
+export declare function registerUniqueFootnote(occurrences: Map<string, string>, id: string, path: string, kind: string): void;
+export declare function readBoolean(value: unknown, path: string): boolean;
+export declare function readInteger(value: unknown, path: string, minimum: number, maximum: number): number;
+export declare function readEnum<Value extends string>(value: unknown, path: string, values: ReadonlySet<Value>): Value;
+export declare function validateUrl(value: unknown, path: string, kind: 'link' | 'resource'): string;