@praxisui/page-builder 8.0.0-beta.3 → 8.0.0-beta.31

package/index.d.ts

@@ -1,13 +1,13 @@
 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, SettingsValueProvider as SettingsValueProvider$1, WidgetPageDefinition, WidgetPageGroupingDefinition, BUILTIN_PAGE_LAYOUT_PRESETS, BUILTIN_PAGE_THEME_PRESETS, PageIdentity, WidgetStateNode, WidgetDerivedStateNode, AiCapabilityCategory, AiValueKind, AiCapability, AiCapabilityCatalog, WidgetInstance, WidgetPageStateInput, CompositionLink, DynamicWidgetPageComponent, SettingsPanelBridge } from '@praxisui/core';
+import { ComponentDocMeta, ComponentMetadataRegistry, WidgetShellConfig, WidgetShellAction, EndpointRef, ComponentPortPathSegment, LinkIntent, CompositionLink, WidgetPageDefinition, TransformKind, SettingsValueProvider as SettingsValueProvider$1, WidgetPageGroupingDefinition, BUILTIN_PAGE_LAYOUT_PRESETS, BUILTIN_PAGE_THEME_PRESETS, PageIdentity, WidgetStateNode, WidgetDerivedStateNode, AiCapabilityCategory, AiValueKind, AiCapability, AiCapabilityCatalog, DomainKnowledgeChangeSetRequest, DomainKnowledgeChangeSet, DomainKnowledgeChangeSetTimelineResponse, DomainKnowledgeChangeSetFilters, DomainKnowledgeValidationResponse, DomainKnowledgeStatusTransitionRequest, DomainRuleIntakeRequest, DomainRuleIntakeResponse, DomainRuleDefinitionRequest, DomainRuleDefinition, DomainRuleSimulationRequest, DomainRuleSimulationResponse, DomainRuleStatusTransitionRequest, DomainRulePublicationRequest, DomainRulePublicationResponse, DomainRuleMaterializationFilters, DomainRuleMaterialization, DomainRuleTimelineResponse, WidgetPageCanvasLayout, WidgetPageStateInput, WidgetInstance, 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 { AgenticAuthoringPlanRequestContract, AgenticAuthoringQuickReplyContract, AgenticAuthoringPendingClarificationContract, AgenticAuthoringAttachmentSummaryContract, AgenticAuthoringIntentResolutionRequestContract, AgenticAuthoringConversationMessageContract, PraxisAssistantShellMessage, PraxisAssistantShellQuickReply, PraxisAssistantShellAttachment, PraxisAssistantShellLayout, PraxisAssistantShellLabels, PraxisAssistantShellState, PraxisAssistantShellContextItem } from '@praxisui/ai';
+import { AgenticAuthoringPlanRequestContract, AgenticAuthoringCandidateContract, AiJsonValue, AgenticAuthoringQuickReplyContract, AgenticAuthoringPendingClarificationContract, AiContextHintsContract, AiJsonObject, AgenticAuthoringSemanticDecisionContract, AgenticAuthoringComponentCapabilitiesResultContract, AgenticAuthoringComponentCapabilityCatalogContract, AgenticAuthoringComponentCapabilityContract, AgenticAuthoringComponentFieldAliasContract, AgenticAuthoringComponentCapabilityExampleContract, AgenticAuthoringAttachmentSummaryContract, AgenticAuthoringIntentResolutionRequestContract, AgenticAuthoringConversationMessageContract, AgenticAuthoringResourceCandidatesRequestContract, AgenticAuthoringResourceCandidatesResultContract, AgenticAuthoringTurnStreamStartResponseContract, AgenticAuthoringTurnStreamEnvelopeContract, PraxisAssistantShellMessage, PraxisAssistantShellQuickReply, PraxisAssistantShellAttachment, PraxisAssistantShellLayout, PraxisAssistantSessionSnapshot, PraxisAssistantShellLabels, PraxisAssistantShellAction, PraxisAssistantShellState, PraxisAssistantShellContextItem } from '@praxisui/ai';
 
 declare const PLACEHOLDER = 1;
 
@@ -40,6 +40,8 @@ declare class FloatingToolbarComponent {
     visible: boolean;
     canUndo: boolean;
     canRedo: boolean;
+    showSave: boolean;
+    showPreview: boolean;
     add: EventEmitter<void>;
     undo: EventEmitter<void>;
     redo: EventEmitter<void>;
@@ -47,30 +49,56 @@ declare class FloatingToolbarComponent {
     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; }; }, { "add": "add"; "undo": "undo"; "redo": "redo"; "settings": "settings"; "preview": "preview"; "save": "save"; }, never, ["[pdx-toolbar-extra]"], true, 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: string;
+    query: _angular_core.WritableSignal<string>;
     private all;
-    filtered: _angular_core.Signal<ComponentDocMeta[]>;
+    filtered: _angular_core.Signal<ComponentPaletteEntry[]>;
     density: _angular_core.Signal<"roomy" | "dense" | "normal">;
-    constructor(dialogRef: MatDialogRef<ComponentPaletteDialogComponent, string>, registry: ComponentMetadataRegistry, data?: ComponentPaletteData | undefined);
+    constructor(dialogRef: MatDialogRef<ComponentPaletteDialogComponent, ComponentPaletteSelection>, registry: ComponentMetadataRegistry, data?: ComponentPaletteData | undefined);
     ngOnInit(): void;
-    select(id: string): void;
-    trackById: (_: number, m: ComponentDocMeta) => string;
-    getPreview(m: ComponentDocMeta): string;
+    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>;
 }
@@ -207,6 +235,539 @@ declare class WidgetShellEditorComponent implements SettingsValueProvider {
     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;
+    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 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 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;
+    tx(key: string, fallback: string): string;
+    private addLink;
+    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"; }, never, never, true, never>;
+}
+
 type EditorTabId$1 = 'canvas' | 'grouping' | 'devices' | 'context' | 'state';
 type DeviceKey = 'desktop' | 'tablet' | 'mobile';
 type GroupingNodeGroup$1 = FormGroup<{
@@ -545,6 +1106,68 @@ 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;
+    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;
@@ -560,11 +1183,29 @@ interface PageBuilderAgenticAuthoringIntentResolutionRequest extends Omit<Agenti
     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 {
+interface PageBuilderAgenticAuthoringCandidate extends AgenticAuthoringCandidateContract {
     resourcePath: string;
     operation: string;
     schemaUrl: string;
@@ -573,6 +1214,19 @@ interface PageBuilderAgenticAuthoringCandidate {
     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;
@@ -587,22 +1241,28 @@ interface PageBuilderAgenticAuthoringGateResult {
     status: string;
     messages: string[];
 }
-interface PageBuilderAgenticAuthoringComponentFieldAlias {
+interface PageBuilderAgenticAuthoringComponentFieldAlias extends AgenticAuthoringComponentFieldAliasContract {
     field: string;
     aliases: string[];
 }
-interface PageBuilderAgenticAuthoringComponentCapability {
+interface PageBuilderAgenticAuthoringComponentCapability extends Omit<AgenticAuthoringComponentCapabilityContract, 'fieldAliases' | 'examples'> {
     id: string;
     changeKind: string;
     triggerTerms: string[];
     fieldAliases: PageBuilderAgenticAuthoringComponentFieldAlias[];
+    examples?: PageBuilderAgenticAuthoringComponentCapabilityExample[];
 }
-interface PageBuilderAgenticAuthoringComponentCapabilityCatalog {
+interface PageBuilderAgenticAuthoringComponentCapabilityExample extends AgenticAuthoringComponentCapabilityExampleContract {
+    prompt: string;
+    intent: string;
+    configHints: string[];
+}
+interface PageBuilderAgenticAuthoringComponentCapabilityCatalog extends Omit<AgenticAuthoringComponentCapabilityCatalogContract, 'capabilities'> {
     componentId: string;
     version: string;
     capabilities: PageBuilderAgenticAuthoringComponentCapability[];
 }
-interface PageBuilderAgenticAuthoringComponentCapabilitiesResult {
+interface PageBuilderAgenticAuthoringComponentCapabilitiesResult extends Omit<AgenticAuthoringComponentCapabilitiesResultContract, 'catalogs'> {
     version: string;
     catalogs: PageBuilderAgenticAuthoringComponentCapabilityCatalog[];
 }
@@ -626,6 +1286,9 @@ interface PageBuilderAgenticAuthoringIntentResolutionResult {
     warnings: string[];
     failureCodes: string[];
     currentPageSummary: unknown;
+    contextHints?: AiContextHintsContract | null;
+    llmDiagnostics?: AiJsonObject | null;
+    semanticDecision?: AgenticAuthoringSemanticDecisionContract | null;
 }
 interface PageBuilderMinimalFormPlanResult {
     valid: boolean;
@@ -648,6 +1311,25 @@ interface PageBuilderPreviewDiagnostics {
     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;
@@ -657,7 +1339,10 @@ interface PageBuilderPreviewResult {
     uiCompositionPlan?: unknown;
     compiledFormPatch: PageBuilderCompiledFormPatch;
     diagnostics?: PageBuilderPreviewDiagnostics | null;
+    assistantMessage?: string | null;
 }
+type PageBuilderAgenticAuthoringTurnStreamStartResponse = AgenticAuthoringTurnStreamStartResponseContract;
+type PageBuilderAgenticAuthoringTurnStreamEvent = AgenticAuthoringTurnStreamEnvelopeContract;
 interface PageBuilderApplyRequest {
     compiledFormPatch: PageBuilderCompiledFormPatch;
     componentId: string;
@@ -665,6 +1350,7 @@ interface PageBuilderApplyRequest {
     scope?: 'user' | 'tenant';
     tags?: Record<string, unknown>;
     ifMatch?: string;
+    semanticDecision?: AgenticAuthoringSemanticDecisionContract | null;
 }
 interface PageBuilderApplyResult {
     applied: boolean;
@@ -687,13 +1373,118 @@ declare class PageBuilderAgenticAuthoringService {
     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 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;
+    canvas?: WidgetPageCanvasLayout;
+    state?: WidgetPageStateInput;
+    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;
@@ -752,16 +1543,83 @@ declare const PAGE_BUILDER_WIDGET_AI_CATALOGS: InjectionToken<Record<string, AiC
 
 declare function providePageBuilderWidgetAiCatalogs(): Provider;
 
+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: 'confirm' | 'revise' | 'cancel' | 'suggestion';
+    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;
@@ -779,9 +1637,21 @@ declare class DynamicPageBuilderComponent implements OnChanges {
     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>;
@@ -789,61 +1659,229 @@ declare class DynamicPageBuilderComponent implements OnChanges {
     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(type: string): 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; }; }, { "pageChange": "pageChange"; "agenticAuthoringApplied": "agenticAuthoringApplied"; }, never, never, true, never>;
+    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, DynamicPageBuilderComponent, DynamicPageConfigEditorComponent, FloatingToolbarComponent, PAGE_BUILDER_AGENTIC_AUTHORING_OPTIONS, PAGE_BUILDER_AI_CAPABILITIES, PAGE_BUILDER_WIDGET_AI_CATALOGS, PLACEHOLDER, PageBuilderAgenticAuthoringService, PageConfigEditorComponent, TileToolbarComponent, WidgetShellEditorComponent, clearWidgetAiCatalogs, getPageAiCatalog, getWidgetAiCapabilities, providePageBuilderWidgetAiCatalogs, registerWidgetAiCatalog, registerWidgetAiCatalogs };
-export type { Capability, CapabilityCatalog, CapabilityCategory, ComponentPaletteData, ConfirmDialogData, PageBuilderAgenticAuthoringAttachmentSummary, PageBuilderAgenticAuthoringCandidate, PageBuilderAgenticAuthoringComponentCapabilitiesResult, PageBuilderAgenticAuthoringComponentCapability, PageBuilderAgenticAuthoringComponentCapabilityCatalog, PageBuilderAgenticAuthoringComponentFieldAlias, PageBuilderAgenticAuthoringConversationMessage, PageBuilderAgenticAuthoringGateResult, PageBuilderAgenticAuthoringIntentResolutionRequest, PageBuilderAgenticAuthoringIntentResolutionResult, PageBuilderAgenticAuthoringOptions, PageBuilderAgenticAuthoringPendingClarification, PageBuilderAgenticAuthoringPromptRequest, PageBuilderAgenticAuthoringProvider, PageBuilderAgenticAuthoringQuickReply, PageBuilderAgenticAuthoringTarget, PageBuilderApplyRequest, PageBuilderApplyResult, PageBuilderCompiledFormPatch, PageBuilderMinimalFormPlanResult, PageBuilderPreviewDiagnostics, PageBuilderPreviewResult, ValueKind };
+export { ComponentPaletteDialogComponent, ConfirmDialogComponent, ConnectionEditorComponent, DynamicPageBuilderComponent, DynamicPageConfigEditorComponent, FloatingToolbarComponent, PAGE_BUILDER_AGENTIC_AUTHORING_OPTIONS, PAGE_BUILDER_AI_CAPABILITIES, 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 };