@endge/ui-vue 0.23.3

package/dist/ui/render/entities/EndgePage.vue.d.ts

@@ -0,0 +1,1852 @@
+import { RPage } from '@endge/core';
+type __VLS_Props = {
+    /** Identity страницы в домене (RPage). */
+    identity: string;
+    /** Параметры страницы (route params, query). */
+    params?: Record<string, unknown>;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {
+            page: RPage | null;
+            runtime: {
+                readonly id: string;
+                readonly parent: {
+                    readonly id: string;
+                    readonly parent: /*elided*/ any | null;
+                    readonly kind: import('@endge/core').RuntimeKind | "runtime";
+                    readonly runtimeType: string;
+                    readonly capabilities: readonly import('@endge/core').RuntimeHostCapability[];
+                    readonly entityType: any;
+                    readonly model: any;
+                    readonly entityIdentity: string;
+                    readonly title: string;
+                    status: import('@endge/core').RuntimeHostStatus;
+                    readonly createdAt: number;
+                    updatedAt: number;
+                    readonly resources: {
+                        id: string;
+                        kind: import('@endge/core').RuntimeHostResourceKind;
+                        title: string;
+                        subtitle?: string | undefined;
+                        payload?: Record<string, unknown> | undefined;
+                    }[];
+                    readonly channels: {
+                        id: string;
+                        kind: import('@endge/core').RuntimeHostChannelKind;
+                        name: string;
+                        direction: "in" | "out" | "both";
+                        subtitle?: string | undefined;
+                    }[];
+                    readonly meta: Record<string, unknown>;
+                    context: any;
+                    readonly runtimeState: {
+                        readonly runtimeId: string;
+                        readonly storageId: string;
+                        readonly storageKey: string;
+                        readonly scope: {
+                            workspaceId: string;
+                            tenantId: string;
+                            projectId: string;
+                            environmentId: string;
+                            userId: string;
+                        };
+                        get: <T>(entityKey: string, section: string, fallback: T) => T;
+                        set: <T>(entityKey: string, section: string, value: T) => void;
+                        remove: (entityKey: string, section?: string) => void;
+                        clear: () => void;
+                    } | null;
+                    readonly node: {
+                        addChild: (node: import('@endge/raph').RaphNode<any>, options?: {
+                            invalidate?: boolean;
+                        }) => boolean;
+                        remove: () => void;
+                        addMeta: (key: string, value: unknown) => void;
+                        options: (opts: Partial<import('@endge/raph').RaphProperties> & {
+                            id?: string;
+                            weight?: number;
+                            meta?: Record<string, unknown>;
+                            type?: string;
+                        }) => import('@endge/raph').RaphNode<import('@endge/raph').RaphProperties>;
+                        get: <K extends string>(key: K) => import('@endge/raph').RaphProperties[K];
+                        set: <K extends string>(key: K, value: import('@endge/raph').RaphProperties[K]) => void;
+                        getLocal: <K extends string>(key: K) => import('@endge/raph').RaphProperties[K];
+                        setLocal: <K extends string>(key: K, value: import('@endge/raph').RaphProperties[K]) => void;
+                        dirty: (phase: import('@endge/raph').PhaseName | string | Array<import('@endge/raph').PhaseName | string>) => void;
+                        traverseAll: (cb: (node: import('@endge/raph').RaphNode<any>) => void) => void;
+                        dispose: () => void;
+                        _attachApp: (app: import('@endge/raph').RaphRuntime<any>) => void;
+                        hasDirtyPhase: (bit: number) => boolean;
+                        markDirtyPhase: (bit: number) => void;
+                        clearDirtyPhase: (bit: number) => void;
+                        readonly app: {
+                            readonly id: string;
+                            options: (opts: Partial<import('@endge/raph').RaphOptions>) => void;
+                            derive: <TSource = unknown, TTarget = unknown>(options: import('@endge/raph').RaphDerivedOptions<TSource, TTarget>) => import('@endge/raph').RaphDerivedHandle;
+                            transaction: (fn: () => void) => void;
+                            getDerivedSnapshot: () => import('@endge/raph').RaphDerivedManagerSnapshot;
+                            definePhases: (phases: Array<import('@endge/raph').RaphPhase>) => void;
+                            addPhase: (phase: import('@endge/raph').RaphPhase) => void;
+                            clearPhases: () => void;
+                            reinitPhases: () => void;
+                            getNode: (id: string) => import('@endge/raph').RaphNode<import('@endge/raph').RaphProperties> | undefined;
+                            addNode: (node: import('@endge/raph').RaphNode<import('@endge/raph').RaphProperties>) => void;
+                            registerNode: (node: import('@endge/raph').RaphNode<any>) => void;
+                            removeNode: (node: import('@endge/raph').RaphNode<any>) => void;
+                            unregisterNode: (node: import('@endge/raph').RaphNode<any>) => void;
+                            addDependency: (parent: import('@endge/raph').RaphNode<any>, child: import('@endge/raph').RaphNode<any>) => boolean;
+                            removeDependency: (parent: import('@endge/raph').RaphNode<any>, child: import('@endge/raph').RaphNode<any>) => void;
+                            init: () => void;
+                            clear: () => void;
+                            destroy: () => void;
+                            traverseAll: (cb: (node: import('@endge/raph').RaphNode<import('@endge/raph').RaphProperties>) => void) => void;
+                            addLocalPhase: (phase: import('@endge/raph').RaphLocalPhaseRuntime<import('@endge/raph').RaphProperties>) => void;
+                            addLocalProperty: <K extends string>(property: import('@endge/raph').RaphLocalPropertyRuntime<import('@endge/raph').RaphProperties, K>) => void;
+                            getLocalProperty: <K extends string>(key: K) => import('@endge/raph').RaphLocalPropertyRuntime<import('@endge/raph').RaphProperties, K> | undefined;
+                            dirtyLocalNodeDefaults: (node: import('@endge/raph').RaphNode<any>, invalidate?: boolean) => void;
+                            setScheduler: (mode: import('@endge/raph').RaphSchedulerType) => void;
+                            notify: (path: import('@endge/raph').DataPathDef, opts?: {
+                                invalidate?: boolean;
+                                vars?: Record<string, any>;
+                            }) => boolean;
+                            observeData: (node: import('@endge/raph').RaphNode<any>, mask: import('@endge/raph').DataPathDef, options: import('@endge/raph').RaphObserveDataOptions) => () => void;
+                            enqueueDataObserver: (observer: import('@endge/raph').RaphDataObserver<any>, path: import('@endge/raph').DataPathDef, opts?: {
+                                invalidate?: boolean;
+                                vars?: Record<string, any>;
+                            }) => boolean;
+                            dirty: (phase: import('@endge/raph').PhaseName | string, node: import('@endge/raph').RaphNode<any>, opts?: {
+                                invalidate: boolean;
+                                event?: import('@endge/raph').PhaseEvent;
+                            }) => void;
+                            run: () => void;
+                            get: (path: import('@endge/raph').DataPathDef, opts?: {
+                                vars?: Record<string, any>;
+                            }) => import('@endge/raph').Undefinable<unknown>;
+                            set: (path: import('@endge/raph').DataPathDef, value: unknown, opts?: {
+                                invalidate?: boolean;
+                                vars?: Record<string, any>;
+                            }) => void;
+                            merge: (path: import('@endge/raph').DataPathDef, value: unknown, opts?: {
+                                invalidate?: boolean;
+                                vars?: Record<string, any>;
+                            }) => void;
+                            delete: (path: import('@endge/raph').DataPathDef, opts?: {
+                                invalidate?: boolean;
+                                vars?: Record<string, any>;
+                            }) => void;
+                            startLoop: () => void;
+                            acquireLoop: (owner: string) => import('@endge/raph').RaphLoopLease;
+                            stopLoop: () => void;
+                            invalidate: () => void;
+                            reset: () => void;
+                            subscribe: (ownerNode: import('@endge/raph').RaphNode<any>, maskOrMasks: import('@endge/raph').DataPathDef | Array<import('@endge/raph').DataPathDef>, callback: import('@endge/raph').ControlFlowCallback, opts?: import('@endge/raph').ControlFlowSubscribeOptions) => () => void;
+                            unsubscribe: (subscriptionId: import('@endge/raph').ControlFlowSubscriptionId) => void;
+                            unsubscribeOwner: (ownerNode: import('@endge/raph').RaphNode<any>) => void;
+                            track: (node: import('@endge/raph').RaphNode<any>, mask: import('@endge/raph').DataPathDef, opts?: {
+                                vars?: Record<string, any>;
+                                wildcardDynamic?: boolean;
+                            }) => void;
+                            untrack: (node: import('@endge/raph').RaphNode<any>, mask?: import('@endge/raph').DataPathDef) => void;
+                            priorityOf: (node: import('@endge/raph').RaphNode<any>) => number;
+                            readonly data: import('@endge/raph').DataObject;
+                            readonly graph: {
+                                addNode: (node: import('@endge/raph').RaphNode<any>) => void;
+                                removeNode: (nodeOrId: string | import('@endge/raph').RaphNode<any>) => void;
+                                hasNode: (nodeOrId: string | import('@endge/raph').RaphNode<any>) => boolean;
+                                getNode: (id: string) => import('@endge/raph').RaphNode<any> | undefined;
+                                size: () => number;
+                                addEdge: (parent: string | import('@endge/raph').RaphNode<any>, child: string | import('@endge/raph').RaphNode<any>) => boolean;
+                                removeEdge: (parent: string | import('@endge/raph').RaphNode<any>, child: string | import('@endge/raph').RaphNode<any>) => void;
+                                parentsOf: (nodeOrId: string | import('@endge/raph').RaphNode<any>) => ReadonlySet<import('@endge/raph').RaphNode<any>>;
+                                childrenOf: (nodeOrId: string | import('@endge/raph').RaphNode<any>) => ReadonlySet<import('@endge/raph').RaphNode<any>>;
+                                rootIds: () => ReadonlySet<string>;
+                                roots: () => ReadonlySet<import('@endge/raph').RaphNode<any>>;
+                                getDepth: (nodeOrId: string | import('@endge/raph').RaphNode<any>) => number;
+                                topoOrder: () => import('@endge/raph').RaphNode<any>[];
+                                expandByTraversal: (base: Set<import('@endge/raph').RaphNode<any>> | null, traversal: "dirty-only" | "dirty-and-down" | "dirty-and-up" | "all") => Set<import('@endge/raph').RaphNode<any>>;
+                            };
+                            readonly loopEnabled: boolean;
+                            readonly frame: {
+                                now: number;
+                                delta: number;
+                                elapsed: number;
+                                frame: number;
+                            };
+                            readonly ups: number;
+                            readonly eps: number;
+                            readonly nps: number;
+                            readonly maxUps: number;
+                            readonly minUpdateInterval: number;
+                            readonly dataAdapter: {
+                                root: () => import('@endge/raph').DataObject;
+                                get: (path: import('@endge/raph').DataPathDef, opts?: {
+                                    vars?: Record<string, any>;
+                                }) => import('@endge/raph').Undefinable<unknown>;
+                                set: (path: import('@endge/raph').DataPathDef, value: unknown, opts?: {
+                                    vars?: Record<string, any>;
+                                }) => void;
+                                delete: (path: import('@endge/raph').DataPathDef, opts?: {
+                                    vars?: Record<string, any>;
+                                }) => void;
+                                merge: (path: import('@endge/raph').DataPathDef, value: unknown, opts?: {
+                                    vars?: Record<string, any>;
+                                }) => void;
+                                indexOf: (path: import('@endge/raph').DataPathDef, opts?: {
+                                    vars?: Record<string, any>;
+                                }) => number;
+                            };
+                            readonly kernel: {
+                                readonly id: string;
+                                createRuntime: <Props extends import('@endge/raph').RaphProperties = import('@endge/raph').RaphProperties>(options?: import('@endge/raph').RaphRuntimeOptions) => import('@endge/raph').RaphRuntime<Props>;
+                                registerRuntime: (runtime: import('@endge/raph').RaphRuntime<any>) => void;
+                                unregisterRuntime: (runtime: import('@endge/raph').RaphRuntime<any>) => void;
+                                registerDerived: <TSource, TTarget>(runtime: import('@endge/raph').RaphRuntime<any>, options: import('@endge/raph').RaphDerivedOptions<TSource, TTarget>) => import('@endge/raph').RaphDerivedHandle;
+                                getDerivedSnapshot: () => import('@endge/raph').RaphDerivedManagerSnapshot;
+                                disposeAllDerived: () => void;
+                                disposeRuntimeDerived: (runtime: import('@endge/raph').RaphRuntime<any>) => void;
+                                registerDataObserver: <Props extends import('@endge/raph').RaphProperties>(runtime: import('@endge/raph').RaphRuntime<Props>, node: import('@endge/raph').RaphDataObserver<Props>["node"], mask: import('@endge/raph').DataPathDef, options: import('@endge/raph').RaphObserveDataOptions) => () => void;
+                                removeDataObserversByRuntime: (runtime: import('@endge/raph').RaphRuntime<any>) => void;
+                                removeDataObserversByNode: (runtime: import('@endge/raph').RaphRuntime<any>, node: import('@endge/raph').RaphDataObserver["node"]) => void;
+                                transaction: (fn: () => void) => void;
+                                get: (path: import('@endge/raph').DataPathDef, opts?: {
+                                    vars?: Record<string, any>;
+                                }) => unknown;
+                                set: (path: import('@endge/raph').DataPathDef, value: unknown, opts?: {
+                                    invalidate?: boolean;
+                                    vars?: Record<string, any>;
+                                }) => void;
+                                merge: (path: import('@endge/raph').DataPathDef, value: unknown, opts?: {
+                                    invalidate?: boolean;
+                                    vars?: Record<string, any>;
+                                }) => void;
+                                delete: (path: import('@endge/raph').DataPathDef, opts?: {
+                                    invalidate?: boolean;
+                                    vars?: Record<string, any>;
+                                }) => void;
+                                notify: (path: import('@endge/raph').DataPathDef, opts?: {
+                                    invalidate?: boolean;
+                                    vars?: Record<string, any>;
+                                }) => void;
+                                setDataAdapter: (adapter: import('@endge/raph').DataAdapter) => void;
+                                clear: () => void;
+                                readonly dataAdapter: {
+                                    root: () => import('@endge/raph').DataObject;
+                                    get: (path: import('@endge/raph').DataPathDef, opts?: {
+                                        vars?: Record<string, any>;
+                                    }) => import('@endge/raph').Undefinable<unknown>;
+                                    set: (path: import('@endge/raph').DataPathDef, value: unknown, opts?: {
+                                        vars?: Record<string, any>;
+                                    }) => void;
+                                    delete: (path: import('@endge/raph').DataPathDef, opts?: {
+                                        vars?: Record<string, any>;
+                                    }) => void;
+                                    merge: (path: import('@endge/raph').DataPathDef, value: unknown, opts?: {
+                                        vars?: Record<string, any>;
+                                    }) => void;
+                                    indexOf: (path: import('@endge/raph').DataPathDef, opts?: {
+                                        vars?: Record<string, any>;
+                                    }) => number;
+                                };
+                                readonly data: import('@endge/raph').DataObject;
+                            };
+                            readonly phases: readonly {
+                                name: import('@endge/raph').PhaseName;
+                                traversal: import('@endge/raph').Traversal;
+                                routes: Array<string>;
+                                always?: boolean | undefined;
+                                mode?: "dirty" | "all" | undefined;
+                                each?: import('@endge/raph').PhaseEachExecutor | undefined;
+                                all?: import('@endge/raph').PhaseAllExecutor | undefined;
+                                nodes?: (((node: import('@endge/raph').RaphNode<any>) => boolean) | Array<import('@endge/raph').RaphNodeType>) | undefined;
+                            }[];
+                            getPhase: (name: import('@endge/raph').PhaseName) => import('@endge/raph').RaphPhase | undefined;
+                            readonly root: /*elided*/ any;
+                            readonly UPS: number;
+                        };
+                        readonly raph: {
+                            readonly id: string;
+                            options: (opts: Partial<import('@endge/raph').RaphOptions>) => void;
+                            derive: <TSource = unknown, TTarget = unknown>(options: import('@endge/raph').RaphDerivedOptions<TSource, TTarget>) => import('@endge/raph').RaphDerivedHandle;
+                            transaction: (fn: () => void) => void;
+                            getDerivedSnapshot: () => import('@endge/raph').RaphDerivedManagerSnapshot;
+                            definePhases: (phases: Array<import('@endge/raph').RaphPhase>) => void;
+                            addPhase: (phase: import('@endge/raph').RaphPhase) => void;
+                            clearPhases: () => void;
+                            reinitPhases: () => void;
+                            getNode: (id: string) => import('@endge/raph').RaphNode<import('@endge/raph').RaphProperties> | undefined;
+                            addNode: (node: import('@endge/raph').RaphNode<import('@endge/raph').RaphProperties>) => void;
+                            registerNode: (node: import('@endge/raph').RaphNode<any>) => void;
+                            removeNode: (node: import('@endge/raph').RaphNode<any>) => void;
+                            unregisterNode: (node: import('@endge/raph').RaphNode<any>) => void;
+                            addDependency: (parent: import('@endge/raph').RaphNode<any>, child: import('@endge/raph').RaphNode<any>) => boolean;
+                            removeDependency: (parent: import('@endge/raph').RaphNode<any>, child: import('@endge/raph').RaphNode<any>) => void;
+                            init: () => void;
+                            clear: () => void;
+                            destroy: () => void;
+                            traverseAll: (cb: (node: import('@endge/raph').RaphNode<import('@endge/raph').RaphProperties>) => void) => void;
+                            addLocalPhase: (phase: import('@endge/raph').RaphLocalPhaseRuntime<import('@endge/raph').RaphProperties>) => void;
+                            addLocalProperty: <K extends string>(property: import('@endge/raph').RaphLocalPropertyRuntime<import('@endge/raph').RaphProperties, K>) => void;
+                            getLocalProperty: <K extends string>(key: K) => import('@endge/raph').RaphLocalPropertyRuntime<import('@endge/raph').RaphProperties, K> | undefined;
+                            dirtyLocalNodeDefaults: (node: import('@endge/raph').RaphNode<any>, invalidate?: boolean) => void;
+                            setScheduler: (mode: import('@endge/raph').RaphSchedulerType) => void;
+                            notify: (path: import('@endge/raph').DataPathDef, opts?: {
+                                invalidate?: boolean;
+                                vars?: Record<string, any>;
+                            }) => boolean;
+                            observeData: (node: import('@endge/raph').RaphNode<any>, mask: import('@endge/raph').DataPathDef, options: import('@endge/raph').RaphObserveDataOptions) => () => void;
+                            enqueueDataObserver: (observer: import('@endge/raph').RaphDataObserver<any>, path: import('@endge/raph').DataPathDef, opts?: {
+                                invalidate?: boolean;
+                                vars?: Record<string, any>;
+                            }) => boolean;
+                            dirty: (phase: import('@endge/raph').PhaseName | string, node: import('@endge/raph').RaphNode<any>, opts?: {
+                                invalidate: boolean;
+                                event?: import('@endge/raph').PhaseEvent;
+                            }) => void;
+                            run: () => void;
+                            get: (path: import('@endge/raph').DataPathDef, opts?: {
+                                vars?: Record<string, any>;
+                            }) => import('@endge/raph').Undefinable<unknown>;
+                            set: (path: import('@endge/raph').DataPathDef, value: unknown, opts?: {
+                                invalidate?: boolean;
+                                vars?: Record<string, any>;
+                            }) => void;
+                            merge: (path: import('@endge/raph').DataPathDef, value: unknown, opts?: {
+                                invalidate?: boolean;
+                                vars?: Record<string, any>;
+                            }) => void;
+                            delete: (path: import('@endge/raph').DataPathDef, opts?: {
+                                invalidate?: boolean;
+                                vars?: Record<string, any>;
+                            }) => void;
+                            startLoop: () => void;
+                            acquireLoop: (owner: string) => import('@endge/raph').RaphLoopLease;
+                            stopLoop: () => void;
+                            invalidate: () => void;
+                            reset: () => void;
+                            subscribe: (ownerNode: import('@endge/raph').RaphNode<any>, maskOrMasks: import('@endge/raph').DataPathDef | Array<import('@endge/raph').DataPathDef>, callback: import('@endge/raph').ControlFlowCallback, opts?: import('@endge/raph').ControlFlowSubscribeOptions) => () => void;
+                            unsubscribe: (subscriptionId: import('@endge/raph').ControlFlowSubscriptionId) => void;
+                            unsubscribeOwner: (ownerNode: import('@endge/raph').RaphNode<any>) => void;
+                            track: (node: import('@endge/raph').RaphNode<any>, mask: import('@endge/raph').DataPathDef, opts?: {
+                                vars?: Record<string, any>;
+                                wildcardDynamic?: boolean;
+                            }) => void;
+                            untrack: (node: import('@endge/raph').RaphNode<any>, mask?: import('@endge/raph').DataPathDef) => void;
+                            priorityOf: (node: import('@endge/raph').RaphNode<any>) => number;
+                            readonly data: import('@endge/raph').DataObject;
+                            readonly graph: {
+                                addNode: (node: import('@endge/raph').RaphNode<any>) => void;
+                                removeNode: (nodeOrId: string | import('@endge/raph').RaphNode<any>) => void;
+                                hasNode: (nodeOrId: string | import('@endge/raph').RaphNode<any>) => boolean;
+                                getNode: (id: string) => import('@endge/raph').RaphNode<any> | undefined;
+                                size: () => number;
+                                addEdge: (parent: string | import('@endge/raph').RaphNode<any>, child: string | import('@endge/raph').RaphNode<any>) => boolean;
+                                removeEdge: (parent: string | import('@endge/raph').RaphNode<any>, child: string | import('@endge/raph').RaphNode<any>) => void;
+                                parentsOf: (nodeOrId: string | import('@endge/raph').RaphNode<any>) => ReadonlySet<import('@endge/raph').RaphNode<any>>;
+                                childrenOf: (nodeOrId: string | import('@endge/raph').RaphNode<any>) => ReadonlySet<import('@endge/raph').RaphNode<any>>;
+                                rootIds: () => ReadonlySet<string>;
+                                roots: () => ReadonlySet<import('@endge/raph').RaphNode<any>>;
+                                getDepth: (nodeOrId: string | import('@endge/raph').RaphNode<any>) => number;
+                                topoOrder: () => import('@endge/raph').RaphNode<any>[];
+                                expandByTraversal: (base: Set<import('@endge/raph').RaphNode<any>> | null, traversal: "dirty-only" | "dirty-and-down" | "dirty-and-up" | "all") => Set<import('@endge/raph').RaphNode<any>>;
+                            };
+                            readonly loopEnabled: boolean;
+                            readonly frame: {
+                                now: number;
+                                delta: number;
+                                elapsed: number;
+                                frame: number;
+                            };
+                            readonly ups: number;
+                            readonly eps: number;
+                            readonly nps: number;
+                            readonly maxUps: number;
+                            readonly minUpdateInterval: number;
+                            readonly dataAdapter: {
+                                root: () => import('@endge/raph').DataObject;
+                                get: (path: import('@endge/raph').DataPathDef, opts?: {
+                                    vars?: Record<string, any>;
+                                }) => import('@endge/raph').Undefinable<unknown>;
+                                set: (path: import('@endge/raph').DataPathDef, value: unknown, opts?: {
+                                    vars?: Record<string, any>;
+                                }) => void;
+                                delete: (path: import('@endge/raph').DataPathDef, opts?: {
+                                    vars?: Record<string, any>;
+                                }) => void;
+                                merge: (path: import('@endge/raph').DataPathDef, value: unknown, opts?: {
+                                    vars?: Record<string, any>;
+                                }) => void;
+                                indexOf: (path: import('@endge/raph').DataPathDef, opts?: {
+                                    vars?: Record<string, any>;
+                                }) => number;
+                            };
+                            readonly kernel: {
+                                readonly id: string;
+                                createRuntime: <Props extends import('@endge/raph').RaphProperties = import('@endge/raph').RaphProperties>(options?: import('@endge/raph').RaphRuntimeOptions) => import('@endge/raph').RaphRuntime<Props>;
+                                registerRuntime: (runtime: import('@endge/raph').RaphRuntime<any>) => void;
+                                unregisterRuntime: (runtime: import('@endge/raph').RaphRuntime<any>) => void;
+                                registerDerived: <TSource, TTarget>(runtime: import('@endge/raph').RaphRuntime<any>, options: import('@endge/raph').RaphDerivedOptions<TSource, TTarget>) => import('@endge/raph').RaphDerivedHandle;
+                                getDerivedSnapshot: () => import('@endge/raph').RaphDerivedManagerSnapshot;
+                                disposeAllDerived: () => void;
+                                disposeRuntimeDerived: (runtime: import('@endge/raph').RaphRuntime<any>) => void;
+                                registerDataObserver: <Props extends import('@endge/raph').RaphProperties>(runtime: import('@endge/raph').RaphRuntime<Props>, node: import('@endge/raph').RaphDataObserver<Props>["node"], mask: import('@endge/raph').DataPathDef, options: import('@endge/raph').RaphObserveDataOptions) => () => void;
+                                removeDataObserversByRuntime: (runtime: import('@endge/raph').RaphRuntime<any>) => void;
+                                removeDataObserversByNode: (runtime: import('@endge/raph').RaphRuntime<any>, node: import('@endge/raph').RaphDataObserver["node"]) => void;
+                                transaction: (fn: () => void) => void;
+                                get: (path: import('@endge/raph').DataPathDef, opts?: {
+                                    vars?: Record<string, any>;
+                                }) => unknown;
+                                set: (path: import('@endge/raph').DataPathDef, value: unknown, opts?: {
+                                    invalidate?: boolean;
+                                    vars?: Record<string, any>;
+                                }) => void;
+                                merge: (path: import('@endge/raph').DataPathDef, value: unknown, opts?: {
+                                    invalidate?: boolean;
+                                    vars?: Record<string, any>;
+                                }) => void;
+                                delete: (path: import('@endge/raph').DataPathDef, opts?: {
+                                    invalidate?: boolean;
+                                    vars?: Record<string, any>;
+                                }) => void;
+                                notify: (path: import('@endge/raph').DataPathDef, opts?: {
+                                    invalidate?: boolean;
+                                    vars?: Record<string, any>;
+                                }) => void;
+                                setDataAdapter: (adapter: import('@endge/raph').DataAdapter) => void;
+                                clear: () => void;
+                                readonly dataAdapter: {
+                                    root: () => import('@endge/raph').DataObject;
+                                    get: (path: import('@endge/raph').DataPathDef, opts?: {
+                                        vars?: Record<string, any>;
+                                    }) => import('@endge/raph').Undefinable<unknown>;
+                                    set: (path: import('@endge/raph').DataPathDef, value: unknown, opts?: {
+                                        vars?: Record<string, any>;
+                                    }) => void;
+                                    delete: (path: import('@endge/raph').DataPathDef, opts?: {
+                                        vars?: Record<string, any>;
+                                    }) => void;
+                                    merge: (path: import('@endge/raph').DataPathDef, value: unknown, opts?: {
+                                        vars?: Record<string, any>;
+                                    }) => void;
+                                    indexOf: (path: import('@endge/raph').DataPathDef, opts?: {
+                                        vars?: Record<string, any>;
+                                    }) => number;
+                                };
+                                readonly data: import('@endge/raph').DataObject;
+                            };
+                            readonly phases: readonly {
+                                name: import('@endge/raph').PhaseName;
+                                traversal: import('@endge/raph').Traversal;
+                                routes: Array<string>;
+                                always?: boolean | undefined;
+                                mode?: "dirty" | "all" | undefined;
+                                each?: import('@endge/raph').PhaseEachExecutor | undefined;
+                                all?: import('@endge/raph').PhaseAllExecutor | undefined;
+                                nodes?: (((node: import('@endge/raph').RaphNode<any>) => boolean) | Array<import('@endge/raph').RaphNodeType>) | undefined;
+                            }[];
+                            getPhase: (name: import('@endge/raph').PhaseName) => import('@endge/raph').RaphPhase | undefined;
+                            readonly root: /*elided*/ any;
+                            readonly UPS: number;
+                        };
+                        readonly id: string;
+                        readonly weight: number;
+                        readonly computedWeight: number;
+                        readonly meta: Record<string, unknown>;
+                        readonly type: string;
+                        readonly parent: /*elided*/ any | null;
+                        readonly children: /*elided*/ any[];
+                        readonly local: {
+                            get: <K extends string>(key: K) => import('@endge/raph').RaphProperties[K];
+                            set: <K extends string>(key: K, value: import('@endge/raph').RaphProperties[K]) => void;
+                        };
+                    } | null;
+                    readonly basePath: string;
+                    statePath: (path?: string) => string;
+                    outputPath: (name: string) => string;
+                    bindInput: (name: string, binding: import('@endge/core').RuntimeHostInputBinding) => void;
+                    readInput: (name: string) => unknown;
+                    readInputs: () => Readonly<Record<string, unknown>>;
+                    bindUpdate: (binding: import('@endge/core').RuntimeHostUpdateBinding) => () => void;
+                    getArtifact: () => import('@endge/core').ProgramArtifact<unknown> | null;
+                    getArtifactPayload: () => unknown;
+                    setStatus: (status: import('@endge/core').RuntimeHostStatus) => void;
+                    hasCapability: (capability: import('@endge/core').RuntimeHostCapability) => boolean;
+                    addResource: (resource: import('@endge/core').RuntimeHostResource) => void;
+                    addChannel: (channel: import('@endge/core').RuntimeHostChannel) => void;
+                    emit: (event: string, payload: any) => void;
+                    on: (event: string, listener: (payload: any) => void) => any;
+                    off: (event: string, listener: (payload: any) => void) => any;
+                    setContext: (patch: Partial<any>) => void;
+                    replaceContext: (context: any) => void;
+                    attachRuntimeState: (runtimeState: import('@endge/core').RuntimeStateControllerLike | null) => void;
+                    update: (ctx: import('@endge/core').RuntimeHostUpdateContext) => Promise<void> | void;
+                    snapshot: () => import('@endge/core').RuntimeHostSnapshot;
+                    create: () => Promise<void> | void;
+                    mount: () => Promise<void> | void;
+                    start: () => Promise<void> | void;
+                    pause: () => Promise<void> | void;
+                    resume: () => Promise<void> | void;
+                    reconcile: () => Promise<void> | void;
+                    stop: () => Promise<void> | void;
+                    unmount: () => Promise<void> | void;
+                    destroy: () => Promise<void> | void;
+                } | null;
+                readonly kind: import('@endge/core').RuntimeKind | "runtime";
+                readonly runtimeType: string;
+                readonly capabilities: readonly import('@endge/core').RuntimeHostCapability[];
+                readonly entityType: keyof import('@endge/core').RuntimeEntityModelMap;
+                readonly model: {
+                    configuration: {
+                        mode: "inherit";
+                        patch: {
+                            vars?: {
+                                entries: ({
+                                    key: string;
+                                    op: "remove";
+                                } | {
+                                    key: string;
+                                    op: "upsert";
+                                    value: {
+                                        name: string;
+                                        defaultValue: string;
+                                    };
+                                })[];
+                            } | undefined;
+                            sse?: {
+                                op: "remove";
+                            } | {
+                                op: "set";
+                                value: {
+                                    url: string;
+                                    authMode?: import('@endge/core').EndgeSSEAuthMode | undefined;
+                                    authProfileIdentity?: string | null | undefined;
+                                    manualToken?: string | null | undefined;
+                                };
+                            } | undefined;
+                            locales?: {
+                                entries: ({
+                                    key: string;
+                                    op: "remove";
+                                } | {
+                                    key: string;
+                                    op: "upsert";
+                                    value: {
+                                        code: string;
+                                        displayName: string;
+                                        shortLabel: string;
+                                        direction?: "ltr" | "rtl" | undefined;
+                                    };
+                                })[];
+                            } | undefined;
+                            defaultLocale?: {
+                                op: "remove";
+                            } | {
+                                op: "set";
+                                value: string;
+                            } | undefined;
+                            fallbackLocale?: {
+                                op: "remove";
+                            } | {
+                                op: "set";
+                                value: string;
+                            } | undefined;
+                            themes?: {
+                                entries: ({
+                                    key: string;
+                                    op: "remove";
+                                } | {
+                                    key: string;
+                                    op: "upsert";
+                                    value: {
+                                        identity: string;
+                                        displayName: string;
+                                    };
+                                })[];
+                            } | undefined;
+                            defaultTheme?: {
+                                op: "remove";
+                            } | {
+                                op: "set";
+                                value: string;
+                            } | undefined;
+                            defaultAuthProfileIdentity?: {
+                                op: "remove";
+                            } | {
+                                op: "set";
+                                value: string;
+                            } | undefined;
+                            sfcAdapterIds?: {
+                                entries: ({
+                                    key: string;
+                                    op: "remove";
+                                } | {
+                                    key: string;
+                                    op: "upsert";
+                                    value: string;
+                                })[];
+                            } | undefined;
+                            defaultSfcAdapterId?: {
+                                op: "remove";
+                            } | {
+                                op: "set";
+                                value: string;
+                            } | undefined;
+                            diagnostics?: {
+                                telemetry?: {
+                                    collection?: {
+                                        enabled?: {
+                                            op: "remove";
+                                        } | {
+                                            op: "set";
+                                            value: boolean;
+                                        } | undefined;
+                                        signals?: {
+                                            entries: ({
+                                                key: string;
+                                                op: "remove";
+                                            } | {
+                                                key: string;
+                                                op: "upsert";
+                                                value: import('@endge/core').DiagnosticsSignal;
+                                            })[];
+                                        } | undefined;
+                                        minSeverity?: {
+                                            op: "remove";
+                                        } | {
+                                            op: "set";
+                                            value: import('@endge/core').DiagnosticsSeverityNumber;
+                                        } | undefined;
+                                        maxRecords?: {
+                                            op: "remove";
+                                        } | {
+                                            op: "set";
+                                            value: number;
+                                        } | undefined;
+                                    } | undefined;
+                                    outputs?: {
+                                        entries: ({
+                                            key: string;
+                                            op: "remove";
+                                        } | {
+                                            key: string;
+                                            op: "upsert";
+                                            value: {
+                                                id: string;
+                                                name: string;
+                                                enabled: boolean;
+                                                adapterType: string;
+                                                options: Record<string, import('@endge/core').DiagnosticsAdapterOptionValue>;
+                                            };
+                                        })[];
+                                    } | undefined;
+                                    routes?: {
+                                        entries: ({
+                                            key: string;
+                                            op: "remove";
+                                        } | {
+                                            key: string;
+                                            op: "upsert";
+                                            value: {
+                                                id: string;
+                                                name: string;
+                                                enabled: boolean;
+                                                match: {
+                                                    signals?: import('@endge/core').DiagnosticsSignal[] | undefined;
+                                                    phases?: import('@endge/core').DiagnosticsPhase[] | undefined;
+                                                    minSeverity?: import('@endge/core').DiagnosticsSeverityNumber | undefined;
+                                                    spanStatuses?: import('@endge/core').DiagnosticsSpanStatus["code"][] | undefined;
+                                                    minDurationMs?: number | undefined;
+                                                    scopes?: string[] | undefined;
+                                                    eventNames?: string[] | undefined;
+                                                    traceId?: string | undefined;
+                                                    spanId?: string | undefined;
+                                                    attributes?: import('@endge/core').DiagnosticsAttributes | undefined;
+                                                    limit?: number | undefined;
+                                                };
+                                                outputId: string;
+                                            };
+                                        })[];
+                                    } | undefined;
+                                } | undefined;
+                                snapshots?: {
+                                    content?: {
+                                        telemetry?: {
+                                            op: "remove";
+                                        } | {
+                                            op: "set";
+                                            value: boolean;
+                                        } | undefined;
+                                        problems?: {
+                                            op: "remove";
+                                        } | {
+                                            op: "set";
+                                            value: boolean;
+                                        } | undefined;
+                                        configuration?: {
+                                            op: "remove";
+                                        } | {
+                                            op: "set";
+                                            value: boolean;
+                                        } | undefined;
+                                    } | undefined;
+                                    automatic?: {
+                                        enabled?: {
+                                            op: "remove";
+                                        } | {
+                                            op: "set";
+                                            value: boolean;
+                                        } | undefined;
+                                        errorCount?: {
+                                            op: "remove";
+                                        } | {
+                                            op: "set";
+                                            value: number;
+                                        } | undefined;
+                                        windowSeconds?: {
+                                            op: "remove";
+                                        } | {
+                                            op: "set";
+                                            value: number;
+                                        } | undefined;
+                                        cooldownSeconds?: {
+                                            op: "remove";
+                                        } | {
+                                            op: "set";
+                                            value: number;
+                                        } | undefined;
+                                        outputIds?: {
+                                            entries: ({
+                                                key: string;
+                                                op: "remove";
+                                            } | {
+                                                key: string;
+                                                op: "upsert";
+                                                value: string;
+                                            })[];
+                                        } | undefined;
+                                    } | undefined;
+                                } | undefined;
+                            } | undefined;
+                        };
+                    } | {
+                        mode: "replace";
+                        value: {
+                            vars: {
+                                name: string;
+                                defaultValue: string;
+                            }[];
+                            sse?: {
+                                url: string;
+                                authMode?: import('@endge/core').EndgeSSEAuthMode | undefined;
+                                authProfileIdentity?: string | null | undefined;
+                                manualToken?: string | null | undefined;
+                            } | undefined;
+                            locales: {
+                                code: string;
+                                displayName: string;
+                                shortLabel: string;
+                                direction?: "ltr" | "rtl" | undefined;
+                            }[];
+                            defaultLocale: string;
+                            fallbackLocale: string;
+                            themes: {
+                                identity: string;
+                                displayName: string;
+                            }[];
+                            defaultTheme: string;
+                            defaultAuthProfileIdentity: string | null;
+                            sfcAdapterIds: string[];
+                            defaultSfcAdapterId: string;
+                            diagnostics: {
+                                telemetry: {
+                                    collection: {
+                                        enabled: boolean;
+                                        signals: import('@endge/core').DiagnosticsSignal[];
+                                        minSeverity: import('@endge/core').DiagnosticsSeverityNumber;
+                                        maxRecords: number;
+                                    };
+                                    outputs: {
+                                        id: string;
+                                        name: string;
+                                        enabled: boolean;
+                                        adapterType: string;
+                                        options: Record<string, import('@endge/core').DiagnosticsAdapterOptionValue>;
+                                    }[];
+                                    routes: {
+                                        id: string;
+                                        name: string;
+                                        enabled: boolean;
+                                        match: {
+                                            signals?: import('@endge/core').DiagnosticsSignal[] | undefined;
+                                            phases?: import('@endge/core').DiagnosticsPhase[] | undefined;
+                                            minSeverity?: import('@endge/core').DiagnosticsSeverityNumber | undefined;
+                                            spanStatuses?: import('@endge/core').DiagnosticsSpanStatus["code"][] | undefined;
+                                            minDurationMs?: number | undefined;
+                                            scopes?: string[] | undefined;
+                                            eventNames?: string[] | undefined;
+                                            traceId?: string | undefined;
+                                            spanId?: string | undefined;
+                                            attributes?: import('@endge/core').DiagnosticsAttributes | undefined;
+                                            limit?: number | undefined;
+                                        };
+                                        outputId: string;
+                                    }[];
+                                };
+                                snapshots: {
+                                    content: {
+                                        telemetry: boolean;
+                                        problems: boolean;
+                                        configuration: boolean;
+                                    };
+                                    automatic: {
+                                        enabled: boolean;
+                                        errorCount: number;
+                                        windowSeconds: number;
+                                        cooldownSeconds: number;
+                                        outputIds: string[];
+                                    };
+                                };
+                            };
+                        };
+                    };
+                    description: string | null;
+                    slug?: string | null | undefined;
+                    order?: number | null | undefined;
+                    navigationId?: number | null | undefined;
+                    allowedEnvironmentIds: number[];
+                    toPlain: () => any;
+                    getDiagnosticProblems: () => import('@endge/core').DiagnosticsProblemInput[];
+                    id: number;
+                    identity: string;
+                    displayName: string;
+                    name: string;
+                    folderId?: string | number | null | undefined;
+                    managedBy: import('@endge/core').ManagedBy;
+                    origin: {
+                        kind: "storage";
+                    } | {
+                        kind: "builtin";
+                        owner: string;
+                    } | {
+                        kind: "local";
+                        owner: string;
+                    } | {
+                        kind: "derived";
+                        source: {
+                            type: string;
+                            identity: string;
+                        };
+                    };
+                    managedById: string | null;
+                    isTemporary: boolean;
+                    meta: Record<string, unknown>;
+                    createdAt?: string | undefined;
+                    updatedAt?: string | undefined;
+                    deletedAt?: string | null | undefined;
+                    author?: string | null | undefined;
+                    active?: boolean | null | undefined;
+                    applyEntityMeta: (raw: unknown) => void;
+                    applyStorageMeta: (raw: any) => void;
+                    applyManagement: (raw: import('@endge/core').EntityManagement | Record<string, unknown> | null | undefined) => void;
+                    compile: () => void;
+                    duplicate: (_options: import('@endge/core').DuplicateOptions) => import('@endge/core').REntity;
+                } | {
+                    type: import('@endge/core').QueryType;
+                    source: string;
+                    sourceVersion: number;
+                    run: (props?: Record<string, unknown>) => Promise<any>;
+                    id: number;
+                    identity: string;
+                    displayName: string;
+                    name: string;
+                    description: string | null;
+                    folderId?: string | number | null | undefined;
+                    managedBy: import('@endge/core').ManagedBy;
+                    origin: {
+                        kind: "storage";
+                    } | {
+                        kind: "builtin";
+                        owner: string;
+                    } | {
+                        kind: "local";
+                        owner: string;
+                    } | {
+                        kind: "derived";
+                        source: {
+                            type: string;
+                            identity: string;
+                        };
+                    };
+                    managedById: string | null;
+                    isTemporary: boolean;
+                    meta: Record<string, unknown>;
+                    createdAt?: string | undefined;
+                    updatedAt?: string | undefined;
+                    deletedAt?: string | null | undefined;
+                    author?: string | null | undefined;
+                    active?: boolean | null | undefined;
+                    applyEntityMeta: (raw: unknown) => void;
+                    applyStorageMeta: (raw: any) => void;
+                    applyManagement: (raw: import('@endge/core').EntityManagement | Record<string, unknown> | null | undefined) => void;
+                    getDiagnosticProblems: () => import('@endge/core').DiagnosticsProblemInput[];
+                    compile: () => void;
+                    duplicate: (_options: import('@endge/core').DuplicateOptions) => import('@endge/core').REntity;
+                } | {
+                    kind: string;
+                    type: import("@endge/core").ComponentType.SFC;
+                    source: string;
+                    tag: string | null;
+                    getSource: () => string;
+                    setSource: (source: string) => void;
+                    setSourceParts: (parts: import('@endge/core').RComponentSFCSource_Parts) => void;
+                    duplicate: (options: import('@endge/core').DuplicateOptions) => import('@endge/core').RComponentSFC;
+                    toPlain: () => Record<string, unknown>;
+                    sourceKind: import('@endge/core').RComponentSourceKind;
+                    modelVersion: number;
+                    supportedTargets: import('@endge/core').RComponentRenderTarget[];
+                    supportsTarget: (target: import('@endge/core').RComponentRenderTarget) => boolean;
+                    id: number;
+                    identity: string;
+                    displayName: string;
+                    name: string;
+                    description: string | null;
+                    folderId?: string | number | null | undefined;
+                    managedBy: import('@endge/core').ManagedBy;
+                    origin: {
+                        kind: "storage";
+                    } | {
+                        kind: "builtin";
+                        owner: string;
+                    } | {
+                        kind: "local";
+                        owner: string;
+                    } | {
+                        kind: "derived";
+                        source: {
+                            type: string;
+                            identity: string;
+                        };
+                    };
+                    managedById: string | null;
+                    isTemporary: boolean;
+                    meta: Record<string, unknown>;
+                    createdAt?: string | undefined;
+                    updatedAt?: string | undefined;
+                    deletedAt?: string | null | undefined;
+                    author?: string | null | undefined;
+                    active?: boolean | null | undefined;
+                    applyEntityMeta: (raw: unknown) => void;
+                    applyStorageMeta: (raw: any) => void;
+                    applyManagement: (raw: import('@endge/core').EntityManagement | Record<string, unknown> | null | undefined) => void;
+                    getDiagnosticProblems: () => import('@endge/core').DiagnosticsProblemInput[];
+                    compile: () => void;
+                } | {
+                    definition: {
+                        version: number;
+                        entrypoint: string;
+                        nodes: {
+                            id: string;
+                            title: string;
+                            blockId: string;
+                            kind: import('@endge/core').EndgeFlowNodeKind;
+                            params?: import('@endge/core').EndgeFlowNodeParams | undefined;
+                            meta?: Record<string, unknown> | undefined;
+                        }[];
+                        edges: {
+                            id: string;
+                            sourceNodeId: string;
+                            sourcePortId: string;
+                            targetNodeId: string;
+                            targetPortId: string;
+                            label?: string | null | undefined;
+                        }[];
+                    };
+                    input: {
+                        name: string;
+                        type: string;
+                        isArray: boolean;
+                        optional: boolean;
+                        params?: (Map<string, /*elided*/ any> & Omit<Map<string, import('@endge/core').RField>, keyof Map<any, any>>) | undefined;
+                        isMethod: () => boolean;
+                    } | null;
+                    output: {
+                        name: string;
+                        type: string;
+                        isArray: boolean;
+                        optional: boolean;
+                        params?: (Map<string, /*elided*/ any> & Omit<Map<string, import('@endge/core').RField>, keyof Map<any, any>>) | undefined;
+                        isMethod: () => boolean;
+                    } | null;
+                    target: {
+                        type: string;
+                        identity?: string | undefined;
+                    }[] | null;
+                    defaultImplementation: {
+                        kind: "flow";
+                    } | {
+                        kind: "provider";
+                        providerKey: string;
+                    } | {
+                        kind: "component-port";
+                        portName: string;
+                    };
+                    owner?: {
+                        type: string;
+                        identity: string;
+                    } | undefined;
+                    setStepHandler: (runtimeId: string, fn: import('@endge/core').ActionStepHandler | undefined) => void;
+                    getStepHandler: (runtimeId: string) => import('@endge/core').ActionStepHandler | undefined;
+                    hasStepHandler: (runtimeId: string) => boolean;
+                    clearStepHandlers: () => void;
+                    readonly compiledFlow: {
+                        flow: {
+                            version: number;
+                            entrypoint: string;
+                            nodes: {
+                                id: string;
+                                title: string;
+                                blockId: string;
+                                kind: import('@endge/core').EndgeFlowNodeKind;
+                                params?: import('@endge/core').EndgeFlowNodeParams | undefined;
+                                meta?: Record<string, unknown> | undefined;
+                            }[];
+                            edges: {
+                                id: string;
+                                sourceNodeId: string;
+                                sourcePortId: string;
+                                targetNodeId: string;
+                                targetPortId: string;
+                                label?: string | null | undefined;
+                            }[];
+                        };
+                        nodesById: Map<string, {
+                            id: string;
+                            title: string;
+                            blockId: string;
+                            kind: import('@endge/core').EndgeFlowNodeKind;
+                            params?: import('@endge/core').EndgeFlowNodeParams | undefined;
+                            meta?: Record<string, unknown> | undefined;
+                        }> & Omit<Map<string, import('@endge/core').EndgeFlowNodeDefinition>, keyof Map<any, any>>;
+                        nodeIdByBlockId: Map<string, string> & Omit<Map<string, string>, keyof Map<any, any>>;
+                        outgoingByNodeId: Map<string, {
+                            id: string;
+                            sourceNodeId: string;
+                            sourcePortId: string;
+                            targetNodeId: string;
+                            targetPortId: string;
+                            label?: string | null | undefined;
+                        }[]> & Omit<Map<string, import('@endge/core').EndgeFlowEdgeDefinition[]>, keyof Map<any, any>>;
+                        incomingByNodeId: Map<string, {
+                            id: string;
+                            sourceNodeId: string;
+                            sourcePortId: string;
+                            targetNodeId: string;
+                            targetPortId: string;
+                            label?: string | null | undefined;
+                        }[]> & Omit<Map<string, import('@endge/core').EndgeFlowEdgeDefinition[]>, keyof Map<any, any>>;
+                        runtimeNodeIdByRuntimeId: Map<string, string> & Omit<Map<string, string>, keyof Map<any, any>>;
+                        reachableNodeIds: string[];
+                        issues: {
+                            code: string;
+                            message: string;
+                            nodeId?: string | undefined;
+                            edgeId?: string | undefined;
+                        }[];
+                    } | null;
+                    getValidationIssues: () => import('@endge/core').FlowValidationIssue[];
+                    validate: () => import('@endge/core').FlowValidationIssue[];
+                    getCompiledRuntimeNodeId: (runtimeId: string) => string | null;
+                    buildCompiledFlow: () => import('@endge/core').ActionCompiledFlow;
+                    compile: () => void;
+                    run: () => Promise<unknown>;
+                    toPlain: () => Record<string, unknown>;
+                    duplicate: (options: import('@endge/core').DuplicateOptions) => import('@endge/core').RAction;
+                    id: number;
+                    identity: string;
+                    displayName: string;
+                    name: string;
+                    description: string | null;
+                    folderId?: string | number | null | undefined;
+                    managedBy: import('@endge/core').ManagedBy;
+                    origin: {
+                        kind: "storage";
+                    } | {
+                        kind: "builtin";
+                        owner: string;
+                    } | {
+                        kind: "local";
+                        owner: string;
+                    } | {
+                        kind: "derived";
+                        source: {
+                            type: string;
+                            identity: string;
+                        };
+                    };
+                    managedById: string | null;
+                    isTemporary: boolean;
+                    meta: Record<string, unknown>;
+                    createdAt?: string | undefined;
+                    updatedAt?: string | undefined;
+                    deletedAt?: string | null | undefined;
+                    author?: string | null | undefined;
+                    active?: boolean | null | undefined;
+                    applyEntityMeta: (raw: unknown) => void;
+                    applyStorageMeta: (raw: any) => void;
+                    applyManagement: (raw: import('@endge/core').EntityManagement | Record<string, unknown> | null | undefined) => void;
+                    getDiagnosticProblems: () => import('@endge/core').DiagnosticsProblemInput[];
+                } | {
+                    description: string | null;
+                    routeName: string | null;
+                    routePath: string | null;
+                    templateId: number | null;
+                    enabled: boolean;
+                    areas: {
+                        slotId: string;
+                        blocks?: {
+                            key: string;
+                            entityType?: string | null | undefined;
+                            entityId?: number | null | undefined;
+                            entityIdentity?: string | null | undefined;
+                            titleOverride?: string | null | undefined;
+                            visibleWhen?: string | null | undefined;
+                            props?: (Record<string, unknown> | null) | undefined;
+                        }[] | undefined;
+                    }[];
+                    readonly type: import('@endge/core').DomainDocumentType;
+                    toPlain: () => import('@endge/core').RPageSchema;
+                    duplicate: (options: import('@endge/core').DuplicateOptions) => RPage;
+                    id: number;
+                    identity: string;
+                    displayName: string;
+                    name: string;
+                    folderId?: string | number | null | undefined;
+                    managedBy: import('@endge/core').ManagedBy;
+                    origin: {
+                        kind: "storage";
+                    } | {
+                        kind: "builtin";
+                        owner: string;
+                    } | {
+                        kind: "local";
+                        owner: string;
+                    } | {
+                        kind: "derived";
+                        source: {
+                            type: string;
+                            identity: string;
+                        };
+                    };
+                    managedById: string | null;
+                    isTemporary: boolean;
+                    meta: Record<string, unknown>;
+                    createdAt?: string | undefined;
+                    updatedAt?: string | undefined;
+                    deletedAt?: string | null | undefined;
+                    author?: string | null | undefined;
+                    active?: boolean | null | undefined;
+                    applyEntityMeta: (raw: unknown) => void;
+                    applyStorageMeta: (raw: any) => void;
+                    applyManagement: (raw: import('@endge/core').EntityManagement | Record<string, unknown> | null | undefined) => void;
+                    getDiagnosticProblems: () => import('@endge/core').DiagnosticsProblemInput[];
+                    compile: () => void;
+                } | {
+                    displayName: string;
+                    fields: {
+                        key: string;
+                        label?: string | undefined;
+                        mode: import('@endge/core').FilterFieldMode;
+                        staticOptions?: {
+                            value: string;
+                            label?: string | undefined;
+                        }[] | undefined;
+                        vocabIdentity?: string | undefined;
+                        vocabCollection?: string | undefined;
+                        valuePath?: string | undefined;
+                        displayNamePath?: string | undefined;
+                        multiple?: boolean | undefined;
+                        converterIdentities?: string[] | undefined;
+                        defaultValue?: string | undefined;
+                        active?: boolean | undefined;
+                    }[];
+                    source: string;
+                    sourceVersion: number;
+                    readonly type: import('@endge/core').DomainDocumentType;
+                    toPlain: () => import('@endge/core').RFilterSchema;
+                    id: number;
+                    identity: string;
+                    name: string;
+                    description: string | null;
+                    folderId?: string | number | null | undefined;
+                    managedBy: import('@endge/core').ManagedBy;
+                    origin: {
+                        kind: "storage";
+                    } | {
+                        kind: "builtin";
+                        owner: string;
+                    } | {
+                        kind: "local";
+                        owner: string;
+                    } | {
+                        kind: "derived";
+                        source: {
+                            type: string;
+                            identity: string;
+                        };
+                    };
+                    managedById: string | null;
+                    isTemporary: boolean;
+                    meta: Record<string, unknown>;
+                    createdAt?: string | undefined;
+                    updatedAt?: string | undefined;
+                    deletedAt?: string | null | undefined;
+                    author?: string | null | undefined;
+                    active?: boolean | null | undefined;
+                    applyEntityMeta: (raw: unknown) => void;
+                    applyStorageMeta: (raw: any) => void;
+                    applyManagement: (raw: import('@endge/core').EntityManagement | Record<string, unknown> | null | undefined) => void;
+                    getDiagnosticProblems: () => import('@endge/core').DiagnosticsProblemInput[];
+                    compile: () => void;
+                    duplicate: (_options: import('@endge/core').DuplicateOptions) => import('@endge/core').REntity;
+                } | {
+                    readonly type: "composition";
+                    description: string | null;
+                    kind: import('@endge/core').RCompositionKind;
+                    kindIdentity: string | null;
+                    source: string;
+                    sourceVersion: number;
+                    duplicate: (options: import('@endge/core').DuplicateOptions) => import('@endge/core').RComposition;
+                    id: number;
+                    identity: string;
+                    displayName: string;
+                    name: string;
+                    folderId?: string | number | null | undefined;
+                    managedBy: import('@endge/core').ManagedBy;
+                    origin: {
+                        kind: "storage";
+                    } | {
+                        kind: "builtin";
+                        owner: string;
+                    } | {
+                        kind: "local";
+                        owner: string;
+                    } | {
+                        kind: "derived";
+                        source: {
+                            type: string;
+                            identity: string;
+                        };
+                    };
+                    managedById: string | null;
+                    isTemporary: boolean;
+                    meta: Record<string, unknown>;
+                    createdAt?: string | undefined;
+                    updatedAt?: string | undefined;
+                    deletedAt?: string | null | undefined;
+                    author?: string | null | undefined;
+                    active?: boolean | null | undefined;
+                    applyEntityMeta: (raw: unknown) => void;
+                    applyStorageMeta: (raw: any) => void;
+                    applyManagement: (raw: import('@endge/core').EntityManagement | Record<string, unknown> | null | undefined) => void;
+                    getDiagnosticProblems: () => import('@endge/core').DiagnosticsProblemInput[];
+                    compile: () => void;
+                } | {
+                    description: string | null;
+                    source: string;
+                    sourceVersion: number;
+                    duplicate: (options: import('@endge/core').DuplicateOptions) => import('@endge/core').RStore;
+                    id: number;
+                    identity: string;
+                    displayName: string;
+                    name: string;
+                    folderId?: string | number | null | undefined;
+                    managedBy: import('@endge/core').ManagedBy;
+                    origin: {
+                        kind: "storage";
+                    } | {
+                        kind: "builtin";
+                        owner: string;
+                    } | {
+                        kind: "local";
+                        owner: string;
+                    } | {
+                        kind: "derived";
+                        source: {
+                            type: string;
+                            identity: string;
+                        };
+                    };
+                    managedById: string | null;
+                    isTemporary: boolean;
+                    meta: Record<string, unknown>;
+                    createdAt?: string | undefined;
+                    updatedAt?: string | undefined;
+                    deletedAt?: string | null | undefined;
+                    author?: string | null | undefined;
+                    active?: boolean | null | undefined;
+                    applyEntityMeta: (raw: unknown) => void;
+                    applyStorageMeta: (raw: any) => void;
+                    applyManagement: (raw: import('@endge/core').EntityManagement | Record<string, unknown> | null | undefined) => void;
+                    getDiagnosticProblems: () => import('@endge/core').DiagnosticsProblemInput[];
+                    compile: () => void;
+                };
+                readonly entityIdentity: string;
+                readonly title: string;
+                status: import('@endge/core').RuntimeHostStatus;
+                readonly createdAt: number;
+                updatedAt: number;
+                readonly resources: {
+                    id: string;
+                    kind: import('@endge/core').RuntimeHostResourceKind;
+                    title: string;
+                    subtitle?: string | undefined;
+                    payload?: Record<string, unknown> | undefined;
+                }[];
+                readonly channels: {
+                    id: string;
+                    kind: import('@endge/core').RuntimeHostChannelKind;
+                    name: string;
+                    direction: "in" | "out" | "both";
+                    subtitle?: string | undefined;
+                }[];
+                readonly meta: Record<string, unknown>;
+                context: {
+                    instance: string;
+                    lastStateChangeAt: string | null;
+                    status: "idle" | "running" | "success" | "error";
+                    startedAt: string | null;
+                    updatedAt: string | null;
+                } | {
+                    target: "dom" | "canvas" | null;
+                    lastParseAt: string | null;
+                    lastCompileAt: string | null;
+                    lastRenderAt: string | null;
+                    status: "idle" | "running" | "success" | "error";
+                    startedAt: string | null;
+                    updatedAt: string | null;
+                } | {
+                    lastStateChangeAt: string | null;
+                    writableFields: string[];
+                    derivedFields: string[];
+                    status: "idle" | "running" | "success" | "error";
+                    startedAt: string | null;
+                    updatedAt: string | null;
+                } | {
+                    input: Record<string, unknown>;
+                    flowState: {
+                        input: Record<string, unknown>;
+                        steps: Record<string, Record<string, unknown>>;
+                        locals: Record<string, unknown>;
+                        globals: Record<string, unknown>;
+                        lastStep: Record<string, unknown> | null;
+                    };
+                    currentNodeId: string | null;
+                    callStack: string[];
+                    lastFlowResult: {
+                        ok: boolean;
+                        state: {
+                            input: Record<string, unknown>;
+                            steps: Record<string, Record<string, unknown>>;
+                            locals: Record<string, unknown>;
+                            globals: Record<string, unknown>;
+                            lastStep: Record<string, unknown> | null;
+                        };
+                        issues: {
+                            code: string;
+                            message: string;
+                            nodeId?: string | undefined;
+                            edgeId?: string | undefined;
+                        }[];
+                    } | null;
+                    parent?: /*elided*/ any | null | undefined;
+                    status: "idle" | "running" | "success" | "error";
+                    startedAt: string | null;
+                    updatedAt: string | null;
+                } | {
+                    lastFilterChangeAt: string | null;
+                    status: "idle" | "running" | "success" | "error";
+                    startedAt: string | null;
+                    updatedAt: string | null;
+                } | {
+                    mountedChildren: number;
+                    lastHookAt: string | null;
+                    status: "idle" | "running" | "success" | "error";
+                    startedAt: string | null;
+                    updatedAt: string | null;
+                } | {
+                    lastRefreshAt: string | null;
+                    status: "idle" | "running" | "success" | "error";
+                    startedAt: string | null;
+                    updatedAt: string | null;
+                } | {
+                    lastRenderAt: string | null;
+                    status: "idle" | "running" | "success" | "error";
+                    startedAt: string | null;
+                    updatedAt: string | null;
+                };
+                readonly runtimeState: {
+                    readonly runtimeId: string;
+                    readonly storageId: string;
+                    readonly storageKey: string;
+                    readonly scope: {
+                        workspaceId: string;
+                        tenantId: string;
+                        projectId: string;
+                        environmentId: string;
+                        userId: string;
+                    };
+                    get: <T>(entityKey: string, section: string, fallback: T) => T;
+                    set: <T>(entityKey: string, section: string, value: T) => void;
+                    remove: (entityKey: string, section?: string) => void;
+                    clear: () => void;
+                } | null;
+                readonly node: {
+                    addChild: (node: import('@endge/raph').RaphNode<any>, options?: {
+                        invalidate?: boolean;
+                    }) => boolean;
+                    remove: () => void;
+                    addMeta: (key: string, value: unknown) => void;
+                    options: (opts: Partial<import('@endge/raph').RaphProperties> & {
+                        id?: string;
+                        weight?: number;
+                        meta?: Record<string, unknown>;
+                        type?: string;
+                    }) => import('@endge/raph').RaphNode<import('@endge/raph').RaphProperties>;
+                    get: <K extends string>(key: K) => import('@endge/raph').RaphProperties[K];
+                    set: <K extends string>(key: K, value: import('@endge/raph').RaphProperties[K]) => void;
+                    getLocal: <K extends string>(key: K) => import('@endge/raph').RaphProperties[K];
+                    setLocal: <K extends string>(key: K, value: import('@endge/raph').RaphProperties[K]) => void;
+                    dirty: (phase: import('@endge/raph').PhaseName | string | Array<import('@endge/raph').PhaseName | string>) => void;
+                    traverseAll: (cb: (node: import('@endge/raph').RaphNode<any>) => void) => void;
+                    dispose: () => void;
+                    _attachApp: (app: import('@endge/raph').RaphRuntime<any>) => void;
+                    hasDirtyPhase: (bit: number) => boolean;
+                    markDirtyPhase: (bit: number) => void;
+                    clearDirtyPhase: (bit: number) => void;
+                    readonly app: {
+                        readonly id: string;
+                        options: (opts: Partial<import('@endge/raph').RaphOptions>) => void;
+                        derive: <TSource = unknown, TTarget = unknown>(options: import('@endge/raph').RaphDerivedOptions<TSource, TTarget>) => import('@endge/raph').RaphDerivedHandle;
+                        transaction: (fn: () => void) => void;
+                        getDerivedSnapshot: () => import('@endge/raph').RaphDerivedManagerSnapshot;
+                        definePhases: (phases: Array<import('@endge/raph').RaphPhase>) => void;
+                        addPhase: (phase: import('@endge/raph').RaphPhase) => void;
+                        clearPhases: () => void;
+                        reinitPhases: () => void;
+                        getNode: (id: string) => import('@endge/raph').RaphNode<import('@endge/raph').RaphProperties> | undefined;
+                        addNode: (node: import('@endge/raph').RaphNode<import('@endge/raph').RaphProperties>) => void;
+                        registerNode: (node: import('@endge/raph').RaphNode<any>) => void;
+                        removeNode: (node: import('@endge/raph').RaphNode<any>) => void;
+                        unregisterNode: (node: import('@endge/raph').RaphNode<any>) => void;
+                        addDependency: (parent: import('@endge/raph').RaphNode<any>, child: import('@endge/raph').RaphNode<any>) => boolean;
+                        removeDependency: (parent: import('@endge/raph').RaphNode<any>, child: import('@endge/raph').RaphNode<any>) => void;
+                        init: () => void;
+                        clear: () => void;
+                        destroy: () => void;
+                        traverseAll: (cb: (node: import('@endge/raph').RaphNode<import('@endge/raph').RaphProperties>) => void) => void;
+                        addLocalPhase: (phase: import('@endge/raph').RaphLocalPhaseRuntime<import('@endge/raph').RaphProperties>) => void;
+                        addLocalProperty: <K extends string>(property: import('@endge/raph').RaphLocalPropertyRuntime<import('@endge/raph').RaphProperties, K>) => void;
+                        getLocalProperty: <K extends string>(key: K) => import('@endge/raph').RaphLocalPropertyRuntime<import('@endge/raph').RaphProperties, K> | undefined;
+                        dirtyLocalNodeDefaults: (node: import('@endge/raph').RaphNode<any>, invalidate?: boolean) => void;
+                        setScheduler: (mode: import('@endge/raph').RaphSchedulerType) => void;
+                        notify: (path: import('@endge/raph').DataPathDef, opts?: {
+                            invalidate?: boolean;
+                            vars?: Record<string, any>;
+                        }) => boolean;
+                        observeData: (node: import('@endge/raph').RaphNode<any>, mask: import('@endge/raph').DataPathDef, options: import('@endge/raph').RaphObserveDataOptions) => () => void;
+                        enqueueDataObserver: (observer: import('@endge/raph').RaphDataObserver<any>, path: import('@endge/raph').DataPathDef, opts?: {
+                            invalidate?: boolean;
+                            vars?: Record<string, any>;
+                        }) => boolean;
+                        dirty: (phase: import('@endge/raph').PhaseName | string, node: import('@endge/raph').RaphNode<any>, opts?: {
+                            invalidate: boolean;
+                            event?: import('@endge/raph').PhaseEvent;
+                        }) => void;
+                        run: () => void;
+                        get: (path: import('@endge/raph').DataPathDef, opts?: {
+                            vars?: Record<string, any>;
+                        }) => import('@endge/raph').Undefinable<unknown>;
+                        set: (path: import('@endge/raph').DataPathDef, value: unknown, opts?: {
+                            invalidate?: boolean;
+                            vars?: Record<string, any>;
+                        }) => void;
+                        merge: (path: import('@endge/raph').DataPathDef, value: unknown, opts?: {
+                            invalidate?: boolean;
+                            vars?: Record<string, any>;
+                        }) => void;
+                        delete: (path: import('@endge/raph').DataPathDef, opts?: {
+                            invalidate?: boolean;
+                            vars?: Record<string, any>;
+                        }) => void;
+                        startLoop: () => void;
+                        acquireLoop: (owner: string) => import('@endge/raph').RaphLoopLease;
+                        stopLoop: () => void;
+                        invalidate: () => void;
+                        reset: () => void;
+                        subscribe: (ownerNode: import('@endge/raph').RaphNode<any>, maskOrMasks: import('@endge/raph').DataPathDef | Array<import('@endge/raph').DataPathDef>, callback: import('@endge/raph').ControlFlowCallback, opts?: import('@endge/raph').ControlFlowSubscribeOptions) => () => void;
+                        unsubscribe: (subscriptionId: import('@endge/raph').ControlFlowSubscriptionId) => void;
+                        unsubscribeOwner: (ownerNode: import('@endge/raph').RaphNode<any>) => void;
+                        track: (node: import('@endge/raph').RaphNode<any>, mask: import('@endge/raph').DataPathDef, opts?: {
+                            vars?: Record<string, any>;
+                            wildcardDynamic?: boolean;
+                        }) => void;
+                        untrack: (node: import('@endge/raph').RaphNode<any>, mask?: import('@endge/raph').DataPathDef) => void;
+                        priorityOf: (node: import('@endge/raph').RaphNode<any>) => number;
+                        readonly data: import('@endge/raph').DataObject;
+                        readonly graph: {
+                            addNode: (node: import('@endge/raph').RaphNode<any>) => void;
+                            removeNode: (nodeOrId: string | import('@endge/raph').RaphNode<any>) => void;
+                            hasNode: (nodeOrId: string | import('@endge/raph').RaphNode<any>) => boolean;
+                            getNode: (id: string) => import('@endge/raph').RaphNode<any> | undefined;
+                            size: () => number;
+                            addEdge: (parent: string | import('@endge/raph').RaphNode<any>, child: string | import('@endge/raph').RaphNode<any>) => boolean;
+                            removeEdge: (parent: string | import('@endge/raph').RaphNode<any>, child: string | import('@endge/raph').RaphNode<any>) => void;
+                            parentsOf: (nodeOrId: string | import('@endge/raph').RaphNode<any>) => ReadonlySet<import('@endge/raph').RaphNode<any>>;
+                            childrenOf: (nodeOrId: string | import('@endge/raph').RaphNode<any>) => ReadonlySet<import('@endge/raph').RaphNode<any>>;
+                            rootIds: () => ReadonlySet<string>;
+                            roots: () => ReadonlySet<import('@endge/raph').RaphNode<any>>;
+                            getDepth: (nodeOrId: string | import('@endge/raph').RaphNode<any>) => number;
+                            topoOrder: () => import('@endge/raph').RaphNode<any>[];
+                            expandByTraversal: (base: Set<import('@endge/raph').RaphNode<any>> | null, traversal: "dirty-only" | "dirty-and-down" | "dirty-and-up" | "all") => Set<import('@endge/raph').RaphNode<any>>;
+                        };
+                        readonly loopEnabled: boolean;
+                        readonly frame: {
+                            now: number;
+                            delta: number;
+                            elapsed: number;
+                            frame: number;
+                        };
+                        readonly ups: number;
+                        readonly eps: number;
+                        readonly nps: number;
+                        readonly maxUps: number;
+                        readonly minUpdateInterval: number;
+                        readonly dataAdapter: {
+                            root: () => import('@endge/raph').DataObject;
+                            get: (path: import('@endge/raph').DataPathDef, opts?: {
+                                vars?: Record<string, any>;
+                            }) => import('@endge/raph').Undefinable<unknown>;
+                            set: (path: import('@endge/raph').DataPathDef, value: unknown, opts?: {
+                                vars?: Record<string, any>;
+                            }) => void;
+                            delete: (path: import('@endge/raph').DataPathDef, opts?: {
+                                vars?: Record<string, any>;
+                            }) => void;
+                            merge: (path: import('@endge/raph').DataPathDef, value: unknown, opts?: {
+                                vars?: Record<string, any>;
+                            }) => void;
+                            indexOf: (path: import('@endge/raph').DataPathDef, opts?: {
+                                vars?: Record<string, any>;
+                            }) => number;
+                        };
+                        readonly kernel: {
+                            readonly id: string;
+                            createRuntime: <Props extends import('@endge/raph').RaphProperties = import('@endge/raph').RaphProperties>(options?: import('@endge/raph').RaphRuntimeOptions) => import('@endge/raph').RaphRuntime<Props>;
+                            registerRuntime: (runtime: import('@endge/raph').RaphRuntime<any>) => void;
+                            unregisterRuntime: (runtime: import('@endge/raph').RaphRuntime<any>) => void;
+                            registerDerived: <TSource, TTarget>(runtime: import('@endge/raph').RaphRuntime<any>, options: import('@endge/raph').RaphDerivedOptions<TSource, TTarget>) => import('@endge/raph').RaphDerivedHandle;
+                            getDerivedSnapshot: () => import('@endge/raph').RaphDerivedManagerSnapshot;
+                            disposeAllDerived: () => void;
+                            disposeRuntimeDerived: (runtime: import('@endge/raph').RaphRuntime<any>) => void;
+                            registerDataObserver: <Props extends import('@endge/raph').RaphProperties>(runtime: import('@endge/raph').RaphRuntime<Props>, node: import('@endge/raph').RaphDataObserver<Props>["node"], mask: import('@endge/raph').DataPathDef, options: import('@endge/raph').RaphObserveDataOptions) => () => void;
+                            removeDataObserversByRuntime: (runtime: import('@endge/raph').RaphRuntime<any>) => void;
+                            removeDataObserversByNode: (runtime: import('@endge/raph').RaphRuntime<any>, node: import('@endge/raph').RaphDataObserver["node"]) => void;
+                            transaction: (fn: () => void) => void;
+                            get: (path: import('@endge/raph').DataPathDef, opts?: {
+                                vars?: Record<string, any>;
+                            }) => unknown;
+                            set: (path: import('@endge/raph').DataPathDef, value: unknown, opts?: {
+                                invalidate?: boolean;
+                                vars?: Record<string, any>;
+                            }) => void;
+                            merge: (path: import('@endge/raph').DataPathDef, value: unknown, opts?: {
+                                invalidate?: boolean;
+                                vars?: Record<string, any>;
+                            }) => void;
+                            delete: (path: import('@endge/raph').DataPathDef, opts?: {
+                                invalidate?: boolean;
+                                vars?: Record<string, any>;
+                            }) => void;
+                            notify: (path: import('@endge/raph').DataPathDef, opts?: {
+                                invalidate?: boolean;
+                                vars?: Record<string, any>;
+                            }) => void;
+                            setDataAdapter: (adapter: import('@endge/raph').DataAdapter) => void;
+                            clear: () => void;
+                            readonly dataAdapter: {
+                                root: () => import('@endge/raph').DataObject;
+                                get: (path: import('@endge/raph').DataPathDef, opts?: {
+                                    vars?: Record<string, any>;
+                                }) => import('@endge/raph').Undefinable<unknown>;
+                                set: (path: import('@endge/raph').DataPathDef, value: unknown, opts?: {
+                                    vars?: Record<string, any>;
+                                }) => void;
+                                delete: (path: import('@endge/raph').DataPathDef, opts?: {
+                                    vars?: Record<string, any>;
+                                }) => void;
+                                merge: (path: import('@endge/raph').DataPathDef, value: unknown, opts?: {
+                                    vars?: Record<string, any>;
+                                }) => void;
+                                indexOf: (path: import('@endge/raph').DataPathDef, opts?: {
+                                    vars?: Record<string, any>;
+                                }) => number;
+                            };
+                            readonly data: import('@endge/raph').DataObject;
+                        };
+                        readonly phases: readonly {
+                            name: import('@endge/raph').PhaseName;
+                            traversal: import('@endge/raph').Traversal;
+                            routes: Array<string>;
+                            always?: boolean | undefined;
+                            mode?: "dirty" | "all" | undefined;
+                            each?: import('@endge/raph').PhaseEachExecutor | undefined;
+                            all?: import('@endge/raph').PhaseAllExecutor | undefined;
+                            nodes?: (((node: import('@endge/raph').RaphNode<any>) => boolean) | Array<import('@endge/raph').RaphNodeType>) | undefined;
+                        }[];
+                        getPhase: (name: import('@endge/raph').PhaseName) => import('@endge/raph').RaphPhase | undefined;
+                        readonly root: /*elided*/ any;
+                        readonly UPS: number;
+                    };
+                    readonly raph: {
+                        readonly id: string;
+                        options: (opts: Partial<import('@endge/raph').RaphOptions>) => void;
+                        derive: <TSource = unknown, TTarget = unknown>(options: import('@endge/raph').RaphDerivedOptions<TSource, TTarget>) => import('@endge/raph').RaphDerivedHandle;
+                        transaction: (fn: () => void) => void;
+                        getDerivedSnapshot: () => import('@endge/raph').RaphDerivedManagerSnapshot;
+                        definePhases: (phases: Array<import('@endge/raph').RaphPhase>) => void;
+                        addPhase: (phase: import('@endge/raph').RaphPhase) => void;
+                        clearPhases: () => void;
+                        reinitPhases: () => void;
+                        getNode: (id: string) => import('@endge/raph').RaphNode<import('@endge/raph').RaphProperties> | undefined;
+                        addNode: (node: import('@endge/raph').RaphNode<import('@endge/raph').RaphProperties>) => void;
+                        registerNode: (node: import('@endge/raph').RaphNode<any>) => void;
+                        removeNode: (node: import('@endge/raph').RaphNode<any>) => void;
+                        unregisterNode: (node: import('@endge/raph').RaphNode<any>) => void;
+                        addDependency: (parent: import('@endge/raph').RaphNode<any>, child: import('@endge/raph').RaphNode<any>) => boolean;
+                        removeDependency: (parent: import('@endge/raph').RaphNode<any>, child: import('@endge/raph').RaphNode<any>) => void;
+                        init: () => void;
+                        clear: () => void;
+                        destroy: () => void;
+                        traverseAll: (cb: (node: import('@endge/raph').RaphNode<import('@endge/raph').RaphProperties>) => void) => void;
+                        addLocalPhase: (phase: import('@endge/raph').RaphLocalPhaseRuntime<import('@endge/raph').RaphProperties>) => void;
+                        addLocalProperty: <K extends string>(property: import('@endge/raph').RaphLocalPropertyRuntime<import('@endge/raph').RaphProperties, K>) => void;
+                        getLocalProperty: <K extends string>(key: K) => import('@endge/raph').RaphLocalPropertyRuntime<import('@endge/raph').RaphProperties, K> | undefined;
+                        dirtyLocalNodeDefaults: (node: import('@endge/raph').RaphNode<any>, invalidate?: boolean) => void;
+                        setScheduler: (mode: import('@endge/raph').RaphSchedulerType) => void;
+                        notify: (path: import('@endge/raph').DataPathDef, opts?: {
+                            invalidate?: boolean;
+                            vars?: Record<string, any>;
+                        }) => boolean;
+                        observeData: (node: import('@endge/raph').RaphNode<any>, mask: import('@endge/raph').DataPathDef, options: import('@endge/raph').RaphObserveDataOptions) => () => void;
+                        enqueueDataObserver: (observer: import('@endge/raph').RaphDataObserver<any>, path: import('@endge/raph').DataPathDef, opts?: {
+                            invalidate?: boolean;
+                            vars?: Record<string, any>;
+                        }) => boolean;
+                        dirty: (phase: import('@endge/raph').PhaseName | string, node: import('@endge/raph').RaphNode<any>, opts?: {
+                            invalidate: boolean;
+                            event?: import('@endge/raph').PhaseEvent;
+                        }) => void;
+                        run: () => void;
+                        get: (path: import('@endge/raph').DataPathDef, opts?: {
+                            vars?: Record<string, any>;
+                        }) => import('@endge/raph').Undefinable<unknown>;
+                        set: (path: import('@endge/raph').DataPathDef, value: unknown, opts?: {
+                            invalidate?: boolean;
+                            vars?: Record<string, any>;
+                        }) => void;
+                        merge: (path: import('@endge/raph').DataPathDef, value: unknown, opts?: {
+                            invalidate?: boolean;
+                            vars?: Record<string, any>;
+                        }) => void;
+                        delete: (path: import('@endge/raph').DataPathDef, opts?: {
+                            invalidate?: boolean;
+                            vars?: Record<string, any>;
+                        }) => void;
+                        startLoop: () => void;
+                        acquireLoop: (owner: string) => import('@endge/raph').RaphLoopLease;
+                        stopLoop: () => void;
+                        invalidate: () => void;
+                        reset: () => void;
+                        subscribe: (ownerNode: import('@endge/raph').RaphNode<any>, maskOrMasks: import('@endge/raph').DataPathDef | Array<import('@endge/raph').DataPathDef>, callback: import('@endge/raph').ControlFlowCallback, opts?: import('@endge/raph').ControlFlowSubscribeOptions) => () => void;
+                        unsubscribe: (subscriptionId: import('@endge/raph').ControlFlowSubscriptionId) => void;
+                        unsubscribeOwner: (ownerNode: import('@endge/raph').RaphNode<any>) => void;
+                        track: (node: import('@endge/raph').RaphNode<any>, mask: import('@endge/raph').DataPathDef, opts?: {
+                            vars?: Record<string, any>;
+                            wildcardDynamic?: boolean;
+                        }) => void;
+                        untrack: (node: import('@endge/raph').RaphNode<any>, mask?: import('@endge/raph').DataPathDef) => void;
+                        priorityOf: (node: import('@endge/raph').RaphNode<any>) => number;
+                        readonly data: import('@endge/raph').DataObject;
+                        readonly graph: {
+                            addNode: (node: import('@endge/raph').RaphNode<any>) => void;
+                            removeNode: (nodeOrId: string | import('@endge/raph').RaphNode<any>) => void;
+                            hasNode: (nodeOrId: string | import('@endge/raph').RaphNode<any>) => boolean;
+                            getNode: (id: string) => import('@endge/raph').RaphNode<any> | undefined;
+                            size: () => number;
+                            addEdge: (parent: string | import('@endge/raph').RaphNode<any>, child: string | import('@endge/raph').RaphNode<any>) => boolean;
+                            removeEdge: (parent: string | import('@endge/raph').RaphNode<any>, child: string | import('@endge/raph').RaphNode<any>) => void;
+                            parentsOf: (nodeOrId: string | import('@endge/raph').RaphNode<any>) => ReadonlySet<import('@endge/raph').RaphNode<any>>;
+                            childrenOf: (nodeOrId: string | import('@endge/raph').RaphNode<any>) => ReadonlySet<import('@endge/raph').RaphNode<any>>;
+                            rootIds: () => ReadonlySet<string>;
+                            roots: () => ReadonlySet<import('@endge/raph').RaphNode<any>>;
+                            getDepth: (nodeOrId: string | import('@endge/raph').RaphNode<any>) => number;
+                            topoOrder: () => import('@endge/raph').RaphNode<any>[];
+                            expandByTraversal: (base: Set<import('@endge/raph').RaphNode<any>> | null, traversal: "dirty-only" | "dirty-and-down" | "dirty-and-up" | "all") => Set<import('@endge/raph').RaphNode<any>>;
+                        };
+                        readonly loopEnabled: boolean;
+                        readonly frame: {
+                            now: number;
+                            delta: number;
+                            elapsed: number;
+                            frame: number;
+                        };
+                        readonly ups: number;
+                        readonly eps: number;
+                        readonly nps: number;
+                        readonly maxUps: number;
+                        readonly minUpdateInterval: number;
+                        readonly dataAdapter: {
+                            root: () => import('@endge/raph').DataObject;
+                            get: (path: import('@endge/raph').DataPathDef, opts?: {
+                                vars?: Record<string, any>;
+                            }) => import('@endge/raph').Undefinable<unknown>;
+                            set: (path: import('@endge/raph').DataPathDef, value: unknown, opts?: {
+                                vars?: Record<string, any>;
+                            }) => void;
+                            delete: (path: import('@endge/raph').DataPathDef, opts?: {
+                                vars?: Record<string, any>;
+                            }) => void;
+                            merge: (path: import('@endge/raph').DataPathDef, value: unknown, opts?: {
+                                vars?: Record<string, any>;
+                            }) => void;
+                            indexOf: (path: import('@endge/raph').DataPathDef, opts?: {
+                                vars?: Record<string, any>;
+                            }) => number;
+                        };
+                        readonly kernel: {
+                            readonly id: string;
+                            createRuntime: <Props extends import('@endge/raph').RaphProperties = import('@endge/raph').RaphProperties>(options?: import('@endge/raph').RaphRuntimeOptions) => import('@endge/raph').RaphRuntime<Props>;
+                            registerRuntime: (runtime: import('@endge/raph').RaphRuntime<any>) => void;
+                            unregisterRuntime: (runtime: import('@endge/raph').RaphRuntime<any>) => void;
+                            registerDerived: <TSource, TTarget>(runtime: import('@endge/raph').RaphRuntime<any>, options: import('@endge/raph').RaphDerivedOptions<TSource, TTarget>) => import('@endge/raph').RaphDerivedHandle;
+                            getDerivedSnapshot: () => import('@endge/raph').RaphDerivedManagerSnapshot;
+                            disposeAllDerived: () => void;
+                            disposeRuntimeDerived: (runtime: import('@endge/raph').RaphRuntime<any>) => void;
+                            registerDataObserver: <Props extends import('@endge/raph').RaphProperties>(runtime: import('@endge/raph').RaphRuntime<Props>, node: import('@endge/raph').RaphDataObserver<Props>["node"], mask: import('@endge/raph').DataPathDef, options: import('@endge/raph').RaphObserveDataOptions) => () => void;
+                            removeDataObserversByRuntime: (runtime: import('@endge/raph').RaphRuntime<any>) => void;
+                            removeDataObserversByNode: (runtime: import('@endge/raph').RaphRuntime<any>, node: import('@endge/raph').RaphDataObserver["node"]) => void;
+                            transaction: (fn: () => void) => void;
+                            get: (path: import('@endge/raph').DataPathDef, opts?: {
+                                vars?: Record<string, any>;
+                            }) => unknown;
+                            set: (path: import('@endge/raph').DataPathDef, value: unknown, opts?: {
+                                invalidate?: boolean;
+                                vars?: Record<string, any>;
+                            }) => void;
+                            merge: (path: import('@endge/raph').DataPathDef, value: unknown, opts?: {
+                                invalidate?: boolean;
+                                vars?: Record<string, any>;
+                            }) => void;
+                            delete: (path: import('@endge/raph').DataPathDef, opts?: {
+                                invalidate?: boolean;
+                                vars?: Record<string, any>;
+                            }) => void;
+                            notify: (path: import('@endge/raph').DataPathDef, opts?: {
+                                invalidate?: boolean;
+                                vars?: Record<string, any>;
+                            }) => void;
+                            setDataAdapter: (adapter: import('@endge/raph').DataAdapter) => void;
+                            clear: () => void;
+                            readonly dataAdapter: {
+                                root: () => import('@endge/raph').DataObject;
+                                get: (path: import('@endge/raph').DataPathDef, opts?: {
+                                    vars?: Record<string, any>;
+                                }) => import('@endge/raph').Undefinable<unknown>;
+                                set: (path: import('@endge/raph').DataPathDef, value: unknown, opts?: {
+                                    vars?: Record<string, any>;
+                                }) => void;
+                                delete: (path: import('@endge/raph').DataPathDef, opts?: {
+                                    vars?: Record<string, any>;
+                                }) => void;
+                                merge: (path: import('@endge/raph').DataPathDef, value: unknown, opts?: {
+                                    vars?: Record<string, any>;
+                                }) => void;
+                                indexOf: (path: import('@endge/raph').DataPathDef, opts?: {
+                                    vars?: Record<string, any>;
+                                }) => number;
+                            };
+                            readonly data: import('@endge/raph').DataObject;
+                        };
+                        readonly phases: readonly {
+                            name: import('@endge/raph').PhaseName;
+                            traversal: import('@endge/raph').Traversal;
+                            routes: Array<string>;
+                            always?: boolean | undefined;
+                            mode?: "dirty" | "all" | undefined;
+                            each?: import('@endge/raph').PhaseEachExecutor | undefined;
+                            all?: import('@endge/raph').PhaseAllExecutor | undefined;
+                            nodes?: (((node: import('@endge/raph').RaphNode<any>) => boolean) | Array<import('@endge/raph').RaphNodeType>) | undefined;
+                        }[];
+                        getPhase: (name: import('@endge/raph').PhaseName) => import('@endge/raph').RaphPhase | undefined;
+                        readonly root: /*elided*/ any;
+                        readonly UPS: number;
+                    };
+                    readonly id: string;
+                    readonly weight: number;
+                    readonly computedWeight: number;
+                    readonly meta: Record<string, unknown>;
+                    readonly type: string;
+                    readonly parent: /*elided*/ any | null;
+                    readonly children: /*elided*/ any[];
+                    readonly local: {
+                        get: <K extends string>(key: K) => import('@endge/raph').RaphProperties[K];
+                        set: <K extends string>(key: K, value: import('@endge/raph').RaphProperties[K]) => void;
+                    };
+                } | null;
+                readonly basePath: string;
+                statePath: (path?: string) => string;
+                outputPath: (name: string) => string;
+                bindInput: (name: string, binding: import('@endge/core').RuntimeHostInputBinding) => void;
+                readInput: (name: string) => unknown;
+                readInputs: () => Readonly<Record<string, unknown>>;
+                bindUpdate: (binding: import('@endge/core').RuntimeHostUpdateBinding) => () => void;
+                getArtifact: () => import('@endge/core').ProgramArtifact<unknown> | null;
+                getArtifactPayload: () => unknown;
+                setStatus: (status: import('@endge/core').RuntimeHostStatus) => void;
+                hasCapability: (capability: import('@endge/core').RuntimeHostCapability) => boolean;
+                addResource: (resource: import('@endge/core').RuntimeHostResource) => void;
+                addChannel: (channel: import('@endge/core').RuntimeHostChannel) => void;
+                emit: (event: string, payload: any) => void;
+                on: (event: string, listener: (payload: any) => void) => any;
+                off: (event: string, listener: (payload: any) => void) => any;
+                setContext: (patch: Partial<import('@endge/core').RuntimeHostContext<keyof import('@endge/core').RuntimeEntityModelMap>>) => void;
+                replaceContext: (context: import('@endge/core').RuntimeHostContext<keyof import('@endge/core').RuntimeEntityModelMap>) => void;
+                attachRuntimeState: (runtimeState: import('@endge/core').RuntimeStateControllerLike | null) => void;
+                update: (ctx: import('@endge/core').RuntimeHostUpdateContext) => Promise<void> | void;
+                snapshot: () => import('@endge/core').RuntimeHostSnapshot;
+                create: () => Promise<void> | void;
+                mount: () => Promise<void> | void;
+                start: () => Promise<void> | void;
+                pause: () => Promise<void> | void;
+                resume: () => Promise<void> | void;
+                reconcile: () => Promise<void> | void;
+                stop: () => Promise<void> | void;
+                unmount: () => Promise<void> | void;
+                destroy: () => Promise<void> | void;
+            } | null;
+        }): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    params: Record<string, unknown>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};