import { MatDialogRef, MatDialog } from '@angular/material/dialog';
import * as _angular_core from '@angular/core';
import { EventEmitter, OnInit, WritableSignal, InjectionToken, Provider, OnChanges, OnDestroy, Type, SimpleChanges } from '@angular/core';
import { ComponentDocMeta, ComponentMetadataRegistry, PraxisI18nService, 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, PraxisRuntimeComponentObservationEnvelope, WidgetPageCanvasLayout, WidgetPageDeviceLayouts, WidgetPageSlotAssignments, WidgetPageStateInput, WidgetInstance, ComponentContextPack, ComponentAuthoringManifest, DynamicWidgetPageComponent, WidgetEventEnvelope, ObservabilityAgenticTurnMetrics, SettingsPanelBridge, ObservabilityAgenticTurnMetricBucket, RichTimelineItem } 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, AiJsonObject, AgenticAuthoringQuickReplyContract, AgenticAuthoringPendingClarificationContract, AiContextHintsContract, AgenticAuthoringSemanticDecisionContract, AgenticAuthoringPlanRequestContract, AgenticAuthoringResourceCandidatesRequestContract, AgenticAuthoringResourceCandidatesResultContract, AgenticAuthoringTurnStreamContextHintsContract, AgenticAuthoringTurnStreamEnvelopeContract, AgenticAuthoringTurnStreamStartResponseContract, PraxisAssistantVoiceInputMode, PraxisAssistantShellMessage, PraxisAssistantShellQuickReply, PraxisAssistantShellAttachment, PraxisAssistantShellLayout, PraxisAssistantSessionSnapshot, PraxisAssistantShellLabels, PraxisAssistantRecommendedIntent, 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;
    editingEnabled: boolean;
    previewActive: boolean;
    connectionMode: boolean;
    modeLabel: string;
    addLabel: string;
    saveLabel: string;
    undoLabel: string;
    redoLabel: string;
    settingsLabel: string;
    previewLabel: string;
    exitPreviewLabel: string;
    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; }; "editingEnabled": { "alias": "editingEnabled"; "required": false; }; "previewActive": { "alias": "previewActive"; "required": false; }; "connectionMode": { "alias": "connectionMode"; "required": false; }; "modeLabel": { "alias": "modeLabel"; "required": false; }; "addLabel": { "alias": "addLabel"; "required": false; }; "saveLabel": { "alias": "saveLabel"; "required": false; }; "undoLabel": { "alias": "undoLabel"; "required": false; }; "redoLabel": { "alias": "redoLabel"; "required": false; }; "settingsLabel": { "alias": "settingsLabel"; "required": false; }; "previewLabel": { "alias": "previewLabel"; "required": false; }; "exitPreviewLabel": { "alias": "exitPreviewLabel"; "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[];
    allowedPresetIds?: 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;
    private i18n;
    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, i18n: PraxisI18nService, data?: ComponentPaletteData | undefined);
    ngOnInit(): void;
    select(entry: ComponentPaletteEntry): void;
    trackById: (_: number, entry: ComponentPaletteEntry) => string;
    getPreview(entry: ComponentPaletteEntry): string;
    tx(key: string, fallback: string): 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;
    private initialTitle;
    private initialSubtitle;
    private readonly actionCopySources;
    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 editableText;
    private preserveTextDescriptor;
    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' | 'feedback-cycle-unguarded' | 'feedback-cycle-guarded';
interface ConnectionEditorDiagnostic {
    code: ConnectionEditorDiagnosticCode;
    severity: ConnectionEditorDiagnosticSeverity;
    endpoint: 'from' | 'to' | 'link';
    relatedLinkIds?: string[];
}
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';
type ConnectionEditorVisualDensity = 'guided' | 'full';
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 lastCreatedLinkId: _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 hoveredNodeId: _angular_core.WritableSignal<string | null>;
    readonly visualDensity: _angular_core.WritableSignal<ConnectionEditorVisualDensity>;
    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 connectedNodeIds: _angular_core.Signal<Set<string>>;
    readonly connectedPortIds: _angular_core.Signal<Set<string>>;
    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 recommendedMasterDetailSuggestion: _angular_core.Signal<ConnectionEditorSuggestion | null>;
    readonly masterDetailReadinessDiagnostic: _angular_core.Signal<string | null>;
    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;
    toggleVisualDensity(event: Event): void;
    visualDensityAriaLabel(): string;
    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;
    isNestedPort(port: ConnectionEditorPort): boolean;
    nestedPortPathText(port: ConnectionEditorPort): string;
    portDescription(port: ConnectionEditorPort): 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;
    connectionHasNestedEndpoint(connection: ConnectionEditorConnection): boolean;
    connectionNestedSummary(connection: ConnectionEditorConnection): string;
    private formatNestedPath;
    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;
    isGuidedQuietNode(node: ConnectionEditorNode): boolean;
    areNodePortsVisible(node: ConnectionEditorNode): boolean;
    isGuidedPortVisible(port: ConnectionEditorPort): boolean;
    isGuidedSegmentLabelVisible(port: ConnectionEditorPort): boolean;
    clearHoveredNode(nodeId: string): void;
    private updateAutoExpandedNode;
    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;
    connectionSemanticLabel(connection: ConnectionEditorConnection): string;
    connectionHumanSummary(connection: ConnectionEditorConnection): string;
    connectionDeliveryPreview(connection: ConnectionEditorConnection): string;
    suggestionSemanticLabel(suggestion: ConnectionEditorSuggestion): string;
    suggestionPreviewText(suggestion: ConnectionEditorSuggestion): string;
    suggestionOutcomeText(suggestion: ConnectionEditorSuggestion): string;
    suggestionRouteTechnicalText(suggestion: ConnectionEditorSuggestion): string;
    suggestionActionText(suggestion: ConnectionEditorSuggestion): string;
    connectionCreatedFeedback(connection: ConnectionEditorConnection): string;
    portAriaLabel(node: ConnectionEditorNode, port: ConnectionEditorPort, role: 'input' | 'output' | 'state'): string;
    transformKindText(kind: TransformKind): string;
    private readableEndpointLabel;
    private isSelectionToDetailConnection;
    private isSuggestedMasterDetail;
    private isCanonicalSelectionToDetailConnection;
    private isTableSelectionOutput;
    private isFormResourceIdInput;
    private portComponentType;
    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 scrollConnectionSidePanelToTop;
    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>;
}>;
type LayoutPresetEntry = {
    id: string;
    label: string;
    description: string;
    category: string;
    defaultColumns: number;
    defaultGap: string;
    slotLabels: string[];
    requiredSlotLabels: string[];
    deviceStacking: string;
    preferTabsOnMobile: boolean;
    hideSecondaryContentOnMobile: boolean;
    defaultThemePreset: string;
};
type ThemePresetEntry = {
    id: string;
    label: string;
    description: string;
    density: string;
    motion: string;
    shellPreset: string;
    chartThemePreset: 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: LayoutPresetEntry[];
    readonly themePresetEntries: ThemePresetEntry[];
    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 readonly i18n;
    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 selectedLayoutPresetEntry(): LayoutPresetEntry | null;
    get selectedThemePresetEntry(): ThemePresetEntry | null;
    get recommendedThemePresetEntry(): ThemePresetEntry | null;
    get canvasSummaryLabel(): string;
    onSelectedTabIndexChange(index: number): void;
    getSettingsValue(): WidgetPageDefinition | null;
    onSave(): WidgetPageDefinition | null;
    reset(): void;
    pinRecommendedThemePreset(): void;
    addGroupingNode(seed?: WidgetPageGroupingDefinition): void;
    removeGroupingNode(index: number): void;
    layoutPresetSummary(preset: LayoutPresetEntry): string;
    slotsSummary(preset: LayoutPresetEntry): string;
    requiredSlotsSummary(preset: LayoutPresetEntry): string;
    devicePolicySummary(preset: LayoutPresetEntry): string;
    inheritedThemeHelp(theme: ThemePresetEntry): string;
    groupLabel(index: number): string;
    tx(key: string, fallback: string): string;
    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>;
    requestTimeoutMs?: number;
    streamStartTimeoutMs?: number;
    streamTurnTimeoutMs?: number;
    streamResultFallbackMs?: number;
    streamSilenceStatusMs?: number;
}
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?: AgenticAuthoringTurnStreamContextHintsContract | null;
    activeSemanticDecision?: AgenticAuthoringSemanticDecisionContract | null;
    diagnostics?: AiJsonObject | null;
    runtimeComponentObservations?: readonly PraxisRuntimeComponentObservationEnvelope[];
    runtimeComponentObservationTrustBoundary?: 'untrusted_frontend_observation';
}
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;
    assistantContent?: AiJsonObject | 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;
    streamId: string;
    resultEventId: 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 turnClient;
    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 buildHeaderRecord;
    private buildHeaders;
    private toTurnStreamEvent;
    private toTurnStreamError;
    private toRecord;
    private streamStartTimeoutMs;
    private streamTurnTimeoutMs;
    private streamResultFallbackMs;
    private streamSilenceStatusMs;
    private streamLifecycleStatusEvent;
    private requestTimeoutMs;
    private streamConnectionError;
    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;
    shell?: WidgetInstance['shell'];
    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>;
}
type UiCompositionPlanSelectionSyncMapping = string | {
    path: string;
    inputSource?: UiCompositionPlanInputSource;
    condition?: unknown;
};
/**
 * Semantic authoring shorthand for projecting the same selection emitted by one
 * or more component outputs into page state. The compiler expands this shape
 * into explicit canonical composition links before preview or persistence.
 */
interface UiCompositionPlanSelectionSync {
    id: string;
    intent: 'selection-sync';
    sources: UiCompositionPlanComponentPortEndpoint[];
    target: UiCompositionPlanStateEndpoint;
    mapping: Record<string, UiCompositionPlanSelectionSyncMapping>;
    policy?: CompositionLink['policy'];
    metadata?: Record<string, unknown>;
}
type UiCompositionPlanContextValue = {
    kind: 'constant';
    value: unknown;
} | {
    kind: 'state';
    path: string;
    layer?: 'values' | 'derived' | 'transient';
    condition?: unknown;
    /** Explicit value materialized before the first state propagation. */
    initial?: unknown;
};
interface UiCompositionPlanContextScopeTarget {
    widget: string;
    nestedPath?: ComponentPortPathSegment[];
    inherit?: string[];
}
/**
 * Groups reusable parent/resource context for one or more component targets.
 * Constants and explicit state initial values become widget inputs, while
 * state values become canonical links during compilation. No hidden runtime
 * inheritance remains in the executable page.
 */
interface UiCompositionPlanContextScope {
    id: string;
    context: Record<string, UiCompositionPlanContextValue>;
    targets: UiCompositionPlanContextScopeTarget[];
    policy?: CompositionLink['policy'];
    metadata?: Record<string, unknown>;
}
interface UiCompositionPlan {
    version: '1.0';
    kind: 'praxis.ui-composition-plan';
    /** Page-owned business copy compiled verbatim into WidgetPageDefinition.i18n. */
    i18n?: WidgetPageDefinition['i18n'];
    /** Explicit page-wide context compiled into WidgetPageDefinition.context. */
    context?: WidgetPageDefinition['context'];
    /** Canonical responsive grid layout compiled into WidgetPageDefinition.layout. */
    layout?: WidgetPageDefinition['layout'];
    layoutPreset?: string;
    layoutPresetOptions?: Record<string, unknown>;
    canvas?: WidgetPageCanvasLayout;
    deviceLayouts?: WidgetPageDeviceLayouts;
    grouping?: WidgetPageGroupingDefinition[];
    slotAssignments?: WidgetPageSlotAssignments;
    state?: WidgetPageStateInput;
    themePreset?: string;
    widgets: UiCompositionPlanWidget[];
    selectionSyncs?: UiCompositionPlanSelectionSync[];
    contextScopes?: UiCompositionPlanContextScope[];
    bindings?: UiCompositionPlanBinding[];
    /** Non-executable authoring and resolution evidence; never copied into WidgetPageDefinition. */
    diagnostics?: Record<string, unknown>;
}
interface UiCompositionPlanTemplateRef {
    registryKey: string;
    configSha256: string;
}
/** Compact intermediate authoring input. It is never a runtime persistence shape. */
interface UiCompositionPlanTemplateReference {
    version: '1.0';
    kind: 'praxis.ui-composition-plan';
    templateRef: UiCompositionPlanTemplateRef;
    overrides?: Readonly<Record<string, never>>;
}
interface UiCompositionPlanTemplateRevision {
    version?: number;
    etag?: string;
    configSha256: string;
}
/** Exact template body and revision evidence supplied by the governed backend. */
interface UiCompositionPlanTemplateMaterialization {
    registryKey: string;
    revision: UiCompositionPlanTemplateRevision;
    authoringPlan: UiCompositionPlan;
}
type UiCompositionPlanAuthoringInput = UiCompositionPlan | UiCompositionPlanTemplateReference;
type UiCompositionPlanTemplateResolutionResult = {
    valid: true;
    referenced: boolean;
    plan: UiCompositionPlan;
    diagnostics: UiCompositionPlanDiagnostic[];
} | {
    valid: false;
    referenced: true;
    plan: null;
    diagnostics: UiCompositionPlanDiagnostic[];
};
interface UiCompositionPlanDiagnostic {
    code: string;
    message: string;
    path?: string;
}
type UiCompositionPlanCompileResult = {
    valid: true;
    page: WidgetPageDefinition;
    diagnostics: UiCompositionPlanDiagnostic[];
} | {
    valid: false;
    page: null;
    diagnostics: UiCompositionPlanDiagnostic[];
};
/**
 * Pure, fail-closed normalization for an exact template reference.
 *
 * The function performs no HTTP, registry search or template selection. The governed backend must
 * supply the exact materialization and its revision evidence before the existing compiler runs.
 */
declare function resolveUiCompositionPlanTemplate(input: UiCompositionPlanAuthoringInput, materialization?: UiCompositionPlanTemplateMaterialization): UiCompositionPlanTemplateResolutionResult;
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 PageBuilderPremiumReadinessSeverity = 'info' | 'warning' | 'error';
type PageBuilderPremiumReadinessActionKind = 'open-page-settings' | 'open-connections' | 'open-widget-config' | 'focus-widget';
interface PageBuilderPremiumReadinessAction {
    kind: PageBuilderPremiumReadinessActionKind;
    label: string;
    widgetKey?: string;
}
interface PageBuilderPremiumReadinessIssue {
    id: string;
    severity: PageBuilderPremiumReadinessSeverity;
    title: string;
    description: string;
    action?: PageBuilderPremiumReadinessAction;
}
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, OnDestroy {
    private dialog;
    private settingsPanel;
    private readonly i18n;
    private readonly injector;
    private readonly hostElement;
    private readonly componentMetadata;
    private readonly agenticAuthoring;
    private readonly agenticTurnOrchestrator;
    private readonly assistantSessions;
    private readonly observabilityDashboard;
    private readonly runtimeObservationRegistry;
    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;
    componentPaletteAllowedWidgetIds: string[] | null;
    componentPaletteAllowedWidgetTags: string[] | null;
    componentPaletteAllowedPresetIds: string[] | null;
    enableAgenticAuthoring: boolean;
    agenticAuthoringProvider?: string;
    agenticAuthoringModel?: string;
    agenticAuthoringApiKey?: string;
    agenticAuthoringComponentId?: string;
    agenticAuthoringScope: 'user' | 'tenant';
    agenticAuthoringEtag?: string;
    agenticAuthoringIncludeLlmDiagnostics: boolean;
    agenticAuthoringEnableStreaming: boolean;
    agenticAuthoringVoiceInputMode: PraxisAssistantVoiceInputMode;
    agenticAuthoringContextHints?: Record<string, unknown> | null;
    showPageLifecycleActions: boolean;
    canDeleteSavedPage: boolean;
    pageLifecycleBusy: boolean;
    pageLifecycleResetRevision: number | string | null;
    pageChange: EventEmitter<WidgetPageDefinition>;
    widgetEvent: EventEmitter<WidgetEventEnvelope>;
    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 hasRecommendedConnectionSuggestion: _angular_core.Signal<boolean>;
    readonly premiumReadinessIssues: _angular_core.Signal<PageBuilderPremiumReadinessIssue[]>;
    readonly connectionsViewerOpen: _angular_core.WritableSignal<boolean>;
    readonly agenticAuthoringOpen: _angular_core.WritableSignal<boolean>;
    readonly agenticAuthoringPrompt: _angular_core.WritableSignal<string>;
    readonly agenticAuthoringBusy: _angular_core.WritableSignal<boolean>;
    private readonly agenticAuthoringTerminalState;
    readonly agenticAuthoringStatus: _angular_core.WritableSignal<string>;
    readonly agenticAuthoringError: _angular_core.WritableSignal<string>;
    readonly agenticAuthoringPreviewResult: _angular_core.WritableSignal<PageBuilderPreviewResult | null>;
    private readonly agenticAuthoringMaterializationPending;
    readonly agenticAuthoringSemanticDecision: _angular_core.WritableSignal<AgenticAuthoringSemanticDecisionContract | null>;
    private readonly agenticAuthoringSemanticResourcePresentationLabel;
    private readonly agenticAuthoringTurnResultRef;
    private readonly agenticAuthoringApplyTarget;
    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 agenticTurnHealth: _angular_core.WritableSignal<ObservabilityAgenticTurnMetrics>;
    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 runtimePreviewPageCache?;
    private runtimeAuthoringPageCache?;
    private agenticComponentCapabilities?;
    private agenticComponentCapabilitiesPromise?;
    private agenticTurnController?;
    private readonly agenticLocalPreviewHistory;
    private agenticLocalPreviewHistoryTruncated;
    private readonly agenticTurnCancel$;
    private agenticTurnRunId;
    private agenticAuthoringTurnInactivityTimeoutMs;
    private sharedRuleHandoffRevision;
    private agenticAuthoringPanelLayoutTouched;
    private readonly observabilityMetricsSubscription;
    constructor(dialog: MatDialog, settingsPanel: SettingsPanelBridge | null);
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    showSettings(): boolean;
    isPreviewMode(): boolean;
    runtimePage(): WidgetPageDefinition;
    builderModeLabel(): string;
    onRuntimePageChange(next: WidgetPageDefinition): void;
    onRuntimeWidgetEvent(event: WidgetEventEnvelope): void;
    onConnectionEditorPageChange(next: WidgetPageDefinition): void;
    onRuntimeWidgetSelectionChange(widgetKey: string | null): void;
    togglePreview(): void;
    toggleAgenticAuthoringLlmDiagnostics(): void;
    agenticAuthoringDiagnosticsAvailable(): boolean;
    agenticTurnHealthBuckets(): Array<{
        dimension: 'provider' | 'model';
        bucket: ObservabilityAgenticTurnMetricBucket;
    }>;
    formatAgenticMetricPercent(rate: number): string;
    formatAgenticDuration(durationMs: number): string;
    private emptyAgenticTurnHealth;
    toggleSharedRuleCockpit(): void;
    toggleProjectKnowledgeCockpit(): void;
    toggleConnectionsViewer(): void;
    connectionsToggleLabel(): string;
    onAddComponent(): void;
    addWidget(selection: string | ComponentPaletteSelection): void;
    private layoutHintsFor;
    openPageSettings(): void;
    saveCurrentPage(): void;
    canSaveCurrentPage(): boolean;
    private evaluatePremiumReadiness;
    runPremiumReadinessAction(issue: PageBuilderPremiumReadinessIssue): void;
    private isPremiumReadinessCandidate;
    private hasDisconnectedOperationalWidgets;
    private latePrimaryChartKey;
    private usesLocalAnalyticData;
    private isAnalyticWidget;
    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;
    showAgenticAuthoringPanel(): boolean;
    showAgenticAuthoringDock(): boolean;
    agenticAuthoringMinimized(): boolean;
    agenticAuthoringToggleLabel(): string;
    agenticAuthoringHeaderTitle(): string;
    agenticAuthoringHeaderSubtitle(): string;
    agenticAuthoringHeaderModeLabel(): string;
    agenticAuthoringShellLabels(): Partial<PraxisAssistantShellLabels>;
    agenticAuthoringRecommendedIntents(): readonly PraxisAssistantRecommendedIntent[];
    private agenticAuthoringEmptyConversationMessage;
    private resolveAgenticAuthoredOpeningMessage;
    private isAgenticAuthoringPageBlank;
    private hasPendingAgenticPreview;
    agenticAuthoringSubmitAction(): PraxisAssistantShellAction;
    agenticAuthoringDockIcon(): string;
    agenticAuthoringDockBadge(): string;
    agenticAuthoringDockSummary(): string;
    agenticAuthoringShellState(): PraxisAssistantShellState;
    private hasAgenticAuthoringSession;
    private resetAgenticAuthoringSessionState;
    private syncAgenticAuthoringSession;
    private resolveAgenticAuthoringSessionId;
    private pageIdentityFingerprint;
    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 agenticSemanticResourceLabel;
    private humanizeAgenticDecisionSummary;
    private humanizeAgenticOperationKind;
    private humanizeAgenticArtifactKind;
    private humanizeAgenticChangeKind;
    private humanizeAgenticDecisionEvidence;
    private humanizeAgenticToken;
    previewAgenticAuthoring(): Promise<void>;
    submitAgenticRecommendedIntent(intent: PraxisAssistantRecommendedIntent): Promise<void>;
    submitAgenticQuickReply(reply: PraxisAssistantShellQuickReply): Promise<void>;
    private isGovernedReviewRepairQuickReply;
    private agenticQuickReplyVisiblePrompt;
    private agenticQuickReplySubmittedPrompt;
    private agenticQuickReplyClarificationConfirmationPrompt;
    private isHumanSafeResourceQuickReplyPrompt;
    private isGenericDataSourceQuickReplyPrompt;
    private isGenericGovernedConfirmationQuickReplyPrompt;
    private agenticQuickReplyGovernedConfirmationPrompt;
    private isResourceQuickReply;
    private isContextualPreviewActionQuickReply;
    private isDashboardQualityQuickReplyText;
    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>;
    updateAgenticAuthoringPrompt(prompt: string): 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 collectRuntimeComponentObservationsForAgenticTurn;
    private resolveSelectedComponentAuthoringContext;
    private isComponentConfigEditorContextResult;
    private ensureAgenticTurnController;
    private applyAgenticPreviewLocally;
    private agenticLocalUndoAction;
    private executeAgenticClientAction;
    private canUndoAgenticLocalPreview;
    private undoAgenticLocalPreview;
    private recordAgenticLocalPreview;
    private clearAgenticLocalPreviewHistory;
    private agenticCurrentPageFingerprint;
    private enterPreviewMode;
    private toPresentationRuntimePage;
    private toAuthoringRuntimePage;
    /**
     * Removes authoring-only inputs from a page emitted by the embedded runtime.
     *
     * The runtime must receive `enableCustomization=true` so nested components can
     * expose their editors, but that projection is not part of the authored page.
     * Restore the canonical value by widget key before publishing `pageChange` so
     * a presentation-only edit cannot accidentally persist authoring chrome.
     */
    private toCanonicalPageFromAuthoringRuntime;
    private toPresentationRuntimeWidget;
    private applyAgenticTurnState;
    private primeSharedRuleHandoff;
    private moveAgenticAuthoringPanelToReviewSidecar;
    private resolveAgenticSharedRuleHandoff;
    private resolveAgenticSharedRuleAssistantMessage;
    private resolveSharedRuleHandoffRuleType;
    private sameSharedRuleHandoff;
    private sameSharedRuleHandoffIdentity;
    private enrichSharedRuleHandoffFromIntake;
    private resolveSharedRuleHeaders;
    private consumeAgenticTurn;
    private beginAgenticTurn;
    private cancelActiveAgenticTurn;
    private invalidateAgenticTerminalAuthorization;
    private isCurrentAgenticTurn;
    private createAgenticTurnTimeoutState;
    private isAgenticTurnTimeoutState;
    private isAgenticTurnTerminalState;
    agenticAuthoringDiagnosticsTop(): number;
    agenticAuthoringLlmDiagnosticsText(): string;
    private resolveAgenticLlmDiagnostics;
    private resolveAgenticSemanticDecision;
    private resolveAgenticSemanticResourcePresentationLabel;
    private resolveAgenticTurnResultRef;
    private resolveAgenticApplyTarget;
    private matchesCurrentAgenticApplyTarget;
    private normalizeAgenticEtag;
    private currentAgenticAuthoringEtag;
    private cloneAgenticContextHints;
    private resolveGovernedDomainContextSummary;
    private shouldShowGovernedDomainContext;
    private humanizeGovernedDomainContextResolutionStatus;
    private trimmedString;
    private toRecord;
    private resolvePreviewCompiledFormPatch;
    focusCanvasWidget(widgetKey: string): void;
    private openWidgetConfiguration;
    private selectInsertedWidget;
    private deferInsertedWidgetFocus;
    private scrollInsertedWidgetIntoView;
    private escapeAttributeValue;
    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 looksLikeHtmlErrorResponse;
    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; }; "componentPaletteAllowedWidgetIds": { "alias": "componentPaletteAllowedWidgetIds"; "required": false; }; "componentPaletteAllowedWidgetTags": { "alias": "componentPaletteAllowedWidgetTags"; "required": false; }; "componentPaletteAllowedPresetIds": { "alias": "componentPaletteAllowedPresetIds"; "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; }; "agenticAuthoringVoiceInputMode": { "alias": "agenticAuthoringVoiceInputMode"; "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"; "widgetEvent": "widgetEvent"; "pageSaveRequested": "pageSaveRequested"; "agenticAuthoringApplied": "agenticAuthoringApplied"; "agenticAuthoringSharedRuleHandoff": "agenticAuthoringSharedRuleHandoff"; "pageRestart": "pageRestart"; "savedPageDeleteRequested": "savedPageDeleteRequested"; }, never, never, true, never>;
}

/** Metadata for Praxis Page Builder component */
declare const PRAXIS_PAGE_BUILDER_COMPONENT_METADATA: ComponentDocMeta;
/** Provider para auto-registrar metadados do componente Page Builder. */
declare function providePraxisPageBuilderMetadata(): Provider;

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, PRAXIS_PAGE_BUILDER_COMPONENT_METADATA, PageBuilderAgenticAuthoringService, PageConfigEditorComponent, TileToolbarComponent, WidgetShellEditorComponent, clearWidgetAiCatalogs, compileUiCompositionPlan, getPageAiCatalog, getWidgetAiCapabilities, providePageBuilderWidgetAiCatalogs, providePraxisPageBuilderMetadata, registerWidgetAiCatalog, registerWidgetAiCatalogs, resolveUiCompositionPlanTemplate, validateUiCompositionPlan };
export type { Capability, CapabilityCatalog, CapabilityCategory, ComponentPaletteData, ComponentPaletteSelection, ConfirmDialogData, PageBuilderAgenticAuthoringAttachmentSummary, PageBuilderAgenticAuthoringCandidate, PageBuilderAgenticAuthoringComponentCapabilitiesResult, PageBuilderAgenticAuthoringComponentCapability, PageBuilderAgenticAuthoringComponentCapabilityCatalog, PageBuilderAgenticAuthoringComponentCapabilityExample, PageBuilderAgenticAuthoringComponentFieldAlias, PageBuilderAgenticAuthoringConversationMessage, PageBuilderAgenticAuthoringGateResult, PageBuilderAgenticAuthoringIntentResolutionRequest, PageBuilderAgenticAuthoringIntentResolutionResult, PageBuilderAgenticAuthoringOptions, PageBuilderAgenticAuthoringPendingClarification, PageBuilderAgenticAuthoringPromptRequest, PageBuilderAgenticAuthoringProvider, PageBuilderAgenticAuthoringQuickReply, PageBuilderAgenticAuthoringResourceCandidatesRequest, PageBuilderAgenticAuthoringResourceCandidatesResult, PageBuilderAgenticAuthoringSharedRuleHandoff, PageBuilderAgenticAuthoringTarget, PageBuilderAgenticAuthoringTurnStreamConnectionError, PageBuilderAgenticAuthoringTurnStreamEvent, PageBuilderAgenticAuthoringTurnStreamRequest, PageBuilderAgenticAuthoringTurnStreamStartResponse, PageBuilderApplyRequest, PageBuilderApplyResult, PageBuilderCompiledFormPatch, PageBuilderMinimalFormPlanResult, PageBuilderPreviewDiagnostics, PageBuilderPreviewResult, PageBuilderProjectKnowledgeAudit, UiCompositionPlan, UiCompositionPlanAuthoringInput, UiCompositionPlanBinding, UiCompositionPlanCompileResult, UiCompositionPlanComponentPortEndpoint, UiCompositionPlanContextScope, UiCompositionPlanContextScopeTarget, UiCompositionPlanContextValue, UiCompositionPlanDiagnostic, UiCompositionPlanEndpoint, UiCompositionPlanGlobalActionEndpoint, UiCompositionPlanInputSource, UiCompositionPlanSelectionSync, UiCompositionPlanSelectionSyncMapping, UiCompositionPlanSourceEndpoint, UiCompositionPlanStateEndpoint, UiCompositionPlanTargetEndpoint, UiCompositionPlanTemplateMaterialization, UiCompositionPlanTemplateRef, UiCompositionPlanTemplateReference, UiCompositionPlanTemplateResolutionResult, UiCompositionPlanTemplateRevision, UiCompositionPlanTransform, UiCompositionPlanWidget, ValueKind };