@onerjs/gui-editor 8.48.4 → 8.48.6

package/dist/babylon.guiEditor.module.d.ts

@@ -3297,6 +3297,1312 @@ export interface IDisplayManager {
     onDispose?(nodeData: INodeData, manager: StateManager): void;
 }
 
+}
+declare module "@onerjs/gui-editor/modularTool/modularTool" {
+import { IDisposable } from "@onerjs/core/index";
+import { IExtensionFeed } from "@onerjs/gui-editor/modularTool/extensibility/extensionFeed";
+import { WeaklyTypedServiceDefinition, ServiceContainer } from "@onerjs/gui-editor/modularTool/modularity/serviceContainer";
+import { ShellServiceOptions } from "@onerjs/gui-editor/modularTool/services/shellService";
+import { ThemeMode } from "@onerjs/gui-editor/modularTool/services/themeService";
+export type ModularToolOptions = {
+    /**
+     * The namespace for the tool, used for scoping persisted settings and other storage.
+     */
+    namespace: string;
+    /**
+     * The container element where the tool will be rendered.
+     */
+    containerElement: HTMLElement;
+    /**
+     * The service definitions to be registered with the tool.
+     */
+    serviceDefinitions: readonly WeaklyTypedServiceDefinition[];
+    /**
+     * The theme mode to use. If not specified, the default is "system", which uses the system/browser preference, and the last used mode is persisted.
+     */
+    themeMode?: ThemeMode;
+    /**
+     * Whether to show the theme selector in the toolbar. Default is true.
+     */
+    showThemeSelector?: boolean;
+    /**
+     * The extension feeds that provide optional extensions the user can install.
+     */
+    extensionFeeds?: readonly IExtensionFeed[];
+    /**
+     * An optional parent ServiceContainer. Dependencies not found in the tool's own container
+     * will be resolved from this parent.
+     */
+    parentContainer?: ServiceContainer;
+} & ShellServiceOptions;
+/**
+ * Creates a modular tool with a base set of common tool services, including the toolbar/side pane basic UI layout.
+ * @param options The options for the tool.
+ * @returns A token that can be used to dispose of the tool.
+ */
+export function MakeModularTool(options: ModularToolOptions): IDisposable;
+
+}
+declare module "@onerjs/gui-editor/modularTool/themes/babylonTheme" {
+
+export const LightTheme: any;
+export const DarkTheme: any;
+
+}
+declare module "@onerjs/gui-editor/modularTool/services/themeService" {
+
+import { IDisposable, IReadonlyObservable } from "@onerjs/core/index";
+import { IService, ServiceDefinition } from "@onerjs/gui-editor/modularTool/modularity/serviceDefinition";
+import { ISettingsStore, SettingDescriptor } from "@onerjs/gui-editor/modularTool/services/settingsStore";
+/**
+ * Represents the theme mode preference.
+ */
+export type ThemeMode = "system" | "light" | "dark";
+/**
+ * The setting descriptor for persisting the theme mode preference.
+ */
+export const ThemeModeSettingDescriptor: SettingDescriptor<ThemeMode>;
+/**
+ * Resolves the current theme based on user preference and system settings.
+ * Listens for changes to both the persisted theme mode and the OS-level dark mode preference.
+ */
+export class ThemeResolver implements IDisposable {
+    private readonly _settingsStore;
+    private readonly _darkModeMediaQuery;
+    private readonly _onChanged;
+    private readonly _onDarkModeMediaQueryChange;
+    private readonly _settingsStoreObserver;
+    constructor(_settingsStore: ISettingsStore);
+    get onChanged(): IReadonlyObservable<void>;
+    get mode(): ThemeMode;
+    set mode(value: ThemeMode);
+    get isDark(): boolean;
+    toggle(): void;
+    dispose(): void;
+}
+/**
+ * The unique identity symbol for the theme service.
+ */
+export const ThemeServiceIdentity: unique symbol;
+/**
+ * Exposes the current theme used by the application.
+ */
+export interface IThemeService extends IService<typeof ThemeServiceIdentity> {
+    /**
+     * Whether the current theme is the dark variant or not.
+     */
+    readonly isDark: boolean;
+    /**
+     * The current theme mode, which can be either "light", "dark" or "system". When set to "system", the theme will match the user's OS-level preference and update automatically when it changes.
+     */
+    mode: ThemeMode;
+    /**
+     * Toggles the theme mode between light and dark. If the current mode is "system", it will toggle based on the current OS-level preference.
+     */
+    toggle(): void;
+    /**
+     * The current theme used by the application.
+     */
+    readonly theme: any;
+    /**
+     * Observable that fires whenever the theme changes.
+     */
+    readonly onChanged: IReadonlyObservable<void>;
+}
+export const ThemeServiceDefinition: ServiceDefinition<[IThemeService], [ISettingsStore]>;
+
+}
+declare module "@onerjs/gui-editor/modularTool/services/themeSelectorService" {
+import { ServiceDefinition } from "@onerjs/gui-editor/modularTool/modularity/serviceDefinition";
+import { IShellService } from "@onerjs/gui-editor/modularTool/services/shellService";
+export const ThemeSelectorServiceDefinition: ServiceDefinition<[], [IShellService]>;
+
+}
+declare module "@onerjs/gui-editor/modularTool/services/shellSettingsService" {
+import { ServiceDefinition } from "@onerjs/gui-editor/modularTool/modularity/serviceDefinition";
+import { ISettingsService } from "@onerjs/gui-editor/modularTool/services/settingsService";
+export const ShellSettingsServiceDefinition: ServiceDefinition<[], [ISettingsService]>;
+
+}
+declare module "@onerjs/gui-editor/modularTool/services/shellService" {
+import { ComponentType } from "react";
+import { IDisposable, Nullable } from "@onerjs/core/index";
+import { IService, ServiceDefinition } from "@onerjs/gui-editor/modularTool/modularity/serviceDefinition";
+import { SettingDescriptor } from "@onerjs/gui-editor/modularTool/services/settingsStore";
+/**
+ * Setting descriptor for persisting side pane dock location overrides.
+ */
+export const SidePaneDockOverridesSettingDescriptor: SettingDescriptor<Record<string, Readonly<{
+    horizontalLocation: HorizontalLocation;
+    verticalLocation: VerticalLocation;
+}> | undefined>>;
+/**
+ * Setting descriptor for persisting the left side pane width adjustment.
+ */
+export const LeftSidePaneWidthAdjustSettingDescriptor: SettingDescriptor<number>;
+/**
+ * Setting descriptor for persisting the left side pane height adjustment.
+ */
+export const LeftSidePaneHeightAdjustSettingDescriptor: SettingDescriptor<number>;
+/**
+ * Setting descriptor for persisting the right side pane width adjustment.
+ */
+export const RightSidePaneWidthAdjustSettingDescriptor: SettingDescriptor<number>;
+/**
+ * Setting descriptor for persisting the right side pane height adjustment.
+ */
+export const RightSidePaneHeightAdjustSettingDescriptor: SettingDescriptor<number>;
+/**
+ * Represents a horizontal location in the shell layout.
+ */
+export type HorizontalLocation = "left" | "right";
+/**
+ * Represents a vertical location in the shell layout.
+ */
+export type VerticalLocation = "top" | "bottom";
+type TeachingMomentInfo = boolean | {
+    readonly title: string;
+    readonly description: string;
+};
+/**
+ * Describes an item that can be added to one of the shell's toolbars.
+ */
+export type ToolbarItemDefinition = {
+    /**
+     * A unique key for the toolbar item.
+     */
+    key: string;
+    /**
+     * The component to render for the toolbar item.
+     */
+    component: ComponentType;
+    /**
+     * An optional order for the toolbar item, relative to other items.
+     * Defaults to 0.
+     */
+    order?: number;
+    /**
+     * The horizontal location of the toolbar item.
+     * Can be either "left" or "right".
+     * In "compact" toolbar mode, "left" and "right" mean the "compact" toolbars at the top/bottom of the left/right side panes.
+     * In "full" toolbar mode, "left" and "right" mean the left side and right side of the full width toolbars above/below the side panes.
+     */
+    horizontalLocation: HorizontalLocation;
+    /**
+     * The vertical location of the toolbar item.
+     * Can be either "top" or "bottom".
+     */
+    verticalLocation: VerticalLocation;
+    /**
+     * An optional display name for the toolbar item, used for teaching moments, tooltips, etc.
+     */
+    displayName?: string;
+    /**
+     * An optional teaching moment info. The default assumes the toolbar item was added by an extension and provides a generic title and description based on the display name or id, which is helpful for discoverability of new items.
+     * Set this to false to suppress the teaching moment, which may be desirable for built in items or items that are added in a non-dynamic way.
+     * Set it to an object with a title and description to provide a custom teaching moment, which may be desirable if the generic title and description are not sufficient.
+     * Teaching moments are more helpful for dynamically added items, possibly from extensions.
+     */
+    teachingMoment?: TeachingMomentInfo;
+};
+/**
+ * Describes a side pane that can be added to the shell's left or right side.
+ */
+export type SidePaneDefinition = {
+    /**
+     * A unique key for the side pane.
+     */
+    key: string;
+    /**
+     * An icon component to render for the pane tab.
+     */
+    icon: ComponentType;
+    /**
+     * The component to render for the side pane's content.
+     */
+    content: ComponentType;
+    /**
+     * An optional order for the side pane, relative to other panes.
+     * Defaults to 0.
+     */
+    order?: number;
+    /**
+     * The horizontal location of the side pane.
+     * Can be either "left" or "right".
+     */
+    horizontalLocation: HorizontalLocation;
+    /**
+     * The vertical location of the side pane.
+     * Can be either "top" or "bottom".
+     */
+    verticalLocation: VerticalLocation;
+    /**
+     * The title of the side pane, displayed as a standardized header at the top of the pane.
+     */
+    title: string;
+    /**
+     * An optional teaching moment info. The default assumes the side pane was added by an extension and provides a generic title and description based on the display name or id, which is helpful for discoverability of new items.
+     * Set this to false to suppress the teaching moment, which may be desirable for built in items or items that are added in a non-dynamic way.
+     * Set it to an object with a title and description to provide a custom teaching moment, which may be desirable if the generic title and description are not sufficient.
+     * Teaching moments are more helpful for dynamically added panes, possibly from extensions.
+     */
+    teachingMoment?: TeachingMomentInfo;
+    /**
+     * Keep the pane mounted even when it is not visible. This is useful if you don't want the
+     * user to lose the complex visual state when switching between tabs.
+     */
+    keepMounted?: boolean;
+};
+type RegisteredSidePane = {
+    readonly key: string;
+    select(): void;
+};
+type SidePaneContainer = {
+    readonly isDocked: boolean;
+    dock(): void;
+    undock(): void;
+    readonly isCollapsed: boolean;
+    collapse(): void;
+    expand(): void;
+};
+/**
+ * Describes content that can be added to the shell's central area (between the side panes and toolbars - e.g. the main content).
+ */
+export type CentralContentDefinition = {
+    /**
+     * A unique key for the central content.
+     */
+    key: string;
+    /**
+     * The component to render for the central content.
+     */
+    component: ComponentType;
+    /**
+     * An optional order for content, relative to other central content.
+     * Defaults to 0.
+     */
+    order?: number;
+};
+/**
+ * The unique identity symbol for the root component service.
+ */
+export const RootComponentServiceIdentity: unique symbol;
+/**
+ * Exposes a top level component that should be rendered as the React root.
+ */
+export interface IRootComponentService extends IService<typeof RootComponentServiceIdentity> {
+    /**
+     * The root component that should be rendered as the React root.
+     */
+    readonly rootComponent: ComponentType;
+}
+/**
+ * The unique identity symbol for the shell service.
+ */
+export const ShellServiceIdentity: unique symbol;
+/**
+ * Provides a shell for the application, including toolbars, side panes, and central content.
+ * This service allows adding toolbar items, side panes, and central content dynamically.
+ */
+export interface IShellService extends IService<typeof ShellServiceIdentity> {
+    /**
+     * Adds a new item to one of the shell's toolbars.
+     * @param item Defines the item to add.
+     */
+    addToolbarItem(item: Readonly<ToolbarItemDefinition>): IDisposable;
+    /**
+     * Adds a new side pane to the shell.
+     * @param pane Defines the side pane to add.
+     */
+    addSidePane(pane: Readonly<SidePaneDefinition>): IDisposable;
+    /**
+     * Adds new central content to the shell.
+     * @param content Defines the content area to add.
+     */
+    addCentralContent(content: Readonly<CentralContentDefinition>): IDisposable;
+    /**
+     * The left side pane container.
+     */
+    readonly leftSidePaneContainer: Nullable<SidePaneContainer>;
+    /**
+     * The right side pane container.
+     */
+    readonly rightSidePaneContainer: Nullable<SidePaneContainer>;
+    /**
+     * The side panes currently present in the shell.
+     */
+    readonly sidePanes: readonly RegisteredSidePane[];
+}
+type ToolbarMode = "full" | "compact";
+/**
+ * Options for configuring the shell service.
+ */
+export type ShellServiceOptions = {
+    /**
+     * The default width of the left side pane.
+     */
+    leftPaneDefaultWidth?: number;
+    /**
+     * The minimum width of the left side pane.
+     */
+    leftPaneMinWidth?: number;
+    /**
+     * The default width of the right side pane.
+     */
+    rightPaneDefaultWidth?: number;
+    /**
+     * The minimum width of the right side pane.
+     */
+    rightPaneMinWidth?: number;
+    /**
+     * The mode of the toolbars.
+     * Can be either "full" (default) or "compact".
+     * In "full" mode, toolbars are displayed above and below the side panes.
+     * In "compact" mode, toolbars are displayed at the top and bottom of the left and right side panes.
+     */
+    toolbarMode?: ToolbarMode;
+    /**
+     * Whether the left side pane should start collapsed. Default is false.
+     */
+    leftPaneDefaultCollapsed?: boolean;
+    /**
+     * Whether the right side pane should start collapsed. Default is false.
+     */
+    rightPaneDefaultCollapsed?: boolean;
+    /**
+     * A function that can remap the default location of side panes.
+     * @param sidePane The side pane to remap.
+     * @returns The new location for the side pane.
+     */
+    sidePaneRemapper?: (sidePane: Readonly<SidePaneDefinition>) => Nullable<{
+        horizontalLocation: HorizontalLocation;
+        verticalLocation: VerticalLocation;
+    }>;
+};
+export function MakeShellServiceDefinition({ leftPaneDefaultWidth, leftPaneMinWidth, rightPaneDefaultWidth, rightPaneMinWidth, leftPaneDefaultCollapsed, rightPaneDefaultCollapsed, toolbarMode, sidePaneRemapper, }?: ShellServiceOptions): ServiceDefinition<[IShellService, IRootComponentService], []>;
+export {};
+
+}
+declare module "@onerjs/gui-editor/modularTool/services/settingsStore" {
+import { IReadonlyObservable } from "@onerjs/core/index";
+import { IService } from "@onerjs/gui-editor/modularTool/modularity/serviceDefinition";
+/**
+ * The unique identity symbol for the settings store service.
+ */
+export const SettingsStoreIdentity: unique symbol;
+/**
+ * Describes a setting by its key and default value.
+ */
+export type SettingDescriptor<T> = {
+    /**
+     * The unique key used to identify this setting in the store.
+     */
+    readonly key: string;
+    /**
+     * The default value to use when the setting has not been explicitly set.
+     */
+    readonly defaultValue: T;
+};
+/**
+ * Provides a key-value store for persisting user settings.
+ */
+export interface ISettingsStore extends IService<typeof SettingsStoreIdentity> {
+    /**
+     * An observable that notifies when a setting has changed, providing the key of the changed setting.
+     */
+    onChanged: IReadonlyObservable<string>;
+    /**
+     * Reads a setting from the store.
+     * @param descriptor The descriptor of the setting to read.
+     * @returns The current value of the setting, or the default value if it has not been set.
+     */
+    readSetting<T>(descriptor: SettingDescriptor<T>): T;
+    /**
+     * Writes a setting to the store.
+     * @param descriptor The descriptor of the setting to write.
+     * @param value The value to write.
+     */
+    writeSetting<T>(descriptor: SettingDescriptor<T>, value: T): void;
+}
+/**
+ * Default implementation of {@link ISettingsStore} that persists settings using browser local storage.
+ */
+export class SettingsStore implements ISettingsStore {
+    private readonly _namespace;
+    private readonly _onChanged;
+    /**
+     * Creates a new settings store.
+     * @param _namespace A namespace used to scope the settings keys to avoid collisions with other stores.
+     */
+    constructor(_namespace: string);
+    get onChanged(): IReadonlyObservable<Readonly<string>>;
+    readSetting<T>(descriptor: SettingDescriptor<T>): T;
+    writeSetting<T>(descriptor: SettingDescriptor<T>, value: T): void;
+}
+
+}
+declare module "@onerjs/gui-editor/modularTool/services/settingsService" {
+import { IDisposable } from "@onerjs/core/index";
+import { DynamicAccordionSection, DynamicAccordionSectionContent } from "@onerjs/gui-editor/modularTool/components/extensibleAccordion";
+import { IService, ServiceDefinition } from "@onerjs/gui-editor/modularTool/modularity/serviceDefinition";
+import { IShellService } from "@onerjs/gui-editor/modularTool/services/shellService";
+/**
+ * The unique identity symbol for the settings service.
+ */
+export const SettingsServiceIdentity: unique symbol;
+/**
+ * Allows new sections or content to be added to the Settings pane.
+ */
+export interface ISettingsService extends IService<typeof SettingsServiceIdentity> {
+    /**
+     * Adds a new section to the settings pane.
+     * @param section A description of the section to add.
+     */
+    addSection(section: DynamicAccordionSection): IDisposable;
+    /**
+     * Adds content to one or more sections in the settings pane.
+     * @param content A description of the content to add.
+     */
+    addSectionContent(content: DynamicAccordionSectionContent<unknown>): IDisposable;
+}
+export const SettingsServiceDefinition: ServiceDefinition<[ISettingsService], [IShellService]>;
+
+}
+declare module "@onerjs/gui-editor/modularTool/services/reactContextService" {
+import { Context } from "react";
+import { IDisposable } from "@onerjs/core/index";
+import { IService } from "@onerjs/gui-editor/modularTool/modularity/serviceDefinition";
+/**
+ * The unique identity symbol for the react context service.
+ */
+export const ReactContextServiceIdentity: unique symbol;
+export type ReactContextHandle<T> = IDisposable & {
+    updateValue: (newValue: T) => void;
+};
+/**
+ * ReactContextService allows global React contexts to be added/removed/updated.
+ */
+export interface IReactContextService extends IService<typeof ReactContextServiceIdentity> {
+    addContext<T>(provider: Context<T>["Provider"], initialValue: T, options?: {
+        order?: number;
+    }): ReactContextHandle<T>;
+}
+
+}
+declare module "@onerjs/gui-editor/modularTool/services/globalSettings" {
+import { SettingDescriptor } from "@onerjs/gui-editor/modularTool/services/settingsStore";
+export const CompactModeSettingDescriptor: SettingDescriptor<boolean>;
+export const DisableCopySettingDescriptor: SettingDescriptor<boolean>;
+
+}
+declare module "@onerjs/gui-editor/modularTool/services/extensionsListService" {
+import { ServiceDefinition } from "@onerjs/gui-editor/modularTool/modularity/serviceDefinition";
+import { IShellService } from "@onerjs/gui-editor/modularTool/services/shellService";
+export const ExtensionListServiceDefinition: ServiceDefinition<[], [IShellService]>;
+
+}
+declare module "@onerjs/gui-editor/modularTool/modularity/serviceDefinition" {
+import { IDisposable } from "@onerjs/core/index";
+/**
+ * A helper to create a service factory function from a class constructor.
+ * @param constructor The class to create a factory function for.
+ * @returns A factory function that creates an instance of the class.
+ */
+export function ConstructorFactory<Class extends new (...args: any) => any>(constructor: Class): (...args: ConstructorParameters<Class>) => InstanceType<Class>;
+const Contract: unique symbol;
+/**
+ * This interface must be implemented by all service contracts.
+ */
+export interface IService<ContractIdentity extends symbol> {
+    /**
+     * @internal
+     */
+    readonly [Contract]?: ContractIdentity;
+}
+type ExtractContractIdentity<ServiceContract extends IService<symbol>> = ServiceContract extends IService<infer ContractIdentity> ? ContractIdentity : never;
+type ExtractContractIdentities<ServiceContracts extends IService<symbol>[]> = {
+    [Index in keyof ServiceContracts]: ExtractContractIdentity<ServiceContracts[Index]>;
+};
+type UnionToIntersection<Union> = (Union extends any ? (k: Union) => void : never) extends (k: infer Intersection) => void ? Intersection : never;
+type MaybePromise<T> = T | Promise<T>;
+/**
+ * A factory function responsible for creating a service instance.
+ * Consumed services are passed as arguments to the factory function.
+ * The returned value must implement all produced services, and may IDisposable.
+ * If not services are produced, the returned value may implement IDisposable, otherwise it may return void.
+ */
+export type ServiceFactory<Produces extends IService<symbol>[], Consumes extends IService<symbol>[]> = (...dependencies: [...Consumes, abortSignal?: AbortSignal]) => MaybePromise<Produces extends [] ? Partial<IDisposable> | void : Partial<IDisposable> & UnionToIntersection<Produces[number]>>;
+/**
+ * Defines a service, which is a logical unit that consumes other services (dependencies), and optionally produces services that can be consumed by other services (dependents).
+ */
+export type ServiceDefinition<Produces extends IService<symbol>[] = [], Consumes extends IService<symbol>[] = []> = {
+    /**
+     * A human readable name for the service to help with debugging.
+     */
+    friendlyName: string;
+    /**
+     * A function that instantiates the service.
+     */
+    factory: ServiceFactory<Produces, Consumes>;
+} & (Produces extends [] ? {
+    /**
+     * An empty list or undefined, since the type specification has indicated no contracts are produced.
+     */
+    produces?: [];
+} : {
+    /**
+     * The list of contract identities that this service produces for consumption by other services.
+     */
+    produces: ExtractContractIdentities<Produces>;
+}) & (Consumes extends [] ? {
+    /**
+     * An empty list or undefined, since the type specification has indicated that no other services are consumed.
+     */
+    consumes?: [];
+} : {
+    /**
+     * The list of contract identities of other services that this service consumes.
+     */
+    consumes: ExtractContractIdentities<Consumes>;
+});
+export {};
+
+}
+declare module "@onerjs/gui-editor/modularTool/modularity/serviceContainer" {
+import { IDisposable } from "@onerjs/core/index";
+import { IService, ServiceDefinition } from "@onerjs/gui-editor/modularTool/modularity/serviceDefinition";
+export type WeaklyTypedServiceDefinition = Omit<ServiceDefinition<IService<symbol>[] | [], IService<symbol>[] | []>, "factory"> & {
+    /**
+     * A factory function responsible for creating a service instance.
+     */
+    factory: (...args: any) => ReturnType<ServiceDefinition<IService<symbol>[] | [], IService<symbol>[] | []>["factory"]>;
+};
+/**
+ * A service container manages the lifetimes of a set of services.
+ * It takes care of instantiating the services in the correct order based on their dependencies,
+ * passing dependencies through to services, and disposing of services when the container is disposed.
+ */
+export class ServiceContainer implements IDisposable {
+    private readonly _friendlyName;
+    private readonly _parent?;
+    private _isDisposed;
+    private readonly _serviceDefinitions;
+    private readonly _serviceDependents;
+    private readonly _serviceInstances;
+    private readonly _children;
+    /**
+     * Creates a new ServiceContainer.
+     * @param _friendlyName A human-readable name for debugging.
+     * @param _parent An optional parent container. Dependencies not found locally will be resolved from the parent.
+     */
+    constructor(_friendlyName: string, _parent?: ServiceContainer | undefined);
+    /**
+     * Adds a set of service definitions in the service container.
+     * The services are sorted based on their dependencies.
+     * @param args The service definitions to register, and optionally an abort signal.
+     * @returns A disposable that will remove the service definition from the service container.
+     */
+    addServicesAsync(...args: WeaklyTypedServiceDefinition[] | [...serviceDefinitions: WeaklyTypedServiceDefinition[], abortSignal: AbortSignal]): Promise<IDisposable>;
+    /**
+     * Registers a service definition in the service container.
+     * @param serviceDefinition The service definition to register.
+     * @param abortSignal An optional abort signal.
+     * @returns A disposable that will remove the service definition from the service container.
+     */
+    addServiceAsync<Produces extends IService<symbol>[] = [], Consumes extends IService<symbol>[] = []>(serviceDefinition: ServiceDefinition<Produces, Consumes>, abortSignal?: AbortSignal): Promise<IDisposable>;
+    private _addServiceAsync;
+    /**
+     * Resolves a dependency by contract identity for a consuming service.
+     * Checks local services first, then walks up the parent chain.
+     * Registers the consumer as a dependent in whichever container owns the dependency.
+     * @param contract The contract identity to resolve.
+     * @param consumer The service definition that consumes this dependency.
+     * @returns The resolved service instance.
+     */
+    private _resolveDependency;
+    /**
+     * Removes a consumer from the dependent set for a given contract, checking locally first then the parent chain.
+     * @param contract The contract identity.
+     * @param consumer The service definition to remove as a dependent.
+     */
+    private _removeDependentFromChain;
+    private _removeService;
+    /**
+     * Disposes the service container and all contained services.
+     * Throws if this container is still a parent of any live child containers.
+     */
+    dispose(): void;
+}
+
+}
+declare module "@onerjs/gui-editor/modularTool/misc/observableCollection" {
+import { IDisposable, IReadonlyObservable } from "@onerjs/core/index";
+/**
+ * A collection of items that can be observed for changes.
+ */
+export class ObservableCollection<T> {
+    private readonly _items;
+    private readonly _keys;
+    private readonly _observable;
+    /**
+     * An observable that notifies observers when the collection changes.
+     */
+    get observable(): IReadonlyObservable<void>;
+    /**
+     * The items in the collection.
+     */
+    get items(): readonly T[];
+    /**
+     * Adds an item to the collection.
+     * @param item The item to add.
+     * @returns A disposable that removes the item from the collection when disposed.
+     */
+    add(item: T): IDisposable;
+}
+
+}
+declare module "@onerjs/gui-editor/modularTool/misc/graphUtils" {
+/**
+ * Performs a topological sort on a graph.
+ * @param graph The set of nodes that make up the graph.
+ * @param getAdjacentNodes A function that returns the adjacent nodes for a given node.
+ * @param onSortedNode A function that is called for each node in the sorted order.
+ * @remarks
+ * This function allocates. Do not use it in the hot path. Instead use an instance of GraphUtils.
+ */
+export function SortGraph<NodeT>(graph: Iterable<NodeT>, getAdjacentNodes: (node: NodeT) => Iterable<NodeT>, onSortedNode: (node: NodeT) => void): void;
+/**
+ * Traverses a graph.
+ * @param graph The set of nodes that make up the graph.
+ * @param getAdjacentNodes A function that returns the adjacent nodes for a given node.
+ * @param onBeforeTraverse A function that is called before traversing each node.
+ * @param onAfterTraverse A function that is called after traversing each node.
+ * @remarks
+ * This function allocates. Do not use it in the hot path. Instead use an instance of GraphUtils.
+ */
+export function TraverseGraph<NodeT>(graph: Iterable<NodeT>, getAdjacentNodes: (node: NodeT) => Iterable<NodeT> | null | undefined, onBeforeTraverse?: (node: NodeT) => void, onAfterTraverse?: (node: NodeT) => void): void;
+/**
+ * A utility class for performing graph operations.
+ * @remarks
+ * The class allocates new objects, but each operation (e.g. sort, traverse) is allocation free. This is useful when used in the hot path.
+ */
+export class GraphUtils<DefaultNodeT = unknown> {
+    private readonly _traversalState;
+    private _isTraversing;
+    /**
+     * Performs a topological sort on a graph.
+     * @param graph The set of nodes that make up the graph.
+     * @param getAdjacentNodes A function that returns the adjacent nodes for a given node.
+     * @param onSortedNode A function that is called for each node in the sorted order.
+     */
+    sort<NodeT extends DefaultNodeT>(graph: Iterable<NodeT>, getAdjacentNodes: (node: NodeT) => Iterable<NodeT>, onSortedNode: (node: NodeT) => void): void;
+    /**
+     * Traverses a graph.
+     * @param graph The set of nodes that make up the graph.
+     * @param getAdjacentNodes A function that returns the adjacent nodes for a given node.
+     * @param onBeforeTraverse A function that is called before traversing each node.
+     * @param onAfterTraverse A function that is called after traversing each node.
+     */
+    traverse<NodeT extends DefaultNodeT>(graph: Iterable<NodeT>, getAdjacentNodes: (node: NodeT) => Iterable<NodeT> | null | undefined, onBeforeTraverse?: (node: NodeT) => void, onAfterTraverse?: (node: NodeT) => void): void;
+    private _traverseCore;
+}
+
+}
+declare module "@onerjs/gui-editor/modularTool/misc/assert" {
+/**
+ * Asserts that the given value is truthy.
+ * @param value The value to check.
+ */
+export function Assert(value: unknown): asserts value;
+
+}
+declare module "@onerjs/gui-editor/modularTool/hooks/useResizeHandle" {
+export type GrowDirection = "end" | "start" | "up" | "down";
+export type UseResizeHandleParams = {
+    /**
+     * The direction in which the element is considered growing in size ('end', 'start', 'up', or 'down').
+     */
+    growDirection: GrowDirection;
+    /**
+     * The name of the CSS variable that will be set on the wrapper element to reflect the current size of the element.
+     */
+    variableName: string;
+    /**
+     * A callback that will be called when the element is resized.
+     *
+     * @remarks The passed function should be memoized for better performance.
+     */
+    onChange?: (value: number) => void;
+    /**
+     * The minimum change allowed (e.g. the smallest negative number allowed).
+     */
+    minValue?: number;
+    /**
+     * The maximum change allowed (e.g. the largest positive number allowed).
+     */
+    maxValue?: number;
+};
+/**
+ * A custom hook that helps with element resizing.
+ * @param params The parameters for the resize handle.
+ * @returns An object containing refs and a function to set the value.
+ */
+export function useResizeHandle(params: UseResizeHandleParams): {
+    elementRef: import("react").Dispatch<import("react").SetStateAction<HTMLElement | null>>;
+    handleRef: import("react").Dispatch<import("react").SetStateAction<HTMLElement | null>>;
+    setValue: (value: number) => void;
+};
+
+}
+declare module "@onerjs/gui-editor/modularTool/hooks/themeHooks" {
+import { ThemeMode } from "@onerjs/gui-editor/modularTool/services/themeService";
+/**
+ * Hook that provides the current theme mode state and controls for changing it.
+ * @returns An object with the current dark mode state, theme mode, and functions to set or toggle the theme.
+ */
+export function useThemeMode(): {
+    readonly isDarkMode: boolean;
+    readonly themeMode: ThemeMode;
+    readonly setThemeMode: (mode: ThemeMode) => void;
+    readonly toggleThemeMode: () => void | undefined;
+};
+/**
+ * Hook that returns the current Fluent UI theme based on the active theme mode.
+ * @param invert If true, inverts the theme (returns light theme in dark mode and vice versa). Defaults to false.
+ * @returns The current Fluent UI theme object.
+ */
+
+
+}
+declare module "@onerjs/gui-editor/modularTool/hooks/teachingMomentHooks" {
+import { Nullable } from "@onerjs/core/index";
+
+/**
+ * Creates a hook for managing teaching moment state.
+ * @param name The unique name of the teaching moment.
+ * @returns A hook that returns the teaching moment state.
+ */
+export function MakeTeachingMoment(name: string): (suppress?: boolean) => {
+    readonly shouldDisplay: boolean;
+    readonly onDismissed: () => void;
+    readonly reset: () => void;
+};
+/**
+ * Creates a hook for managing teaching moment state for a dialog.
+ * @param name The unique name of the teaching moment.
+ * @returns A hook that returns the teaching moment state for a dialog.
+ */
+export function MakeDialogTeachingMoment(name: string): (suppress?: boolean) => {
+    readonly shouldDisplay: boolean;
+    readonly onOpenChange: (e: unknown, data: any) => void;
+    readonly reset: () => void;
+};
+/**
+ * Creates a hook for managing teaching moment state for a popover.
+ * @param name The unique name of the teaching moment.
+ * @returns A hook that returns the teaching moment state for a popover.
+ */
+export function MakePopoverTeachingMoment(name: string): (suppress?: boolean) => {
+    readonly shouldDisplay: boolean;
+    readonly positioningRef: import("react").Dispatch<import("react").SetStateAction<Nullable<any>>>;
+    readonly targetRef: import("react").Dispatch<import("react").SetStateAction<Nullable<HTMLElement>>>;
+    readonly onOpenChange: (e: unknown, data: any) => void;
+    readonly reset: () => void;
+};
+
+}
+declare module "@onerjs/gui-editor/modularTool/hooks/settingsHooks" {
+import { Dispatch, SetStateAction } from "react";
+import { SettingDescriptor } from "@onerjs/gui-editor/modularTool/services/settingsStore";
+/**
+ * Hook that reads and writes a setting from the settings store.
+ * @param descriptor The setting descriptor that identifies the setting and its default value.
+ * @returns A tuple of [currentValue, setValue, resetValue] similar to React's useState.
+ */
+export function useSetting<T>(descriptor: SettingDescriptor<T>): [T, Dispatch<SetStateAction<T>>, () => void];
+
+}
+declare module "@onerjs/gui-editor/modularTool/hooks/resourceHooks" {
+import { DependencyList } from "react";
+import { IDisposable } from "@onerjs/core/index";
+/**
+ * Custom hook to manage a resource with automatic disposal. The resource is created once initially, and recreated
+ * if the factory function or any dependency changes. Whenever the resource is recreated, the previous instance is
+ * disposed. The final instance is disposed when the component using this hook unmounts.
+ * @param factory A function that creates the resource.
+ * @param deps An optional dependency list. When any dependency changes, the resource is disposed and recreated.
+ * @returns The created resource.
+ */
+export function useResource<T extends IDisposable | null | undefined>(factory: () => T, deps?: DependencyList): T;
+/**
+ * Custom hook to manage an asynchronous resource with automatic disposal. The resource is created once initially, and recreated
+ * if the factory function or any dependency changes. Whenever the resource is recreated, the previous instance is
+ * disposed. The final instance is disposed when the component using this hook unmounts.
+ * @param factory A function that creates the resource.
+ * @param deps An optional dependency list. When any dependency changes, the resource is disposed and recreated.
+ * @returns The created resource.
+ */
+export function useAsyncResource<T extends IDisposable | null | undefined>(factory: (abortSignal: AbortSignal) => Promise<T>, deps?: DependencyList): T | undefined;
+
+}
+declare module "@onerjs/gui-editor/modularTool/hooks/observableHooks" {
+import { IReadonlyObservable } from "@onerjs/core/index";
+import { ObservableCollection } from "@onerjs/gui-editor/modularTool/misc/observableCollection";
+/**
+ * Returns the current value of the accessor and updates it when the specified event is fired on the specified element.
+ * @param accessor A function that returns the current value.
+ * @param element The element to listen for the event on.
+ * @param eventNames The names of the events to listen for.
+ * @returns The current value of the accessor.
+ *  * @remarks If the accessor function is not idempotent (e.g. it returns a different array or object instance each time it is called),
+ * then there is a good chance it should be wrapped in a `useCallback` to prevent unnecessary re-renders or re-render infinite loops.
+ */
+export function useEventfulState<T>(accessor: () => T, element: HTMLElement | null | undefined, ...eventNames: string[]): T;
+/**
+ * Returns the current value of the accessor and updates it when any of the specified observables change.
+ * @param accessor A function that returns the current value.
+ * @param observables The observables to listen for changes on.
+ * @returns The current value of the accessor.
+ * @remarks If the accessor function is not idempotent (e.g. it returns a different array or object instance each time it is called),
+ * then there is a good chance it should be wrapped in a `useCallback` to prevent unnecessary re-renders or re-render infinite loops.
+ */
+export function useObservableState<T>(accessor: () => T, ...observables: Array<IReadonlyObservable | null | undefined>): T;
+/**
+ * Returns a copy of the items in the collection and updates it when the collection changes.
+ * @param collection The collection to observe.
+ * @returns A copy of the items in the collection.
+ */
+export function useObservableCollection<T>(collection: ObservableCollection<T>): T[];
+/**
+ * Returns a copy of the items in the collection sorted by the order property and updates it when the collection changes.
+ * @param collection The collection to observe.
+ * @returns A copy of the items in the collection sorted by the order property.
+ */
+export function useOrderedObservableCollection<T extends Readonly<{
+    order?: number;
+}>>(collection: ObservableCollection<T>): T[];
+
+}
+declare module "@onerjs/gui-editor/modularTool/extensibility/extensionManager" {
+import { IDisposable } from "@onerjs/core/index";
+import { ServiceContainer } from "@onerjs/gui-editor/modularTool/modularity/serviceContainer";
+import { IExtensionFeed, ExtensionMetadata } from "@onerjs/gui-editor/modularTool/extensibility/extensionFeed";
+/**
+ * Represents a loaded extension.
+ */
+export interface IExtension {
+    /**
+     * The metadata for the extension.
+     */
+    readonly metadata: ExtensionMetadata;
+    /**
+     * Whether the extension is currently being installed, uninstalled, enabled, or disabled.
+     */
+    readonly isStateChanging: boolean;
+    /**
+     * Whether the extension is enabled.
+     */
+    readonly isInstalled: boolean;
+    /**
+     * Installs the extension.
+     */
+    installAsync(): Promise<void>;
+    /**
+     * Uninstalls the extension.
+     */
+    uninstallAsync(): Promise<void>;
+    /**
+     * Adds a handler that is called when the state of the extension changes.
+     * @param handler The handler to add.
+     * @returns A disposable that removes the handler when disposed.
+     */
+    addStateChangedHandler(handler: () => void): IDisposable;
+}
+/**
+ * Provides information about an extension installation failure.
+ */
+export type InstallFailedInfo = {
+    /**
+     * The metadata of the extension that failed to install.
+     */
+    extension: ExtensionMetadata;
+    /**
+     * The error that occurred during the installation.
+     */
+    error: unknown;
+};
+/**
+ * Represents a query for loaded extensions.
+ */
+export interface IExtensionQuery {
+    /**
+     * The total number of extensions that satisfy the query.
+     */
+    readonly totalCount: number;
+    /**
+     * Fetches a range of extensions from the query.
+     * @param index The index of the first extension to fetch.
+     * @param count The number of extensions to fetch.
+     * @returns A promise that resolves to the extensions.
+     */
+    getExtensionsAsync(index: number, count: number): Promise<IExtension[]>;
+}
+/**
+ * Manages the installation, uninstallation, enabling, and disabling of extensions.
+ */
+export class ExtensionManager implements IDisposable {
+    private readonly _namespace;
+    private readonly _serviceContainer;
+    private readonly _feeds;
+    private readonly _onInstallFailed;
+    private readonly _installedExtensions;
+    private readonly _stateChangedHandlers;
+    private constructor();
+    /**
+     * Creates a new instance of the ExtensionManager.
+     * This will automatically rehydrate previously installed and enabled extensions.
+     * @param namespace The namespace to use for storing extension state in local storage.
+     * @param serviceContainer The service container to use.
+     * @param feeds The extension feeds to include.
+     * @param onInstallFailed A callback that is called when an extension installation fails.
+     * @returns A promise that resolves to the new instance of the ExtensionManager.
+     */
+    static CreateAsync(namespace: string, serviceContainer: ServiceContainer, feeds: readonly IExtensionFeed[], onInstallFailed: (info: InstallFailedInfo) => void): Promise<ExtensionManager>;
+    /**
+     * Gets the names of the feeds that are included in the extension manager.
+     * @returns The names of the feeds.
+     */
+    get feedNames(): string[];
+    /**
+     * Queries the extension manager for extensions.
+     * @param filter The filter to apply to the query.
+     * @param feeds The feeds to include in the query.
+     * @param installedOnly Whether to only include installed extensions.
+     * @returns A promise that resolves to the extension query.
+     */
+    queryExtensionsAsync(filter?: string, feeds?: string[], installedOnly?: boolean): Promise<IExtensionQuery>;
+    /**
+     * Disposes the extension manager.
+     */
+    dispose(): void;
+    private _getInstalledExtensionStorageKey;
+    private _updateInstalledExtensionsStorage;
+    private _installAsync;
+    private _uninstallAsync;
+    private _enableAsync;
+    private _disableAsync;
+    private _addStateChangedHandler;
+    private _createExtension;
+    private _createInstalledExtension;
+}
+
+}
+declare module "@onerjs/gui-editor/modularTool/extensibility/extensionFeed" {
+import { WeaklyTypedServiceDefinition } from "@onerjs/gui-editor/modularTool/modularity/serviceContainer";
+export type PersonMetadata = {
+    /**
+     * The name of the person.
+     */
+    readonly name: string;
+    /**
+     * The email address of the person.
+     */
+    readonly email?: string;
+    /**
+     * The URL to the person's website.
+     */
+    readonly url?: string;
+    /**
+     * The Babylon forum username of the person.
+     */
+    readonly forumUserName?: string;
+    /**
+     * A base64 encoded PNG image to use as the person's avatar.
+     */
+    readonly avatar?: string;
+};
+export type ExtensionMetadata = {
+    /**
+     * The name of the extension.
+     */
+    readonly name: string;
+    /**
+     * The version of the extension (as valid semver).
+     */
+    readonly version?: string;
+    /**
+     * The description of the extension.
+     */
+    readonly description: string;
+    /**
+     * The keywords of the extension.
+     */
+    readonly keywords?: readonly string[];
+    /**
+     * The URL to the extension homepage.
+     */
+    readonly homepage?: string;
+    /**
+     * Specify the place where your code lives. This is helpful for people who want to contribute.
+     */
+    readonly repository?: string;
+    /**
+     * The URL to your extension's issue tracker and / or the email address to which issues should be reported. These are helpful for people who encounter issues with your extension.
+     */
+    readonly bugs?: string;
+    /**
+     * A license for your package so that people know how they are permitted to use it, and any restrictions you're placing on it.
+     */
+    readonly license?: string;
+    /**
+     * The primary author of the extension.
+     */
+    readonly author?: string | PersonMetadata;
+    /**
+     * The contributors to the extension.
+     */
+    readonly contributors?: readonly (string | PersonMetadata)[];
+};
+export type ExtensionModule = {
+    /**
+     * The default export of the module (e.g. export default).
+     */
+    default: {
+        /**
+         * The services that are included with the extension.
+         */
+        serviceDefinitions?: readonly WeaklyTypedServiceDefinition[];
+    };
+};
+/**
+ * Represents a query to fetch subset ranges of extension metadata from a feed.
+ */
+export interface IExtensionMetadataQuery {
+    /**
+     * The total number of extensions that satisfy the query.
+     */
+    readonly totalCount: number;
+    /**
+     * Fetches a range of extension metadata from the feed.
+     * @param index The index of the first extension to fetch.
+     * @param count The number of extensions to fetch.
+     * @returns A promise that resolves to the extension metadata.
+     */
+    getExtensionMetadataAsync(index: number, count: number): Promise<readonly ExtensionMetadata[]>;
+}
+/**
+ * Represents a feed/source of extensions.
+ */
+export interface IExtensionFeed {
+    /**
+     * The name of the feed.
+     */
+    readonly name: string;
+    /**
+     * Creates an extension metadata query given a filter.
+     * @param filter The filter to apply to the query.
+     * @returns A promise that resolves to the extension metadata query.
+     */
+    queryExtensionsAsync(filter?: string): Promise<IExtensionMetadataQuery>;
+    /**
+     * Gets the extension module for the specified extension.
+     * @param name The name of the extension.
+     * @returns A promise that resolves to the extension module.
+     */
+    getExtensionModuleAsync(name: string): Promise<ExtensionModule | undefined>;
+}
+
+}
+declare module "@onerjs/gui-editor/modularTool/extensibility/builtInsExtensionFeed" {
+import { IExtensionFeed, ExtensionMetadata, IExtensionMetadataQuery, ExtensionModule } from "@onerjs/gui-editor/modularTool/extensibility/extensionFeed";
+export type BuiltInExtension = ExtensionMetadata & {
+    /**
+     * Gets the extension module, typically dynamically importing the extension.
+     * @returns The extension module (e.g. a collection of ServiceDefinitions).
+     */
+    getExtensionModuleAsync(): Promise<ExtensionModule>;
+};
+/**
+ * A simple extension feed implementation that provides a fixed set of "built in" extensions.
+ * "Built in" in this context means extensions that are known at bundling time, and included
+ * in the bundle. Each extension can be dynamically imported so they are split into separate
+ * bundle chunks and downloaded only when first installed.
+ */
+export class BuiltInsExtensionFeed implements IExtensionFeed {
+    readonly name: string;
+    private readonly _extensions;
+    constructor(name: string, extensions: Iterable<BuiltInExtension>);
+    queryExtensionsAsync(filter?: string): Promise<IExtensionMetadataQuery>;
+    getExtensionModuleAsync(name: string): Promise<ExtensionModule | undefined>;
+}
+
+}
+declare module "@onerjs/gui-editor/modularTool/contexts/settingsContext" {
+import { ISettingsStore } from "@onerjs/gui-editor/modularTool/services/settingsStore";
+export const SettingsStoreContext: import("react").Context<ISettingsStore | undefined>;
+export function useSettingsStore(): ISettingsStore | undefined;
+
+}
+declare module "@onerjs/gui-editor/modularTool/contexts/extensionManagerContext" {
+import { ExtensionManager } from "@onerjs/gui-editor/modularTool/extensibility/extensionManager";
+export type ExtensionManagerContext = {
+    readonly extensionManager: ExtensionManager;
+};
+export const ExtensionManagerContext: import("react").Context<ExtensionManagerContext | undefined>;
+export function useExtensionManager(): ExtensionManager | undefined;
+
+}
+declare module "@onerjs/gui-editor/modularTool/components/uxContextProvider" {
+import { FunctionComponent, PropsWithChildren } from "react";
+export const UXContextProvider: FunctionComponent<PropsWithChildren>;
+
+}
+declare module "@onerjs/gui-editor/modularTool/components/theme" {
+
+import { FunctionComponent } from "react";
+/**
+ * A themed Fluent UI provider that applies the current theme mode (light or dark).
+ * @param props Fluent provider props, plus an optional `invert` flag to swap the theme.
+ * @returns The themed Fluent UI provider component.
+ */
+export const Theme: FunctionComponent<any & {
+    invert?: boolean;
+}>;
+
+}
+declare module "@onerjs/gui-editor/modularTool/components/teachingMoment" {
+import { FunctionComponent } from "react";
+import { MakePopoverTeachingMoment } from "@onerjs/gui-editor/modularTool/hooks/teachingMomentHooks";
+/**
+ * The state returned by the teaching moment hook.
+ */
+type TeachingMomentState = ReturnType<ReturnType<typeof MakePopoverTeachingMoment>>;
+/**
+ * Props for the {@link TeachingMoment} component.
+ */
+type TeachingMomentProps = Pick<TeachingMomentState, "shouldDisplay" | "positioningRef" | "onOpenChange"> & {
+    title: string;
+    description: string;
+};
+/**
+ * A component that displays a teaching moment popover.
+ * @param props Props for the teaching moment popover.
+ * @returns The teaching moment popover.
+ */
+export const TeachingMoment: FunctionComponent<TeachingMomentProps>;
+export {};
+
+}
+declare module "@onerjs/gui-editor/modularTool/components/pane" {
+/**
+ * Used to apply common styles to panes.
+ */
+export const SidePaneContainer: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+
+}
+declare module "@onerjs/gui-editor/modularTool/components/extensibleAccordion" {
+import { ComponentType, PropsWithChildren, Ref } from "react";
+import { AccordionProps } from "@onerjs/gui-editor/fluent/primitives/accordion";
+/**
+ * Describes a section within a dynamic accordion that can be added at runtime.
+ */
+export type DynamicAccordionSection = Readonly<{
+    /**
+     * A unique identity for the section, which can be referenced by section content.
+     */
+    identity: string;
+    /**
+     * An optional order for the section, relative to other sections.
+     * Defaults to 0.
+     */
+    order?: number;
+    /**
+     * An optional flag indicating whether the section should be collapsed by default.
+     * Defaults to false.
+     */
+    collapseByDefault?: boolean;
+}>;
+/**
+ * Describes content that belongs to a section within a dynamic accordion.
+ */
+export type DynamicAccordionSectionContent<ContextT> = Readonly<{
+    /**
+     * A unique key for the the content.
+     */
+    key: string;
+    /**
+     * The section this content belongs to.
+     */
+    section: string;
+    /**
+     * An optional order for the content within the section.
+     * Defaults to 0.
+     */
+    order?: number;
+    /**
+     * The React component that will be rendered for this content.
+     */
+    component: ComponentType<{
+        context: ContextT;
+    }>;
+}>;
+/**
+ * Imperative handle for controlling section highlights on the extensible accordion.
+ */
+export type SectionsImperativeRef = {
+    /**
+     * Highlights the specified sections, collapsing all others until the context changes.
+     * @param sections The identity strings of the sections to highlight.
+     */
+    highlightSections: (sections: readonly string[]) => void;
+};
+/**
+ * An accordion component that supports dynamically adding sections and section content at runtime.
+ * Combines statically defined children sections with dynamically registered sections and content.
+ * @param props The accordion props including sections, section content, context, and an optional imperative ref.
+ * @returns The extensible accordion component.
+ */
+export function ExtensibleAccordion<ContextT = unknown>(props: PropsWithChildren<{
+    sections: readonly DynamicAccordionSection[];
+    sectionContent: readonly DynamicAccordionSectionContent<ContextT>[];
+    context: ContextT;
+    sectionsRef?: Ref<SectionsImperativeRef>;
+} & AccordionProps>): import("react/jsx-runtime").JSX.Element;
+
+}
+declare module "@onerjs/gui-editor/modularTool/components/errorBoundary" {
+import { ErrorInfo, ReactNode, Component } from "react";
+/**
+ * Props for the {@link ErrorBoundary} component.
+ */
+type ErrorBoundaryProps = {
+    /** Child components to render */
+    children: ReactNode;
+    /** Optional fallback UI to show on error */
+    fallback?: ReactNode;
+    /** Optional callback when an error occurs */
+    onError?: (error: Error, errorInfo: ErrorInfo) => void;
+    /** Optional name for identifying this boundary in logs */
+    name?: string;
+};
+type ErrorBoundaryState = {
+    hasError: boolean;
+    error: Error | null;
+    errorInfo: ErrorInfo | null;
+};
+/**
+ * Error boundary component that catches JavaScript errors in child components
+ * and displays a fallback UI instead of crashing the entire application.
+ */
+export class ErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundaryState> {
+    constructor(props: ErrorBoundaryProps);
+    static getDerivedStateFromError(error: Error): Partial<ErrorBoundaryState>;
+    componentDidCatch(error: Error, errorInfo: ErrorInfo): void;
+    private _handleRetry;
+    render(): string | number | boolean | Iterable<ReactNode> | import("react/jsx-runtime").JSX.Element | null | undefined;
+}
+export {};
+
 }
 declare module "@onerjs/gui-editor/lines/vector4LineComponent" {
 import * as React from "react";