npm - @praxisui/page-builder - Versions diffs - 8.0.0-beta.9 → 8.0.0-beta.90 - Mend

@praxisui/page-builder 8.0.0-beta.9 → 8.0.0-beta.90

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/README.md +189 -15
package/fesm2022/praxisui-page-builder.mjs +14380 -1836
package/package.json +14 -12
package/types/praxisui-page-builder.d.ts +1912 -0
package/index.d.ts +0 -914

package/types/praxisui-page-builder.d.ts ADDED Viewed

@@ -0,0 +1,1912 @@
+import { MatDialogRef, MatDialog } from '@angular/material/dialog';
+import * as _angular_core from '@angular/core';
+import { EventEmitter, OnInit, WritableSignal, InjectionToken, Provider, OnChanges, Type, SimpleChanges } from '@angular/core';
+import { ComponentDocMeta, ComponentMetadataRegistry, WidgetShellConfig, WidgetShellAction, EndpointRef, ComponentPortPathSegment, LinkIntent, CompositionLink, WidgetPageDefinition, TransformKind, SurfaceOpenPayload, SettingsValueProvider as SettingsValueProvider$1, WidgetPageGroupingDefinition, BUILTIN_PAGE_LAYOUT_PRESETS, BUILTIN_PAGE_THEME_PRESETS, PageIdentity, WidgetStateNode, WidgetDerivedStateNode, AiCapability, AiCapabilityCategory, AiCapabilityCatalog, AiValueKind, DomainKnowledgeChangeSetRequest, DomainKnowledgeChangeSet, DomainKnowledgeChangeSetTimelineResponse, DomainKnowledgeChangeSetFilters, DomainKnowledgeValidationResponse, DomainKnowledgeStatusTransitionRequest, DomainRuleIntakeRequest, DomainRuleIntakeResponse, DomainRuleDefinitionRequest, DomainRuleDefinition, DomainRuleSimulationRequest, DomainRuleSimulationResponse, DomainRuleStatusTransitionRequest, DomainRulePublicationRequest, DomainRulePublicationResponse, DomainRuleMaterializationFilters, DomainRuleMaterialization, DomainRuleTimelineResponse, WidgetPageCanvasLayout, WidgetPageDeviceLayouts, WidgetPageSlotAssignments, WidgetPageStateInput, WidgetInstance, ComponentContextPack, ComponentAuthoringManifest, DynamicWidgetPageComponent, SettingsPanelBridge, WidgetEventEnvelope, RichTimelineItem } from '@praxisui/core';
+export { WidgetShellComponent } from '@praxisui/core';
+import * as rxjs from 'rxjs';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { FormGroup, FormControl, FormArray } from '@angular/forms';
+import { SettingsValueProvider } from '@praxisui/settings-panel';
+import { AgenticAuthoringAttachmentSummaryContract, AgenticAuthoringCandidateContract, AiJsonValue, AgenticAuthoringComponentCapabilitiesResultContract, AgenticAuthoringComponentCapabilityCatalogContract, AgenticAuthoringComponentCapabilityContract, AgenticAuthoringComponentFieldAliasContract, AgenticAuthoringComponentCapabilityExampleContract, AgenticAuthoringConversationMessageContract, AgenticAuthoringIntentResolutionRequestContract, AgenticAuthoringQuickReplyContract, AgenticAuthoringPendingClarificationContract, AiContextHintsContract, AiJsonObject, AgenticAuthoringSemanticDecisionContract, AgenticAuthoringPlanRequestContract, AgenticAuthoringResourceCandidatesRequestContract, AgenticAuthoringResourceCandidatesResultContract, AgenticAuthoringTurnStreamEnvelopeContract, AgenticAuthoringTurnStreamStartResponseContract, PraxisAssistantShellMessage, PraxisAssistantShellQuickReply, PraxisAssistantShellAttachment, PraxisAssistantShellLayout, PraxisAssistantSessionSnapshot, PraxisAssistantShellLabels, PraxisAssistantShellAction, PraxisAssistantShellState, PraxisAssistantShellContextItem } from '@praxisui/ai';
+declare const PLACEHOLDER = 1;
+interface ConfirmDialogData {
+    title?: string;
+    message?: string;
+    confirmLabel?: string;
+    cancelLabel?: string;
+    icon?: string;
+}
+declare class ConfirmDialogComponent {
+    data: ConfirmDialogData;
+    ref: MatDialogRef<ConfirmDialogComponent, boolean>;
+    constructor(data: ConfirmDialogData, ref: MatDialogRef<ConfirmDialogComponent, boolean>);
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ConfirmDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ConfirmDialogComponent, "praxis-confirm-dialog", never, {}, {}, never, never, true, never>;
+}
+declare class TileToolbarComponent {
+    selected: boolean;
+    widgetType: string | null;
+    remove: EventEmitter<void>;
+    settings: EventEmitter<void>;
+    shell: EventEmitter<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TileToolbarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TileToolbarComponent, "praxis-tile-toolbar", never, { "selected": { "alias": "selected"; "required": false; }; "widgetType": { "alias": "widgetType"; "required": false; }; }, { "remove": "remove"; "settings": "settings"; "shell": "shell"; }, never, never, true, never>;
+}
+declare class FloatingToolbarComponent {
+    visible: boolean;
+    canUndo: boolean;
+    canRedo: boolean;
+    showSave: boolean;
+    showPreview: boolean;
+    add: EventEmitter<void>;
+    undo: EventEmitter<void>;
+    redo: EventEmitter<void>;
+    settings: EventEmitter<void>;
+    preview: EventEmitter<void>;
+    save: EventEmitter<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FloatingToolbarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FloatingToolbarComponent, "praxis-floating-toolbar", never, { "visible": { "alias": "visible"; "required": false; }; "canUndo": { "alias": "canUndo"; "required": false; }; "canRedo": { "alias": "canRedo"; "required": false; }; "showSave": { "alias": "showSave"; "required": false; }; "showPreview": { "alias": "showPreview"; "required": false; }; }, { "add": "add"; "undo": "undo"; "redo": "redo"; "settings": "settings"; "preview": "preview"; "save": "save"; }, never, ["[pdx-toolbar-extra]"], true, never>;
+}
+interface ComponentPaletteSelection {
+    componentId: string;
+    presetId?: string;
+    inputs?: Record<string, unknown>;
+}
+interface ComponentPaletteData {
+    title?: string;
+    allowedWidgetIds?: string[];
+    allowedWidgetTags?: string[];
+    predicate?: (m: ComponentDocMeta) => boolean;
+}
+interface ComponentPaletteEntry {
+    key: string;
+    componentId: string;
+    presetId?: string;
+    title: string;
+    description: string;
+    icon: string;
+    badges: ComponentPaletteBadge[];
+    searchText: string;
+    inputs?: Record<string, unknown>;
+}
+interface ComponentPaletteBadge {
+    label: string;
+    icon: string;
+    tone: 'ready' | 'info' | 'warning' | 'neutral';
+    description: string;
+}
+declare class ComponentPaletteDialogComponent implements OnInit {
+    private dialogRef;
+    private registry;
+    data?: ComponentPaletteData | undefined;
+    query: _angular_core.WritableSignal<string>;
+    private all;
+    filtered: _angular_core.Signal<ComponentPaletteEntry[]>;
+    density: _angular_core.Signal<"roomy" | "dense" | "normal">;
+    constructor(dialogRef: MatDialogRef<ComponentPaletteDialogComponent, ComponentPaletteSelection>, registry: ComponentMetadataRegistry, data?: ComponentPaletteData | undefined);
+    ngOnInit(): void;
+    select(entry: ComponentPaletteEntry): void;
+    trackById: (_: number, entry: ComponentPaletteEntry) => string;
+    getPreview(entry: ComponentPaletteEntry): string;
+    private _adjustSizeEffect;
+    private applyFilters;
+    private buildEntries;
+    private buildBadges;
+    private buildBadgeSearchText;
+    private hasDataSourceInputs;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ComponentPaletteDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ComponentPaletteDialogComponent, "praxis-component-palette-dialog", never, {}, {}, never, never, true, never>;
+}
+type ShellInputs = {
+    shell?: WidgetShellConfig | null;
+    widgetKey?: string;
+    widgetType?: string;
+    presets?: Record<string, WidgetShellConfig['appearance']> | null;
+    pagePreset?: string | null;
+};
+type ShellEditorResult = {
+    shell: WidgetShellConfig | null;
+    applyToAll?: boolean;
+    pagePreset?: string;
+};
+type AvailableShellAction = {
+    kind: 'action' | 'command';
+    id: string;
+    label: string;
+    icon?: string;
+    scope?: NonNullable<ComponentDocMeta['actions']>[number]['scope'] | 'any';
+    emit?: string;
+    command?: string;
+    description?: string;
+    payloadExample?: any;
+};
+type SetInputValueOption = {
+    label: string;
+    value: any;
+    icon?: string;
+};
+type SetInputPreset = {
+    input: string;
+    label: string;
+    icon?: string;
+    values: SetInputValueOption[];
+};
+declare class WidgetShellEditorComponent implements SettingsValueProvider {
+    private registry?;
+    form: FormGroup<{
+        kind: FormControl<"none" | "dashboard-card">;
+        preset: FormControl<string>;
+        applyToAll: FormControl<boolean>;
+        title: FormControl<string>;
+        subtitle: FormControl<string>;
+        icon: FormControl<string>;
+        showHeader: FormControl<"auto" | "true" | "false">;
+        collapsible: FormControl<boolean>;
+        cardBg: FormControl<string>;
+        cardBorder: FormControl<string>;
+        cardRadius: FormControl<string>;
+        cardShadow: FormControl<string>;
+        headerBg: FormControl<string>;
+        headerBorder: FormControl<string>;
+        titleColor: FormControl<string>;
+        subtitleColor: FormControl<string>;
+        iconColor: FormControl<string>;
+        bodyBg: FormControl<string>;
+        bodyColor: FormControl<string>;
+        bodyPadding: FormControl<string>;
+        titleSize: FormControl<string>;
+        titleWeight: FormControl<string>;
+        subtitleSize: FormControl<string>;
+        actions: FormArray<FormGroup<any>>;
+    }>;
+    private readonly initialShell;
+    private readonly dirtySubject;
+    private readonly validSubject;
+    private readonly busySubject;
+    isDirty$: rxjs.Observable<boolean>;
+    isValid$: rxjs.Observable<boolean>;
+    isBusy$: rxjs.Observable<boolean>;
+    private snapshot;
+    presetOptions: Array<{
+        id: string;
+        label: string;
+    }>;
+    private presets;
+    availableActions: AvailableShellAction[];
+    actionQuery: FormControl<string>;
+    showScopeShell: boolean;
+    showScopeAny: boolean;
+    showScopeToolbar: boolean;
+    showScopeContext: boolean;
+    setInputPresets: SetInputPreset[];
+    setInputTarget: FormControl<string>;
+    setInputValue: FormControl<any>;
+    previewCollapsed: boolean;
+    previewExpanded: boolean;
+    pagePreset: string | null;
+    constructor(data?: ShellInputs | null, registry?: (ComponentMetadataRegistry | null) | undefined);
+    get actions(): FormArray<FormGroup>;
+    get hasAvailableActions(): boolean;
+    addAction(seed?: Partial<WidgetShellAction>): void;
+    removeAction(index: number): void;
+    getSettingsValue(): ShellEditorResult;
+    onSave(): ShellEditorResult;
+    reset(): void;
+    private applyShell;
+    private loadAvailableActions;
+    private createActionGroup;
+    private buildShell;
+    private buildResult;
+    private buildAppearance;
+    previewVars(): Record<string, string | null>;
+    previewShowHeader(): boolean;
+    previewTitle(): string;
+    previewSubtitle(): string;
+    private buildPreviewAppearance;
+    private mergeAppearance;
+    togglePreviewCollapse(): void;
+    togglePreviewExpand(): void;
+    previewHeaderActions(): WidgetShellAction[];
+    previewOverflowCount(): number;
+    previewWindowActions(): WidgetShellAction[];
+    private normalizeAction;
+    private tryParsePayload;
+    private snapshotValue;
+    filteredAvailableActions(): AvailableShellAction[];
+    isActionSelected(action: AvailableShellAction): boolean;
+    toggleAvailableAction(action: AvailableShellAction): void;
+    scopeLabel(scope?: string): string;
+    stringifyPayload(payload: any): string;
+    displayInputPath(path: string): string;
+    extractActionInput(actionValue: any): string;
+    showActionInputPath(actionValue: any): boolean;
+    currentSetInputValues(): SetInputValueOption[];
+    addSetInputAction(): void;
+    private findActionIndex;
+    private previewActions;
+    private loadSetInputPresets;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WidgetShellEditorComponent, [{ optional: true; }, { optional: true; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WidgetShellEditorComponent, "praxis-widget-shell-editor", never, {}, {}, never, never, true, never>;
+}
+type ConnectionEditorPortKind = 'output' | 'input' | 'state';
+interface ConnectionEditorPort {
+    id: string;
+    nodeId: string;
+    label: string;
+    kind: ConnectionEditorPortKind;
+    endpoint: EndpointRef;
+    nestedPath?: ComponentPortPathSegment[];
+}
+interface ConnectionEditorNode {
+    id: string;
+    title: string;
+    subtitle: string;
+    icon?: string;
+    x: number;
+    y: number;
+    rotationDegrees?: number;
+    portOrder?: string[];
+    outputs: ConnectionEditorPort[];
+    inputs: ConnectionEditorPort[];
+    states: ConnectionEditorPort[];
+}
+type ConnectionEditorDiagnosticSeverity = 'error' | 'warning';
+type ConnectionEditorDiagnosticCode = 'endpoint-widget-missing' | 'endpoint-unresolved' | 'endpoint-not-declared' | 'nested-path-terminal-missing' | 'nested-path-not-declared' | 'state-path-not-declared';
+interface ConnectionEditorDiagnostic {
+    code: ConnectionEditorDiagnosticCode;
+    severity: ConnectionEditorDiagnosticSeverity;
+    endpoint: 'from' | 'to';
+}
+interface ConnectionEditorConnection {
+    id: string;
+    fromNode: string | null;
+    toNode: string | null;
+    fromLabel: string;
+    toLabel: string;
+    fromPort: ConnectionEditorPort | null;
+    toPort: ConnectionEditorPort | null;
+    intent: LinkIntent;
+    link: CompositionLink;
+    diagnostics: ConnectionEditorDiagnostic[];
+}
+interface ConnectionEditorGraph {
+    nodes: ConnectionEditorNode[];
+    connections: ConnectionEditorConnection[];
+    portById: Map<string, ConnectionEditorPort>;
+    portByEndpointKey: Map<string, ConnectionEditorPort>;
+    connectionToLink: Map<string, CompositionLink>;
+    diagnostics: ConnectionEditorDiagnostic[];
+}
+type ConnectionEditorSuggestionReason = 'row-selection-to-id' | 'state-to-input' | 'compatible-port';
+interface ConnectionEditorSuggestion {
+    id: string;
+    source: ConnectionEditorPort;
+    target: ConnectionEditorPort;
+    sourceNodeTitle: string;
+    targetNodeTitle: string;
+    intent: LinkIntent;
+    reason: ConnectionEditorSuggestionReason;
+    score: number;
+}
+type ConnectionEditorTracePhase = 'emit' | 'condition' | 'transform' | 'deliver' | 'write' | 'read' | 'blocked';
+interface ConnectionEditorTraceStep {
+    id: string;
+    order: number;
+    connectionId: string;
+    phase: ConnectionEditorTracePhase;
+    fromLabel: string;
+    toLabel: string;
+    intent: string;
+    blocked: boolean;
+}
+interface ConnectionsViewerNode {
+    widgetId: string;
+    componentType: string;
+    incomingCount: number;
+    outgoingCount: number;
+}
+interface ConnectionsViewerEdge {
+    id: string;
+    fromKind: CompositionLink['from']['kind'];
+    fromWidgetId: string | null;
+    fromEndpointId: string | null;
+    fromNestedPath: ComponentPortPathSegment[] | null;
+    fromPort: string | null;
+    toKind: CompositionLink['to']['kind'];
+    toWidgetId: string | null;
+    toEndpointId: string | null;
+    toNestedPath: ComponentPortPathSegment[] | null;
+    toPort: string | null;
+    toStatePath: string | null;
+    intent: CompositionLink['intent'];
+    hasCondition: boolean;
+    hasTransform: boolean;
+    hasPolicy: boolean;
+    hasDiagnostics: boolean;
+    diagnosticReasons: string[];
+    link: CompositionLink;
+}
+interface ConnectionsViewerModel {
+    nodes: ConnectionsViewerNode[];
+    edges: ConnectionsViewerEdge[];
+    totalLinks: number;
+    conditionLinks: number;
+    transformLinks: number;
+    policyLinks: number;
+    diagnosticLinks: number;
+}
+interface ConnectionEditorPoint {
+    x: number;
+    y: number;
+}
+interface ConnectionEditorSegmentGeometry {
+    port: ConnectionEditorPort;
+    path: string;
+    anchor: ConnectionEditorPoint;
+    label: ConnectionEditorPoint;
+    icon: ConnectionEditorPoint;
+    normalAngle: number;
+    color: string;
+}
+type ConnectionEditorPortOrderState = Record<string, string[]>;
+type ConnectionsEditorFilter = 'all' | 'condition' | 'transform' | 'policy' | 'diagnostic';
+type ConnectionEditorFlowMode = 'all' | 'data' | 'event' | 'capability' | 'simulation';
+type ConnectionEditorDockTab = 'json' | 'links' | 'derived' | 'export';
+type ConnectionEditorConditionPreset = 'source-present' | 'source-id-present';
+type ConnectionEditorPolicyPreset = 'stable-delivery' | 'skip-missing';
+interface DragState {
+    port: ConnectionEditorPort;
+    source: ConnectionEditorPoint;
+    pointer: ConnectionEditorPoint;
+    candidate: ConnectionEditorPort | null;
+}
+interface PendingSegmentState {
+    port: ConnectionEditorPort;
+    nodeId: string;
+    start: ConnectionEditorPoint;
+    source: ConnectionEditorPoint;
+}
+interface InvalidDropFeedbackState {
+    id: number;
+    source: ConnectionEditorPort;
+    target: ConnectionEditorPort | null;
+    point: ConnectionEditorPoint;
+}
+interface PanState {
+    startClientX: number;
+    startClientY: number;
+    originX: number;
+    originY: number;
+}
+interface MinimapPanState {
+    pointerId: number;
+}
+interface RotationState {
+    nodeId: string;
+    startAngle: number;
+    startRotation: number;
+}
+interface NodeDragState {
+    nodeId: string;
+    start: ConnectionEditorPoint;
+    originOffset: ConnectionEditorPoint;
+    moved: boolean;
+}
+interface ViewportState {
+    x: number;
+    y: number;
+    scale: number;
+}
+interface ConnectionEditorBounds {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+interface ConnectionEditorTooltipPosition {
+    x: number;
+    y: number;
+}
+interface ConnectionEditorHistoryEntry {
+    before: WidgetPageDefinition;
+    after: WidgetPageDefinition;
+    selectedBefore: string | null;
+    selectedAfter: string | null;
+}
+interface ConnectionEditorDockTabDefinition {
+    id: ConnectionEditorDockTab;
+    label: string;
+    glyph: string;
+}
+declare class ConnectionEditorComponent {
+    readonly stateNodeId = "__page_state__";
+    readonly nodeViewBox = "0 0 168 168";
+    readonly canvasViewBox = "0 0 900 540";
+    readonly nodeHaloPaths: string[];
+    private readonly i18n;
+    private readonly hostElement;
+    private readonly globalActionCatalog;
+    readonly open: _angular_core.InputSignal<boolean>;
+    readonly page: _angular_core.InputSignal<WidgetPageDefinition | null | undefined>;
+    readonly pageChange: _angular_core.OutputEmitterRef<WidgetPageDefinition>;
+    readonly focusWidget: _angular_core.OutputEmitterRef<string>;
+    readonly openPageSettings: _angular_core.OutputEmitterRef<void>;
+    readonly close: _angular_core.OutputEmitterRef<void>;
+    readonly activeMode: _angular_core.WritableSignal<ConnectionEditorFlowMode>;
+    readonly activeFilter: _angular_core.WritableSignal<ConnectionsEditorFilter>;
+    readonly selectedWidgetId: _angular_core.WritableSignal<string | null>;
+    readonly selectedLinkId: _angular_core.WritableSignal<string | null>;
+    readonly recentLinkId: _angular_core.WritableSignal<string | null>;
+    readonly hoveredLinkId: _angular_core.WritableSignal<string | null>;
+    readonly expandedNodeId: _angular_core.WritableSignal<string | null>;
+    readonly activeDockTab: _angular_core.WritableSignal<ConnectionEditorDockTab>;
+    readonly dockCollapsed: _angular_core.WritableSignal<boolean>;
+    readonly traceEnabled: _angular_core.WritableSignal<boolean>;
+    readonly traceStepIndex: _angular_core.WritableSignal<number>;
+    readonly traceSourceNodeId: _angular_core.WritableSignal<string | null>;
+    readonly selectedPort: _angular_core.WritableSignal<ConnectionEditorPort | null>;
+    readonly globalActionPayloadError: _angular_core.WritableSignal<string | null>;
+    readonly pendingSegmentState: _angular_core.WritableSignal<PendingSegmentState | null>;
+    readonly dragState: _angular_core.WritableSignal<DragState | null>;
+    readonly nodeDragState: _angular_core.WritableSignal<NodeDragState | null>;
+    readonly invalidDropFeedback: _angular_core.WritableSignal<InvalidDropFeedbackState | null>;
+    readonly panState: _angular_core.WritableSignal<PanState | null>;
+    readonly minimapPanState: _angular_core.WritableSignal<MinimapPanState | null>;
+    readonly rotationState: _angular_core.WritableSignal<RotationState | null>;
+    readonly viewport: _angular_core.WritableSignal<ViewportState>;
+    readonly portOrder: _angular_core.WritableSignal<ConnectionEditorPortOrderState>;
+    readonly nodeRotations: _angular_core.WritableSignal<Record<string, number>>;
+    readonly nodeOffsets: _angular_core.WritableSignal<Record<string, ConnectionEditorPoint>>;
+    readonly undoStack: _angular_core.WritableSignal<ConnectionEditorHistoryEntry[]>;
+    readonly redoStack: _angular_core.WritableSignal<ConnectionEditorHistoryEntry[]>;
+    private invalidDropFeedbackId;
+    private invalidDropFeedbackTimer;
+    private recentLinkFeedbackTimer;
+    private minimapPointerCaptureTarget;
+    private suppressedNodeClickId;
+    private readonly fitViewportOnOpen;
+    readonly filters: ({
+        id: "all";
+        label: string;
+    } | {
+        id: "condition";
+        label: string;
+    } | {
+        id: "transform";
+        label: string;
+    } | {
+        id: "policy";
+        label: string;
+    } | {
+        id: "diagnostic";
+        label: string;
+    })[];
+    readonly flowModes: ({
+        id: "all";
+        label: string;
+        glyph: string;
+    } | {
+        id: "data";
+        label: string;
+        glyph: string;
+    } | {
+        id: "event";
+        label: string;
+        glyph: string;
+    } | {
+        id: "capability";
+        label: string;
+        glyph: string;
+    } | {
+        id: "simulation";
+        label: string;
+        glyph: string;
+    })[];
+    readonly dockTabs: ({
+        id: "json";
+        label: string;
+        glyph: string;
+    } | {
+        id: "links";
+        label: string;
+        glyph: string;
+    } | {
+        id: "derived";
+        label: string;
+        glyph: string;
+    } | {
+        id: "export";
+        label: string;
+        glyph: string;
+    })[];
+    readonly model: _angular_core.Signal<ConnectionsViewerModel>;
+    readonly selectedNode: _angular_core.Signal<ConnectionsViewerNode | null>;
+    readonly visibleEdges: _angular_core.Signal<ConnectionsViewerEdge[]>;
+    readonly selectedEdge: _angular_core.Signal<ConnectionsViewerEdge | null>;
+    readonly editorGraph: _angular_core.Signal<ConnectionEditorGraph>;
+    readonly editorNodes: _angular_core.Signal<ConnectionEditorNode[]>;
+    readonly navigationBounds: _angular_core.Signal<ConnectionEditorBounds>;
+    readonly minimapViewBox: _angular_core.Signal<string>;
+    readonly editorConnections: _angular_core.Signal<ConnectionEditorConnection[]>;
+    readonly canvasEditorConnections: _angular_core.Signal<ConnectionEditorConnection[]>;
+    readonly visibleEditorConnections: _angular_core.Signal<ConnectionEditorConnection[]>;
+    readonly modeMatchedConnectionIds: _angular_core.Signal<Set<string>>;
+    readonly modeMatchedNodeIds: _angular_core.Signal<Set<string>>;
+    readonly modeMatchedPortIds: _angular_core.Signal<Set<string>>;
+    readonly smartSuggestions: _angular_core.Signal<ConnectionEditorSuggestion[]>;
+    readonly traceSteps: _angular_core.Signal<ConnectionEditorTraceStep[]>;
+    readonly activeTraceStepIndex: _angular_core.Signal<number>;
+    readonly traceActiveStep: _angular_core.Signal<ConnectionEditorTraceStep>;
+    readonly tracedConnectionIds: _angular_core.Signal<Set<string>>;
+    readonly traceProgressPercent: _angular_core.Signal<number>;
+    readonly traceProgressLabel: _angular_core.Signal<string>;
+    readonly traceSourceNodeIds: _angular_core.Signal<Set<string>>;
+    readonly traceReactingNodeIds: _angular_core.Signal<Set<string>>;
+    readonly focusedConnectionNodeIds: _angular_core.Signal<Set<string>>;
+    readonly focusedConnectionPortIds: _angular_core.Signal<Set<string>>;
+    readonly diagnosticConnectionIds: _angular_core.Signal<Set<string>>;
+    readonly diagnosticLinkCount: _angular_core.Signal<number>;
+    readonly selectedEditorNode: _angular_core.Signal<ConnectionEditorNode | null>;
+    readonly selectedConnection: _angular_core.Signal<ConnectionEditorConnection | null>;
+    readonly connectionTooltip: _angular_core.Signal<ConnectionEditorConnection | null>;
+    readonly canvasInteractionActive: _angular_core.Signal<boolean>;
+    readonly visibleConnectionTooltip: _angular_core.Signal<ConnectionEditorConnection | null>;
+    readonly visibleExpandedNodeId: _angular_core.Signal<string | null>;
+    readonly canUndo: _angular_core.Signal<boolean>;
+    readonly canRedo: _angular_core.Signal<boolean>;
+    readonly hasVisualPortOrder: _angular_core.Signal<boolean>;
+    readonly dragPreviewPath: _angular_core.Signal<string>;
+    readonly dragTargetPoint: _angular_core.Signal<ConnectionEditorPoint>;
+    readonly dragTipPosition: _angular_core.Signal<{
+        x: number;
+        y: number;
+    }>;
+    readonly invalidDropPosition: _angular_core.Signal<{
+        x: number;
+        y: number;
+    }>;
+    readonly invalidDropTipPosition: _angular_core.Signal<{
+        x: number;
+        y: number;
+    }>;
+    readonly dragEndpointText: _angular_core.Signal<string>;
+    readonly invalidDropEndpointText: _angular_core.Signal<string>;
+    readonly dragStatusText: _angular_core.Signal<string>;
+    readonly invalidDropStatusText: _angular_core.Signal<string>;
+    readonly viewportTransform: _angular_core.Signal<string>;
+    readonly minimapViewport: _angular_core.Signal<{
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }>;
+    selectNode(nodeId: string): void;
+    selectSegment(port: ConnectionEditorPort, event: MouseEvent): void;
+    selectWidget(node: ConnectionsViewerNode): void;
+    selectLink(edge: ConnectionsViewerEdge): void;
+    selectConnection(connection: ConnectionEditorConnection): void;
+    jumpToConnection(connection: ConnectionEditorConnection, event: Event): void;
+    previewConnection(connection: ConnectionEditorConnection): void;
+    clearPreviewConnection(connection: ConnectionEditorConnection): void;
+    handleEditorKeydown(event: KeyboardEvent): void;
+    setFilter(filter: ConnectionsEditorFilter): void;
+    setMode(mode: ConnectionEditorFlowMode): void;
+    activeModeStatus(): string;
+    setDockTab(tab: ConnectionEditorDockTab): void;
+    handleDockTabKeydown(event: KeyboardEvent, tab: ConnectionEditorDockTab): void;
+    toggleDock(): void;
+    toggleTrace(event: Event): void;
+    selectTraceSource(nodeId: string | null, event: Event): void;
+    moveTraceStep(delta: -1 | 1, event: Event): void;
+    selectTraceStep(index: number, event: Event): void;
+    quickConnectSuggestion(suggestion: ConnectionEditorSuggestion, event: Event): void;
+    startDrag(port: ConnectionEditorPort, event: PointerEvent): void;
+    startSegmentDrag(port: ConnectionEditorPort, event: PointerEvent): void;
+    updatePendingSegment(event: PointerEvent): void;
+    updateDrag(event: PointerEvent): void;
+    startNodeDrag(nodeId: string, event: PointerEvent): void;
+    updateNodeDrag(event: PointerEvent): void;
+    stopNodeDrag(): void;
+    finishNodePointer(nodeId: string, event: PointerEvent): void;
+    closeFloatingPanelsOnOutsidePointerDown(event: PointerEvent): void;
+    previewDrop(target: ConnectionEditorPort): void;
+    clearPreviewDrop(target: ConnectionEditorPort): void;
+    completeDrag(target: ConnectionEditorPort, event: PointerEvent): void;
+    cancelDrag(event?: PointerEvent): void;
+    cancelPendingSegment(): void;
+    startPan(event: PointerEvent): void;
+    updatePan(event: PointerEvent): void;
+    stopPan(): void;
+    startMinimapPan(event: PointerEvent): void;
+    updateMinimapPan(event: PointerEvent): void;
+    stopMinimapPan(): void;
+    startNodeRotation(nodeId: string, event: PointerEvent): void;
+    updateRotation(event: PointerEvent): void;
+    stopRotation(): void;
+    zoomCanvas(event: WheelEvent): void;
+    zoomBy(delta: number, event: Event): void;
+    resetViewport(event?: Event): void;
+    autoArrange(event: Event): void;
+    reorganizeSlices(event: Event): void;
+    isCompatibleDrop(target: ConnectionEditorPort): boolean;
+    isCompatibilityPreview(target: ConnectionEditorPort): boolean;
+    isDropCandidate(target: ConnectionEditorPort): boolean;
+    isDragSource(port: ConnectionEditorPort): boolean;
+    isIncompatibleDrop(target: ConnectionEditorPort): boolean;
+    nodeHasCompatiblePreviewPort(node: ConnectionEditorNode): boolean;
+    isInvalidDropFeedbackTarget(target: ConnectionEditorPort): boolean;
+    removeLink(linkId: string): void;
+    undoHistory(event: Event): void;
+    redoHistory(event: Event): void;
+    enableTransform(connection: ConnectionEditorConnection, event: Event): void;
+    addTransformStep(connection: ConnectionEditorConnection, kind: TransformKind, event: Event): void;
+    removeTransformStep(connection: ConnectionEditorConnection, index: number, event: Event): void;
+    clearTransform(connection: ConnectionEditorConnection, event: Event): void;
+    applyConditionPreset(connection: ConnectionEditorConnection, preset: ConnectionEditorConditionPreset, event: Event): void;
+    clearCondition(connection: ConnectionEditorConnection, event: Event): void;
+    applyPolicyPreset(connection: ConnectionEditorConnection, preset: ConnectionEditorPolicyPreset, event: Event): void;
+    clearPolicy(connection: ConnectionEditorConnection, event: Event): void;
+    nodeSegments(node: ConnectionEditorNode): ConnectionEditorSegmentGeometry[];
+    nodeSvgRotation(node: ConnectionEditorNode): string | null;
+    segmentLabelTransform(segment: ConnectionEditorSegmentGeometry, node: ConnectionEditorNode): string;
+    nodeRotationHandleTransform(node: ConnectionEditorNode): string;
+    segmentDisplayLabel(label: string): string;
+    segmentKindGlyph(kind: ConnectionEditorPortKind): string;
+    nodeIcon(node: ConnectionEditorNode): string;
+    dockTabLabel(tab: ConnectionEditorDockTabDefinition): string;
+    dockTabId(tab: ConnectionEditorDockTab): string;
+    dockPanelId(tab: ConnectionEditorDockTab): string;
+    dockToggleLabel(): string;
+    segmentKindText(kind: ConnectionEditorPortKind): string;
+    connectionHasErrors(connection: ConnectionEditorConnection): boolean;
+    connectionHasWarnings(connection: ConnectionEditorConnection): boolean;
+    connectionHasPolicy(connection: ConnectionEditorConnection): boolean;
+    connectionMatchesMode(connection: ConnectionEditorConnection): boolean;
+    hasModeFocus(): boolean;
+    isModeDimmedConnection(connection: ConnectionEditorConnection): boolean;
+    isModeDimmedNode(node: ConnectionEditorNode): boolean;
+    isModeDimmedPort(port: ConnectionEditorPort): boolean;
+    edgeMatchesMode(edge: ConnectionsViewerEdge): boolean;
+    isNodeFocusedByConnection(node: ConnectionEditorNode): boolean;
+    isPortFocusedByConnection(port: ConnectionEditorPort): boolean;
+    isTracedConnection(connection: ConnectionEditorConnection): boolean;
+    isTraceSourceNode(node: ConnectionEditorNode): boolean;
+    isTraceReactingNode(node: ConnectionEditorNode): boolean;
+    traceNodeLabel(node: ConnectionEditorNode): string | null;
+    tracePhaseText(phase: ConnectionEditorTracePhase): string;
+    diagnosticSeverityLabel(diagnostic: ConnectionEditorDiagnostic): string;
+    diagnosticText(diagnostic: ConnectionEditorDiagnostic): string;
+    suggestionReasonText(reason: ConnectionEditorSuggestionReason): string;
+    transformKindText(kind: TransformKind): string;
+    expandedPorts(node: ConnectionEditorNode): ConnectionEditorPort[];
+    movePort(node: ConnectionEditorNode, port: ConnectionEditorPort, direction: -1 | 1, event: Event): void;
+    toggleSegments(node: ConnectionEditorNode, event: Event): void;
+    wirePath(connection: ConnectionEditorConnection): string;
+    wireSourcePoint(connection: ConnectionEditorConnection): {
+        x: number;
+        y: number;
+    } | null;
+    wireTargetPoint(connection: ConnectionEditorConnection): {
+        x: number;
+        y: number;
+    } | null;
+    wireRoutePoint(connection: ConnectionEditorConnection, key: 'sourceStub' | 'sourceControl' | 'targetControl' | 'targetStub' | 'midpoint'): {
+        x: number;
+        y: number;
+    } | null;
+    wireLabelTransform(connection: ConnectionEditorConnection, endpoint: 'source' | 'target'): string;
+    minimapWirePath(connection: ConnectionEditorConnection): string;
+    connectionTooltipPosition(connection: ConnectionEditorConnection): ConnectionEditorTooltipPosition;
+    connectionTooltipCalloutX(connection: ConnectionEditorConnection): number;
+    connectionTooltipKind(connection: ConnectionEditorConnection): string;
+    dockJson(): WidgetPageDefinition | null | undefined;
+    dockLinks(): unknown[];
+    dockDerived(): unknown;
+    dockExport(): unknown;
+    describeEdge(edge: ConnectionsViewerEdge): string;
+    edgeHasDiagnostics(edge: ConnectionsViewerEdge): boolean;
+    edgeDiagnostics(edge: ConnectionsViewerEdge): unknown[];
+    describeSource(edge: ConnectionsViewerEdge): string;
+    describeTarget(edge: ConnectionsViewerEdge): string;
+    globalActionPayloadText(connection: ConnectionEditorConnection): string;
+    globalActionPayloadExample(connection: ConnectionEditorConnection): string;
+    surfaceOpenPayloadValue(connection: ConnectionEditorConnection): SurfaceOpenPayload | null;
+    surfaceOpenHostKind(connection: ConnectionEditorConnection): string;
+    applySurfaceOpenPayload(connection: ConnectionEditorConnection, payload: SurfaceOpenPayload): void;
+    applyGlobalActionPayload(connection: ConnectionEditorConnection, payloadText: string, event: Event): void;
+    tx(key: string, fallback: string): string;
+    private availableGlobalActions;
+    private availableGlobalActionIds;
+    private addLink;
+    private ensureSourceOutputDeclared;
+    private setConnectionTransform;
+    private setConnectionCondition;
+    private setConnectionPolicy;
+    private updateConnectionLink;
+    private commitPageChange;
+    private defaultTransformPipeline;
+    private createTransformStep;
+    private createConditionPreset;
+    private createPolicyPreset;
+    private applyNodeRotation;
+    private nodeRotationHandlePoint;
+    private applyNodeOffset;
+    private compatibilitySourcePort;
+    private intentMatchesMode;
+    private clonePage;
+    private pagesEqual;
+    private anchorForPort;
+    private showInvalidDropFeedback;
+    private clearInvalidDropFeedback;
+    private markRecentLink;
+    private clearPreviewConnectionState;
+    private shouldIgnoreEditorShortcut;
+    private scrollActiveModeIntoView;
+    private focusDockTab;
+    private portQualifiedLabel;
+    private stagePointFromEvent;
+    private rotationAngleForNode;
+    private snapDegrees;
+    private portIndexAtPoint;
+    private previewWirePath;
+    private formatPoint;
+    private labelPointBetween;
+    private connectionTooltipAnchor;
+    private applyZoom;
+    private centerViewportOnMinimapEvent;
+    private minimapPointFromEvent;
+    private fitViewportState;
+    private clampViewport;
+    private connectionEditorNavigationBounds;
+    private stageClientSize;
+    private stageRect;
+    private shouldIgnorePanTarget;
+    private shouldIgnoreNodeDragTarget;
+    private isFloatingPanelInteractionTarget;
+    private clamp;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ConnectionEditorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ConnectionEditorComponent, "praxis-connection-editor", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "page": { "alias": "page"; "required": false; "isSignal": true; }; }, { "pageChange": "pageChange"; "focusWidget": "focusWidget"; "openPageSettings": "openPageSettings"; "close": "close"; }, never, never, true, never>;
+}
+type EditorTabId$1 = 'canvas' | 'grouping' | 'devices' | 'context' | 'state';
+type DeviceKey = 'desktop' | 'tablet' | 'mobile';
+type GroupingNodeGroup$1 = FormGroup<{
+    kind: FormControl<string>;
+    id: FormControl<string>;
+    label: FormControl<string>;
+    widgetKeysCsv: FormControl<string>;
+    layout: FormControl<string>;
+    emphasis: FormControl<string>;
+    side: FormControl<string>;
+    tabsJson: FormControl<string>;
+}>;
+type DeviceVariantForm = FormGroup<{
+    columns: FormControl<number | null>;
+    rowUnit: FormControl<string>;
+    gap: FormControl<string>;
+    autoRows: FormControl<'fixed' | 'content' | ''>;
+    groupingOverrides: FormControl<string>;
+    widgetOverrides: FormControl<string>;
+}>;
+declare class DynamicPageConfigEditorComponent implements OnInit, SettingsValueProvider$1 {
+    set page(value: WidgetPageDefinition | string | null | undefined);
+    layout?: unknown;
+    presets?: unknown;
+    pagePreset?: string | null;
+    pageChange: EventEmitter<WidgetPageDefinition>;
+    readonly layoutPresetEntries: {
+        id: string;
+        label: string;
+    }[];
+    readonly themePresetEntries: {
+        id: string;
+        label: string;
+    }[];
+    readonly shellPresetEntries: {
+        id: string;
+        label: string;
+    }[];
+    readonly deviceKeys: DeviceKey[];
+    readonly deviceLabels: Record<DeviceKey, string>;
+    readonly canvasColumnsControl: FormControl<number>;
+    readonly canvasRowUnitControl: FormControl<string>;
+    readonly canvasGapControl: FormControl<string>;
+    readonly canvasAutoRowsControl: FormControl<"content" | "fixed">;
+    readonly layoutPresetControl: FormControl<string>;
+    readonly themePresetControl: FormControl<string>;
+    readonly shellPresetControl: FormControl<string>;
+    readonly contextControl: FormControl<string>;
+    readonly stateControl: FormControl<string>;
+    readonly groupingNodes: FormArray<GroupingNodeGroup$1>;
+    readonly deviceForms: Record<DeviceKey, DeviceVariantForm>;
+    readonly isDirty$: BehaviorSubject<boolean>;
+    readonly isValid$: BehaviorSubject<boolean>;
+    readonly isBusy$: BehaviorSubject<boolean>;
+    readonly activeTab: WritableSignal<EditorTabId$1>;
+    readonly canvasError: WritableSignal<string | null>;
+    readonly groupingError: WritableSignal<string | null>;
+    readonly contextError: WritableSignal<string | null>;
+    readonly stateError: WritableSignal<string | null>;
+    readonly deviceError: WritableSignal<string | null>;
+    private readonly injectedData;
+    private pageInput;
+    private snapshot;
+    private hydrating;
+    private readonly tabOrder;
+    constructor();
+    ngOnInit(): void;
+    get selectedTabIndex(): number;
+    get isConfigurationValid(): boolean;
+    get hasPendingChanges(): boolean;
+    get validationStateLabel(): string;
+    get dirtyStateLabel(): string;
+    get selectedLayoutPresetLabel(): string;
+    get selectedThemePresetLabel(): string;
+    get canvasSummaryLabel(): string;
+    onSelectedTabIndexChange(index: number): void;
+    getSettingsValue(): WidgetPageDefinition | null;
+    onSave(): WidgetPageDefinition | null;
+    reset(): void;
+    addGroupingNode(seed?: WidgetPageGroupingDefinition): void;
+    removeGroupingNode(index: number): void;
+    private createDeviceVariantForm;
+    private createGroupingNodeGroup;
+    private hydrate;
+    private replaceGroupingNodes;
+    private buildCurrentPage;
+    private buildGrouping;
+    private buildDeviceLayouts;
+    private invalidate;
+    private refreshPanelState;
+    private currentPageInput;
+    private parsePage;
+    private parseJson;
+    private parseRecordJson;
+    private parseGroupingTabs;
+    private parseGroupingOverrides;
+    private parseWidgetOverrides;
+    private isGroupingTab;
+    private isGroupingOverride;
+    private isWidgetOverride;
+    private isPlainObject;
+    private hasDuplicateIds;
+    private hasDuplicateStrings;
+    private stringify;
+    private stringifyGroupingWidgetKeys;
+    private extractShellPreset;
+    private removeShellPresetFromContext;
+    private applyShellPresetToContext;
+    private lookupPresetLabel;
+    private defaultCanvas;
+    private clone;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DynamicPageConfigEditorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DynamicPageConfigEditorComponent, "praxis-dynamic-page-config-editor", never, { "page": { "alias": "page"; "required": false; }; "layout": { "alias": "layout"; "required": false; }; "presets": { "alias": "presets"; "required": false; }; "pagePreset": { "alias": "pagePreset"; "required": false; }; }, { "pageChange": "pageChange"; }, never, never, true, never>;
+}
+type LegacyGridOptions = {
+    cols?: number;
+    rowHeight?: number;
+    gap?: number;
+};
+type PageDefinition = WidgetPageDefinition & {
+    options?: LegacyGridOptions;
+};
+type EditorTabId = 'layout' | 'grouping' | 'devices' | 'state' | 'context';
+type SchemaNodeGroup = FormGroup<{
+    path: FormControl<string>;
+    type: FormControl<string>;
+    initialMode: FormControl<string>;
+    initialJson: FormControl<string>;
+    initialScalar: FormControl<string>;
+    persist: FormControl<string>;
+    mergeStrategy: FormControl<string>;
+    description: FormControl<string>;
+}>;
+type DerivedNodeGroup = FormGroup<{
+    path: FormControl<string>;
+    dependsOn: FormControl<string>;
+    computeKind: FormControl<string>;
+    operator: FormControl<string>;
+    sourcePath: FormControl<string>;
+    keysCsv: FormControl<string>;
+    expression: FormControl<string>;
+    transformerId: FormControl<string>;
+    options: FormControl<string>;
+    templateMode: FormControl<string>;
+    templateJson: FormControl<string>;
+    templateScalar: FormControl<string>;
+    description: FormControl<string>;
+}>;
+type GroupingNodeGroup = FormGroup<{
+    kind: FormControl<string>;
+    id: FormControl<string>;
+    label: FormControl<string>;
+    widgetKeysCsv: FormControl<string>;
+    layout: FormControl<string>;
+    emphasis: FormControl<string>;
+    side: FormControl<string>;
+    tabsJson: FormControl<string>;
+}>;
+declare class PageConfigEditorComponent implements SettingsValueProvider$1 {
+    protected readonly derivedOperators: readonly ["merge-objects", "pick", "omit"];
+    protected readonly mergeStrategies: readonly ["replace", "merge", "append", "remove-keys"];
+    protected readonly valueModes: readonly ["json", "string", "number", "boolean", "null"];
+    protected readonly groupingKinds: readonly ["section", "tabs", "hero", "rail"];
+    protected readonly layoutPresetEntries: Array<(typeof BUILTIN_PAGE_LAYOUT_PRESETS)[string]>;
+    protected readonly themePresetEntries: Array<(typeof BUILTIN_PAGE_THEME_PRESETS)[string]>;
+    readonly page: _angular_core.InputSignal<string | PageDefinition | null>;
+    readonly identity: _angular_core.InputSignal<PageIdentity | null>;
+    readonly layoutCompatOptions: _angular_core.InputSignal<any>;
+    readonly pageChange: _angular_core.OutputEmitterRef<PageDefinition>;
+    readonly form: FormGroup<{
+        cols: FormControl<number | null>;
+        rowHeight: FormControl<number | null>;
+        gap: FormControl<number | null>;
+    }>;
+    readonly contextControl: FormControl<string>;
+    readonly shellPresetControl: FormControl<string>;
+    readonly layoutPresetControl: FormControl<string>;
+    readonly themePresetControl: FormControl<string>;
+    readonly groupingControl: FormControl<string>;
+    readonly deviceLayoutsControl: FormControl<string>;
+    readonly stateValuesControl: FormControl<string>;
+    readonly groupingNodes: FormArray<GroupingNodeGroup>;
+    readonly schemaNodes: FormArray<SchemaNodeGroup>;
+    readonly derivedNodes: FormArray<DerivedNodeGroup>;
+    readonly deviceDesktopForm: FormGroup<{
+        orientation: FormControl<string>;
+        columns: FormControl<number | null>;
+        gap: FormControl<string>;
+        breakpointsJson: FormControl<string>;
+        groupingOverridesJson: FormControl<string>;
+        widgetOverridesJson: FormControl<string>;
+    }>;
+    readonly deviceTabletForm: FormGroup<{
+        orientation: FormControl<string>;
+        columns: FormControl<number | null>;
+        gap: FormControl<string>;
+        breakpointsJson: FormControl<string>;
+        groupingOverridesJson: FormControl<string>;
+        widgetOverridesJson: FormControl<string>;
+    }>;
+    readonly deviceMobileForm: FormGroup<{
+        orientation: FormControl<string>;
+        columns: FormControl<number | null>;
+        gap: FormControl<string>;
+        breakpointsJson: FormControl<string>;
+        groupingOverridesJson: FormControl<string>;
+        widgetOverridesJson: FormControl<string>;
+    }>;
+    readonly contextError: _angular_core.WritableSignal<string | null>;
+    readonly layoutError: _angular_core.WritableSignal<string | null>;
+    readonly stateError: _angular_core.WritableSignal<string | null>;
+    readonly activeTab: _angular_core.WritableSignal<EditorTabId>;
+    readonly shellPresetEntries: Array<{
+        id: string;
+        label: string;
+    }>;
+    private lastContext;
+    private lastGrouping;
+    private lastDeviceLayouts;
+    private lastStateValues;
+    private readonly dirtySubject;
+    private readonly validSubject;
+    private readonly busySubject;
+    private snapshot;
+    private readonly tabOrder;
+    private readonly i18n;
+    private readonly injectedData;
+    readonly isDirty$: rxjs.Observable<boolean>;
+    readonly isValid$: rxjs.Observable<boolean>;
+    readonly isBusy$: rxjs.Observable<boolean>;
+    protected readonly embeddedInSettingsPanel: boolean;
+    get selectedTabIndex(): number;
+    protected get hasPendingChanges(): boolean;
+    protected get isConfigurationValid(): boolean;
+    protected get validationStateLabel(): string;
+    protected get dirtyStateLabel(): string;
+    protected get selectedLayoutPresetLabel(): string;
+    protected get selectedThemePresetLabel(): string;
+    protected get selectedShellPresetLabel(): string;
+    protected get contextExample(): string;
+    protected get stateValuesExample(): string;
+    protected get layoutPresetHint(): string;
+    protected get themePresetHint(): string;
+    protected get shellPresetHint(): string;
+    protected get tabsJsonHint(): string;
+    protected get breakpointsHint(): string;
+    protected get groupingOverridesHint(): string;
+    protected get widgetOverridesHint(): string;
+    protected get schemaInitialHint(): string;
+    protected get templateJsonHint(): string;
+    protected get transformerOptionsHint(): string;
+    constructor();
+    protected tx(key: string, fallback: string): string;
+    addSchemaNode(seed?: {
+        path?: string;
+        config?: WidgetStateNode;
+    }): void;
+    removeSchemaNode(index: number): void;
+    addDerivedNode(seed?: {
+        path?: string;
+        config?: WidgetDerivedStateNode;
+    }): void;
+    removeDerivedNode(index: number): void;
+    addGroupingNode(seed?: WidgetPageGroupingDefinition): void;
+    removeGroupingNode(index: number): void;
+    setActiveTab(tab: EditorTabId): void;
+    onSelectedTabIndexChange(index: number): void;
+    apply(): void;
+    reset(): void;
+    private replaceGroupingNodes;
+    private createGroupingNodeGroup;
+    private stringifyGroupingWidgetKeys;
+    private buildGrouping;
+    private hydrateDeviceLayoutControls;
+    private buildDeviceLayouts;
+    private createDeviceLayoutForm;
+    private patchDeviceLayoutForm;
+    private buildDeviceLayoutVariant;
+    private hydrateStateEditor;
+    private replaceSchemaNodes;
+    private replaceDerivedNodes;
+    private createSchemaNodeGroup;
+    private createDerivedNodeGroup;
+    private buildState;
+    private buildSchema;
+    private buildDerived;
+    private normalizeState;
+    getSettingsValue(): PageDefinition | null;
+    onSave(): PageDefinition | null;
+    private lookupPresetLabel;
+    private currentPageInput;
+    private extractShellPreset;
+    private buildCurrentPage;
+    private applyShellPresetToContext;
+    private refreshPanelState;
+    private parsePage;
+    private parseContext;
+    private parseGrouping;
+    private parseDeviceLayouts;
+    private parseJson;
+    private parseValueInput;
+    private describeValue;
+    private buildOperatorOptions;
+    private buildOptions;
+    private clone;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PageConfigEditorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PageConfigEditorComponent, "praxis-page-config-editor", never, { "page": { "alias": "page"; "required": false; "isSignal": true; }; "identity": { "alias": "identity"; "required": false; "isSignal": true; }; "layoutCompatOptions": { "alias": "layoutCompatOptions"; "required": false; "isSignal": true; }; }, { "pageChange": "pageChange"; }, never, never, true, never>;
+}
+/**
+ * Capabilities catalog for the canonical dynamic page builder/runtime.
+ */
+declare module '@praxisui/core' {
+    interface AiCapabilityCategoryMap {
+        page: true;
+        widgets: true;
+        connections: true;
+        context: true;
+        state: true;
+    }
+}
+type CapabilityCategory = AiCapabilityCategory;
+type ValueKind = AiValueKind;
+interface Capability extends AiCapability {
+    category: CapabilityCategory;
+}
+interface CapabilityCatalog extends AiCapabilityCatalog {
+    capabilities: Capability[];
+}
+declare const PAGE_BUILDER_AI_CAPABILITIES: CapabilityCatalog;
+type PageBuilderAgenticAuthoringProvider = 'openai' | 'gemini' | string;
+interface PageBuilderAgenticAuthoringOptions {
+    baseUrl?: string;
+    headersFactory?: () => Record<string, string | undefined>;
+    defaultHeaders?: Record<string, string>;
+    createProjectKnowledgeChangeSet?: (request: DomainKnowledgeChangeSetRequest, options?: {
+        headers?: Record<string, string> | undefined;
+    }) => Observable<DomainKnowledgeChangeSet>;
+    getProjectKnowledgeChangeSet?: (changeSetId: string, options?: {
+        headers?: Record<string, string> | undefined;
+    }) => Observable<DomainKnowledgeChangeSet>;
+    getProjectKnowledgeChangeSetTimeline?: (changeSetId: string, options?: {
+        headers?: Record<string, string> | undefined;
+    }) => Observable<DomainKnowledgeChangeSetTimelineResponse>;
+    listProjectKnowledgeChangeSets?: (filters: DomainKnowledgeChangeSetFilters, options?: {
+        headers?: Record<string, string> | undefined;
+    }) => Observable<DomainKnowledgeChangeSet[]>;
+    validateProjectKnowledgeChangeSet?: (changeSetId: string, options?: {
+        headers?: Record<string, string> | undefined;
+    }) => Observable<DomainKnowledgeValidationResponse>;
+    transitionProjectKnowledgeChangeSetStatus?: (changeSetId: string, request: DomainKnowledgeStatusTransitionRequest, options?: {
+        headers?: Record<string, string> | undefined;
+    }) => Observable<DomainKnowledgeChangeSet>;
+    applyProjectKnowledgeChangeSet?: (changeSetId: string, options?: {
+        headers?: Record<string, string> | undefined;
+    }) => Observable<DomainKnowledgeChangeSet>;
+    sharedRuleIntake?: (request: DomainRuleIntakeRequest, options?: {
+        headers?: Record<string, string> | undefined;
+    }) => Observable<DomainRuleIntakeResponse>;
+    sharedRuleCreateDefinition?: (request: DomainRuleDefinitionRequest, options?: {
+        headers?: Record<string, string> | undefined;
+    }) => Observable<DomainRuleDefinition>;
+    sharedRuleSimulate?: (request: DomainRuleSimulationRequest, options?: {
+        headers?: Record<string, string> | undefined;
+    }) => Observable<DomainRuleSimulationResponse>;
+    sharedRuleTransitionDefinitionStatus?: (definitionId: string, request: DomainRuleStatusTransitionRequest, options?: {
+        headers?: Record<string, string> | undefined;
+    }) => Observable<DomainRuleDefinition>;
+    sharedRulePublish?: (request: DomainRulePublicationRequest, options?: {
+        headers?: Record<string, string> | undefined;
+    }) => Observable<DomainRulePublicationResponse>;
+    sharedRuleListMaterializations?: (filters: DomainRuleMaterializationFilters, options?: {
+        headers?: Record<string, string> | undefined;
+    }) => Observable<DomainRuleMaterialization[]>;
+    sharedRuleGetDefinitionTimeline?: (definitionId: string, options?: {
+        headers?: Record<string, string> | undefined;
+    }) => Observable<DomainRuleTimelineResponse>;
+    eventSourceFactory?: PageBuilderAgenticAuthoringEventSourceFactory;
+    requestTimeoutMs?: number;
+    streamStartTimeoutMs?: number;
+    streamTurnTimeoutMs?: number;
+    streamResultFallbackMs?: number;
+    streamSilenceStatusMs?: number;
+    streamConnectionErrorGraceMs?: number;
+}
+interface PageBuilderAgenticAuthoringEventSource {
+    readonly readyState?: number;
+    onmessage: ((event: MessageEvent<string>) => void) | null;
+    onerror: ((event: Event) => void) | null;
+    addEventListener?(type: string, listener: (event: MessageEvent<string>) => void): void;
+    close(): void;
+}
+interface PageBuilderAgenticAuthoringEventSourceOptions {
+    withCredentials?: boolean;
+}
+type PageBuilderAgenticAuthoringEventSourceFactory = (url: string, options?: PageBuilderAgenticAuthoringEventSourceOptions) => PageBuilderAgenticAuthoringEventSource;
+interface PageBuilderAgenticAuthoringTurnStreamConnectionError {
+    readonly praxisAgenticTurnStreamConnectionError: true;
+    readonly cause: unknown;
+}
+interface PageBuilderAgenticAuthoringPromptRequest extends Omit<AgenticAuthoringPlanRequestContract, 'currentPage' | 'intentResolution'> {
+    provider?: PageBuilderAgenticAuthoringProvider | null;
+    currentPage?: unknown;
+    selectedWidgetKey?: string | null;
+    intentResolution?: PageBuilderAgenticAuthoringIntentResolutionResult | null;
+    componentCapabilities?: PageBuilderAgenticAuthoringComponentCapabilitiesResult | null;
+    attachmentSummaries?: PageBuilderAgenticAuthoringAttachmentSummary[];
+}
+interface PageBuilderAgenticAuthoringIntentResolutionRequest extends Omit<AgenticAuthoringIntentResolutionRequestContract, 'currentPage'> {
+    provider?: PageBuilderAgenticAuthoringProvider | null;
+    currentPage?: unknown;
+    componentCapabilities?: PageBuilderAgenticAuthoringComponentCapabilitiesResult | null;
+    attachmentSummaries?: PageBuilderAgenticAuthoringAttachmentSummary[];
+}
+interface PageBuilderAgenticAuthoringTurnStreamRequest {
+    userPrompt: string;
+    targetApp?: string | null;
+    targetComponentId?: string | null;
+    currentRoute?: string | null;
+    provider?: PageBuilderAgenticAuthoringProvider | null;
+    model?: string | null;
+    apiKey?: string | null;
+    currentPage?: unknown;
+    selectedWidgetKey?: string | null;
+    sessionId?: string | null;
+    clientTurnId?: string | null;
+    conversationMessages?: PageBuilderAgenticAuthoringConversationMessage[];
+    pendingClarification?: PageBuilderAgenticAuthoringPendingClarification | null;
+    componentCapabilities?: PageBuilderAgenticAuthoringComponentCapabilitiesResult | null;
+    attachmentSummaries?: PageBuilderAgenticAuthoringAttachmentSummary[];
+    contextHints?: AiContextHintsContract | null;
+}
+type PageBuilderAgenticAuthoringConversationMessage = AgenticAuthoringConversationMessageContract;
+type PageBuilderAgenticAuthoringPendingClarification = AgenticAuthoringPendingClarificationContract;
+type PageBuilderAgenticAuthoringQuickReply = AgenticAuthoringQuickReplyContract;
+type PageBuilderAgenticAuthoringAttachmentSummary = AgenticAuthoringAttachmentSummaryContract;
+interface PageBuilderAgenticAuthoringCandidate extends AgenticAuthoringCandidateContract {
+    resourcePath: string;
+    operation: string;
+    schemaUrl: string;
+    submitUrl: string;
+    submitMethod: string;
+    score: number;
+    reason: string;
+    evidence: string[];
+    [key: string]: AiJsonValue | undefined;
+}
+interface PageBuilderAgenticAuthoringResourceCandidatesRequest extends AgenticAuthoringResourceCandidatesRequestContract {
+}
+interface PageBuilderAgenticAuthoringResourceCandidatesResult extends Omit<AgenticAuthoringResourceCandidatesResultContract, 'candidates'> {
+    valid: boolean;
+    tool: string;
+    retrievalQuery: string;
+    artifactKind: string;
+    assistantMessage?: string | null;
+    candidates: PageBuilderAgenticAuthoringCandidate[];
+    quickReplies?: PageBuilderAgenticAuthoringQuickReply[];
+    warnings: string[];
+}
+interface PageBuilderAgenticAuthoringTarget {
+    widgetKey: string;
+    componentId: string;
+    resourcePath: string;
+    schemaUrl: string;
+    submitUrl: string;
+    submitMethod: string;
+}
+interface PageBuilderAgenticAuthoringGateResult {
+    gateId: string;
+    status: string;
+    messages: string[];
+}
+interface PageBuilderAgenticAuthoringComponentFieldAlias extends AgenticAuthoringComponentFieldAliasContract {
+    field: string;
+    aliases: string[];
+}
+interface PageBuilderAgenticAuthoringComponentCapability extends Omit<AgenticAuthoringComponentCapabilityContract, 'fieldAliases' | 'examples'> {
+    id: string;
+    changeKind: string;
+    triggerTerms: string[];
+    fieldAliases: PageBuilderAgenticAuthoringComponentFieldAlias[];
+    examples?: PageBuilderAgenticAuthoringComponentCapabilityExample[];
+}
+interface PageBuilderAgenticAuthoringComponentCapabilityExample extends AgenticAuthoringComponentCapabilityExampleContract {
+    prompt: string;
+    intent: string;
+    configHints: string[];
+}
+interface PageBuilderAgenticAuthoringComponentCapabilityCatalog extends Omit<AgenticAuthoringComponentCapabilityCatalogContract, 'capabilities'> {
+    componentId: string;
+    version: string;
+    capabilities: PageBuilderAgenticAuthoringComponentCapability[];
+}
+interface PageBuilderAgenticAuthoringComponentCapabilitiesResult extends Omit<AgenticAuthoringComponentCapabilitiesResultContract, 'catalogs'> {
+    version: string;
+    catalogs: PageBuilderAgenticAuthoringComponentCapabilityCatalog[];
+}
+interface PageBuilderAgenticAuthoringIntentResolutionResult {
+    valid: boolean;
+    operationKind: string;
+    artifactKind: string;
+    changeKind: string;
+    authoringProfile: string;
+    targetApp: string;
+    targetComponentId: string;
+    target: PageBuilderAgenticAuthoringTarget | null;
+    selectedCandidate: PageBuilderAgenticAuthoringCandidate | null;
+    candidates: PageBuilderAgenticAuthoringCandidate[];
+    gate: PageBuilderAgenticAuthoringGateResult;
+    effectivePrompt?: string | null;
+    assistantMessage?: string | null;
+    quickReplies?: PageBuilderAgenticAuthoringQuickReply[];
+    pendingClarification?: PageBuilderAgenticAuthoringPendingClarification | null;
+    clarificationQuestions: string[];
+    warnings: string[];
+    failureCodes: string[];
+    currentPageSummary: unknown;
+    contextHints?: AiContextHintsContract | null;
+    llmDiagnostics?: AiJsonObject | null;
+    semanticDecision?: AgenticAuthoringSemanticDecisionContract | null;
+}
+interface PageBuilderMinimalFormPlanResult {
+    valid: boolean;
+    failureCodes: string[];
+    warnings: string[];
+    minimalFormPlan: unknown;
+}
+interface PageBuilderCompiledFormPatch {
+    profileId?: string;
+    catalogReleaseId?: string;
+    builderVersion?: string;
+    patch?: {
+        page?: BuilderPageDefinition;
+    };
+    [key: string]: unknown;
+}
+interface PageBuilderPreviewDiagnostics {
+    derivedCurrentPageSummary?: boolean;
+    targetWidgetKey?: string;
+    operationKind?: string;
+    changeKind?: string;
+    fieldScopeDecision?: string;
+    projectKnowledgeAudit?: PageBuilderProjectKnowledgeAudit | null;
+}
+interface PageBuilderProjectKnowledgeAudit {
+    schemaVersion?: string;
+    source?: string;
+    influenceCount?: number;
+    citedCount?: number;
+    uncitedCount?: number;
+    citationPolicy?: string;
+    entries?: Array<{
+        knowledgeId?: string;
+        conceptKey?: string;
+        kind?: string;
+        visibility?: string;
+        influence?: string;
+        sourceSummary?: string;
+        cited?: boolean;
+        sourceRefs?: string[];
+    }>;
+}
+interface PageBuilderPreviewResult {
+    valid: boolean;
+    failureCodes: string[];
+    warnings: string[];
+    minimalFormPlan: unknown;
+    uiCompositionPlan?: unknown;
+    compiledFormPatch: PageBuilderCompiledFormPatch;
+    diagnostics?: PageBuilderPreviewDiagnostics | null;
+    assistantMessage?: string | null;
+}
+type PageBuilderAgenticAuthoringTurnStreamStartResponse = AgenticAuthoringTurnStreamStartResponseContract;
+type PageBuilderAgenticAuthoringTurnStreamEvent = AgenticAuthoringTurnStreamEnvelopeContract;
+interface PageBuilderApplyRequest {
+    compiledFormPatch: PageBuilderCompiledFormPatch;
+    componentId: string;
+    componentType?: string;
+    scope?: 'user' | 'tenant';
+    tags?: Record<string, unknown>;
+    ifMatch?: string;
+    semanticDecision?: AgenticAuthoringSemanticDecisionContract | null;
+}
+interface PageBuilderApplyResult {
+    applied: boolean;
+    componentType: string;
+    componentId: string;
+    environment?: string;
+    scope: 'user' | 'tenant' | string;
+    version: number;
+    etag?: string;
+    payload: BuilderPageDefinition;
+    tags?: Record<string, unknown>;
+    warnings: string[];
+}
+declare const PAGE_BUILDER_AGENTIC_AUTHORING_OPTIONS: InjectionToken<PageBuilderAgenticAuthoringOptions>;
+declare class PageBuilderAgenticAuthoringService {
+    private readonly http;
+    private readonly options;
+    private readonly baseUrl;
+    private readonly headersFactory;
+    getComponentCapabilities(): Observable<PageBuilderAgenticAuthoringComponentCapabilitiesResult>;
+    previewPage(request: PageBuilderAgenticAuthoringPromptRequest): Observable<PageBuilderPreviewResult>;
+    resolveIntent(request: PageBuilderAgenticAuthoringIntentResolutionRequest): Observable<PageBuilderAgenticAuthoringIntentResolutionResult>;
+    searchResourceCandidates(request: PageBuilderAgenticAuthoringResourceCandidatesRequest): Observable<PageBuilderAgenticAuthoringResourceCandidatesResult>;
+    streamTurn(request: PageBuilderAgenticAuthoringTurnStreamRequest): Observable<PageBuilderAgenticAuthoringTurnStreamEvent>;
+    applyPage(request: PageBuilderApplyRequest): Observable<PageBuilderApplyResult>;
+    private buildHeaders;
+    private connectTurnStream;
+    private consumeFetchTurnStream;
+    private consumeBufferedSseFrames;
+    private findSseFrameBoundary;
+    private streamStartTimeoutMs;
+    private streamTurnTimeoutMs;
+    private streamResultFallbackMs;
+    private streamSilenceStatusMs;
+    private streamSilenceStatusEvent;
+    private streamLifecycleStatusEvent;
+    private requestTimeoutMs;
+    private streamConnectionError;
+    private buildStreamUrl;
+    private buildStreamProbeUrl;
+    private createEventSource;
+    private probeTurnStreamEndpoint;
+    private formatEtag;
+    private normalizeIntentResolutionResult;
+    private normalizeStringList;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PageBuilderAgenticAuthoringService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PageBuilderAgenticAuthoringService>;
+}
+type UiCompositionPlanInputSource = 'event' | 'payload' | 'state' | 'context' | 'constant';
+type UiCompositionPlanComponentPortEndpoint = {
+    kind: 'component-port';
+    widget: string;
+    port: string;
+    direction: 'input' | 'output';
+    nestedPath?: ComponentPortPathSegment[];
+};
+type UiCompositionPlanStateEndpoint = {
+    kind: 'state';
+    path: string;
+    layer?: 'values' | 'derived' | 'transient';
+};
+type UiCompositionPlanGlobalActionEndpoint = {
+    kind: 'global-action';
+    actionId: string;
+    payload?: unknown;
+    payloadExpr?: string;
+    meta?: Record<string, unknown>;
+};
+type UiCompositionPlanSourceEndpoint = UiCompositionPlanComponentPortEndpoint | UiCompositionPlanStateEndpoint;
+type UiCompositionPlanTargetEndpoint = UiCompositionPlanSourceEndpoint | UiCompositionPlanGlobalActionEndpoint;
+type UiCompositionPlanEndpoint = UiCompositionPlanTargetEndpoint;
+type UiCompositionPlanTransform = {
+    kind: 'pick-path';
+    id: string;
+    path: string;
+    inputSource?: UiCompositionPlanInputSource;
+} | {
+    kind: 'constant';
+    id: string;
+    value: unknown;
+} | {
+    kind: 'query-context';
+    id: string;
+    field: string;
+    operator?: string;
+    valueVar?: string;
+    inputSource?: UiCompositionPlanInputSource;
+} | {
+    kind: 'template';
+    id: string;
+    template: unknown;
+    inputSource?: UiCompositionPlanInputSource;
+};
+interface UiCompositionPlanWidget {
+    key: string;
+    componentId: string;
+    role?: string;
+    inputs?: Record<string, unknown>;
+    outputs?: Record<string, unknown>;
+    bindingOrder?: string[];
+}
+interface UiCompositionPlanBinding {
+    id: string;
+    from: UiCompositionPlanSourceEndpoint;
+    to: UiCompositionPlanTargetEndpoint;
+    intent: CompositionLink['intent'];
+    condition?: unknown;
+    transform?: UiCompositionPlanTransform;
+    policy?: CompositionLink['policy'];
+    metadata?: Record<string, unknown>;
+}
+interface UiCompositionPlan {
+    version: '1.0';
+    kind: 'praxis.ui-composition-plan';
+    layoutPreset?: string;
+    layoutPresetOptions?: Record<string, unknown>;
+    canvas?: WidgetPageCanvasLayout;
+    deviceLayouts?: WidgetPageDeviceLayouts;
+    grouping?: WidgetPageGroupingDefinition[];
+    slotAssignments?: WidgetPageSlotAssignments;
+    state?: WidgetPageStateInput;
+    themePreset?: string;
+    widgets: UiCompositionPlanWidget[];
+    bindings?: UiCompositionPlanBinding[];
+}
+interface UiCompositionPlanDiagnostic {
+    code: string;
+    message: string;
+    path?: string;
+}
+type UiCompositionPlanCompileResult = {
+    valid: true;
+    page: WidgetPageDefinition;
+    diagnostics: UiCompositionPlanDiagnostic[];
+} | {
+    valid: false;
+    page: null;
+    diagnostics: UiCompositionPlanDiagnostic[];
+};
+declare function compileUiCompositionPlan(plan: UiCompositionPlan): UiCompositionPlanCompileResult;
+declare function validateUiCompositionPlan(plan: UiCompositionPlan): UiCompositionPlanDiagnostic[];
+type LegacyLayoutOptions = {
+    cols?: number;
+    rowHeight?: number;
+    gap?: number;
+};
+type PageBuilderLayoutOptions = Partial<LegacyLayoutOptions>;
+type PageBuilderConfig = {
+    page?: BuilderPageDefinition;
+    context?: Record<string, unknown> | null;
+    enableCustomization?: boolean;
+    showSettingsButton?: boolean;
+    strictValidation?: boolean;
+    layoutOptions?: PageBuilderLayoutOptions;
+    pageIdentity?: PageIdentity;
+};
+type BuilderWidgetInstance = WidgetInstance;
+type BuilderCanvasItem = {
+    col: number;
+    row: number;
+    colSpan: number;
+    rowSpan: number;
+};
+type BuilderCanvasLayout = {
+    mode: 'grid';
+    columns: number;
+    rowUnit?: string;
+    gap?: string;
+    autoRows?: 'fixed' | 'content';
+    collisionPolicy?: 'block' | 'swap';
+    items: Record<string, BuilderCanvasItem>;
+};
+type BuilderPageDefinition = Omit<WidgetPageDefinition, 'widgets'> & {
+    widgets: BuilderWidgetInstance[];
+    canvas?: BuilderCanvasLayout;
+    state?: WidgetPageStateInput;
+    composition?: {
+        links: BuilderCompositionLink[];
+    };
+};
+type BuilderCompositionLink = CompositionLink;
+declare function registerWidgetAiCatalog(widgetId: string, catalog: AiCapabilityCatalog): void;
+declare function registerWidgetAiCatalogs(entries: Record<string, AiCapabilityCatalog>): void;
+declare function clearWidgetAiCatalogs(): void;
+/**
+ * Retrieves the CapabilityCatalog for a given widget ID.
+ */
+declare function getWidgetAiCapabilities(widgetId: string): AiCapabilityCatalog | undefined;
+/**
+ * Aggregates macro page builder capabilities with specific micro capabilities
+ * of the widgets present in the page configuration.
+ */
+declare function getPageAiCatalog(pageConfig?: PageBuilderConfig): AiCapabilityCatalog;
+declare const PAGE_BUILDER_WIDGET_AI_CATALOGS: InjectionToken<Record<string, AiCapabilityCatalog>>;
+declare function providePageBuilderWidgetAiCatalogs(): Provider;
+declare const PAGE_BUILDER_COMPONENT_CONTEXT_PACK: ComponentContextPack;
+declare const PRAXIS_PAGE_BUILDER_AUTHORING_MANIFEST: ComponentAuthoringManifest;
+type PageBuilderGovernedContinuationFamily = 'shared-rule' | 'project-knowledge';
+type PageBuilderGovernedContinuationActionKind = 'open_definition' | 'simulate' | 'approve' | 'reject' | 'publish' | 'materialize' | 'validate_enforcement' | 'create_knowledge_change_set' | 'validate_knowledge_change_set' | 'apply_knowledge_change_set' | 'open_timeline';
+type PageBuilderGovernedContinuationBlockedReason = 'busy' | 'missing_handoff' | 'missing_authoring_target' | 'missing_definition' | 'definition_already_available' | 'missing_materialization' | 'missing_project_knowledge_audit' | 'missing_project_knowledge_candidate' | 'change_set_already_available' | 'missing_change_set' | 'validation_required' | 'validation_already_valid' | 'approval_required' | 'already_applied' | 'timeline_unavailable' | 'timeline_contract_unwired';
+interface PageBuilderGovernedContinuationTarget {
+    artifactType: 'domain-rule-definition' | 'domain-knowledge-change-set' | 'materialization' | 'timeline';
+    id?: string | null;
+    key?: string | null;
+    resourceKey?: string | null;
+    contextKey?: string | null;
+}
+interface PageBuilderGovernedContinuationAction {
+    kind: PageBuilderGovernedContinuationActionKind;
+    family: PageBuilderGovernedContinuationFamily;
+    enabled: boolean;
+    blockedReason?: PageBuilderGovernedContinuationBlockedReason;
+    labelKey: string;
+    labelFallback: string;
+    descriptionKey: string;
+    descriptionFallback: string;
+    target?: PageBuilderGovernedContinuationTarget;
+}
+interface AgenticAuthoringQuickReply extends PraxisAssistantShellQuickReply {
+    kind: string;
+}
+type AgenticAuthoringPanelLayout = PraxisAssistantShellLayout;
+type SharedRuleCockpitAction = 'definition' | 'simulation' | 'approve' | 'activate' | 'publication' | 'materializations' | 'timeline' | 'enforcement';
+type ProjectKnowledgeCockpitAction = 'change-set' | 'validate' | 'approve' | 'reject' | 'apply' | 'readback';
+interface SharedRuleEnforcementSummary {
+    status: 'ready' | 'waiting' | 'unavailable';
+    targetLayers: string[];
+    targetArtifacts: string[];
+    projections: SharedRuleEnforcementProjection[];
+    appliedCount: number;
+    pendingCount: number;
+    sourceHashes: string[];
+}
+interface SharedRuleEnforcementProjection {
+    targetLayer: string;
+    targetLayerLabel: string;
+    status: 'ready' | 'waiting';
+    targetArtifact: string;
+    sourceHash: string | null;
+}
+interface PageBuilderAgenticAuthoringSharedRuleHandoff {
+    endpoint: string;
+    flowId: 'shared_rule_authoring';
+    intakeEndpoint?: string | null;
+    intakeId?: string | null;
+    intakeStatus?: string | null;
+    nextEndpoint?: string | null;
+    ruleDefinitionId?: string | null;
+    ruleKey?: string | null;
+    recommendedRuleType?: string | null;
+    targetLayer?: string | null;
+    sourcePrompt: string;
+    assistantMessage: string;
+    resourcePath?: string | null;
+    resourceKey?: string | null;
+    contextKey?: string | null;
+    routeGateStatus?: string | null;
+    routeFailureCode?: string | null;
+    routeDecisionSource?: string | null;
+    previewDisposition?: string | null;
+}
+declare class DynamicPageBuilderComponent implements OnChanges {
+    private dialog;
+    private settingsPanel;
+    private readonly i18n;
+    private readonly injector;
+    private readonly componentMetadata;
+    private readonly agenticAuthoring;
+    private readonly agenticTurnOrchestrator;
+    private readonly assistantSessions;
+    private readonly agenticAuthoringOptions;
+    runtime?: DynamicWidgetPageComponent;
+    page?: WidgetPageDefinition | string;
+    context?: Record<string, unknown> | null;
+    strictValidation: boolean;
+    autoPersist: boolean;
+    enableCustomization: boolean;
+    showSettingsButton: boolean;
+    pageIdentity?: PageIdentity;
+    componentInstanceId?: string;
+    pageEditorComponent: Type<any> | undefined;
+    enableAgenticAuthoring: boolean;
+    agenticAuthoringProvider?: string;
+    agenticAuthoringModel?: string;
+    agenticAuthoringApiKey?: string;
+    agenticAuthoringComponentId?: string;
+    agenticAuthoringScope: 'user' | 'tenant';
+    agenticAuthoringEtag?: string;
+    agenticAuthoringIncludeLlmDiagnostics: boolean;
+    agenticAuthoringEnableStreaming: boolean;
+    agenticAuthoringContextHints?: Record<string, unknown> | null;
+    showPageLifecycleActions: boolean;
+    canDeleteSavedPage: boolean;
+    pageLifecycleBusy: boolean;
+    pageLifecycleResetRevision: number | string | null;
+    pageChange: EventEmitter<WidgetPageDefinition>;
+    pageSaveRequested: EventEmitter<WidgetPageDefinition>;
+    agenticAuthoringApplied: EventEmitter<PageBuilderApplyResult>;
+    agenticAuthoringSharedRuleHandoff: EventEmitter<PageBuilderAgenticAuthoringSharedRuleHandoff>;
+    pageRestart: EventEmitter<void>;
+    savedPageDeleteRequested: EventEmitter<void>;
+    readonly currentPage: _angular_core.WritableSignal<WidgetPageDefinition>;
+    readonly hasPageWidgets: _angular_core.Signal<boolean>;
+    readonly connectionsViewerOpen: _angular_core.WritableSignal<boolean>;
+    readonly agenticAuthoringOpen: _angular_core.WritableSignal<boolean>;
+    readonly agenticAuthoringPrompt: _angular_core.WritableSignal<string>;
+    readonly agenticAuthoringBusy: _angular_core.WritableSignal<boolean>;
+    readonly agenticAuthoringStatus: _angular_core.WritableSignal<string>;
+    readonly agenticAuthoringError: _angular_core.WritableSignal<string>;
+    readonly agenticAuthoringPreviewResult: _angular_core.WritableSignal<PageBuilderPreviewResult | null>;
+    readonly agenticAuthoringSemanticDecision: _angular_core.WritableSignal<AgenticAuthoringSemanticDecisionContract | null>;
+    readonly agenticAuthoringCanApply: _angular_core.WritableSignal<boolean>;
+    readonly agenticAuthoringLastEtag: _angular_core.WritableSignal<string | null>;
+    readonly agenticAuthoringConversation: _angular_core.WritableSignal<PraxisAssistantShellMessage[]>;
+    readonly agenticAuthoringQuickReplies: _angular_core.WritableSignal<AgenticAuthoringQuickReply[]>;
+    readonly agenticAuthoringAttachments: _angular_core.WritableSignal<PraxisAssistantShellAttachment[]>;
+    readonly agenticAuthoringSharedRuleHandoffState: _angular_core.WritableSignal<PageBuilderAgenticAuthoringSharedRuleHandoff | null>;
+    readonly sharedRuleCockpitBusyAction: _angular_core.WritableSignal<SharedRuleCockpitAction | null>;
+    readonly sharedRuleCockpitError: _angular_core.WritableSignal<string>;
+    readonly sharedRuleCockpitDefinition: _angular_core.WritableSignal<DomainRuleDefinition | null>;
+    readonly sharedRuleCockpitSimulation: _angular_core.WritableSignal<DomainRuleSimulationResponse | null>;
+    readonly sharedRuleCockpitTimeline: _angular_core.WritableSignal<DomainRuleTimelineResponse | null>;
+    readonly sharedRuleCockpitPublication: _angular_core.WritableSignal<DomainRulePublicationResponse | null>;
+    readonly sharedRuleCockpitMaterializations: _angular_core.WritableSignal<DomainRuleMaterialization[]>;
+    readonly sharedRuleCockpitEnforcement: _angular_core.WritableSignal<SharedRuleEnforcementSummary | null>;
+    readonly projectKnowledgeCockpitBusyAction: _angular_core.WritableSignal<ProjectKnowledgeCockpitAction | null>;
+    readonly projectKnowledgeCockpitError: _angular_core.WritableSignal<string>;
+    readonly projectKnowledgeCockpitChangeSet: _angular_core.WritableSignal<DomainKnowledgeChangeSet | null>;
+    readonly projectKnowledgeCockpitValidation: _angular_core.WritableSignal<DomainKnowledgeValidationResponse | null>;
+    readonly projectKnowledgeCockpitTimeline: _angular_core.WritableSignal<DomainKnowledgeChangeSetTimelineResponse | null>;
+    readonly agenticAuthoringLlmDiagnostics: _angular_core.WritableSignal<Record<string, unknown> | null>;
+    readonly agenticAuthoringLlmDiagnosticsCollapsed: _angular_core.WritableSignal<boolean>;
+    readonly sharedRuleCockpitCollapsed: _angular_core.WritableSignal<boolean>;
+    readonly projectKnowledgeCockpitCollapsed: _angular_core.WritableSignal<boolean>;
+    readonly agenticAuthoringEditingMessageId: _angular_core.WritableSignal<string | null>;
+    readonly selectedWidgetKey: _angular_core.WritableSignal<string | null>;
+    readonly agenticAuthoringWidgetContextKey: _angular_core.WritableSignal<string | null>;
+    readonly agenticAuthoringPanelLayout: _angular_core.WritableSignal<PraxisAssistantShellLayout>;
+    private previewMode;
+    private agenticComponentCapabilities?;
+    private agenticComponentCapabilitiesPromise?;
+    private agenticTurnController?;
+    private sharedRuleHandoffRevision;
+    private agenticAuthoringPanelLayoutTouched;
+    constructor(dialog: MatDialog, settingsPanel: SettingsPanelBridge | null);
+    ngOnChanges(changes: SimpleChanges): void;
+    showSettings(): boolean;
+    onRuntimePageChange(next: WidgetPageDefinition): void;
+    onRuntimeWidgetEvent(event: WidgetEventEnvelope): void;
+    onConnectionEditorPageChange(next: WidgetPageDefinition): void;
+    onRuntimeWidgetSelectionChange(widgetKey: string | null): void;
+    togglePreview(): void;
+    toggleAgenticAuthoringLlmDiagnostics(): void;
+    toggleSharedRuleCockpit(): void;
+    toggleProjectKnowledgeCockpit(): void;
+    toggleConnectionsViewer(): void;
+    onAddComponent(): void;
+    addWidget(selection: string | ComponentPaletteSelection): void;
+    openPageSettings(): void;
+    saveCurrentPage(): void;
+    applyConfigFromAdapter(config: PageBuilderConfig): void;
+    private createAdapterHost;
+    toggleAgenticAuthoring(): void;
+    openAgenticAuthoring(): void;
+    openAgenticAuthoringForWidget(widgetKey: string): void;
+    openAgenticAuthoringFromSession(session: PraxisAssistantSessionSnapshot): void;
+    minimizeAgenticAuthoring(): void;
+    onAgenticAuthoringLayoutChange(layout: AgenticAuthoringPanelLayout): void;
+    agenticAuthoringReviewRailActive(): boolean;
+    showAgenticAuthoringDock(): boolean;
+    agenticAuthoringMinimized(): boolean;
+    agenticAuthoringToggleLabel(): string;
+    agenticAuthoringHeaderTitle(): string;
+    agenticAuthoringHeaderSubtitle(): string;
+    agenticAuthoringHeaderModeLabel(): string;
+    agenticAuthoringShellLabels(): Partial<PraxisAssistantShellLabels>;
+    private agenticAuthoringEmptyConversationMessage;
+    private resolveAgenticAuthoredOpeningMessage;
+    private isAgenticAuthoringPageBlank;
+    agenticAuthoringSubmitAction(): PraxisAssistantShellAction;
+    agenticAuthoringDockIcon(): string;
+    agenticAuthoringDockBadge(): string;
+    agenticAuthoringDockSummary(): string;
+    agenticAuthoringShellState(): PraxisAssistantShellState;
+    private hasAgenticAuthoringSession;
+    private resetAgenticAuthoringSessionState;
+    private syncAgenticAuthoringSession;
+    private resolveAgenticAuthoringSessionId;
+    private truncateAgenticDockText;
+    agenticAuthoringProjectKnowledgeAudit(): PageBuilderProjectKnowledgeAudit | null;
+    canRunProjectKnowledgeChangeSet(): boolean;
+    sharedRuleGovernedContinuationActions(): PageBuilderGovernedContinuationAction[];
+    projectKnowledgeGovernedContinuationActions(): PageBuilderGovernedContinuationAction[];
+    trackGovernedContinuationAction(_index: number, action: PageBuilderGovernedContinuationAction): string;
+    trackSharedRuleEnforcementProjection(index: number, projection: SharedRuleEnforcementProjection): string;
+    governedContinuationActionTestId(action: PageBuilderGovernedContinuationAction): string;
+    governedContinuationActionTooltip(action: PageBuilderGovernedContinuationAction): string;
+    projectKnowledgeTimelineItems(): RichTimelineItem[];
+    trackProjectKnowledgeTimelineItem(index: number, item: RichTimelineItem): string;
+    runSharedRuleGovernedContinuationAction(action: PageBuilderGovernedContinuationAction): Promise<void>;
+    runProjectKnowledgeGovernedContinuationAction(action: PageBuilderGovernedContinuationAction): Promise<void>;
+    agenticAuthoringContextItems(): PraxisAssistantShellContextItem[];
+    private agenticAuthoringSemanticDecisionContextItems;
+    private shouldHideSemanticDecisionContextItems;
+    private humanizeAgenticResourcePath;
+    private humanizeAgenticDecisionSummary;
+    private humanizeAgenticOperationKind;
+    private humanizeAgenticArtifactKind;
+    private humanizeAgenticChangeKind;
+    private humanizeAgenticDecisionEvidence;
+    private humanizeAgenticToken;
+    previewAgenticAuthoring(): Promise<void>;
+    submitAgenticQuickReply(reply: PraxisAssistantShellQuickReply): Promise<void>;
+    private agenticQuickReplyVisiblePrompt;
+    private agenticQuickReplySubmittedPrompt;
+    private agenticQuickReplyClarificationConfirmationPrompt;
+    private isHumanSafeResourceQuickReplyPrompt;
+    private isGenericDataSourceQuickReplyPrompt;
+    private isGenericGovernedConfirmationQuickReplyPrompt;
+    private agenticQuickReplyGovernedConfirmationPrompt;
+    private isResourceQuickReply;
+    private isContextualPreviewActionQuickReply;
+    private isGovernedConfirmationQuickReply;
+    private isConfirmationQuickReply;
+    private hasResourceContextHint;
+    private describeResourceContext;
+    attachAgenticContext(): void;
+    addAgenticAttachments(attachments: readonly PraxisAssistantShellAttachment[]): void;
+    removeAgenticAttachment(attachment: PraxisAssistantShellAttachment): void;
+    editAgenticMessage(message: PraxisAssistantShellMessage): void;
+    resendAgenticMessage(message: PraxisAssistantShellMessage): Promise<void>;
+    retryAgenticAuthoring(): Promise<void>;
+    cancelAgenticAuthoring(): Promise<void>;
+    persistAgenticAuthoring(): Promise<void>;
+    ensureSharedRuleDefinition(): Promise<DomainRuleDefinition | null>;
+    simulateSharedRule(): Promise<DomainRuleSimulationResponse | null>;
+    transitionSharedRuleDefinition(status: 'approved' | 'active'): Promise<DomainRuleDefinition | null>;
+    publishSharedRule(): Promise<DomainRulePublicationResponse | null>;
+    openSharedRuleEnforcementValidation(): Promise<SharedRuleEnforcementSummary | null>;
+    runProjectKnowledgeChangeSetLifecycle(): Promise<DomainKnowledgeChangeSet | null>;
+    createProjectKnowledgeCockpitChangeSet(): Promise<DomainKnowledgeChangeSet | null>;
+    validateProjectKnowledgeCockpitChangeSet(): Promise<DomainKnowledgeValidationResponse | null>;
+    approveProjectKnowledgeCockpitChangeSet(): Promise<DomainKnowledgeChangeSet | null>;
+    rejectProjectKnowledgeCockpitChangeSet(): Promise<DomainKnowledgeChangeSet | null>;
+    applyProjectKnowledgeCockpitChangeSet(): Promise<DomainKnowledgeChangeSet | null>;
+    private refreshSharedRuleTimeline;
+    private resolveDomainRuleService;
+    private resolveDomainKnowledgeService;
+    private createProjectKnowledgeChangeSet;
+    private getProjectKnowledgeChangeSet;
+    private validateProjectKnowledgeChangeSet;
+    private getProjectKnowledgeChangeSetTimeline;
+    private transitionProjectKnowledgeChangeSetStatus;
+    private applyProjectKnowledgeChangeSet;
+    private refreshProjectKnowledgeTimeline;
+    private createSharedRuleDefinition;
+    private simulateSharedRuleDefinition;
+    private transitionSharedRuleDefinitionStatus;
+    private publishSharedRuleDefinition;
+    private listSharedRuleMaterializations;
+    private getSharedRuleDefinitionTimeline;
+    private resolveSharedRuleDefinitionId;
+    private runSharedRuleCockpitAction;
+    private clearSharedRuleCockpitState;
+    private runProjectKnowledgeCockpitAction;
+    private clearProjectKnowledgeCockpitState;
+    private resolveProjectKnowledgeEvidenceCandidate;
+    private createProjectKnowledgeChangeSetRequest;
+    private slugifyProjectKnowledgeKey;
+    private governedContinuationActionDomKey;
+    private updateSharedRuleHandoff;
+    private promoteSharedRuleHandoffFromQuickReply;
+    private resolveSharedRuleQuickReplyRuleType;
+    private resolveSharedRuleQuickReplyTargetLayer;
+    private resolveSharedRuleKey;
+    private resolveSharedRuleResourceKey;
+    private resolveSharedRuleContextKey;
+    private deriveResourceKeyFromPath;
+    private deriveContextKeyFromPath;
+    private resolveSharedRuleType;
+    private normalizeSharedRuleType;
+    private inferSharedRuleTypeFromHumanIntent;
+    private summarizeSharedRuleEnforcement;
+    private isAppliedSharedRuleProjection;
+    private formatSharedRuleTargetLayer;
+    private loadAgenticComponentCapabilities;
+    private ensureAgenticTurnController;
+    private applyAgenticPreviewLocally;
+    private applyAgenticTurnState;
+    private primeSharedRuleHandoff;
+    private moveAgenticAuthoringPanelToReviewSidecar;
+    private resolveAgenticSharedRuleHandoff;
+    private resolveAgenticSharedRuleAssistantMessage;
+    private resolveSharedRuleHandoffRuleType;
+    private sameSharedRuleHandoff;
+    private sameSharedRuleHandoffIdentity;
+    private enrichSharedRuleHandoffFromIntake;
+    private resolveSharedRuleHeaders;
+    private consumeAgenticTurn;
+    private isAgenticTurnTerminalState;
+    agenticAuthoringDiagnosticsTop(): number;
+    agenticAuthoringLlmDiagnosticsText(): string;
+    private resolveAgenticLlmDiagnostics;
+    private resolveAgenticSemanticDecision;
+    private cloneAgenticContextHints;
+    private resolveGovernedDomainContextSummary;
+    private shouldShowGovernedDomainContext;
+    private trimmedString;
+    private toRecord;
+    private resolvePreviewCompiledFormPatch;
+    focusCanvasWidget(widgetKey: string): void;
+    private parsePage;
+    private clonePage;
+    private clearSelectedWidgetIfMissing;
+    private defaultInputsFor;
+    private applyWidgetIdentityDefaults;
+    private resolveAgenticComponentId;
+    private resolveSelectedWidgetKey;
+    private resolveWidgetByKey;
+    private resolveSelectedWidgetLabel;
+    private describeSelectedWidgetContext;
+    private resolveWidgetDisplayName;
+    private formatAgenticFailures;
+    private describeAgenticPreviewFailure;
+    private describeAgenticPreviewStatus;
+    private isAgenticTableContractError;
+    private appendAgenticMessage;
+    private describeAgenticError;
+    private cloneValue;
+    tx(key: string, fallback: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DynamicPageBuilderComponent, [null, { optional: true; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DynamicPageBuilderComponent, "praxis-dynamic-page-builder", never, { "page": { "alias": "page"; "required": false; }; "context": { "alias": "context"; "required": false; }; "strictValidation": { "alias": "strictValidation"; "required": false; }; "autoPersist": { "alias": "autoPersist"; "required": false; }; "enableCustomization": { "alias": "enableCustomization"; "required": false; }; "showSettingsButton": { "alias": "showSettingsButton"; "required": false; }; "pageIdentity": { "alias": "pageIdentity"; "required": false; }; "componentInstanceId": { "alias": "componentInstanceId"; "required": false; }; "pageEditorComponent": { "alias": "pageEditorComponent"; "required": false; }; "enableAgenticAuthoring": { "alias": "enableAgenticAuthoring"; "required": false; }; "agenticAuthoringProvider": { "alias": "agenticAuthoringProvider"; "required": false; }; "agenticAuthoringModel": { "alias": "agenticAuthoringModel"; "required": false; }; "agenticAuthoringApiKey": { "alias": "agenticAuthoringApiKey"; "required": false; }; "agenticAuthoringComponentId": { "alias": "agenticAuthoringComponentId"; "required": false; }; "agenticAuthoringScope": { "alias": "agenticAuthoringScope"; "required": false; }; "agenticAuthoringEtag": { "alias": "agenticAuthoringEtag"; "required": false; }; "agenticAuthoringIncludeLlmDiagnostics": { "alias": "agenticAuthoringIncludeLlmDiagnostics"; "required": false; }; "agenticAuthoringEnableStreaming": { "alias": "agenticAuthoringEnableStreaming"; "required": false; }; "agenticAuthoringContextHints": { "alias": "agenticAuthoringContextHints"; "required": false; }; "showPageLifecycleActions": { "alias": "showPageLifecycleActions"; "required": false; }; "canDeleteSavedPage": { "alias": "canDeleteSavedPage"; "required": false; }; "pageLifecycleBusy": { "alias": "pageLifecycleBusy"; "required": false; }; "pageLifecycleResetRevision": { "alias": "pageLifecycleResetRevision"; "required": false; }; }, { "pageChange": "pageChange"; "pageSaveRequested": "pageSaveRequested"; "agenticAuthoringApplied": "agenticAuthoringApplied"; "agenticAuthoringSharedRuleHandoff": "agenticAuthoringSharedRuleHandoff"; "pageRestart": "pageRestart"; "savedPageDeleteRequested": "savedPageDeleteRequested"; }, never, never, true, never>;
+}
+export { ComponentPaletteDialogComponent, ConfirmDialogComponent, ConnectionEditorComponent, DynamicPageBuilderComponent, DynamicPageConfigEditorComponent, FloatingToolbarComponent, PAGE_BUILDER_AGENTIC_AUTHORING_OPTIONS, PAGE_BUILDER_AI_CAPABILITIES, PAGE_BUILDER_COMPONENT_CONTEXT_PACK, PAGE_BUILDER_WIDGET_AI_CATALOGS, PLACEHOLDER, PRAXIS_PAGE_BUILDER_AUTHORING_MANIFEST, PageBuilderAgenticAuthoringService, PageConfigEditorComponent, TileToolbarComponent, WidgetShellEditorComponent, clearWidgetAiCatalogs, compileUiCompositionPlan, getPageAiCatalog, getWidgetAiCapabilities, providePageBuilderWidgetAiCatalogs, registerWidgetAiCatalog, registerWidgetAiCatalogs, validateUiCompositionPlan };
+export type { Capability, CapabilityCatalog, CapabilityCategory, ComponentPaletteData, ComponentPaletteSelection, ConfirmDialogData, PageBuilderAgenticAuthoringAttachmentSummary, PageBuilderAgenticAuthoringCandidate, PageBuilderAgenticAuthoringComponentCapabilitiesResult, PageBuilderAgenticAuthoringComponentCapability, PageBuilderAgenticAuthoringComponentCapabilityCatalog, PageBuilderAgenticAuthoringComponentCapabilityExample, PageBuilderAgenticAuthoringComponentFieldAlias, PageBuilderAgenticAuthoringConversationMessage, PageBuilderAgenticAuthoringEventSource, PageBuilderAgenticAuthoringEventSourceFactory, PageBuilderAgenticAuthoringEventSourceOptions, PageBuilderAgenticAuthoringGateResult, PageBuilderAgenticAuthoringIntentResolutionRequest, PageBuilderAgenticAuthoringIntentResolutionResult, PageBuilderAgenticAuthoringOptions, PageBuilderAgenticAuthoringPendingClarification, PageBuilderAgenticAuthoringPromptRequest, PageBuilderAgenticAuthoringProvider, PageBuilderAgenticAuthoringQuickReply, PageBuilderAgenticAuthoringResourceCandidatesRequest, PageBuilderAgenticAuthoringResourceCandidatesResult, PageBuilderAgenticAuthoringSharedRuleHandoff, PageBuilderAgenticAuthoringTarget, PageBuilderAgenticAuthoringTurnStreamConnectionError, PageBuilderAgenticAuthoringTurnStreamEvent, PageBuilderAgenticAuthoringTurnStreamRequest, PageBuilderAgenticAuthoringTurnStreamStartResponse, PageBuilderApplyRequest, PageBuilderApplyResult, PageBuilderCompiledFormPatch, PageBuilderMinimalFormPlanResult, PageBuilderPreviewDiagnostics, PageBuilderPreviewResult, PageBuilderProjectKnowledgeAudit, UiCompositionPlan, UiCompositionPlanBinding, UiCompositionPlanCompileResult, UiCompositionPlanComponentPortEndpoint, UiCompositionPlanDiagnostic, UiCompositionPlanEndpoint, UiCompositionPlanGlobalActionEndpoint, UiCompositionPlanInputSource, UiCompositionPlanSourceEndpoint, UiCompositionPlanStateEndpoint, UiCompositionPlanTargetEndpoint, UiCompositionPlanTransform, UiCompositionPlanWidget, ValueKind };