@esrf/daiquiri-lib 1.1.0 → 2.1.0

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="react" />
 import * as React$1 from 'react';
-import React__default, { ReactElement, Component, ComponentType, PropsWithChildren, ReactChild, ChangeEvent, KeyboardEvent } from 'react';
+import React__default, { ComponentType, ReactElement, PropsWithChildren, ReactChild, ChangeEvent, KeyboardEvent, Component } from 'react';
 
 interface HardwareError {
     property: string;
@@ -53,188 +53,1728 @@ interface Hardware {
     /** Any potential errors initialising this object */
     errors?: HardwareError[];
 }
+interface AnyHardware extends Hardware {
+    properties: 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
+ * 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;
+}
+declare 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>;
+    /** Static schema describing the hardware */
+    schema: HardwareSchemaDescription;
+    /** 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;
+}
+declare type HardwareComponentType<H extends Hardware = Hardware> = ComponentType<HardwareWidgetProps<H, any>>;
+interface HardwareVariant<H extends Hardware = Hardware> {
+    [name: string]: HardwareComponentType<H>;
+}
+
+type types_d_AnyHardware = AnyHardware;
+type types_d_EditableHardware<H extends Hardware = Hardware> = EditableHardware<H>;
+type types_d_Hardware = Hardware;
+type types_d_HardwareChangeActions = HardwareChangeActions;
+type types_d_HardwareComponentType<H extends Hardware = Hardware> = HardwareComponentType<H>;
+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>;
+declare namespace types_d {
+  export type { types_d_AnyHardware as AnyHardware, types_d_EditableHardware as EditableHardware, types_d_Hardware as Hardware, types_d_HardwareChangeActions as HardwareChangeActions, types_d_HardwareComponentType as HardwareComponentType, types_d_HardwareSchemaDescription as HardwareSchemaDescription, types_d_HardwareVariant as HardwareVariant, types_d_HardwareWidgetOptions as HardwareWidgetOptions, types_d_HardwareWidgetProps as HardwareWidgetProps };
+}
+
+interface GenericSchema extends Hardware {
+    properties: {
+        state: string;
+    };
+}
+interface AnySchema extends Hardware {
+    properties: any;
+}
+
+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 Variants$q: HardwareVariant<AnySchema>;
+
+declare const Mocks$m: {
+    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(props: HardwareWidgetProps<AnySchema>): JSX.Element;
+
+interface BaseNameWidgetOptions extends HardwareWidgetOptions {
+    overrideName?: string;
+    emptyifnone?: boolean;
+}
+declare function Name(props: HardwareWidgetProps<AnySchema, BaseNameWidgetOptions>): JSX.Element;
+
+interface BasePropertyWidgetOptions extends HardwareWidgetOptions {
+    header?: string;
+    property?: string;
+    unit?: string;
+}
+declare function Property(props: HardwareWidgetProps<AnySchema, BasePropertyWidgetOptions>): JSX.Element;
+
+interface BaseInfoWidgetOptions extends HardwareWidgetOptions {
+    /** The property */
+    property?: string;
+    /** Unit for the property */
+    unit?: string;
+}
+declare function Info(props: HardwareWidgetProps<AnySchema, BaseInfoWidgetOptions>): JSX.Element;
+
+/**
+ * Hardware as exposed by Redux
+ */
+interface ActuatorSchema extends Hardware {
+    properties: {
+        state: string;
+    };
+}
+
+/**
+ * Hardware as exposed by Redux
+ */
+interface AirBearingSchema extends Hardware {
+    properties: {
+        state: string;
+    };
+}
+declare const Variants$p: HardwareVariant<AirBearingSchema>;
+
+declare function AirBearing(props: HardwareWidgetProps<AirBearingSchema, HardwareWidgetOptions>): JSX.Element;
+
+declare function AirBearingProtected(props: HardwareWidgetProps<AirBearingSchema, HardwareWidgetOptions>): JSX.Element;
+
+declare function AirBearingState(props: {
+    hardware: AirBearingSchema;
+}): JSX.Element;
+
+declare const Mocks$l: {
+    default: {
+        callables: string[];
+        id: string;
+        name: string;
+        online: boolean;
+        properties: {
+            state: string;
+        };
+        protocol: string;
+        require_staff: boolean;
+        type: string;
+    };
+};
+
+declare 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): JSX.Element;
+
+interface FrontendSchema extends Hardware {
+    properties: {
+        state: string;
+        status: string;
+        automatic: boolean;
+        frontend: string;
+        current: number;
+        refill: number;
+        mode: string;
+        message: string;
+        feitlk: string;
+        pssitlk: string;
+        expitlk: string;
+    };
+}
+declare const Variants$o: HardwareVariant<FrontendSchema>;
+
+declare function Frontend(props: HardwareWidgetProps<FrontendSchema>): JSX.Element;
+
+declare const Mocks$k: {
+    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
+ */
+interface GaugeSchema extends Hardware {
+    properties: {
+        state: string;
+        status: string;
+        pressure: number;
+        unit?: string;
+    };
+}
+declare const Variants$n: HardwareVariant<GaugeSchema>;
+
+interface GaugeWidgetOptions extends HardwareWidgetOptions {
+    /** Unit of pressure */
+    unit?: string;
+    /** Precision to show, default 3 */
+    precision?: number;
+}
+declare function Gauge(props: HardwareWidgetProps<GaugeSchema, GaugeWidgetOptions>): JSX.Element;
+
+declare const Mocks$j: {
+    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
+ */
+interface LaserSchema extends Hardware {
+    properties: {
+        state: string;
+        power: number;
+    };
+}
+declare const Variants$m: HardwareVariant<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>): JSX.Element;
+
+declare const Mocks$i: {
+    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
+ */
+interface LaserHeatingSchema extends Hardware {
+    properties: {
+        state: string;
+        exposure_time: number;
+        background_mode: 'ON' | 'OFF' | 'ALWAYS';
+        fit_wavelength: number[];
+        current_calibration: string;
+    };
+}
+declare const Variants$l: HardwareVariant<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>): JSX.Element;
+
+declare const Mocks$h: {
+    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
+ */
+interface LightSchema extends Hardware {
+    properties: {
+        state: string;
+        temperature: number;
+        intensity: number;
+    };
+}
+declare const Variants$k: HardwareVariant<LightSchema>;
+
+declare function Light(props: HardwareWidgetProps<LightSchema>): JSX.Element;
+
+declare const Mocks$g: {
+    default: {
+        callables: never[];
+        id: string;
+        name: string;
+        online: boolean;
+        properties: {
+            intensity: number;
+            state: string;
+            temperature: number;
+        };
+        protocol: string;
+        require_staff: boolean;
+        type: string;
+    };
+};
+
+/**
+ * Hardware as exposed by Redux
+ */
+interface LimaSchema extends Hardware {
+    properties: {
+        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];
+        /**
+         * 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];
+    };
+}
+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 Variants$j: HardwareVariant<LimaSchema>;
+
+declare function LimaBinning(props: HardwareWidgetProps<LimaSchema, HardwareWidgetOptions>): JSX.Element;
+
+declare function LimaDefault(props: HardwareWidgetProps<LimaSchema>): JSX.Element;
+
+declare function TomoDetectorSize$3(props: HardwareWidgetProps<LimaSchema, HardwareWidgetOptions>): JSX.Element;
+
+declare function TomoDetectorSize$2(props: HardwareWidgetProps<LimaSchema, HardwareWidgetOptions>): JSX.Element;
+
+declare function TomoDetectorSize$1(props: HardwareWidgetProps<LimaSchema, HardwareWidgetOptions>): JSX.Element;
+
+declare function TomoDetectorSize(props: HardwareWidgetProps<LimaSchema, HardwareWidgetOptions>): JSX.Element;
+
+declare function LimaState(props: {
+    hardware: LimaSchema;
+}): JSX.Element;
+
+declare const Mocks$f: {
+    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[];
+            max_size: number[];
+            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[];
+            max_size: number[];
+            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[];
+            max_size: number[];
+            pixel_size: number[];
+            raw_roi: number[];
+            roi: number[];
+            rotation: number;
+            size: number[];
+            state: string;
+        };
+    };
+};
+
+declare function LimaSimulator(props: PropsWithSimulator): JSX.Element;
+
+/**
+ * Hardware as exposed by Redux
+ */
+interface MeasurementGroupSchema extends Hardware {
+    properties: {
+        /** List of available counters */
+        available: string[];
+        /** List of disabled counters.
+         *
+         * It is a subset of the `available` list.
+         */
+        disabled: string[];
+    };
+}
+declare const Variants$i: HardwareVariant<MeasurementGroupSchema>;
+
+declare function MeasurementGroup(props: HardwareWidgetProps<MeasurementGroupSchema>): JSX.Element;
+
+declare const Mocks$e: {
+    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): JSX.Element;
+
+interface MotorSchema extends Hardware {
+    properties: {
+        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;
+declare const Variants$h: HardwareVariant<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;
+}
+
+/**
+ * The default motor widget
+ */
+declare function MotorDefault(props: HardwareWidgetProps<MotorSchema, MotorDefaultOptions>): JSX.Element;
+
+/**
+ * The default motor widget
+ */
+declare function MotorText(props: HardwareWidgetProps<MotorSchema, MotorDefaultOptions>): 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;
+}): JSX.Element;
+
+declare const Mocks$d: {
+    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$e {
+    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$e): JSX.Element;
+
+interface MultipositionSchema extends Hardware {
+    properties: {
+        position: string;
+        positions: {
+            position: string;
+            description: string;
+            target: {
+                axis: string;
+                destination: number;
+                tolerance: number;
+            }[];
+        }[];
+        state: string;
+    };
+}
+declare const Variants$g: HardwareVariant<MultipositionSchema>;
+
+declare function Multiposition(props: HardwareWidgetProps<MultipositionSchema>): JSX.Element;
+
+declare const Mocks$c: {
+    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): JSX.Element;
+
+/**
+ * Hardware as exposed by Redux
+ */
+interface OpticSchema extends Hardware {
+    properties: {
+        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;
+    };
+}
+declare function isOpticHardware(entity: Hardware): entity is OpticSchema;
+declare const Variants$f: HardwareVariant<OpticSchema>;
+
+interface OpticWidgetOptions extends HardwareWidgetOptions {
+    readonly?: boolean;
+    digits?: number;
+    allowtuning?: boolean;
+}
+declare function Optic(props: HardwareWidgetProps<OpticSchema, OpticWidgetOptions>): JSX.Element;
+
+declare function OpticState(props: {
+    hardware: OpticSchema;
+}): JSX.Element;
+
+declare const Mocks$b: {
+    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$d {
+    kind: 'fixed' | 'range' | 'multi';
+}
+declare function OpticSimulator(props: PropsWithSimulator<Props$d>): JSX.Element;
+
+interface ProcedureSchema extends Hardware {
+    properties: {
+        state: string;
+        previous_run_state: string;
+        previous_run_exception: string | null;
+        parameters: Record<string, any>;
+    };
+}
+declare const Variants$e: HardwareVariant<ProcedureSchema>;
+
+interface HardwareFromProcedure {
+    __type__: 'hardware';
+    name: string;
+}
+interface ScanFromProcedure {
+    __type__: 'scan';
+    mmh3: number;
+    node?: string;
+    key?: string;
+}
+interface ExceptionFromProcedure {
+    __type__: 'exception';
+    class: string;
+    message: string;
+    traceback: Record<string, any>;
+}
+
+declare function ProcedureExecution(props: HardwareWidgetProps<ProcedureSchema>): JSX.Element;
+
+declare function ProcedureManage(props: HardwareWidgetProps<ProcedureSchema>): JSX.Element;
+
+declare function ProcedureValidate(props: HardwareWidgetProps<ProcedureSchema>): JSX.Element;
+
+declare function ProcedureState(props: {
+    hardware: ProcedureSchema;
+}): JSX.Element;
+
+declare const Mocks$a: {
+    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;
+                };
+            };
+        };
+    };
+};
+
+interface ShutterSchema extends Hardware {
+    properties: {
+        state: string;
+        status: string;
+        valid: boolean;
+        open_text: string;
+        closed_text: string;
+    };
+}
+declare const Variants$d: HardwareVariant<ShutterSchema>;
+
+declare function ShutterDefault(props: HardwareWidgetProps<ShutterSchema, HardwareWidgetOptions>): JSX.Element;
+
+declare function ShutterProtected(props: HardwareWidgetProps<ShutterSchema, HardwareWidgetOptions>): JSX.Element;
+
+declare function ShutterState(props: {
+    hardware: ShutterSchema;
+    useReadyState?: boolean;
+}): 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;
+    };
+};
+
+declare function ShutterSimulator(props: PropsWithSimulator): JSX.Element;
+
+/**
+ * Hardware as exposed by Redux
+ */
+interface SlitSchema extends Hardware {
+    properties: {
+        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 Variants$c: HardwareVariant<SlitSchema>;
+
+declare function SlitDefault(props: HardwareWidgetProps<SlitSchema, SlitDefaultOptions>): JSX.Element;
+
+declare function SlitState(props: {
+    hardware: SlitSchema;
+}): 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
+ */
+interface PumpSchema extends Hardware {
+    properties: {
+        state: string;
+        status: string;
+        pressure: number;
+        voltage: number;
+        current: number;
+        unit?: string;
+    };
+}
+declare const Variants$b: HardwareVariant<PumpSchema>;
+
+interface PumpWidgetOptions extends HardwareWidgetOptions {
+    unit?: string;
+    precision?: number;
+}
+declare function Pump(props: HardwareWidgetProps<PumpSchema, PumpWidgetOptions>): 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
  */
-interface HardwareWidgetOptions {
-    /** Whether to show the extended popup */
-    extended?: boolean;
-    /** Kind of header displayed */
-    header?: string;
+interface PusherSchema extends Hardware {
+    properties: {
+        state: string;
+    };
 }
-declare type EditableHardware<H extends Hardware = Hardware> = H & {
-    /** Call the API to make a change on the hardware object */
-    actions: HardwareChangeActions;
+declare const Variants$a: HardwareVariant<PusherSchema>;
+
+declare function Pusher(props: HardwareWidgetProps<PusherSchema, HardwareWidgetOptions>): JSX.Element;
+
+declare function PusherState(props: {
+    hardware: PusherSchema;
+}): 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): JSX.Element;
+
 /**
- * Properties which are passed to the widgets
+ * Hardware as exposed by Redux
  */
-interface HardwareWidgetProps<H extends Hardware = Hardware, O extends HardwareWidgetOptions = HardwareWidgetOptions> {
-    /** Dynamic state of the hardware */
-    hardware: EditableHardware<H>;
-    /** Static schema describing the hardware */
-    schema: HardwareSchemaDescription;
-    /** 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;
+interface ServiceSchema extends Hardware {
+    properties: {
+        state: 'STOPPED' | 'STARTING' | 'RUNNING' | 'BACKOFF' | 'STOPPING' | 'EXITED' | 'FATAL' | 'UNKNOWN';
+    };
 }
+declare const Variants$9: HardwareVariant<ServiceSchema>;
 
-type types_d_EditableHardware<H extends Hardware = Hardware> = EditableHardware<H>;
-type types_d_Hardware = Hardware;
-type types_d_HardwareChangeActions = HardwareChangeActions;
-type types_d_HardwareSchemaDescription = HardwareSchemaDescription;
-type types_d_HardwareWidgetOptions = HardwareWidgetOptions;
-type types_d_HardwareWidgetProps<H extends Hardware = Hardware, O extends HardwareWidgetOptions = HardwareWidgetOptions> = HardwareWidgetProps<H, O>;
-declare namespace types_d {
-  export type { types_d_EditableHardware as EditableHardware, types_d_Hardware as Hardware, types_d_HardwareChangeActions as HardwareChangeActions, types_d_HardwareSchemaDescription as HardwareSchemaDescription, types_d_HardwareWidgetOptions as HardwareWidgetOptions, types_d_HardwareWidgetProps as HardwareWidgetProps };
+declare function ServiceDefault(props: HardwareWidgetProps<ServiceSchema, HardwareWidgetOptions>): JSX.Element;
+
+interface ServiceProectedOptions extends HardwareWidgetOptions {
+    /** Direction to drop the menu */
+    dropDirection?: string;
 }
+declare function ServiceProtected(props: HardwareWidgetProps<ServiceSchema, ServiceProectedOptions>): JSX.Element;
 
-interface FrontendSchema extends Hardware {
+declare function ServiceState(props: {
+    hardware: ServiceSchema;
+}): 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;
+}
+/**
+ * Hardware as exposed by Redux
+ */
+interface TomoFlatMotionSchema extends Hardware {
     properties: {
-        state: string;
-        status: string;
-        automatic: boolean;
-        frontend: string;
-        current: number;
-        refill: number;
-        mode: string;
-        message: string;
-        feitlk: string;
-        pssitlk: string;
-        expitlk: string;
+        state: 'READY';
+        available_axes: string[];
+        motion: TomoFlatMotionStep[];
+        move_in_parallel: boolean;
+        power_onoff: boolean;
+        settle_time: number;
     };
 }
+declare const Variants$8: HardwareVariant<TomoFlatMotionSchema>;
 
-declare function Frontend(props: HardwareWidgetProps<FrontendSchema>): JSX.Element;
+declare function isTomoFlatMotionHardware(entity: Hardware): entity is TomoFlatMotionSchema;
+declare function useTomoFlatMotionHardware(name: string | null): TomoFlatMotionSchema | null;
 
-interface InfoOptions extends HardwareWidgetOptions {
-    /** The property */
-    property?: string;
-    /** Unit for the property */
-    unit?: string;
+declare function TomoFlatMotionDefault(props: HardwareWidgetProps<TomoFlatMotionSchema>): JSX.Element;
+
+declare function TomoFlatMotionSmall(props: HardwareWidgetProps<TomoFlatMotionSchema>): JSX.Element;
+
+declare function TomoFlatMotionState(props: {
+    hardware: TomoFlatMotionSchema;
+}): 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): JSX.Element;
+
+/**
+ * Hardware as exposed by Redux
+ */
+interface TomoReferencePositionSchema extends Hardware {
+    properties: Record<string, never>;
 }
+declare function isTomoReferencePositionHardware(entity: Hardware): entity is TomoReferencePositionSchema;
+declare const Variants$7: HardwareVariant<TomoReferencePositionSchema>;
 
-declare function Info(props: HardwareWidgetProps<Hardware, InfoOptions>): JSX.Element;
+declare function TomoReferencePositionDefault(props: HardwareWidgetProps<TomoReferencePositionSchema>): JSX.Element;
 
-interface MotorSchema extends Hardware {
+/**
+ * Hardware as exposed by Redux
+ */
+interface TomoDetectorSchema extends Hardware {
     properties: {
-        position: number | null;
-        target: number;
-        tolerance: number;
-        acceleration: number;
-        velocity: number;
-        limits: [number, number];
-        state: string[];
-        unit: string;
-        offset: number;
-        sign: number;
-        display_digits: number | null;
+        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 Variants$6: HardwareVariant<TomoDetectorSchema>;
 
-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;
-    /** 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;
+declare function isTomoDetectorHardware(entity: Hardware): entity is TomoDetectorSchema;
+declare function useTomoDetectorHardware(name: string | null): TomoDetectorSchema | null;
+
+declare function TomoDetectorAcquisitionMode(props: HardwareWidgetProps<TomoDetectorSchema, HardwareWidgetOptions>): JSX.Element;
+
+interface TomoDetectorSamplePixelSizeOptions extends HardwareWidgetOptions {
+    display_unit?: string | null;
 }
+declare function TomoDetectorSamplePixelSize(props: HardwareWidgetProps<TomoDetectorSchema, TomoDetectorSamplePixelSizeOptions>): JSX.Element;
 
-/**
- * The default motor widget
- */
-declare function MotorDefault(props: HardwareWidgetProps<MotorSchema, MotorDefaultOptions>): JSX.Element;
+declare function TomoDetectorState(props: {
+    hardware: TomoDetectorSchema;
+}): JSX.Element;
+
+declare const Mocks$3: {
+    default: {
+        id: string;
+        name: string;
+        online: boolean;
+        properties: {
+            state: string;
+            actual_size: number[];
+            sample_pixel_size_mode: string;
+            user_sample_pixel_size: number;
+            sample_pixel_size: number;
+        };
+        protocol: string;
+        require_staff: boolean;
+        type: string;
+    };
+};
 
 /**
- * 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.
+ * Hardware as exposed by Redux
  */
-declare function MotorState(props: {
-    hardware: MotorSchema;
+interface TomoDetectorsSchema extends Hardware {
+    properties: {
+        state: string;
+        detectors: string[];
+        active_detector: string;
+        target_detector?: string;
+    };
+}
+declare const Variants$5: HardwareVariant<TomoDetectorsSchema>;
+
+declare function isTomoDetectorsHardware(entity: Hardware): entity is TomoDetectorsSchema;
+declare function useTomoDetectorsHardware(name: string | null): TomoDetectorsSchema | null;
+
+declare function TomoDetectors(props: HardwareWidgetProps<TomoDetectorsSchema>): JSX.Element;
+
+declare function TomoDetectorsState(props: {
+    hardware: TomoDetectorsSchema;
 }): JSX.Element;
 
-interface MultipositionSchema extends Hardware {
+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
+ */
+interface TomoImagingSchema extends Hardware {
     properties: {
-        position: string;
-        positions: {
-            position: string;
-            description: string;
-            target: {
-                axis: string;
-                destination: number;
-                tolerance: number;
-            }[];
-        }[];
         state: string;
+        update_on_move: boolean;
+        exposure_time: number;
+        settle_time: number;
     };
 }
+declare const Variants$4: HardwareVariant<TomoImagingSchema>;
 
-declare function Multiposition(props: HardwareWidgetProps<MultipositionSchema>): JSX.Element;
+declare function TomoImagingActions(props: HardwareWidgetProps<TomoImagingSchema>): JSX.Element;
 
-interface GenericSchema extends Hardware {
+declare function TomoImagingDefault(props: HardwareWidgetProps<TomoImagingSchema>): JSX.Element;
+
+declare function TomoImagingExposureTime(props: HardwareWidgetProps<TomoImagingSchema>): JSX.Element;
+
+declare function TomoImagingSettleTime(props: HardwareWidgetProps<TomoImagingSchema>): JSX.Element;
+
+declare function TomoImagingUpdateMode(props: HardwareWidgetProps<TomoImagingSchema>): JSX.Element;
+
+declare function TomoImagingState(props: {
+    hardware: TomoImagingSchema;
+}): 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): JSX.Element;
+
+/**
+ * Hardware as exposed by Redux
+ */
+interface TomoSampleStageSchema extends Hardware {
     properties: {
-        state: string;
+        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 Variants$3: HardwareVariant<TomoSampleStageSchema>;
 
-type schema_d_GenericSchema = GenericSchema;
-declare namespace schema_d {
-  export type { schema_d_GenericSchema as GenericSchema };
+declare function isTomoSampleStageHardware(entity: Hardware): entity is TomoSampleStageSchema;
+declare function useTomoSampleStageHardware(name: string | null): TomoSampleStageSchema | null;
+
+/**
+ * Hardware as exposed by Redux
+ */
+interface TomoConfigSchema extends Hardware {
+    properties: {
+        sample_stage: string;
+        sxbeam: string;
+        detectors: string;
+        holotomo: string;
+        latency_time: number;
+    };
 }
+declare const Variants$2: HardwareVariant<TomoConfigSchema>;
 
-interface PropertyWidgetOptions extends HardwareWidgetOptions {
-    header?: string;
-    property?: string;
-    unit?: string;
+declare function isTomoConfigHardware(entity: Hardware): entity is TomoConfigSchema;
+declare function useTomoConfigHardware(name: string | null): TomoConfigSchema | null;
+
+declare function TomoConfigLatencyTime(props: HardwareWidgetProps<TomoConfigSchema>): JSX.Element;
+
+interface TomoHoloDistance {
+    z1: number;
+    position: number;
+    pixel_size: number;
+}
+/**
+ * Hardware as exposed by Redux
+ */
+interface TomoHoloSchema extends Hardware {
+    properties: {
+        state: string;
+        settle_time: number;
+        pixel_size: number | null;
+        nb_distances: number;
+        distances: TomoHoloDistance[];
+    };
 }
+declare const Variants$1: HardwareVariant<TomoHoloSchema>;
 
-declare function Property(props: HardwareWidgetProps<GenericSchema, PropertyWidgetOptions>): JSX.Element;
+declare function isTomoHoloHardware(entity: Hardware): entity is TomoHoloSchema;
+declare function useTomoHoloHardware(name: string | null): TomoHoloSchema | null;
 
-interface ShutterSchema extends Hardware {
+declare function TomoHoloState(props: {
+    hardware: TomoHoloSchema;
+}): JSX.Element;
+
+/**
+ * Hardware as exposed by Redux
+ */
+interface ValveSchema extends Hardware {
     properties: {
         state: string;
         status: string;
-        valid: boolean;
-        open_text: string;
-        closed_text: string;
     };
 }
+declare const Variants: HardwareVariant<ValveSchema>;
 
-declare function ShutterDefault(props: HardwareWidgetProps<ShutterSchema, HardwareWidgetOptions>): JSX.Element;
+declare function Valve(props: HardwareWidgetProps<ValveSchema>): JSX.Element;
 
-declare function ShutterState(props: {
-    hardware: ShutterSchema;
-    useReadyState?: boolean;
-}): 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$c {
     online: boolean;
@@ -300,6 +1840,8 @@ declare function HardwareNumericStep(props: {
     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 */
@@ -371,18 +1913,6 @@ 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 HardwareVariantOptions {
-    options: {
-        variant: string;
-    };
-}
-declare class HardwareVariant extends Component<HardwareVariantOptions, void> {
-    variants: {
-        [name: string]: ComponentType<any>;
-    };
-    render(): JSX.Element;
-}
-
 interface NoObjectProps {
     id: string;
     name?: string;
@@ -402,6 +1932,7 @@ interface Props$9 {
     step?: number | string;
     steps?: (number | string)[];
     disabled: boolean;
+    stepOnly?: boolean;
     id?: string;
     unit?: string;
     overlay?: ReactChild | null;
@@ -667,6 +2198,12 @@ declare namespace asserts_d {
   export { 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_assertOptionalBackend as assertOptionalBackend, asserts_d_assertOptionalBoolean as assertOptionalBoolean, 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 };
 }
 
+interface RuntimeHooks {
+    useHardware?: (id: string | null) => Hardware | null;
+    useHardwareChangeActions?: (name: string | null) => HardwareChangeActions;
+}
+declare function registerRuntimeHook(hooks: Partial<RuntimeHooks>): void;
+
 interface HardwareObjectProps {
     id: string;
     options: {
@@ -684,15 +2221,11 @@ interface ResolvedHardwareObjectProps extends HardwareObjectProps {
     runningScan?: boolean;
     obj: Hardware | null;
 }
-interface ComponentMapping {
-    [name: string]: ComponentType<any> | typeof HardwareVariant;
-}
 
-type HardwareObject_d_ComponentMapping = ComponentMapping;
 type HardwareObject_d_HardwareObjectProps = HardwareObjectProps;
 type HardwareObject_d_ResolvedHardwareObjectProps = ResolvedHardwareObjectProps;
 declare namespace HardwareObject_d {
-  export type { HardwareObject_d_ComponentMapping as ComponentMapping, HardwareObject_d_HardwareObjectProps as HardwareObjectProps, HardwareObject_d_ResolvedHardwareObjectProps as ResolvedHardwareObjectProps };
+  export type { HardwareObject_d_HardwareObjectProps as HardwareObjectProps, HardwareObject_d_ResolvedHardwareObjectProps as ResolvedHardwareObjectProps };
 }
 
 /**
@@ -710,7 +2243,6 @@ interface Monitor {
     unit?: string;
 }
 
-declare function registerRuntimeHook(name: string, hook: (id: string | null) => Hardware | null): void;
 declare const dynamicOp: (op: string, a1: any, b1: any) => boolean | undefined;
 declare function MonitorHardware(props: {
     monitor: Monitor;
@@ -727,4 +2259,4 @@ interface MonitorPanelItemProps {
 }
 declare function MonitorPanelItem(props: PropsWithChildren<MonitorPanelItemProps>): JSX.Element;
 
-export { formatting_d as Formatting, Frontend, FullSizer, HardwareObject_d as HWObject, type Hardware, HardwareInputNumber, HardwareNumericStep, schema_d as HardwareSchema, State_d as HardwareState, HardwareTemplate, types_d as HardwareTypes, HardwareVariant, Info, type InfoOptions, KeyError, MissingKeysError, type Monitor, MonitorHardware, MonitorPanel, MonitorPanelItem, type MonitorPanelProps, MotorDefault, type MotorDefaultOptions, type MotorSchema, MotorState, Multiposition, NoObject, NumericStep, Panel, Property, ShutterDefault, type ShutterSchema, ShutterState, TypeIcon, type Props$c as TypeIconOptions, ErrorBoundary as YAMLErrorBoundary, Main as YAMLLayout, asserts_d as YamlAsserts, type YamlComponent$1 as YamlComponent, type YamlNode, dynamicOp, registerHardwareComponent, registerMonitorComponent, registerRuntimeHook, registerComponent as registerYamlComponent, registerComponents as registerYamlComponents, registerYamlType, renderYamlNode, yamlMap };
+export { type ActuatorSchema, AirBearing, Mocks$l as AirBearingMocks, AirBearingProtected, type AirBearingSchema, AirBearingSimulator, AirBearingState, Variants$p as AirBearingVariants, type AnySchema, Info as BaseInfo, type BaseInfoWidgetOptions, Mocks$m as BaseMocks, Name as BaseName, type BaseNameWidgetOptions, Property as BaseProperty, type BasePropertyWidgetOptions, DefaultState as BaseState, Variants$q as BaseVariants, type ExceptionFromProcedure, formatting_d as Formatting, Frontend, Mocks$k as FrontendMocks, type FrontendSchema, Variants$o as FrontendVariants, FullSizer, Gauge, Mocks$j as GaugeMocks, type GaugeSchema, Variants$n as GaugeVariants, type GaugeWidgetOptions, type GenericSchema, HardwareObject_d as HWObject, type Hardware, type HardwareComponentType, type HardwareFromProcedure, HardwareInputNumber, HardwareNumericStep, schema_d as HardwareSchema, State_d as HardwareState, HardwareTemplate, types_d as HardwareTypes, type HardwareVariant, KeyError, Laser, LaserHeating, Mocks$h as LaserHeatingMocks, type LaserHeatingSchema, Variants$l as LaserHeatingVariants, type LaserHeatingWidgetOptions, Mocks$i as LaserMocks, type LaserSchema, Variants$m as LaserVariants, type LaserWidgetOptions, Light, Mocks$g as LightMocks, type LightSchema, Variants$k as LightVariants, LimaBinning, LimaDefault, TomoDetectorSize$3 as LimaDescription, TomoDetectorSize$2 as LimaImageRoi, Mocks$f as LimaMocks, type LimaSchema, LimaSimulator, TomoDetectorSize$1 as LimaSize, LimaState, TomoDetectorSize as LimaTransformation, Variants$j as LimaVariants, MeasurementGroup as MeasurementGroupDefault, Mocks$e as MeasurementGroupMocks, type MeasurementGroupSchema, MeasurementGroupSimulator, Variants$i as MeasurementGroupVariants, MissingKeysError, type Monitor, MonitorHardware, MonitorPanel, MonitorPanelItem, type MonitorPanelProps, MotorDefault, type MotorDefaultOptions, Mocks$d as MotorMocks, type MotorSchema, MotorSimulator, MotorState, MotorText, Variants$h as MotorVariants, Multiposition, Mocks$c as MultipositionMocks, type MultipositionSchema, MultipositionSimulator, Variants$g as MultipositionVariants, NoObject, NumericStep, Optic as OpticDefault, Mocks$b as OpticMocks, type OpticSchema, OpticSimulator, OpticState, Variants$f as OpticVariants, type OpticWidgetOptions, Panel, ProcedureExecution, ProcedureManage, Mocks$a as ProcedureMocks, type ProcedureSchema, ProcedureState, ProcedureValidate, Variants$e as ProcedureVariants, Pump as PumpDefault, Mocks$7 as PumpMocks, type PumpSchema, Variants$b as PumpVariants, Pusher as PusherDefault, Mocks$6 as PusherMocks, type PusherSchema, PusherSimulator, PusherState, Variants$a as PusherVariants, type ScanFromProcedure, ServiceDefault, Mocks$5 as ServiceMocks, ServiceProtected, type ServiceSchema, ServiceState, Variants$9 as ServiceVariants, ShutterDefault, Mocks$9 as ShutterMocks, ShutterProtected, type ShutterSchema, ShutterSimulator, ShutterState, Variants$d as ShutterVariants, SlitDefault, Mocks$8 as SlitMocks, type SlitSchema, SlitState, Variants$c as SlitVariants, TomoConfigLatencyTime, type TomoConfigSchema, Variants$2 as TomoConfigVariants, TomoDetectorAcquisitionMode, Mocks$3 as TomoDetectorMocks, TomoDetectorSamplePixelSize, type TomoDetectorSchema, TomoDetectorState, Variants$6 as TomoDetectorVariants, TomoDetectors as TomoDetectorsDefault, Mocks$2 as TomoDetectorsMocks, type TomoDetectorsSchema, TomoDetectorsState, Variants$5 as TomoDetectorsVariants, TomoFlatMotionDefault, Mocks$4 as TomoFlatMotionMocks, type TomoFlatMotionSchema, TomoFlatMotionSimulator, TomoFlatMotionSmall, TomoFlatMotionState, type TomoFlatMotionStep, Variants$8 as TomoFlatMotionVariants, type TomoHoloDistance, type TomoHoloSchema, TomoHoloState, Variants$1 as TomoHoloVariants, TomoImagingActions, TomoImagingDefault, TomoImagingExposureTime, Mocks$1 as TomoImagingMocks, type TomoImagingSchema, TomoImagingSettleTime, TomoImagingSimulator, TomoImagingState, TomoImagingUpdateMode, Variants$4 as TomoImagingVariants, TomoReferencePositionDefault, type TomoReferencePositionSchema, Variants$7 as TomoReferencePositionVariants, type TomoSampleStageSchema, Variants$3 as TomoSampleStageVariants, TypeIcon, type Props$c as TypeIconOptions, Valve as ValveDefault, Mocks as ValveMocks, type ValveSchema, Variants as ValveVariants, ErrorBoundary as YAMLErrorBoundary, Main as YAMLLayout, asserts_d as YamlAsserts, type YamlComponent$1 as YamlComponent, type YamlNode, createMotorMock, dynamicOp, isLimaHardware, isMotorHardware, isOpticHardware, isTomoConfigHardware, isTomoDetectorHardware, isTomoDetectorsHardware, isTomoFlatMotionHardware, isTomoHoloHardware, isTomoReferencePositionHardware, isTomoSampleStageHardware, limaGuessSubframes, registerHardwareComponent, registerMonitorComponent, registerRuntimeHook, registerComponent as registerYamlComponent, registerComponents as registerYamlComponents, registerYamlType, renderYamlNode, useLimaHardware, useMotorHardware, useMotorStates, useTomoConfigHardware, useTomoDetectorHardware, useTomoDetectorsHardware, useTomoFlatMotionHardware, useTomoHoloHardware, useTomoSampleStageHardware, yamlMap };