@esrf/daiquiri-lib 5.7.0 → 5.7.2

package/dist/index.d.ts

@@ -0,0 +1,2989 @@
+import { JSONSchema7 } from 'json-schema';
+import * as react from 'react';
+import react__default, { ComponentType, ReactElement, PropsWithChildren, ReactNode, ChangeEvent, KeyboardEvent, Component } from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+
+interface HardwareError {
+    property: string;
+    exception: string;
+    traceback: string;
+}
+interface HardwareSchemaDescription {
+    properties: JSONSchema7;
+    callables: JSONSchema7;
+}
+interface LockDescription {
+    /**
+     * A unique key for identification purpose.
+     *
+     * It actually mangles BLISS object id, role,
+     * and PID of the owner process.
+     *
+     * For example `srot_move,pid:26567`
+     *
+     * In the future this will be split into meaningful information.
+     */
+    reason: string;
+}
+interface BaseHardware<O = boolean, P extends Record<string, any> = Record<string, never>> {
+    /** Object name */
+    name: string;
+    /** Object id */
+    id: string;
+    /** An optional object alias */
+    alias: string | null;
+    /** A list of user tags */
+    user_tags: string[];
+    /** The object properties as defined in the relevant schema */
+    properties: P;
+    /** Whether the device is available */
+    online: O;
+    /** The reason why the hardware is locked, else null */
+    locked: LockDescription | null;
+    /** The object type as defined by the REST API */
+    type: string;
+    /** Any potential errors initialising this object */
+    errors?: HardwareError[];
+}
+type OnlineHardware<P extends Record<string, any> = Record<string, never>> = BaseHardware<true, P>;
+type OfflineHardware = BaseHardware<false, Record<string, never>>;
+type Hardware<P extends Record<string, unknown> = Record<string, any>> = OnlineHardware<P> | OfflineHardware;
+type AnyHardware = Hardware<any>;
+interface HardwareChangeActions {
+    setProperty: (name: string, value: any) => Promise<void>;
+    call: (name: string, ...args: any[]) => Promise<void>;
+}
+/**
+ * Common options exposed to user as yaml configuration for hardware widgets
+ */
+interface HardwareWidgetOptions {
+    /** Whether to show the extended popup */
+    extended?: boolean;
+    /** Kind of header displayed */
+    header?: string;
+}
+/**
+ * Common options exposed to user as yaml configuration for editable hardware widgets
+ */
+interface EditableHardwareWidgetOptions extends HardwareWidgetOptions {
+    /** Disable edition for an editable widget */
+    readonly?: boolean;
+}
+type EditableHardware<H extends Hardware = Hardware> = H & {
+    /** Call the API to make a change on the hardware object */
+    actions: HardwareChangeActions;
+};
+/**
+ * Properties which are passed to the widgets
+ */
+interface HardwareWidgetProps<H extends Hardware = Hardware, O extends HardwareWidgetOptions = HardwareWidgetOptions> {
+    /** Dynamic state of the hardware */
+    hardware: EditableHardware<H>;
+    /** Options passed to the widget by the yaml configuration */
+    options: O;
+    /** Global state of the widget (aggregating scan/operator/hardware states) */
+    disabled: boolean;
+    /** True if the session have the control */
+    operator: boolean;
+}
+/**
+ * Options propagated from the monitor yaml description.
+ *
+ * It is used for the monitor defined by the hardware.
+ *
+ * FIXME: Rework the hardware variant variants to specialize
+ * and drop HardwareWidgetOptions.
+ */
+interface HardwareMonitorOptions extends HardwareWidgetOptions {
+    /**
+     * Override the name of the hardware.
+     */
+    name?: string;
+}
+type HardwareComponentType<H extends Hardware = Hardware> = ComponentType<HardwareWidgetProps<H, any>>;
+interface HardwareVariant<H extends Hardware = Hardware> {
+    [name: string]: HardwareComponentType<H>;
+}
+/**
+ * Bundles everything a hardware module exposes: its widget
+ * variants, plus optional mocks/simulator/monitor.
+ */
+interface HardwareDesc<H extends Hardware = Hardware> {
+    /** Widget variants, keyed by variant name */
+    variants: HardwareVariant<H>;
+    /** Static mock data samples used for documentation */
+    mocks?: Record<string, unknown>;
+    /** Component emulating live hardware, for tests/demo */
+    simulator?: ComponentType<any>;
+    /** Monitor panel widget override */
+    monitor?: HardwareComponentType<H>;
+}
+/**
+ * Props accepted by a hardware widget container
+ */
+interface HardwareObjectProps {
+    /** Hardware id to bind to. */
+    id: string;
+    options: {
+        /** Hardware variant used for the widget container. */
+        variant?: string;
+        /** Header text shown above the hardware widget. */
+        header?: string;
+        /** Width, in pixels, of the widget container. */
+        width?: number;
+        /** Bootstrap column width (1-12) of the widget container. */
+        colWidth?: number;
+        /** If true, don't render anything when the underlying value is empty/none. */
+        emptyifnone?: boolean;
+    };
+    propertiesSchema?: Record<string, unknown>;
+    callablesSchema?: Record<string, unknown>;
+}
+
+type types_d_AnyHardware = AnyHardware;
+type types_d_BaseHardware<O = boolean, P extends Record<string, any> = Record<string, never>> = BaseHardware<O, P>;
+type types_d_EditableHardware<H extends Hardware = Hardware> = EditableHardware<H>;
+type types_d_EditableHardwareWidgetOptions = EditableHardwareWidgetOptions;
+type types_d_Hardware<P extends Record<string, unknown> = Record<string, any>> = Hardware<P>;
+type types_d_HardwareChangeActions = HardwareChangeActions;
+type types_d_HardwareComponentType<H extends Hardware = Hardware> = HardwareComponentType<H>;
+type types_d_HardwareDesc<H extends Hardware = Hardware> = HardwareDesc<H>;
+type types_d_HardwareMonitorOptions = HardwareMonitorOptions;
+type types_d_HardwareObjectProps = HardwareObjectProps;
+type types_d_HardwareSchemaDescription = HardwareSchemaDescription;
+type types_d_HardwareVariant<H extends Hardware = Hardware> = HardwareVariant<H>;
+type types_d_HardwareWidgetOptions = HardwareWidgetOptions;
+type types_d_HardwareWidgetProps<H extends Hardware = Hardware, O extends HardwareWidgetOptions = HardwareWidgetOptions> = HardwareWidgetProps<H, O>;
+type types_d_LockDescription = LockDescription;
+type types_d_OfflineHardware = OfflineHardware;
+type types_d_OnlineHardware<P extends Record<string, any> = Record<string, never>> = OnlineHardware<P>;
+declare namespace types_d {
+  export type { types_d_AnyHardware as AnyHardware, types_d_BaseHardware as BaseHardware, types_d_EditableHardware as EditableHardware, types_d_EditableHardwareWidgetOptions as EditableHardwareWidgetOptions, types_d_Hardware as Hardware, types_d_HardwareChangeActions as HardwareChangeActions, types_d_HardwareComponentType as HardwareComponentType, types_d_HardwareDesc as HardwareDesc, types_d_HardwareMonitorOptions as HardwareMonitorOptions, types_d_HardwareObjectProps as HardwareObjectProps, types_d_HardwareSchemaDescription as HardwareSchemaDescription, types_d_HardwareVariant as HardwareVariant, types_d_HardwareWidgetOptions as HardwareWidgetOptions, types_d_HardwareWidgetProps as HardwareWidgetProps, types_d_LockDescription as LockDescription, types_d_OfflineHardware as OfflineHardware, types_d_OnlineHardware as OnlineHardware };
+}
+
+/**
+ * Guess the hardware have a state
+ *
+ * FIXME: This should be dropped.
+ */
+type GenericSchema = Hardware<{
+    state: string;
+}>;
+type AnySchema = AnyHardware;
+
+type schema_d_AnySchema = AnySchema;
+type schema_d_GenericSchema = GenericSchema;
+declare namespace schema_d {
+  export type { schema_d_AnySchema as AnySchema, schema_d_GenericSchema as GenericSchema };
+}
+
+declare const BaseHardwareDesc: HardwareDesc<AnySchema>;
+
+declare const Mocks$q: {
+    default: {
+        response: {
+            callables: never[];
+            id: string;
+            name: string;
+            online: boolean;
+            properties: {
+                number: number;
+                option: string;
+                state: string;
+                string: string;
+            };
+            protocol: string;
+            require_staff: boolean;
+            type: string;
+        };
+        schema: {
+            $ref: string;
+            $schema: string;
+            asyncValidate: boolean;
+            cache: boolean;
+            definitions: {
+                HWTestSchema: {
+                    additionalProperties: boolean;
+                    properties: {
+                        callables: {
+                            $ref: string;
+                            type: string;
+                        };
+                        id: {
+                            title: string;
+                            type: string;
+                        };
+                        name: {
+                            title: string;
+                            type: string;
+                        };
+                        online: {
+                            title: string;
+                            type: string;
+                        };
+                        properties: {
+                            $ref: string;
+                            type: string;
+                        };
+                        protocol: {
+                            title: string;
+                            type: string;
+                        };
+                        require_staff: {
+                            title: string;
+                            type: string;
+                        };
+                        type: {
+                            title: string;
+                            type: string;
+                        };
+                    };
+                    type: string;
+                };
+                HardwareSchema: {
+                    additionalProperties: boolean;
+                    cache: boolean;
+                    properties: {};
+                    type: string;
+                };
+                TestPropertiesSchema: {
+                    additionalProperties: boolean;
+                    cache: boolean;
+                    properties: {
+                        number: {
+                            format: string;
+                            title: string;
+                            type: string;
+                        };
+                        option: {
+                            enum: string[];
+                            enumNames: never[];
+                            title: string;
+                            type: string;
+                        };
+                        state: {
+                            enum: string[];
+                            enumNames: never[];
+                            readOnly: boolean;
+                            title: string;
+                            type: string;
+                        };
+                        string: {
+                            title: string;
+                            type: string;
+                        };
+                    };
+                    type: string;
+                };
+            };
+            save_presets: boolean;
+        };
+    };
+};
+
+declare function DefaultState$1(props: HardwareWidgetProps<AnySchema>): react_jsx_runtime.JSX.Element;
+
+interface BaseNameWidgetOptions extends HardwareWidgetOptions {
+    overrideName?: string;
+    emptyifnone?: boolean;
+}
+declare function Name(props: HardwareWidgetProps<AnySchema, BaseNameWidgetOptions>): react_jsx_runtime.JSX.Element;
+
+interface BasePropertyWidgetOptions extends HardwareWidgetOptions {
+    header?: string;
+    property?: string;
+    unit?: string;
+}
+declare function Property(props: HardwareWidgetProps<AnySchema, BasePropertyWidgetOptions>): react_jsx_runtime.JSX.Element;
+
+interface BaseInfoWidgetOptions extends HardwareWidgetOptions {
+    /** The property */
+    property?: string;
+    /** Unit for the property */
+    unit?: string;
+}
+declare function Info(props: HardwareWidgetProps<AnySchema, BaseInfoWidgetOptions>): react_jsx_runtime.JSX.Element;
+
+/**
+ * Hardware as exposed by Redux
+ */
+type ActuatorSchema = Hardware<{
+    state: string;
+}>;
+
+/**
+ * Hardware as exposed by Redux
+ */
+type AirBearingSchema = Hardware<{
+    state: string;
+}>;
+declare const AirBearingHardwareDesc: HardwareDesc<AirBearingSchema>;
+
+declare function AirBearing(props: HardwareWidgetProps<AirBearingSchema, HardwareWidgetOptions>): react_jsx_runtime.JSX.Element;
+
+declare function AirBearingProtected(props: HardwareWidgetProps<AirBearingSchema, HardwareWidgetOptions>): react_jsx_runtime.JSX.Element;
+
+declare function AirBearingState(props: {
+    hardware: AirBearingSchema;
+}): react_jsx_runtime.JSX.Element;
+
+declare const Mocks$p: {
+    default: {
+        callables: string[];
+        id: string;
+        name: string;
+        online: boolean;
+        properties: {
+            state: string;
+        };
+        protocol: string;
+        require_staff: boolean;
+        type: string;
+    };
+};
+
+type PropsWithSimulator<P = Record<string, never>> = P & {
+    name: string;
+    alias?: string;
+    useHardwareContext?: () => {
+        actions: {
+            updateHardware: (name: string, hardware: Hardware) => void;
+            updateHardwareChangeActions: (name: string, actions: HardwareChangeActions) => void;
+        };
+    };
+};
+
+declare function AirBearingSimulator(props: PropsWithSimulator): react_jsx_runtime.JSX.Element;
+
+/**
+ * Hardware as exposed by Redux
+ */
+type BeamlineSchema = Hardware<{
+    mdt_mode: boolean;
+}>;
+declare const BeamlineHardwareDesc: HardwareDesc<BeamlineSchema>;
+
+/**
+ * Hardware as exposed by Redux
+ */
+type BeamviewerSchema = Hardware<{
+    /**
+     * Tango state of the Lima camera monitoring the beam
+     */
+    state: string;
+    foil: 'IN' | 'OUT' | 'NONE' | 'UNKNOWN';
+    led: 'ON' | 'OFF' | 'UNKNOWN';
+    screen: 'IN' | 'OUT' | 'UNKNOWN';
+    diode_ranges: string[];
+    diode_range: string;
+}>;
+declare const BeamviewerHardwareDesc: HardwareDesc<BeamviewerSchema>;
+
+declare function Beamviewer(props: HardwareWidgetProps<BeamviewerSchema>): react_jsx_runtime.JSX.Element;
+
+declare const Mocks$o: {
+    default: {
+        callables: string[];
+        id: string;
+        name: string;
+        online: boolean;
+        properties: {
+            diode_range: string;
+            diode_ranges: string[];
+            foil: string;
+            led: string;
+            screen: string;
+            state: string;
+        };
+        protocol: string;
+        require_staff: boolean;
+        type: string;
+    };
+};
+
+declare function BeamviewerSimulator(props: PropsWithSimulator): react_jsx_runtime.JSX.Element;
+
+type EnergyManagerSchema = Hardware<{
+    energy: number | null;
+    unit: string;
+    available_source_names: string[];
+    source: string;
+}>;
+declare const EnergyManagerHardwareDesc: HardwareDesc<EnergyManagerSchema>;
+
+declare function EnergyManagerDefault(props: HardwareWidgetProps<EnergyManagerSchema>): react_jsx_runtime.JSX.Element;
+
+declare function EnergyManagerState(props: {
+    hardware: EnergyManagerSchema;
+}): react_jsx_runtime.JSX.Element;
+
+declare const Mocks$n: {
+    default: {
+        callables: never[];
+        id: string;
+        name: string;
+        online: boolean;
+        properties: {
+            energy: number;
+            unit: string;
+            available_source_names: string[];
+            source: string;
+        };
+        protocol: string;
+        require_staff: boolean;
+        type: string;
+    };
+};
+
+declare function EnergyManagerSimulator(props: PropsWithSimulator): react_jsx_runtime.JSX.Element;
+
+interface FilterDescription {
+    name: string;
+    description: string;
+    state: 'IN' | 'OUT' | 'IN_OUT' | 'MOVING' | 'UNKNOWN';
+}
+type FiltersetStateType = 'READY' | 'MOVING' | 'DISABLED' | 'UNKNOWN' | 'OFFLINE' | 'FAULT';
+type FiltersetSchema = Hardware<{
+    /**
+     * Actual state of the device.
+     *
+     * Can be READY and MOVING at the same time.
+     */
+    state: FiltersetStateType;
+    /**
+     * Human readable reason of the state
+     */
+    status?: string | null;
+    /**
+     * Actual state of the filters
+     */
+    filters: FilterDescription[];
+}>;
+declare const FiltersetHardwareDesc: HardwareDesc<FiltersetSchema>;
+
+declare function FiltersetDefault(props: HardwareWidgetProps<FiltersetSchema, HardwareWidgetOptions>): react_jsx_runtime.JSX.Element;
+
+declare function DefaultState(props: HardwareWidgetProps<FiltersetSchema>): react_jsx_runtime.JSX.Element;
+
+declare const Mocks$m: {
+    default: {
+        callables: string[];
+        id: string;
+        name: string;
+        online: boolean;
+        properties: {
+            state: string;
+            status: string;
+            filters: {
+                name: string;
+                description: string;
+                state: string;
+            }[];
+        };
+        protocol: string;
+        require_staff: boolean;
+        type: string;
+    };
+    small: {
+        callables: string[];
+        id: string;
+        name: string;
+        online: boolean;
+        properties: {
+            state: string;
+            status: string;
+            filters: {
+                name: string;
+                description: string;
+                state: string;
+            }[];
+        };
+        protocol: string;
+        require_staff: boolean;
+        type: string;
+    };
+};
+
+declare function FiltersetSimulator(props: PropsWithSimulator): react_jsx_runtime.JSX.Element;
+
+type FrontendSchema = Hardware<{
+    state: string;
+    status: string;
+    automatic: boolean;
+    frontend: string;
+    current: number;
+    refill: number;
+    mode: string;
+    message: string;
+    feitlk: string;
+    pssitlk: string;
+    expitlk: string;
+}>;
+declare const FrontendHardwareDesc: HardwareDesc<FrontendSchema>;
+
+declare function Frontend(props: HardwareWidgetProps<FrontendSchema>): react_jsx_runtime.JSX.Element;
+
+declare const Mocks$l: {
+    default: {
+        callables: string[];
+        id: string;
+        name: string;
+        online: boolean;
+        properties: {
+            current: number;
+            expitlk: string;
+            feitlk: string;
+            frontend: string;
+            pssitlk: string;
+            refill: number;
+            state: string;
+            mode: string;
+            message: string;
+            status: string;
+        };
+        protocol: string;
+        require_staff: boolean;
+        type: string;
+    };
+};
+
+/**
+ * Hardware as exposed by Redux
+ */
+type GaugeSchema = Hardware<{
+    state: string;
+    status: string;
+    pressure: number;
+    unit?: string;
+}>;
+declare const GaugeHardwareDesc: HardwareDesc<GaugeSchema>;
+
+interface GaugeWidgetOptions extends HardwareWidgetOptions {
+    /** Unit of pressure */
+    unit?: string;
+    /** Precision to show, default 3 */
+    precision?: number;
+}
+declare function Gauge$1(props: HardwareWidgetProps<GaugeSchema, GaugeWidgetOptions>): react_jsx_runtime.JSX.Element;
+
+declare const Mocks$k: {
+    default: {
+        callables: string[];
+        id: string;
+        name: string;
+        online: boolean;
+        properties: {
+            pressure: number;
+            state: string;
+            status: string;
+        };
+        protocol: string;
+        require_staff: boolean;
+        type: string;
+    };
+    default2: {
+        callables: string[];
+        id: string;
+        name: string;
+        online: boolean;
+        properties: {
+            pressure: number;
+            state: string;
+            status: string;
+        };
+        protocol: string;
+        require_staff: boolean;
+        type: string;
+    };
+};
+
+/**
+ * Hardware as exposed by Redux
+ */
+type LaserSchema = Hardware<{
+    state: string;
+    power: number;
+}>;
+declare const LaserHardwareDesc: HardwareDesc<LaserSchema>;
+
+interface LaserWidgetOptions extends HardwareWidgetOptions {
+    /** Default step size to use for up / down arrows */
+    step?: number;
+    /** Array of selectable step sizes */
+    steps?: number[];
+}
+declare function Laser(props: HardwareWidgetProps<LaserSchema, LaserWidgetOptions>): react_jsx_runtime.JSX.Element;
+
+declare const Mocks$j: {
+    default: {
+        callables: never[];
+        id: string;
+        name: string;
+        online: boolean;
+        properties: {
+            power: number;
+            state: string;
+        };
+        protocol: string;
+        require_staff: boolean;
+        type: string;
+    };
+};
+
+/**
+ * Hardware as exposed by Redux
+ */
+type LaserHeatingSchema = Hardware<{
+    state: string;
+    exposure_time: number;
+    background_mode: 'ON' | 'OFF' | 'ALWAYS';
+    fit_wavelength: number[];
+    current_calibration: string;
+}>;
+declare const LaserHeatingHardwareDesc: HardwareDesc<LaserHeatingSchema>;
+
+interface LaserHeatingWidgetOptions extends HardwareWidgetOptions {
+    /** Default step size to use for up / down arrows */
+    exposureStep?: number;
+    /** Array of selectable step sizes */
+    exposureSteps?: number[];
+}
+declare function LaserHeating(props: HardwareWidgetProps<LaserHeatingSchema, LaserHeatingWidgetOptions>): react_jsx_runtime.JSX.Element;
+
+declare const Mocks$i: {
+    default: {
+        callables: never[];
+        id: string;
+        name: string;
+        online: boolean;
+        properties: {
+            exposure_time: number;
+            state: string;
+            background_mode: string;
+            fit_wavelength: number[];
+            current_calibration: string;
+        };
+        protocol: string;
+        require_staff: boolean;
+        type: string;
+    };
+};
+
+/**
+ * Hardware as exposed by Redux
+ */
+type LightSchema = Hardware<{
+    state: string;
+    temperature: number;
+    intensity: number;
+}>;
+declare const LightHardwareDesc: HardwareDesc<LightSchema>;
+
+declare function Light(props: HardwareWidgetProps<LightSchema>): react_jsx_runtime.JSX.Element;
+
+declare const Mocks$h: {
+    default: {
+        callables: never[];
+        id: string;
+        name: string;
+        online: boolean;
+        properties: {
+            intensity: number;
+            state: string;
+            temperature: number;
+        };
+        protocol: string;
+        require_staff: boolean;
+        type: string;
+    };
+};
+
+interface LimaProperties extends Record<string, unknown> {
+    state: 'READY' | 'ACQUIRING' | 'CONFIGURATION' | 'FAULT' | 'UNKNOWN' | 'OFFLINE';
+    static: {
+        lima_version: string;
+        lima_type: string;
+        camera_type: string;
+        camera_model: string;
+        camera_pixelsize: [number, number];
+        image_max_dim: [number, number];
+    } | null;
+    /**
+     * Pixel size of the detector (without binning).
+     *
+     * It's a read-only property.
+     */
+    pixel_size: [number, number];
+    /**
+     * Max exposition time of a single sub frame in accumulation.
+     *
+     * It is used (together with the exposure time) to determine the
+     * nb of sub frames and the expo time of a single sub frame.
+     * See `guessSubframes`.
+     */
+    acc_max_expo_time: number | null;
+    /**
+     * Flip applied to the resulting image
+     */
+    flip: [boolean, boolean];
+    /**
+     * Rotation applied to the resulting image.
+     *
+     * One of 0, 90, 180, 270
+     */
+    rotation: 0 | 90 | 180 | 270;
+    /**
+     * Binning applied to the resulting image
+     */
+    binning: [number, number];
+    /**
+     * Binning mode applied to the resulting image
+     *
+     * Introduced in BLISS 2.3, Lima 1.10.4
+     */
+    binning_mode?: 'SUM' | 'MEAN';
+    /**
+     * Location and size of the ROI in the raw image.
+     *
+     * When binning=[1, 1] flip=[false, false], rotation=0
+     */
+    raw_roi: [number, number, number, number];
+    /**
+     * Location of the ROI in the transformed image.
+     */
+    roi: [number, number, number, number];
+    /**
+     * Final size of the detector. Including the crop of the ROI.
+     */
+    size: [number, number];
+}
+/**
+ * Hardware as exposed by Redux
+ */
+type LimaSchema = Hardware<LimaProperties>;
+declare function isLimaHardware(entity: Hardware): entity is LimaSchema;
+declare function useLimaHardware(name: string | null): LimaSchema | null;
+/**
+ * Compute the nb sub frames which will be used for a specific exposure time
+ */
+declare function limaGuessSubframes(exposureTime: number, accMaxExpoTime: number): [number, number];
+declare const LimaHardwareDesc: HardwareDesc<LimaSchema>;
+
+declare function LimaBinning(props: HardwareWidgetProps<LimaSchema, EditableHardwareWidgetOptions>): react_jsx_runtime.JSX.Element;
+
+declare function LimaDefault(props: HardwareWidgetProps<LimaSchema>): react_jsx_runtime.JSX.Element;
+
+declare function TomoDetectorSize$2(props: HardwareWidgetProps<LimaSchema, HardwareWidgetOptions>): react_jsx_runtime.JSX.Element;
+
+declare function TomoDetectorSize$1(props: HardwareWidgetProps<LimaSchema, HardwareWidgetOptions>): react_jsx_runtime.JSX.Element;
+
+declare function TomoDetectorSize(props: HardwareWidgetProps<LimaSchema, HardwareWidgetOptions>): react_jsx_runtime.JSX.Element;
+
+declare function LimaTransformation(props: HardwareWidgetProps<LimaSchema, EditableHardwareWidgetOptions>): react_jsx_runtime.JSX.Element;
+
+declare function LimaRoiShape(props: HardwareWidgetProps<LimaSchema, HardwareWidgetOptions>): react_jsx_runtime.JSX.Element;
+
+declare function LimaState(props: {
+    hardware: LimaSchema;
+}): react_jsx_runtime.JSX.Element;
+
+declare const Mocks$g: {
+    default: {
+        id: string;
+        name: string;
+        protocol: string;
+        type: string;
+        online: boolean;
+        require_staff: boolean;
+        properties: {
+            static: {
+                lima_version: string;
+                lima_type: string;
+                camera_type: string;
+                camera_model: string;
+                camera_pixelsize: number[];
+                image_max_dim: number[];
+            };
+            acc_max_expo_time: number;
+            binning: number[];
+            flip: boolean[];
+            pixel_size: number[];
+            raw_roi: number[];
+            roi: number[];
+            rotation: number;
+            size: number[];
+            state: string;
+        };
+    };
+    flip: {
+        id: string;
+        name: string;
+        protocol: string;
+        type: string;
+        online: boolean;
+        require_staff: boolean;
+        properties: {
+            static: {
+                lima_version: string;
+                lima_type: string;
+                camera_type: string;
+                camera_model: string;
+                camera_pixelsize: number[];
+                image_max_dim: number[];
+            };
+            acc_max_expo_time: number;
+            binning: number[];
+            flip: boolean[];
+            pixel_size: number[];
+            raw_roi: number[];
+            roi: number[];
+            rotation: number;
+            size: number[];
+            state: string;
+        };
+    };
+    rot: {
+        id: string;
+        name: string;
+        protocol: string;
+        type: string;
+        online: boolean;
+        require_staff: boolean;
+        properties: {
+            static: {
+                lima_version: string;
+                lima_type: string;
+                camera_type: string;
+                camera_model: string;
+                camera_pixelsize: number[];
+                image_max_dim: number[];
+            };
+            acc_max_expo_time: number;
+            binning: number[];
+            flip: boolean[];
+            pixel_size: number[];
+            raw_roi: number[];
+            roi: number[];
+            rotation: number;
+            size: number[];
+            state: string;
+        };
+    };
+    roicenter: {
+        id: string;
+        name: string;
+        protocol: string;
+        type: string;
+        online: boolean;
+        require_staff: boolean;
+        properties: {
+            static: {
+                lima_version: string;
+                lima_type: string;
+                camera_type: string;
+                camera_model: string;
+                camera_pixelsize: number[];
+                image_max_dim: number[];
+            };
+            acc_max_expo_time: number;
+            binning: number[];
+            flip: boolean[];
+            pixel_size: number[];
+            raw_roi: number[];
+            roi: number[];
+            rotation: number;
+            size: number[];
+            state: string;
+        };
+    };
+    squaredetector: {
+        id: string;
+        name: string;
+        protocol: string;
+        type: string;
+        online: boolean;
+        require_staff: boolean;
+        properties: {
+            static: {
+                lima_version: string;
+                lima_type: string;
+                camera_type: string;
+                camera_model: string;
+                camera_pixelsize: number[];
+                image_max_dim: number[];
+            };
+            acc_max_expo_time: number;
+            binning: number[];
+            flip: boolean[];
+            pixel_size: number[];
+            raw_roi: number[];
+            roi: number[];
+            rotation: number;
+            size: number[];
+            state: string;
+        };
+    };
+};
+
+declare function LimaSimulator(props: PropsWithSimulator): react_jsx_runtime.JSX.Element;
+
+interface MeasurementGroupProperties extends Record<string, unknown> {
+    /** List of available counters */
+    available: string[];
+    /** List of disabled counters.
+     *
+     * It is a subset of the `available` list.
+     */
+    disabled: string[];
+}
+/**
+ * Hardware as exposed by Redux
+ */
+type MeasurementGroupSchema = Hardware<MeasurementGroupProperties>;
+declare const MeasurementGroupHardwareDesc: HardwareDesc<MeasurementGroupSchema>;
+
+declare function MeasurementGroup(props: HardwareWidgetProps<MeasurementGroupSchema>): react_jsx_runtime.JSX.Element;
+
+declare const Mocks$f: {
+    default: {
+        callables: never[];
+        id: string;
+        name: string;
+        online: boolean;
+        properties: {
+            available: string[];
+            disabled: string[];
+        };
+        protocol: string;
+        require_staff: boolean;
+        type: string;
+    };
+};
+
+declare function MeasurementGroupSimulator(props: PropsWithSimulator): react_jsx_runtime.JSX.Element;
+
+type MotorSchema = Hardware<{
+    position: number | null;
+    /**
+     * Target of the actual motion.
+     *
+     * If there is no motion, it is `null`.
+     */
+    target: number | null;
+    tolerance: number;
+    acceleration: number;
+    velocity: number;
+    limits: [number, number];
+    state: string[];
+    unit: string;
+    offset: number;
+    sign: number;
+    display_digits: number | null;
+}>;
+/**
+ * Exposes the standard supported motor states
+ */
+interface MotorStates {
+    READY?: true;
+    MOVING?: true;
+    FAULT?: true;
+    HIGHLIMIT?: true;
+    LOWLIMIT?: true;
+    HOME?: true;
+    OFF?: true;
+    DISABLED?: true;
+    UNKNOWN?: true;
+    NOT_READY?: true;
+}
+/**
+ * Normalize the motor state exposed by the hardware.
+ *
+ * This does not exposes the custom states in a useful maner.
+ *
+ * Store states are changed depending of existing user tags
+ *
+ * - `auto_on`: This allow to move the motor even if `OFF` is enabled.
+ *              When `OFF` is enabled `READY` is turned to true.
+ * - `auto_ready`: This allow to move the motor even if `NOT_READY` is enabled.
+ *
+ * TODO: An improvement would be to normalize that when redux is populated.
+ *       instead of storing a list.
+ *
+ * @param state: List of the controller state
+ * @param userTags: List of the hardware user tags
+ */
+declare function useMotorStates(state: string[] | undefined, userTags?: string[]): MotorStates;
+declare function isMotorHardware(entity: Hardware): entity is MotorSchema;
+/**
+ * Return a motor from it's hardware name.
+ *
+ * Return `null` if the name refers to nothing or a mismatching hardware.
+ *
+ * @param name: An hardware identifier
+ */
+declare function useMotorHardware(name: string | null): MotorSchema | null;
+/**
+ * True if the motor positon is clock wise.
+ *
+ * This is based on dial metadata, and user sign.
+ */
+declare function isMotorClockWise(hardware: MotorSchema, options?: {
+    clockwise?: boolean;
+}): boolean;
+/**
+ * Normalize the limits as finite values or `undefined`.
+ */
+declare function motorLimits(hardware: MotorSchema): [number | undefined, number | undefined];
+declare const MotorHardwareDesc: HardwareDesc<MotorSchema>;
+
+interface MotorDefaultOptions extends HardwareWidgetOptions {
+    /** Default step size to use for up / down arrows */
+    step?: number;
+    /** Array of selectable step sizes */
+    steps?: number[];
+    /** Number of decimals to show */
+    precision?: number;
+    /** Whether to show popup to configure extended parameters */
+    extended?: boolean;
+    /** Whether this widget is read only */
+    readOnly?: boolean;
+    /** Whether this widget can only be changed using steps */
+    stepOnly?: boolean;
+    /** Kind of header displayed */
+    header?: string;
+    /** Specify a fontawesome to inc the value */
+    incicon?: string;
+    /** Specify a fontawesome to dec the value */
+    decicon?: string;
+    /** If true inc and dec icon are swapped */
+    swapincdec?: boolean;
+    /** Show the step arrows horizontally instead of vertically */
+    horizontalarrows?: boolean;
+    /** Show large step arrows */
+    largearrows?: boolean;
+    /**
+     * Enforce the way the positive direction is displayed.
+     *
+     * For example this can change the behavior of a knob representation.
+     */
+    clockwise?: boolean;
+}
+
+/**
+ * The default motor widget
+ */
+declare function MotorDefault(props: HardwareWidgetProps<MotorSchema, MotorDefaultOptions>): react_jsx_runtime.JSX.Element;
+
+/**
+ * The default motor widget
+ */
+declare function MotorText(props: HardwareWidgetProps<MotorSchema, MotorDefaultOptions>): react_jsx_runtime.JSX.Element;
+
+declare function MotorRotation(props: HardwareWidgetProps<MotorSchema, MotorDefaultOptions>): react_jsx_runtime.JSX.Element;
+
+/**
+ * A motor have a set of flags as state.
+ *
+ * For example an axis can expose `READY` and `MOVING` at the same time.
+ * It means the controller is ready to change it's target, even
+ * during a motion.
+ *
+ * For now we only display a "main" state.
+ */
+declare function MotorState(props: {
+    hardware: MotorSchema;
+}): react_jsx_runtime.JSX.Element;
+
+declare const Mocks$e: {
+    default: {
+        callables: string[];
+        id: string;
+        name: string;
+        online: boolean;
+        properties: {
+            offset: number;
+            sign: number;
+            acceleration: number;
+            limits: number[];
+            position: number;
+            state: string[];
+            tolerance: number;
+            unit: string;
+            velocity: number;
+            display_digits: number;
+        };
+        protocol: string;
+        require_staff: boolean;
+        type: string;
+        user_tags: never[];
+    };
+    halfMotor: {
+        callables: string[];
+        id: string;
+        name: string;
+        online: boolean;
+        properties: {
+            offset: number;
+            sign: number;
+            acceleration: number;
+            limits: number[];
+            position: number;
+            state: string[];
+            tolerance: number;
+            unit: string;
+            velocity: number;
+        };
+        protocol: string;
+        require_staff: boolean;
+        type: string;
+        user_tags: never[];
+    };
+    unknownMotor: {
+        callables: string[];
+        id: string;
+        name: string;
+        online: boolean;
+        properties: {
+            acceleration: null;
+            limits: null[];
+            offset: null;
+            position: number;
+            sign: null;
+            state: string[];
+            target: null;
+            tolerance: number;
+            unit: string;
+            velocity: null;
+        };
+        protocol: string;
+        require_staff: boolean;
+        type: string;
+        user_tags: never[];
+    };
+    notReadyMotor: {
+        callables: string[];
+        id: string;
+        name: string;
+        online: boolean;
+        properties: {
+            acceleration: null;
+            limits: null[];
+            offset: null;
+            position: number;
+            sign: null;
+            state: never[];
+            target: null;
+            tolerance: number;
+            unit: string;
+            velocity: null;
+        };
+        protocol: string;
+        require_staff: boolean;
+        type: string;
+        user_tags: never[];
+    };
+    disconnectedMotor: {
+        callables: string[];
+        id: string;
+        name: string;
+        online: boolean;
+        properties: {};
+        protocol: string;
+        require_staff: boolean;
+        type: string;
+        user_tags: never[];
+    };
+    powerOffMotor: {
+        callables: string[];
+        id: string;
+        name: string;
+        online: boolean;
+        properties: {
+            acceleration: null;
+            limits: null[];
+            offset: null;
+            position: number;
+            sign: null;
+            state: string[];
+            target: null;
+            tolerance: number;
+            unit: string;
+            velocity: null;
+        };
+        protocol: string;
+        require_staff: boolean;
+        type: string;
+        user_tags: never[];
+    };
+};
+
+declare function createMotorMock(name: string, position: number): {
+    id: string;
+    name: string;
+    type: string;
+    properties: {
+        position: number;
+        unit: string;
+        limits: number[];
+    };
+    online: boolean;
+};
+
+interface Props$c {
+    name?: string;
+    minLimit?: number;
+    maxLimit?: number;
+    initialPosition?: number;
+    initialVelocity?: number;
+    useHardwareContext?: () => {
+        actions: {
+            updateHardware: (name: string, hardware: Hardware) => void;
+            updateHardwareChangeActions: (name: string, actions: HardwareChangeActions) => void;
+        };
+    };
+}
+declare function MotorSimulator(props: Props$c): react_jsx_runtime.JSX.Element;
+
+type MultipositionSchema = Hardware<{
+    /**
+     * Actual position
+     */
+    position: string | 'unknown' | null;
+    /**
+     * Actual state of the device.
+     *
+     * Can be any state of a motor.
+     */
+    state: 'MOVING' | 'OFF' | 'READY' | 'FAULT' | 'DISABLED' | 'UNKNOWN';
+    /**
+     * Described positions
+     */
+    positions: {
+        /**
+         * Identifier of the position
+         */
+        position: string;
+        /**
+         * Human readable description
+         */
+        description?: string;
+        /**
+         * Location of this position represented by a set of motor/position
+         */
+        target: {
+            object: string;
+            destination: number | string;
+            tolerance?: number;
+        }[];
+    }[];
+}>;
+declare const MultipositionHardwareDesc: HardwareDesc<MultipositionSchema>;
+
+declare function Multiposition$1(props: HardwareWidgetProps<MultipositionSchema>): react_jsx_runtime.JSX.Element;
+
+interface MultipositionDefault2Options extends HardwareWidgetOptions {
+    /**
+     * Display a search input
+     */
+    search?: boolean;
+}
+declare function Multiposition(props: HardwareWidgetProps<MultipositionSchema, MultipositionDefault2Options>): react_jsx_runtime.JSX.Element;
+
+declare const Mocks$d: {
+    default: {
+        callables: string[];
+        id: string;
+        name: string;
+        online: boolean;
+        properties: {
+            position: string;
+            positions: {
+                description: string;
+                position: string;
+                target: {
+                    destination: number;
+                    tolerance: number;
+                }[];
+            }[];
+            state: string;
+        };
+        protocol: string;
+        require_staff: boolean;
+        type: string;
+    };
+};
+
+declare function MultipositionSimulator(props: PropsWithSimulator): react_jsx_runtime.JSX.Element;
+
+interface OpticProperties extends Record<string, unknown> {
+    state: string;
+    magnification: number;
+    available_magnifications: number[] | null;
+    /**
+     * Target of the actual motion.
+     *
+     * If there is no motion, it is `null `.
+     */
+    target_magnification: number | null;
+    magnification_range: [number, number] | null;
+}
+/**
+ * Hardware as exposed by Redux
+ */
+type OpticSchema = Hardware<OpticProperties>;
+declare function isOpticHardware(entity: Hardware): entity is OpticSchema;
+declare const OpticHardwareDesc: HardwareDesc<OpticSchema>;
+
+interface OpticWidgetOptions extends HardwareWidgetOptions {
+    readonly?: boolean;
+    digits?: number;
+    allowtuning?: boolean;
+}
+declare function Optic(props: HardwareWidgetProps<OpticSchema, OpticWidgetOptions>): react_jsx_runtime.JSX.Element;
+
+declare function OpticState(props: {
+    hardware: OpticSchema;
+}): react_jsx_runtime.JSX.Element;
+
+declare const Mocks$c: {
+    default: {
+        callables: string[];
+        id: string;
+        name: string;
+        online: boolean;
+        properties: {
+            state: string;
+            magnification: number;
+            target_magnification: null;
+            available_magnifications: number[];
+            magnification_range: null;
+        };
+        protocol: string;
+        require_staff: boolean;
+        type: string;
+    };
+    fixed: {
+        callables: string[];
+        id: string;
+        name: string;
+        online: boolean;
+        properties: {
+            state: string;
+            magnification: number;
+            target_magnification: null;
+            available_magnifications: number[];
+            magnification_range: null;
+        };
+        protocol: string;
+        require_staff: boolean;
+        type: string;
+    };
+    off: {
+        callables: string[];
+        id: string;
+        name: string;
+        online: boolean;
+        properties: {
+            state: string;
+            magnification: number;
+            target_magnification: null;
+            available_magnifications: number[];
+            magnification_range: null;
+        };
+        protocol: string;
+        require_staff: boolean;
+        type: string;
+    };
+    range: {
+        callables: string[];
+        id: string;
+        name: string;
+        online: boolean;
+        properties: {
+            state: string;
+            magnification: number;
+            target_magnification: null;
+            available_magnifications: number[];
+            magnification_range: null;
+        };
+        protocol: string;
+        require_staff: boolean;
+        type: string;
+    };
+};
+
+interface Props$b {
+    kind: 'fixed' | 'range' | 'multi';
+}
+declare function OpticSimulator(props: PropsWithSimulator<Props$b>): react_jsx_runtime.JSX.Element;
+
+type ProcedureSchema = Hardware<{
+    state: string;
+    previous_run_state: string;
+    previous_run_exception: string | null;
+    parameters: Record<string, any>;
+}>;
+declare const ProcedureHardwareDesc: HardwareDesc<ProcedureSchema>;
+
+interface HardwareFromProcedure {
+    __type__: 'hardware';
+    name: string;
+}
+interface ScanFromProcedure {
+    __type__: 'scan';
+    key?: string;
+}
+interface ExceptionFromProcedure {
+    __type__: 'exception';
+    class: string;
+    message: string;
+    traceback: Record<string, any>;
+}
+declare function isProcedureHardware(entity: Hardware): entity is ProcedureSchema;
+/**
+ * Return a procedure from it's hardware name.
+ *
+ * Return `null` if the name refers to nothing or a mismatching hardware.
+ *
+ * @param name: An hardware identifier
+ */
+declare function useProcedureHardware(name: string | null): ProcedureSchema | null;
+
+declare function FinishedState(props: {
+    hardware: EditableHardware<ProcedureSchema>;
+}): react_jsx_runtime.JSX.Element;
+declare function ProcedureExecution(props: HardwareWidgetProps<ProcedureSchema>): react_jsx_runtime.JSX.Element;
+
+interface ProcedureOptions extends HardwareWidgetOptions {
+    /**
+     * If true, execute the procedure in the BLISS session foreground.
+     *
+     * As result, the terminal first have to be available to
+     * start the procedure, else it fails.
+     *
+     * Also, as it takes the prompt, it is visible by the users,
+     * so they have to kill or to wait for the end before doing
+     * anything else.
+     */
+    foreground?: boolean;
+}
+declare function Actions(props: {
+    hardware: EditableHardware<ProcedureSchema>;
+    disabled: boolean;
+    options: ProcedureOptions;
+}): react_jsx_runtime.JSX.Element;
+declare function ProcedureManage(props: HardwareWidgetProps<ProcedureSchema, ProcedureOptions>): react_jsx_runtime.JSX.Element;
+
+declare function ProcedureValidate(props: HardwareWidgetProps<ProcedureSchema>): react_jsx_runtime.JSX.Element;
+
+declare function ProcedureState(props: {
+    hardware: ProcedureSchema;
+}): react_jsx_runtime.JSX.Element;
+
+declare const Mocks$b: {
+    standby: {
+        callables: string[];
+        type: string;
+        id: string;
+        name: string;
+        protocol: string;
+        require_staff: boolean;
+        online: boolean;
+        properties: {
+            state: string;
+            previous_run_state: string;
+            previous_run_exception: null;
+            parameters: {
+                my_number: number;
+                my_string: string;
+                my_null: null;
+                my_boolean: boolean;
+                my_dict: {
+                    a: number;
+                    b: string;
+                    c: boolean;
+                };
+                my_list: (string | number | boolean)[];
+                "my_scan_1.11": {
+                    __type__: string;
+                    node: string;
+                    mmh3: number;
+                };
+                "my_scan_2.0": {
+                    __type__: string;
+                    key: string;
+                    mmh3: number;
+                };
+                my_quantity: {
+                    __type__: string;
+                    scalar: number;
+                    unit: string;
+                };
+                my_nan: {
+                    __type__: string;
+                };
+                my_posinf: {
+                    __type__: string;
+                };
+                my_neginf: {
+                    __type__: string;
+                };
+                my_obj: {
+                    __type__: string;
+                    name: string;
+                };
+            };
+        };
+    };
+};
+
+/**
+ * Hardware as exposed by Redux
+ */
+type RegulationSchema = Hardware<{
+    state: string;
+    is_monitoring: boolean;
+    is_softloop: boolean;
+    setpoint: number;
+    input_value: number;
+    output_value: number;
+    input_unit: string;
+    output_unit: string;
+    deadband?: number;
+}>;
+declare const RegulationHardwareDesc: HardwareDesc<RegulationSchema>;
+
+/**
+ * Mirrors react-bootstrap's `Placement` (itself re-exported from
+ * `@restart/ui`/`@popperjs/core` via an inline `import()` type), spelled out
+ * as a literal union so widget-options codegen (which walks these
+ * interfaces with the TypeScript compiler API to produce a JSON Schema) can
+ * represent it — codegen can't resolve through the `import()` type node.
+ */
+type PopupPlacement = 'auto' | 'auto-start' | 'auto-end' | 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'right' | 'right-start' | 'right-end' | 'left' | 'left-start' | 'left-end';
+interface RegulationOptions extends HardwareWidgetOptions {
+    /** Default step size to use for up / down arrows */
+    step?: number;
+    /** Array of selectable step sizes */
+    steps?: number[];
+    /** Plot height */
+    plotHeight?: string;
+    /** Plot width */
+    plotWidth?: string;
+    /** Show output details
+     * @default true
+     */
+    showOutput?: boolean;
+    /** Popup button title */
+    buttonTitle?: string;
+    /** Popup placement */
+    popupPlacement?: PopupPlacement;
+}
+
+declare function RegulationLoop(props: HardwareWidgetProps<RegulationSchema, RegulationOptions>): react_jsx_runtime.JSX.Element;
+
+declare function RegulationPlot(props: HardwareWidgetProps<RegulationSchema, RegulationOptions>): react_jsx_runtime.JSX.Element;
+
+declare const Mocks$a: {
+    default: {
+        alias: null;
+        errors: never[];
+        locked: null;
+        name: string;
+        online: boolean;
+        properties: {
+            deadband: number;
+            input_unit: string;
+            input_value: number;
+            is_monitoring: boolean;
+            output_unit: string;
+            output_value: number;
+            setpoint: number;
+            state: string;
+        };
+        type: string;
+        user_tags: never[];
+    };
+};
+
+declare function RegulationSimulator(props: PropsWithSimulator): react_jsx_runtime.JSX.Element;
+
+type ShutterSchema = Hardware<{
+    state: string;
+    status: string;
+    valid: boolean;
+    open_text: string;
+    closed_text: string;
+}>;
+declare const ShutterHardwareDesc: HardwareDesc<ShutterSchema>;
+
+declare function ShutterDefault(props: HardwareWidgetProps<ShutterSchema, HardwareWidgetOptions>): react_jsx_runtime.JSX.Element;
+
+declare function ShutterProtected(props: HardwareWidgetProps<ShutterSchema, HardwareWidgetOptions>): react_jsx_runtime.JSX.Element;
+
+declare function ShutterState(props: {
+    hardware: ShutterSchema;
+    useReadyState?: boolean;
+}): react_jsx_runtime.JSX.Element;
+
+declare const Mocks$9: {
+    default: {
+        callables: string[];
+        id: string;
+        name: string;
+        online: boolean;
+        properties: {
+            closed_text: string;
+            open_text: string;
+            state: string;
+            status: string;
+            valid: boolean;
+        };
+        protocol: string;
+        require_staff: boolean;
+        type: string;
+    };
+    closed: {
+        callables: string[];
+        id: string;
+        name: string;
+        online: boolean;
+        properties: {
+            closed_text: string;
+            open_text: string;
+            state: string;
+            status: string;
+            valid: boolean;
+        };
+        protocol: string;
+        require_staff: boolean;
+        type: string;
+    };
+};
+
+declare function ShutterSimulator(props: PropsWithSimulator): react_jsx_runtime.JSX.Element;
+
+/**
+ * Hardware as exposed by Redux
+ */
+type SlitSchema = Hardware<{
+    state: string;
+    type: 'vertical' | 'horizontal' | 'both';
+    hgap: string;
+    vgap: string;
+    hoffset: string;
+    voffset: string;
+}>;
+interface SlitDefaultOptions extends HardwareWidgetOptions {
+    /** Number of decimals to show */
+    precision?: number;
+    /** Setup the widget to be read only */
+    readonly?: boolean;
+}
+declare const SlitHardwareDesc: HardwareDesc<SlitSchema>;
+
+declare function SlitDefault(props: HardwareWidgetProps<SlitSchema, SlitDefaultOptions>): react_jsx_runtime.JSX.Element;
+
+declare function SlitState(props: {
+    hardware: SlitSchema;
+}): react_jsx_runtime.JSX.Element;
+
+declare const Mocks$8: {
+    default: {
+        id: string;
+        name: string;
+        online: boolean;
+        properties: {
+            vgap: string;
+            voffset: string;
+            hgap: string;
+            hoffset: string;
+        };
+        type: string;
+    };
+    horizontal: {
+        id: string;
+        name: string;
+        online: boolean;
+        properties: {
+            vgap: string;
+            voffset: string;
+            hgap: string;
+            hoffset: string;
+        };
+        type: string;
+    };
+    vertical: {
+        id: string;
+        name: string;
+        online: boolean;
+        properties: {
+            vgap: string;
+            voffset: string;
+            hgap: string;
+            hoffset: string;
+        };
+        type: string;
+    };
+};
+
+/**
+ * Hardware as exposed by Redux
+ */
+type PumpSchema = Hardware<{
+    state: string;
+    status: string;
+    pressure: number;
+    voltage: number;
+    current: number;
+    unit?: string;
+}>;
+declare const PumpHardwareDesc: HardwareDesc<PumpSchema>;
+
+interface PumpWidgetOptions extends HardwareWidgetOptions {
+    unit?: string;
+    precision?: number;
+}
+declare function Pump(props: HardwareWidgetProps<PumpSchema, PumpWidgetOptions>): react_jsx_runtime.JSX.Element;
+
+declare const Mocks$7: {
+    default: {
+        callables: string[];
+        id: string;
+        name: string;
+        online: boolean;
+        properties: {
+            current: number;
+            pressure: number;
+            state: string;
+            status: string;
+            voltage: number;
+        };
+        protocol: string;
+        require_staff: boolean;
+        type: string;
+    };
+};
+
+/**
+ * Hardware as exposed by Redux
+ */
+type PusherSchema = Hardware<{
+    state: string;
+}>;
+declare const PusherHardwareDesc: HardwareDesc<PusherSchema>;
+
+interface PusherOptions extends HardwareWidgetOptions {
+    /**
+     * Orientation of the push action.
+     *
+     * This changes the way the widget is displayed.
+     *
+     * One of:
+     * - `right-left`: Push the sample from the right to the left (default)
+     * - `left-right`: Push the sample from the left to the right
+     */
+    orientation?: 'right-left' | 'left-right';
+}
+
+declare function Pusher(props: HardwareWidgetProps<PusherSchema, PusherOptions>): react_jsx_runtime.JSX.Element;
+
+declare function PusherState(props: {
+    hardware: PusherSchema;
+}): react_jsx_runtime.JSX.Element;
+
+declare const Mocks$6: {
+    default: {
+        callables: string[];
+        id: string;
+        name: string;
+        online: boolean;
+        properties: {
+            state: string;
+        };
+        protocol: string;
+        require_staff: boolean;
+        type: string;
+    };
+};
+
+declare function PusherSimulator(props: PropsWithSimulator): react_jsx_runtime.JSX.Element;
+
+/**
+ * Hardware as exposed by Redux
+ */
+type ServiceSchema = Hardware<{
+    state: 'STOPPED' | 'STARTING' | 'RUNNING' | 'BACKOFF' | 'STOPPING' | 'EXITED' | 'FATAL' | 'UNKNOWN';
+}>;
+declare const ServiceHardwareDesc: HardwareDesc<ServiceSchema>;
+
+declare function ServiceDefault(props: HardwareWidgetProps<ServiceSchema, HardwareWidgetOptions>): react_jsx_runtime.JSX.Element;
+
+interface ServiceProectedOptions extends HardwareWidgetOptions {
+    /** Direction to drop the menu */
+    dropDirection?: string;
+}
+declare function ServiceProtected(props: HardwareWidgetProps<ServiceSchema, ServiceProectedOptions>): react_jsx_runtime.JSX.Element;
+
+declare function ServiceState(props: {
+    hardware: ServiceSchema;
+}): react_jsx_runtime.JSX.Element;
+
+declare const Mocks$5: {
+    default: {
+        callables: string[];
+        id: string;
+        name: string;
+        online: boolean;
+        properties: {
+            state: string;
+        };
+        protocol: string;
+        require_staff: boolean;
+        type: string;
+    };
+};
+
+interface TomoFlatMotionStep {
+    /** Axis reference, following the pattern `hardware:my_axis` */
+    axisRef: string;
+    absolute_position: number | null;
+    relative_position: number | null;
+}
+interface TomoFlatMotionProperties extends Record<string, unknown> {
+    state: 'READY' | 'IN' | 'OUT' | 'MOVING_IN' | 'MOVING_OUT' | 'LOST' | 'UNKNOWN';
+    available_axes: string[];
+    motion: TomoFlatMotionStep[];
+    move_in_parallel: boolean;
+    power_onoff: boolean;
+    settle_time: number;
+}
+/**
+ * Hardware as exposed by Redux
+ */
+type TomoFlatMotionSchema = Hardware<TomoFlatMotionProperties>;
+declare const TomoFlatMotionHardwareDesc: HardwareDesc<TomoFlatMotionSchema>;
+
+declare function isTomoFlatMotionHardware(entity: Hardware): entity is TomoFlatMotionSchema;
+declare function useTomoFlatMotionHardware(name: string | null): TomoFlatMotionSchema | null;
+
+declare function TomoFlatMotionDefault(props: HardwareWidgetProps<TomoFlatMotionSchema>): react_jsx_runtime.JSX.Element;
+
+declare function TomoFlatMotionSmall(props: HardwareWidgetProps<TomoFlatMotionSchema>): react_jsx_runtime.JSX.Element;
+
+declare function TomoFlatMotionState(props: {
+    hardware: TomoFlatMotionSchema;
+}): react_jsx_runtime.JSX.Element;
+
+declare const Mocks$4: {
+    default: {
+        id: string;
+        name: string;
+        online: boolean;
+        properties: {
+            state: string;
+            settle_time: number;
+            power_onoff: boolean;
+            move_in_parallel: boolean;
+            available_axes: string[];
+            motion: {
+                axisRef: string;
+                absolute_position: null;
+                relative_position: number;
+            }[];
+        };
+        protocol: string;
+        require_staff: boolean;
+        type: string;
+    };
+    sy: {
+        callables: string[];
+        id: string;
+        name: string;
+        online: boolean;
+        properties: {
+            offset: number;
+            sign: number;
+            acceleration: number;
+            limits: number[];
+            position: number;
+            state: string[];
+            tolerance: number;
+            unit: string;
+            velocity: number;
+            display_digits: number;
+        };
+        protocol: string;
+        require_staff: boolean;
+        type: string;
+        user_tags: never[];
+    };
+    sy2: {
+        callables: string[];
+        id: string;
+        name: string;
+        online: boolean;
+        properties: {
+            offset: number;
+            sign: number;
+            acceleration: number;
+            limits: number[];
+            position: number;
+            state: string[];
+            tolerance: number;
+            unit: string;
+            velocity: number;
+            display_digits: number;
+        };
+        protocol: string;
+        require_staff: boolean;
+        type: string;
+        user_tags: never[];
+    };
+};
+
+declare function TomoFlatMotionSimulator(props: PropsWithSimulator): react_jsx_runtime.JSX.Element;
+
+/**
+ * Hardware as exposed by Redux
+ */
+type TomoReferencePositionSchema = Hardware<Record<string, never>>;
+declare function isTomoReferencePositionHardware(entity: Hardware): entity is TomoReferencePositionSchema;
+declare const TomoReferencePositionHardwareDesc: HardwareDesc<TomoReferencePositionSchema>;
+
+interface TomoReferencePositionDefaultOptions extends HardwareWidgetOptions {
+    /**
+     * If defined, this label is displayed in the button.
+     */
+    label?: string;
+}
+declare function TomoReferencePositionDefault(props: HardwareWidgetProps<TomoReferencePositionSchema, TomoReferencePositionDefaultOptions>): react_jsx_runtime.JSX.Element;
+
+/**
+ * Hardware as exposed by Redux
+ */
+type TomoDetectorSchema = Hardware<{
+    state: string;
+    user_sample_pixel_size: number | null;
+    sample_pixel_size_mode: string;
+    sample_pixel_size: number | null;
+    field_of_view: number;
+    detector: string;
+    optic: string;
+    source_distance: number | null;
+    acq_mode: 'MANUAL' | 'SINGLE' | 'ACCUMULATION';
+}>;
+declare const TomoDetectorHardwareDesc: HardwareDesc<TomoDetectorSchema>;
+
+declare function isTomoDetectorHardware(entity: Hardware): entity is TomoDetectorSchema;
+declare function useTomoDetectorHardware(name: string | null): TomoDetectorSchema | null;
+
+declare function TomoDetectorAcquisitionMode(props: HardwareWidgetProps<TomoDetectorSchema, HardwareWidgetOptions>): react_jsx_runtime.JSX.Element;
+
+interface TomoDetectorSamplePixelSizeOptions extends HardwareWidgetOptions {
+    display_unit?: string | null;
+}
+declare function TomoDetectorSamplePixelSize(props: HardwareWidgetProps<TomoDetectorSchema, TomoDetectorSamplePixelSizeOptions>): react_jsx_runtime.JSX.Element;
+
+declare function TomoDetectorState(props: {
+    hardware: TomoDetectorSchema;
+}): react_jsx_runtime.JSX.Element;
+
+interface TomoDetectorFieldOfViewOptions extends HardwareWidgetOptions {
+    /**
+     * The unit to be used to display the field of view.
+     */
+    display_unit?: string;
+    /**
+     * Number of digits
+     */
+    digits?: number;
+}
+
+declare const Mocks$3: {
+    default: {
+        id: string;
+        name: string;
+        online: boolean;
+        properties: {
+            state: string;
+            sample_pixel_size_mode: string;
+            user_sample_pixel_size: number;
+            sample_pixel_size: number;
+            detector: string;
+            optic: string;
+            source_distance: number;
+            acq_mode: string;
+        };
+        protocol: string;
+        require_staff: boolean;
+        type: string;
+    };
+};
+
+/**
+ * Hardware as exposed by Redux
+ */
+type TomoDetectorsSchema = Hardware<{
+    state: string;
+    detectors: string[];
+    active_detector: string;
+    target_detector?: string;
+}>;
+declare const TomoDetectorsHardwareDesc: HardwareDesc<TomoDetectorsSchema>;
+
+declare function isTomoDetectorsHardware(entity: Hardware): entity is TomoDetectorsSchema;
+declare function useTomoDetectorsHardware(name: string | null): TomoDetectorsSchema | null;
+
+declare function TomoDetectors(props: HardwareWidgetProps<TomoDetectorsSchema>): react_jsx_runtime.JSX.Element;
+
+declare function TomoDetectorsState(props: {
+    hardware: TomoDetectorsSchema;
+}): react_jsx_runtime.JSX.Element;
+
+declare const Mocks$2: {
+    default: {
+        id: string;
+        name: string;
+        online: boolean;
+        properties: {
+            state: string;
+            active_detector: string;
+            detectors: string[];
+        };
+        protocol: string;
+        require_staff: boolean;
+        type: string;
+    };
+};
+
+/**
+ * Hardware as exposed by Redux
+ */
+type TomoImagingSchema = Hardware<{
+    state: string;
+    update_on_move: boolean;
+    exposure_time: number;
+    settle_time: number;
+}>;
+declare const TomoImagingHardwareDesc: HardwareDesc<TomoImagingSchema>;
+
+interface TomoImagingActionsOptions extends HardwareWidgetOptions {
+    /**
+     * If true, the default, the sample location is restored after the action.
+     */
+    restore_sample?: boolean;
+}
+declare function TomoImagingActions(props: HardwareWidgetProps<TomoImagingSchema, TomoImagingActionsOptions>): react_jsx_runtime.JSX.Element;
+
+declare function TomoImagingDefault(props: HardwareWidgetProps<TomoImagingSchema>): react_jsx_runtime.JSX.Element;
+
+interface TomoImagingOptions extends HardwareWidgetOptions {
+    /** Number of digits for the time */
+    digits?: number;
+    /** Unit tailed for the time (if undefined the default is 's' for second) */
+    unit?: string;
+}
+
+declare function TomoImagingExposureTime(props: HardwareWidgetProps<TomoImagingSchema, TomoImagingOptions>): react_jsx_runtime.JSX.Element;
+
+declare function TomoImagingSettleTime(props: HardwareWidgetProps<TomoImagingSchema>): react_jsx_runtime.JSX.Element;
+
+declare function TomoImagingUpdateMode(props: HardwareWidgetProps<TomoImagingSchema>): react_jsx_runtime.JSX.Element;
+
+declare function TomoImagingState(props: {
+    hardware: TomoImagingSchema;
+}): react_jsx_runtime.JSX.Element;
+
+declare const Mocks$1: {
+    default: {
+        id: string;
+        name: string;
+        online: boolean;
+        properties: {
+            state: string;
+            update_on_move: boolean;
+            exposure_time: number;
+        };
+        protocol: string;
+        require_staff: boolean;
+        type: string;
+    };
+};
+
+declare function TomoImagingSimulator(props: PropsWithSimulator): react_jsx_runtime.JSX.Element;
+
+/**
+ * Hardware as exposed by Redux
+ */
+type TomoSampleStageSchema = Hardware<{
+    sx: string;
+    sy: string;
+    sz: string;
+    somega: string;
+    sampx: string;
+    sampy: string;
+    sampu: string;
+    sampv: string;
+    x_axis_focal_pos: number | null;
+    detector_center: [number | null, number | null];
+}>;
+declare const TomoSampleStageHardwareDesc: HardwareDesc<TomoSampleStageSchema>;
+
+declare function isTomoSampleStageHardware(entity: Hardware): entity is TomoSampleStageSchema;
+declare function useTomoSampleStageHardware(name: string | null): TomoSampleStageSchema | null;
+
+/**
+ * Hardware as exposed by Redux
+ */
+type TomoConfigSchema = Hardware<{
+    sample_stage: string;
+    sxbeam: string;
+    detectors: string;
+    holotomo: string;
+    latency_time: number;
+}>;
+declare const TomoConfigHardwareDesc: HardwareDesc<TomoConfigSchema>;
+
+declare function isTomoConfigHardware(entity: Hardware): entity is TomoConfigSchema;
+declare function useTomoConfigHardware(name: string | null): TomoConfigSchema | null;
+
+declare function TomoConfigLatencyTime(props: HardwareWidgetProps<TomoConfigSchema>): react_jsx_runtime.JSX.Element;
+
+interface TomoHoloDistance {
+    z1: number;
+    position: number;
+    pixel_size: number;
+}
+/**
+ * Hardware as exposed by Redux
+ */
+type TomoHoloSchema = Hardware<{
+    state: string;
+    settle_time: number;
+    pixel_size: number | null;
+    nb_distances: number;
+    distances: TomoHoloDistance[];
+}>;
+declare const TomoHoloHardwareDesc: HardwareDesc<TomoHoloSchema>;
+
+declare function isTomoHoloHardware(entity: Hardware): entity is TomoHoloSchema;
+declare function useTomoHoloHardware(name: string | null): TomoHoloSchema | null;
+
+declare function TomoHoloState(props: {
+    hardware: TomoHoloSchema;
+}): react_jsx_runtime.JSX.Element;
+
+/**
+ * Hardware as exposed by Redux
+ */
+type ValveSchema = Hardware<{
+    state: string;
+    status: string;
+}>;
+declare const ValveHardwareDesc: HardwareDesc<ValveSchema>;
+
+declare function Valve(props: HardwareWidgetProps<ValveSchema>): react_jsx_runtime.JSX.Element;
+
+declare const Mocks: {
+    default: {
+        callables: string[];
+        id: string;
+        name: string;
+        online: boolean;
+        properties: {
+            state: string;
+            status: string;
+        };
+        protocol: string;
+        require_staff: boolean;
+        type: string;
+    };
+};
+
+interface Props$a {
+    online: boolean;
+    activeMessage?: string;
+    inactiveMessage?: string;
+    message?: string;
+    icon: string;
+    name: string;
+}
+declare function TypeIcon(props: Props$a): react_jsx_runtime.JSX.Element;
+
+interface Props$9 {
+    hardware: Hardware;
+    headerMode?: string;
+    widgetIcon: ReactElement;
+    widgetState: ReactElement;
+    widgetContent: ReactElement;
+}
+/**
+ * Normalized way to compose hardware component in order to provide the same
+ * kind of layout
+ */
+declare function HardwareTemplate(props: Props$9): react_jsx_runtime.JSX.Element;
+
+/**
+ * Input number synchronized with a hardware.
+ *
+ * Input related to hardware have specificities because the hardware state can
+ * change during the user interaction.
+ *
+ * TODO: Maybe normalize `precision` and `step` together
+ */
+declare function HardwareInputNumber(props: {
+    hardwareValue: number;
+    hardwareIsDisabled: boolean;
+    hardwareIsMoving?: boolean;
+    hardwareIsReady?: boolean;
+    onMoveRequested: (value: number) => Promise<void> | null;
+    onAbortRequested?: () => void;
+    readOnly?: boolean;
+    precision?: number;
+    step?: number;
+}): react_jsx_runtime.JSX.Element;
+
+/**
+ * NumericStep handled hardware properties.
+ *
+ * Input related to hardware have specificities because the hardware state can
+ * change during the user interaction.
+ */
+declare function HardwareNumericStep(props: {
+    hardwareValue: number | null;
+    hardwareIsDisabled: boolean;
+    hardwareIsMoving: boolean;
+    hardwareIsReady: boolean;
+    onMoveRequested: (value: number) => Promise<void> | null;
+    onAbortRequested: () => void;
+    /** Default step size to use for up / down arrows */
+    step?: number | string;
+    /** Array of selectable step sizes */
+    steps?: (number | string)[];
+    /** Number of decimals to show */
+    precision?: number;
+    /** Whether this widget is read only */
+    readOnly?: boolean;
+    /** Whether this widget can only be changed using steps */
+    stepOnly?: boolean;
+    /** Specify a fontawesome to inc the value */
+    incIcon?: string;
+    /** Specify a fontawesome to dec the value */
+    decIcon?: string;
+    /** If true inc and dec icon are swapped */
+    swapIncDec?: boolean;
+    /** Show the step arrows horizontally instead of vertically */
+    horizontalArrows?: boolean;
+    /** Show large step arrows */
+    largeArrows?: boolean;
+    /** Identifier passed to the input element */
+    id?: string;
+}): react_jsx_runtime.JSX.Element;
+
+/**
+ * Normalize the way to display an hardware state.
+ *
+ * If `minWidth` is pecified (in `em`) it ensure the widget width will stay the
+ * same when the state change
+ *
+ * A `hardwareStatus` can be defined, which is a human readable global description
+ * of the state of the device.
+ */
+declare function State$1(props: {
+    state: string;
+    variant: string;
+    minWidth?: number;
+    description?: string;
+    hardwareStatus?: string;
+}): react_jsx_runtime.JSX.Element;
+/**
+ * Normalize the way to display an hardware exposing multiple states.
+ *
+ * - `states` is the states exposed by the hardware.
+ * - `variants` contains a variant for each of this states, else `fatal` is used.
+ * - `descriptions` can be provided to add a description to the state.
+ * - `hardwareStatus` A global description of the state of the device
+ *
+ * If `minWidth` is pecified (in `em`) it ensure the widget width will stay the
+ * same when the state change
+ */
+declare function MultiState(props: {
+    states: string[];
+    variants?: Record<string, string>;
+    descriptions?: Record<string, string>;
+    minWidth?: number;
+    hardwareStatus?: string;
+}): react_jsx_runtime.JSX.Element;
+
+declare function formatEng(scalar: number): {
+    scalar: number;
+    prefix: string;
+    multiplier: number;
+};
+/**
+ * Returns the argument as capitalized string.
+ */
+declare function ucfirst(str: string): string;
+declare function toHoursMins(seconds: number): string;
+declare function toEnergy(wavelength: number): string | 0;
+declare function round(value: number, digits: number): number;
+
+declare const formatting_d_formatEng: typeof formatEng;
+declare const formatting_d_round: typeof round;
+declare const formatting_d_toEnergy: typeof toEnergy;
+declare const formatting_d_toHoursMins: typeof toHoursMins;
+declare const formatting_d_ucfirst: typeof ucfirst;
+declare namespace formatting_d {
+  export { formatting_d_formatEng as formatEng, formatting_d_round as round, formatting_d_toEnergy as toEnergy, formatting_d_toHoursMins as toHoursMins, formatting_d_ucfirst as ucfirst };
+}
+
+interface NoObjectProps$5 {
+    id: string;
+    name?: string;
+    options: {
+        header?: string;
+        emptyifnone?: boolean;
+    };
+}
+declare function NoObject$1(props: NoObjectProps$5): react_jsx_runtime.JSX.Element;
+
+interface NoObjectProps$4 {
+    id: string;
+    name?: string;
+    options: {
+        header?: string;
+    };
+}
+declare function LoadingObject(props: NoObjectProps$4): react_jsx_runtime.JSX.Element;
+
+interface NoObjectProps$3 {
+    id: string;
+    name?: string;
+    options: {
+        header?: string;
+        emptyifnone?: boolean;
+    };
+}
+declare function MissingObject(props: NoObjectProps$3): react_jsx_runtime.JSX.Element;
+
+interface NoObjectProps$2 {
+    id: string;
+    name?: string;
+    properties?: {
+        message?: string;
+    };
+    options: {
+        header?: string;
+    };
+}
+declare function ErrorObject(props: NoObjectProps$2): react_jsx_runtime.JSX.Element;
+
+interface NoObjectProps$1 {
+    id: string;
+    name?: string;
+    type?: string;
+    options: {
+        variant?: string;
+        header?: string;
+        emptyifnone?: boolean;
+    };
+}
+declare function MissingComponentObject(props: NoObjectProps$1): react_jsx_runtime.JSX.Element;
+
+interface NoObjectProps {
+    id: string;
+    name?: string;
+    options: {
+        header?: string;
+        emptyifnone?: boolean;
+    };
+}
+declare function NoObject(props: NoObjectProps): react_jsx_runtime.JSX.Element;
+
+interface Props$8 {
+    className?: string;
+}
+declare function FullSizer(props: PropsWithChildren<Props$8>): react_jsx_runtime.JSX.Element;
+
+interface Props$7 {
+    size: number;
+    value?: number | null;
+    target?: number | null;
+    min?: number;
+    max?: number;
+    disabled?: boolean;
+    readOnly?: boolean;
+    origin?: 'up' | 'down' | 'left' | 'right';
+    direction?: 'clockwise' | 'anticlockwise';
+    onChange?: (value: number) => void;
+    onInteractiveChange?: (value: number) => void;
+    className: string;
+}
+/**
+ * Widget to handle cyclic angle value in degree displayed as an infinite knob
+ */
+declare function InfiniteKnob360(props: Props$7): react_jsx_runtime.JSX.Element;
+
+declare function Gauge(props: {
+    size: number;
+    value: number | null;
+    min: number;
+    max: number;
+    lowWarning?: number;
+    hiWarning?: number;
+    lowDanger?: number;
+    hiDanger?: number;
+}): react_jsx_runtime.JSX.Element;
+
+interface Props$6 {
+    step?: number | string;
+    steps?: (number | string)[];
+    disabled: boolean;
+    stepOnly?: boolean;
+    id?: string;
+    unit?: string;
+    overlay?: ReactNode | null;
+    incIcon?: string;
+    decIcon?: string;
+    swapIncDec?: boolean;
+    className?: string;
+    type?: 'number' | 'text';
+    precision?: number;
+    horizontalArrows?: boolean;
+    largeArrows?: boolean;
+    onBlur: () => void;
+    onChange: (e: ChangeEvent<HTMLInputElement>) => void;
+    onStep: (params: {
+        target: HTMLInputElement;
+    }) => void;
+    onKeyDown?: (e: KeyboardEvent<HTMLInputElement>) => void;
+}
+declare const NumericStep: react.ForwardRefExoticComponent<Props$6 & react.RefAttributes<HTMLInputElement>>;
+
+declare function PanelHeader(props: PropsWithChildren<{
+    style?: Record<string, any>;
+}>): react_jsx_runtime.JSX.Element;
+declare function PanelContents(props: PropsWithChildren<{
+    style?: Record<string, any>;
+    className?: string;
+}>): react_jsx_runtime.JSX.Element;
+interface Props$5 {
+    style?: Record<string, any>;
+    scroll?: boolean;
+    className?: string;
+}
+declare function Panel(props: PropsWithChildren<Props$5>): react_jsx_runtime.JSX.Element;
+declare namespace Panel {
+    var Header: typeof PanelHeader;
+    var Contents: typeof PanelContents;
+}
+
+interface YamlNode {
+    type: string;
+    children?: YamlNode[];
+    _parentNode: YamlNode | null;
+    _indexFromParent: number | null;
+}
+interface YamlRoot extends YamlNode {
+    name: string;
+    error: string;
+}
+interface AnyYamlNode extends YamlNode {
+    [key: string]: any;
+}
+interface YamlComponent {
+    providers?: Record<string, any>;
+    yamlNode: YamlNode;
+    [option: string]: unknown;
+}
+
+interface YamlTodoOptions {
+    /** Message to display, defaults to "TODO" */
+    message?: string;
+}
+declare function Yaml$1(props: YamlComponent & YamlTodoOptions): react_jsx_runtime.JSX.Element;
+
+declare function Yaml(props: YamlComponent): react_jsx_runtime.JSX.Element;
+
+/**
+ * Component which display the state of a hardware.
+ *
+ * It is based on the type of the hardware, and fallback to the
+ * `AnyHardwareState` component if no components are available.
+ */
+declare function HardwareState(props: {
+    hardware: AnyHardware | null;
+    options?: {
+        emptyifnone?: boolean;
+    };
+}): react_jsx_runtime.JSX.Element;
+
+interface StateComparator {
+    /** The state comparator */
+    comparator: string;
+    /** The state value to compare */
+    comparison: string;
+    /** Optionally, a color for this comparison */
+    color?: string;
+}
+interface SynopticElementType {
+    /** The svg element class name */
+    name: string;
+    /** Which property to use as the value, i.e. `s1b.position` */
+    value?: string;
+    /** How many digits to display */
+    value_display_digits?: number;
+    /** Optionally, Which property to use to display the state. If left blank, the aggregated state from each element in `ids` below will be used */
+    state?: string;
+    /** Optionally, a comparison, can be a single comparison for red/green or a list of comparisons with colors */
+    state_comparison?: StateComparator | StateComparator[];
+    /** A list of hardware object ids to display on click */
+    ids?: string[];
+}
+interface SynopticType {
+    /** A list of elements to be mapped to their classes in the svg */
+    elements: SynopticElementType[];
+    /** The synoptic file to load */
+    synoptic: string;
+    /** Whether to enable daiquiri `colorisation` of icons */
+    color_icons: boolean;
+}
+interface Props$4 {
+    fetchSVG: (image: string) => Promise<{
+        data: any;
+    }>;
+    getHardwareGroupComponent: (ids: string[]) => JSX.Element;
+    hardwareObjects: Record<string, AnyHardware>;
+    synoptic: SynopticType;
+}
+declare function Synoptic(props: Props$4): react_jsx_runtime.JSX.Element;
+
+interface Props$3 {
+    testid: string;
+    layout: YamlRoot;
+    className?: string;
+    unhandledComponentDidCatch?: (error: Error, setStateCallback: (data: Record<string, any>) => void) => void;
+    UnhandledErrorComponent?: React.ComponentType<any>;
+}
+declare function Main(props: Props$3): react_jsx_runtime.JSX.Element;
+
+interface State {
+    hasError: boolean;
+    message: string;
+    error?: Error;
+}
+interface Props$2 {
+    resetKey?: any;
+    unhandledComponentDidCatch?: (error: Error, setStateCallback: (data: Record<string, any>) => void) => void;
+    UnhandledErrorComponent?: react__default.ComponentType<any>;
+}
+declare class ErrorBoundary extends Component<PropsWithChildren<Props$2>, State> {
+    constructor(props: Props$2);
+    static getDerivedStateFromError(): {
+        hasError: boolean;
+    };
+    private readonly reload;
+    componentDidCatch(error: Error): void;
+    componentDidUpdate(prevProps: Props$2, prevState: State): void;
+    render(): string | number | boolean | react_jsx_runtime.JSX.Element | Iterable<react__default.ReactNode> | null | undefined;
+}
+
+/**
+ * Render a Yaml node using registred component from the node type
+ */
+declare function renderYamlNode(yamlNode: AnyYamlNode, key: number | string, panel?: boolean): react_jsx_runtime.JSX.Element;
+declare class LayoutError extends Error {
+    readonly yamlNode: YamlNode;
+    constructor(message: string, yamlNode: YamlNode);
+}
+declare class MissingKeysError extends LayoutError {
+    readonly keys: string[];
+    constructor(yamlNode: YamlNode, missingKeys: string[]);
+}
+declare class KeyError extends LayoutError {
+    readonly key: string;
+    readonly keyMessage: string;
+    constructor(yamlNode: YamlNode, key: string, message: string);
+}
+
+/**
+ * Store the mapping from Yaml `type` to React component handling the
+ * rendering of such Yaml node
+ */
+declare const yamlContainers: Record<string, ComponentType<any>>;
+/**
+ * Register the Yaml type with the component used to render this Yaml node.
+ */
+declare function registerYamlContainer(name: string, component: ComponentType<any>): void;
+declare const yamlComponents: Record<string, ComponentType<any>>;
+/**
+ * Register a yaml component.
+ *
+ * Such component is wrapped inside a `Panel`.
+ */
+declare function registerYamlComponent(name: string, component: ComponentType<any>): void;
+/**
+ * Register multiple yaml components.
+ *
+ * Such components are wrapped inside a `Panel`.
+ */
+declare function registerYamlComponents(map: Record<string, ComponentType<any>>): void;
+/**
+ * Get the current mapping from Yaml `type` to registered component.
+ */
+declare function getYamlComponents(): Record<string, ComponentType<any>>;
+/**
+ * Get the current mapping from Yaml `type` to registered container.
+ */
+declare function getYamlContainers(): Record<string, ComponentType<any>>;
+
+type Defined<T> = T extends undefined ? never : T;
+declare function assertKeyExpected<T>(yamlNode: YamlNode | undefined, key: string, value: T): asserts value is Defined<T>;
+declare function assertString(yamlNode: YamlNode, key: string, value: any): asserts value is string;
+declare function assertBoolean(yamlNode: YamlNode, key: string, value: unknown): asserts value is boolean;
+declare function assertNumber(yamlNode: YamlNode, key: string, value: unknown): asserts value is number;
+declare function assertOptionalBoolean(yamlNode: YamlNode, key: string, value: unknown): asserts value is boolean | undefined;
+declare function assertOptionalString(yamlNode: YamlNode, key: string, value: unknown): asserts value is string | undefined;
+declare function assertStringList(yamlNode: YamlNode, key: string, value: unknown): asserts value is string[];
+declare function assertOptionalStringOrStringList(yamlNode: YamlNode, key: string, value: unknown): asserts value is string | string[] | undefined;
+declare function assertOptionalStringList(yamlNode: YamlNode, key: string, value: unknown): asserts value is string[] | undefined;
+declare function assertOptionalNumber(yamlNode: YamlNode, key: string, value: unknown): asserts value is number | undefined;
+declare function assertOptionalNumberList(yamlNode: YamlNode, key: string, value: unknown): asserts value is string[] | undefined;
+declare function assertOptionalListOfType<Y>(yamlNode: YamlNode, key: string, value: unknown, isType: (value: Y) => boolean, typeName: string): asserts value is Y[] | undefined;
+declare function assertNoUnknownKeys(yamlNode: YamlNode | undefined, remainingContent: Record<string, any>): void;
+declare function assertDataCollectionId(yamlNode: YamlNode, key: string, value: unknown): asserts value is number | 'last';
+declare function assertOptionalBackend(yamlNode: YamlNode, key: string, value: unknown): asserts value is 'plotly' | 'h5web' | undefined;
+/**
+ * Assert function for generic 'args' as used in python
+ * function with `*args`.
+ *
+ * The argument is validated as a list of unknown items.
+ */
+declare function assertOptionalArgs(yamlNode: YamlNode, key: string, value: unknown): asserts value is unknown[] | undefined;
+/**
+ * Assert function for generic 'kwargs' as used in python
+ * function with `**kwargs`.
+ *
+ * The argument is validated as a record from string to unknown values.
+ */
+declare function assertOptionalKwargs(yamlNode: YamlNode, key: string, value: unknown): asserts value is Record<string, unknown> | undefined;
+/**
+ * Type a schema from it;s typescript description.
+ *
+ * See `assertStringMappingRecord`
+ */
+type Schema<T> = Record<keyof T, (yamlNode: YamlNode, key: string, value: unknown) => void>;
+/**
+ * Assert function for generic record of string.
+ *
+ * Can be used as the basis of a specific assertion.
+ *
+ * The argument is validated as a record from string to unknown values.
+ *
+ * @param options: Parsing parameters
+ */
+declare function assertStringMappingRecord<T extends Partial<Record<string, any>>>(yamlNode: YamlNode, key: string, value: unknown, options: {
+    /** If true, the value can be `undefined` */
+    optional?: boolean;
+    /** Mapping from expected keys to the relative assert function */
+    schema: Record<string, (yamlNode: YamlNode, key: string, value: unknown) => void>;
+}): asserts value is T;
+
+type asserts_d_Schema<T> = Schema<T>;
+declare const asserts_d_assertBoolean: typeof assertBoolean;
+declare const asserts_d_assertDataCollectionId: typeof assertDataCollectionId;
+declare const asserts_d_assertKeyExpected: typeof assertKeyExpected;
+declare const asserts_d_assertNoUnknownKeys: typeof assertNoUnknownKeys;
+declare const asserts_d_assertNumber: typeof assertNumber;
+declare const asserts_d_assertOptionalArgs: typeof assertOptionalArgs;
+declare const asserts_d_assertOptionalBackend: typeof assertOptionalBackend;
+declare const asserts_d_assertOptionalBoolean: typeof assertOptionalBoolean;
+declare const asserts_d_assertOptionalKwargs: typeof assertOptionalKwargs;
+declare const asserts_d_assertOptionalListOfType: typeof assertOptionalListOfType;
+declare const asserts_d_assertOptionalNumber: typeof assertOptionalNumber;
+declare const asserts_d_assertOptionalNumberList: typeof assertOptionalNumberList;
+declare const asserts_d_assertOptionalString: typeof assertOptionalString;
+declare const asserts_d_assertOptionalStringList: typeof assertOptionalStringList;
+declare const asserts_d_assertOptionalStringOrStringList: typeof assertOptionalStringOrStringList;
+declare const asserts_d_assertString: typeof assertString;
+declare const asserts_d_assertStringList: typeof assertStringList;
+declare const asserts_d_assertStringMappingRecord: typeof assertStringMappingRecord;
+declare namespace asserts_d {
+  export { type asserts_d_Schema as Schema, asserts_d_assertBoolean as assertBoolean, asserts_d_assertDataCollectionId as assertDataCollectionId, asserts_d_assertKeyExpected as assertKeyExpected, asserts_d_assertNoUnknownKeys as assertNoUnknownKeys, asserts_d_assertNumber as assertNumber, asserts_d_assertOptionalArgs as assertOptionalArgs, asserts_d_assertOptionalBackend as assertOptionalBackend, asserts_d_assertOptionalBoolean as assertOptionalBoolean, asserts_d_assertOptionalKwargs as assertOptionalKwargs, asserts_d_assertOptionalListOfType as assertOptionalListOfType, asserts_d_assertOptionalNumber as assertOptionalNumber, asserts_d_assertOptionalNumberList as assertOptionalNumberList, asserts_d_assertOptionalString as assertOptionalString, asserts_d_assertOptionalStringList as assertOptionalStringList, asserts_d_assertOptionalStringOrStringList as assertOptionalStringOrStringList, asserts_d_assertString as assertString, asserts_d_assertStringList as assertStringList, asserts_d_assertStringMappingRecord as assertStringMappingRecord };
+}
+
+interface YamlRowOptions {
+    /** Inline CSS styles applied to the row */
+    style?: Record<string, any>;
+}
+
+interface YamlColOptions {
+    /** Inline CSS styles applied to the column */
+    style?: Record<string, any>;
+    /** Bootstrap column width (1-12) */
+    xs?: number;
+}
+
+interface YamlContainerOptions {
+    /** Options spread onto the underlying Container */
+    options?: Record<string, any>;
+    /** Inline CSS styles applied to the row */
+    style?: Record<string, any>;
+}
+
+interface YamlGridOptions {
+    /** Grid panel title */
+    title?: string;
+    /** CSS grid-template-columns value */
+    columns?: string;
+    /** CSS grid-template-rows value */
+    rows?: string;
+    /** Inline CSS styles applied to the column */
+    style?: Record<string, any>;
+}
+/** Options for an individual cell within a grid. */
+interface YamlGridCellOptions {
+    /** Number of grid columns this cell spans */
+    columnSpan?: number;
+    /** Number of grid rows this cell spans */
+    rowSpan?: number;
+}
+
+interface YamlPanelOptions {
+    /** Options spread onto the underlying Panel */
+    options?: Record<string, any>;
+    /** Panel title */
+    title?: string;
+    /** Center the panel's contents */
+    centerContent?: boolean;
+    /** Inline CSS styles applied to the underlying Panel */
+    style?: Record<string, any>;
+}
+
+/** Options for an individual tab within Tabs */
+interface YamlTabsRowOptions {
+    /** Tab header */
+    title?: string;
+    /** Inline CSS styles applied to the tab's content pane */
+    style?: Record<string, any>;
+}
+interface YamlTabsOptions {
+    /** Options spread onto the underlying Panel */
+    options?: Record<string, any>;
+    /** Tabs panel title */
+    title: string;
+    /** Inline CSS styles applied to the underlying Panel */
+    style?: Record<string, any>;
+}
+
+/** A section header spanning both columns of the form grid. */
+interface YamlFormHeaderOptions {
+    type: 'formheader';
+    /** Header text */
+    title?: string;
+    /** Inline CSS styles applied to the form's content grid */
+    style?: Record<string, any>;
+}
+
+/** A single labelled row of the form, rendering its content in the second column. */
+interface YamlFormRowOptions {
+    /** Type of the node rendered in the row's content column (e.g. 'hardware') */
+    type: string;
+    /** Row title shown in the first column; for hardware rows, defaults to the hardware id's name if unset */
+    title: string;
+    /** For hardware rows, show the hardware state under the title */
+    stateinheader?: boolean;
+    /** CSS align-self applied to the title cell */
+    titlealign?: string;
+    /** Hardware id, used for the default title and passed to the rendered content node */
+    id?: string;
+    /** Hardware variant passed to the rendered content node */
+    variant?: string;
+    /** Passed through to the rendered content node */
+    options?: Record<string, any>;
+    /** Passed through to the rendered content node */
+    even: boolean;
+}
+interface YamlFormOptions {
+    /** Form panel title */
+    title?: string;
+    /** Options spread onto the underlying Panel */
+    options?: Record<string, any>;
+    /** Inline CSS styles applied to the form's content grid */
+    style?: Record<string, any>;
+}
+
+interface YamlLabelOptions {
+    /** Text to display */
+    label: string;
+}
+
+interface RuntimeHooks {
+    useHardware?: (id: string | null) => AnyHardware | null;
+    useHardwareChangeActions?: (name: string | null) => HardwareChangeActions;
+    useHardwareSchema?: (hardware: {
+        id: string;
+        type: string;
+    } | null) => HardwareSchemaDescription | null;
+    useOperator?: () => boolean;
+    useScanRunning?: () => boolean;
+}
+declare function registerRuntimeHook(hooks: Partial<RuntimeHooks>): void;
+/**
+ * Return a hardware from it's hardware name.
+ *
+ * Return `null` if the name refers to nothing.
+ *
+ * @param name: An hardware identifier, or null
+ */
+declare function useHardware(id: string | null): AnyHardware | null;
+/**
+ * Expose the generic actions provided by a specific hardware.
+ *
+ * If null is passed, dummy actions are exposed.
+ *
+ * @param name: Am hardware identifier, or null
+ */
+declare function useHardwareChangeActions(name: string | null): HardwareChangeActions;
+/**
+ * Expose the generic actions provided by a specific hardware.
+ *
+ * If null is passed, dummy actions are exposed.
+ *
+ * @param name: Am hardware identifier, or null
+ */
+declare function useHardwareSchema(hardware: {
+    id: string;
+    type: string;
+} | null): HardwareSchemaDescription | null;
+/**
+ * True if the actual user can control the beamline (like moving motors)
+ */
+declare function useOperator(): boolean;
+/**
+ * True if a scan is actually running
+ */
+declare function useScanRunning(): boolean;
+
+interface Monitor {
+    /**
+     * Title shown above the value.
+     */
+    name: string;
+    /**
+     * Describe the kind of widget.
+     *
+     * NOTE: New components can be registered with `registerMonitorComponent`
+     */
+    type?: string;
+}
+
+/** Valid `comparator` values for a Monitor's `comparator`/`comparison` pair — see `dynamicOp`. */
+declare const COMPARATORS: string[];
+declare const dynamicOp: (op: string, a1: any, b1: any) => boolean | undefined;
+interface MonitorHardwarePropertyOptions {
+    /**
+     * The value to display, a path, for example `omega.position`
+     */
+    value: string;
+    /**
+     * An optional second value shown in a tooltip on
+     * hover. Again a path.
+     */
+    overlay?: string;
+    /**
+     * One of `COMPARATORS`, green if the comparison holds,
+     * red otherwise, grey if either `comparator` or `comparison` is unset.
+     */
+    comparator?: string;
+    /**
+     * The value `comparator` compares the
+     * live `value` against.schema
+     */
+    comparison?: any;
+    /**
+     * A fixed unit string (e.g. `mA`)
+     */
+    unit?: string;
+}
+interface Props$1 {
+    monitor: MonitorHardwarePropertyOptions & Monitor;
+}
+declare function MonitorHardwareProperty(props: Props$1): react_jsx_runtime.JSX.Element;
+
+interface MonitorHardwareOptions {
+    /**
+     * The hardware id to render
+     */
+    id?: string;
+}
+interface Props {
+    monitor: MonitorHardwareOptions & Monitor;
+}
+/**
+ * HardwareMonitor which provide callback to get the
+ * component from the hardware type.
+ */
+declare function MonitorHardware(props: Props): react_jsx_runtime.JSX.Element;
+
+interface MonitorMapping {
+    [name: string]: ComponentType<any>;
+}
+declare function registerMonitorComponent(name: string, component: React.ComponentType<any>): void;
+declare function getAllMonitors(): MonitorMapping;
+interface MonitorPanelProps {
+    monitors: Monitor[];
+    margin?: 'start' | null;
+    bg?: 'light' | null;
+}
+declare function MonitorPanel(props: MonitorPanelProps): react_jsx_runtime.JSX.Element;
+
+interface MonitorPanelItemProps {
+    className?: string;
+    style?: Record<string, unknown>;
+}
+/**
+ * Component for any item displayed in the monitor panel.
+ *
+ * The implementation with `forwardRef` and `...rest` allow
+ * to use it inside a `OverlayTrigger`
+ *
+ * @param rest: Passthough to allow to wrap the component inside
+ *              OverlayTrigger. It contains callbacks.
+ */
+declare const MonitorPanelItem: react.ForwardRefExoticComponent<MonitorPanelItemProps & {
+    children?: react.ReactNode | undefined;
+} & react.RefAttributes<HTMLDivElement>>;
+
+/**
+ * Drop the leading `$` from a hardware id reference (e.g. `$sampz`).
+ *
+ * @todo: In the future this should be done earlier and
+ *        should raise a parsing error
+ */
+declare function normalizeId(id: unknown): string | null;
+
+/**
+ * Register an hardware variant.
+ */
+declare function registerHardwareVariant(type: string, variant: string, component: HardwareComponentType<AnySchema>): void;
+/**
+ * Return a hardware variant component.
+ *
+ * - Check first if a hardware type and variant
+ *   is registered, return it.
+ * - Else, check if the 'base' type and variant
+ *   is registered, return it
+ * - Else, return null
+ *
+ * @param type: Type of the hardware
+ * @param variant: Variant requested
+ */
+declare function getHardwareVariantComponent(type: string, variant: string): HardwareComponentType | null;
+/**
+ * Get the full list of hardware descriptions.
+ */
+declare function getAllHardwareDesc(): Record<string, HardwareDesc<AnyHardware>>;
+
+export { type ActuatorSchema, AirBearing, AirBearingHardwareDesc, Mocks$p as AirBearingMocks, AirBearingProtected, type AirBearingSchema, AirBearingSimulator, AirBearingState, type AnyHardware, type AnySchema, type BaseHardware, BaseHardwareDesc, Info as BaseInfo, type BaseInfoWidgetOptions, Mocks$q as BaseMocks, Name as BaseName, type BaseNameWidgetOptions, Property as BaseProperty, type BasePropertyWidgetOptions, DefaultState$1 as BaseState, BeamlineHardwareDesc, Beamviewer, BeamviewerHardwareDesc, Mocks$o as BeamviewerMocks, type BeamviewerSchema, BeamviewerSimulator, COMPARATORS, EnergyManagerDefault, EnergyManagerHardwareDesc, Mocks$n as EnergyManagerMocks, type EnergyManagerSchema, EnergyManagerSimulator, EnergyManagerState, ErrorObject, type ExceptionFromProcedure, FiltersetDefault, FiltersetHardwareDesc, Mocks$m as FiltersetMocks, type FiltersetSchema, FiltersetSimulator, DefaultState as FiltersetState, formatting_d as Formatting, Frontend, FrontendHardwareDesc, Mocks$l as FrontendMocks, type FrontendSchema, FullSizer, Gauge$1 as Gauge, GaugeHardwareDesc, Gauge as GaugeIndicator, Mocks$k as GaugeMocks, type GaugeSchema, type GaugeWidgetOptions, type GenericSchema, type Hardware, type HardwareComponentType, type HardwareDesc, type HardwareFromProcedure, HardwareInputNumber, HardwareNumericStep, type HardwareObjectProps, schema_d as HardwareSchema, HardwareState, HardwareTemplate, types_d as HardwareTypes, type HardwareVariant, InfiniteKnob360, KeyError, Laser, LaserHardwareDesc, LaserHeating, LaserHeatingHardwareDesc, Mocks$i as LaserHeatingMocks, type LaserHeatingSchema, type LaserHeatingWidgetOptions, Mocks$j as LaserMocks, type LaserSchema, type LaserWidgetOptions, Light, LightHardwareDesc, Mocks$h as LightMocks, type LightSchema, LimaBinning, LimaDefault, TomoDetectorSize$2 as LimaDescription, LimaHardwareDesc, TomoDetectorSize$1 as LimaImageRoi, Mocks$g as LimaMocks, type LimaSchema, LimaRoiShape as LimaShape, LimaSimulator, TomoDetectorSize as LimaSize, LimaState, LimaTransformation, LoadingObject, MeasurementGroup as MeasurementGroupDefault, MeasurementGroupHardwareDesc, Mocks$f as MeasurementGroupMocks, type MeasurementGroupSchema, MeasurementGroupSimulator, MissingComponentObject, MissingKeysError, MissingObject, type Monitor, MonitorHardware, MonitorHardwareProperty, MonitorPanel, MonitorPanelItem, type MonitorPanelProps, MotorDefault, type MotorDefaultOptions, MotorHardwareDesc, Mocks$e as MotorMocks, MotorRotation, type MotorSchema, MotorSimulator, MotorState, MotorText, MultiState, Multiposition$1 as Multiposition, Multiposition as MultipositionDefault2, type MultipositionDefault2Options, MultipositionHardwareDesc, Mocks$d as MultipositionMocks, type MultipositionSchema, MultipositionSimulator, NoObject$1 as NoObject, Yaml as None, NoObject as NullObject, NumericStep, Optic as OpticDefault, OpticHardwareDesc, Mocks$c as OpticMocks, type OpticSchema, OpticSimulator, OpticState, type OpticWidgetOptions, Panel, Actions as ProcedureActions, ProcedureExecution, FinishedState as ProcedureFinishedState, ProcedureHardwareDesc, ProcedureManage, Mocks$b as ProcedureMocks, type ProcedureOptions, type ProcedureSchema, ProcedureState, ProcedureValidate, Pump as PumpDefault, PumpHardwareDesc, Mocks$7 as PumpMocks, type PumpSchema, Pusher as PusherDefault, PusherHardwareDesc, Mocks$6 as PusherMocks, type PusherOptions, type PusherSchema, PusherSimulator, PusherState, RegulationLoop as RegulationDefault, RegulationHardwareDesc, Mocks$a as RegulationMocks, type RegulationOptions, RegulationPlot, type RegulationSchema, RegulationSimulator, type ScanFromProcedure, ServiceDefault, ServiceHardwareDesc, Mocks$5 as ServiceMocks, ServiceProtected, type ServiceSchema, ServiceState, ShutterDefault, ShutterHardwareDesc, Mocks$9 as ShutterMocks, ShutterProtected, type ShutterSchema, ShutterSimulator, ShutterState, SlitDefault, SlitHardwareDesc, Mocks$8 as SlitMocks, type SlitSchema, SlitState, State$1 as State, Synoptic, type SynopticElementType, type SynopticType, Yaml$1 as Todo, TomoConfigHardwareDesc, TomoConfigLatencyTime, type TomoConfigSchema, TomoDetectorAcquisitionMode, type TomoDetectorFieldOfViewOptions, TomoDetectorHardwareDesc, Mocks$3 as TomoDetectorMocks, TomoDetectorSamplePixelSize, type TomoDetectorSchema, TomoDetectorState, TomoDetectors as TomoDetectorsDefault, TomoDetectorsHardwareDesc, Mocks$2 as TomoDetectorsMocks, type TomoDetectorsSchema, TomoDetectorsState, TomoFlatMotionDefault, TomoFlatMotionHardwareDesc, Mocks$4 as TomoFlatMotionMocks, type TomoFlatMotionSchema, TomoFlatMotionSimulator, TomoFlatMotionSmall, TomoFlatMotionState, type TomoFlatMotionStep, type TomoHoloDistance, TomoHoloHardwareDesc, type TomoHoloSchema, TomoHoloState, TomoImagingActions, TomoImagingDefault, TomoImagingExposureTime, TomoImagingHardwareDesc, Mocks$1 as TomoImagingMocks, type TomoImagingOptions, type TomoImagingSchema, TomoImagingSettleTime, TomoImagingSimulator, TomoImagingState, TomoImagingUpdateMode, TomoReferencePositionDefault, TomoReferencePositionHardwareDesc, type TomoReferencePositionSchema, TomoSampleStageHardwareDesc, type TomoSampleStageSchema, TypeIcon, type Props$a as TypeIconOptions, Valve as ValveDefault, ValveHardwareDesc, Mocks as ValveMocks, type ValveSchema, ErrorBoundary as YAMLErrorBoundary, Main as YAMLLayout, asserts_d as YamlAsserts, type YamlColOptions, type YamlComponent, type YamlContainerOptions, type YamlFormHeaderOptions, type YamlFormOptions, type YamlFormRowOptions, type YamlGridCellOptions, type YamlGridOptions, type YamlLabelOptions, type YamlNode, type YamlPanelOptions, type YamlRowOptions, type YamlTabsOptions, type YamlTabsRowOptions, type YamlTodoOptions, createMotorMock, dynamicOp, getAllHardwareDesc, getAllMonitors, getHardwareVariantComponent, getYamlComponents, getYamlContainers, isLimaHardware, isMotorClockWise, isMotorHardware, isOpticHardware, isProcedureHardware, isTomoConfigHardware, isTomoDetectorHardware, isTomoDetectorsHardware, isTomoFlatMotionHardware, isTomoHoloHardware, isTomoReferencePositionHardware, isTomoSampleStageHardware, limaGuessSubframes, motorLimits, normalizeId, registerHardwareVariant, registerMonitorComponent, registerRuntimeHook, registerYamlComponent, registerYamlComponents, registerYamlContainer, renderYamlNode, useHardware, useHardwareChangeActions, useHardwareSchema, useLimaHardware, useMotorHardware, useMotorStates, useOperator, useProcedureHardware, useScanRunning, useTomoConfigHardware, useTomoDetectorHardware, useTomoDetectorsHardware, useTomoFlatMotionHardware, useTomoHoloHardware, useTomoSampleStageHardware, yamlComponents, yamlContainers };