@esrf/daiquiri-lib 2.0.0 → 2.2.0

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="react" />
 import * as React$1 from 'react';
-import React__default, { ComponentType, ReactChild, ReactElement, PropsWithChildren, ChangeEvent, KeyboardEvent, Component } from 'react';
+import React__default, { ComponentType, ReactElement, PropsWithChildren, ReactChild, ChangeEvent, KeyboardEvent, Component } from 'react';
+import { YamlComponent as YamlComponent$2 } from '@esrf/daiquiri-lib';
 
 interface HardwareError {
     property: string;
@@ -121,9 +122,9 @@ declare namespace schema_d {
   export type { schema_d_AnySchema as AnySchema, schema_d_GenericSchema as GenericSchema };
 }
 
-declare const Variants$o: HardwareVariant<AnySchema>;
+declare const Variants$q: HardwareVariant<AnySchema>;
 
-declare const Mocks$k: {
+declare const Mocks$m: {
     default: {
         response: {
             callables: never[];
@@ -248,16 +249,6 @@ interface BaseInfoWidgetOptions extends HardwareWidgetOptions {
 }
 declare function Info(props: HardwareWidgetProps<AnySchema, BaseInfoWidgetOptions>): JSX.Element;
 
-interface Props$e {
-    showActions: boolean;
-    children: ReactChild | ReactChild[];
-}
-/**
- * Wrap hardware widget passed as children with addToast and hardware
- * change actions triggering console log.
- */
-declare function Wrapper(props: Props$e): JSX.Element;
-
 /**
  * Hardware as exposed by Redux
  */
@@ -275,7 +266,7 @@ interface AirBearingSchema extends Hardware {
         state: string;
     };
 }
-declare const Variants$n: HardwareVariant<AirBearingSchema>;
+declare const Variants$p: HardwareVariant<AirBearingSchema>;
 
 declare function AirBearing(props: HardwareWidgetProps<AirBearingSchema, HardwareWidgetOptions>): JSX.Element;
 
@@ -285,7 +276,7 @@ declare function AirBearingState(props: {
     hardware: AirBearingSchema;
 }): JSX.Element;
 
-declare const Mocks$j: {
+declare const Mocks$l: {
     default: {
         callables: string[];
         id: string;
@@ -300,6 +291,19 @@ declare const Mocks$j: {
     };
 };
 
+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;
@@ -315,11 +319,11 @@ interface FrontendSchema extends Hardware {
         expitlk: string;
     };
 }
-declare const Variants$m: HardwareVariant<FrontendSchema>;
+declare const Variants$o: HardwareVariant<FrontendSchema>;
 
 declare function Frontend(props: HardwareWidgetProps<FrontendSchema>): JSX.Element;
 
-declare const Mocks$i: {
+declare const Mocks$k: {
     default: {
         callables: string[];
         id: string;
@@ -354,7 +358,7 @@ interface GaugeSchema extends Hardware {
         unit?: string;
     };
 }
-declare const Variants$l: HardwareVariant<GaugeSchema>;
+declare const Variants$n: HardwareVariant<GaugeSchema>;
 
 interface GaugeWidgetOptions extends HardwareWidgetOptions {
     /** Unit of pressure */
@@ -364,7 +368,7 @@ interface GaugeWidgetOptions extends HardwareWidgetOptions {
 }
 declare function Gauge(props: HardwareWidgetProps<GaugeSchema, GaugeWidgetOptions>): JSX.Element;
 
-declare const Mocks$h: {
+declare const Mocks$j: {
     default: {
         callables: string[];
         id: string;
@@ -404,7 +408,7 @@ interface LaserSchema extends Hardware {
         power: number;
     };
 }
-declare const Variants$k: HardwareVariant<LaserSchema>;
+declare const Variants$m: HardwareVariant<LaserSchema>;
 
 interface LaserWidgetOptions extends HardwareWidgetOptions {
     /** Default step size to use for up / down arrows */
@@ -414,7 +418,7 @@ interface LaserWidgetOptions extends HardwareWidgetOptions {
 }
 declare function Laser(props: HardwareWidgetProps<LaserSchema, LaserWidgetOptions>): JSX.Element;
 
-declare const Mocks$g: {
+declare const Mocks$i: {
     default: {
         callables: never[];
         id: string;
@@ -442,7 +446,7 @@ interface LaserHeatingSchema extends Hardware {
         current_calibration: string;
     };
 }
-declare const Variants$j: HardwareVariant<LaserHeatingSchema>;
+declare const Variants$l: HardwareVariant<LaserHeatingSchema>;
 
 interface LaserHeatingWidgetOptions extends HardwareWidgetOptions {
     /** Default step size to use for up / down arrows */
@@ -452,7 +456,7 @@ interface LaserHeatingWidgetOptions extends HardwareWidgetOptions {
 }
 declare function LaserHeating(props: HardwareWidgetProps<LaserHeatingSchema, LaserHeatingWidgetOptions>): JSX.Element;
 
-declare const Mocks$f: {
+declare const Mocks$h: {
     default: {
         callables: never[];
         id: string;
@@ -481,11 +485,11 @@ interface LightSchema extends Hardware {
         intensity: number;
     };
 }
-declare const Variants$i: HardwareVariant<LightSchema>;
+declare const Variants$k: HardwareVariant<LightSchema>;
 
 declare function Light(props: HardwareWidgetProps<LightSchema>): JSX.Element;
 
-declare const Mocks$e: {
+declare const Mocks$g: {
     default: {
         callables: never[];
         id: string;
@@ -566,7 +570,7 @@ 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$h: HardwareVariant<LimaSchema>;
+declare const Variants$j: HardwareVariant<LimaSchema>;
 
 declare function LimaBinning(props: HardwareWidgetProps<LimaSchema, HardwareWidgetOptions>): JSX.Element;
 
@@ -584,7 +588,7 @@ declare function LimaState(props: {
     hardware: LimaSchema;
 }): JSX.Element;
 
-declare const Mocks$d: {
+declare const Mocks$f: {
     default: {
         id: string;
         name: string;
@@ -671,6 +675,8 @@ declare const Mocks$d: {
     };
 };
 
+declare function LimaSimulator(props: PropsWithSimulator): JSX.Element;
+
 /**
  * Hardware as exposed by Redux
  */
@@ -685,11 +691,37 @@ interface MeasurementGroupSchema extends Hardware {
         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: number;
+        /**
+         * Target of the actual motion.
+         *
+         * If there is no motion, it is `null`.
+         */
+        target: number | null;
         tolerance: number;
         acceleration: number;
         velocity: number;
@@ -743,7 +775,7 @@ declare function isMotorHardware(entity: Hardware): entity is MotorSchema;
  * @param name: An hardware identifier
  */
 declare function useMotorHardware(name: string | null): MotorSchema | null;
-declare const Variants$g: HardwareVariant<MotorSchema>;
+declare const Variants$h: HardwareVariant<MotorSchema>;
 
 interface MotorDefaultOptions extends HardwareWidgetOptions {
     /** Default step size to use for up / down arrows */
@@ -795,7 +827,7 @@ declare function MotorState(props: {
     hardware: MotorSchema;
 }): JSX.Element;
 
-declare const Mocks$c: {
+declare const Mocks$d: {
     default: {
         callables: string[];
         id: string;
@@ -930,14 +962,20 @@ declare function createMotorMock(name: string, position: number): {
     online: boolean;
 };
 
-interface Props$d {
+interface Props$e {
+    name?: string;
     minLimit?: number;
     maxLimit?: number;
     initialPosition?: number;
     initialVelocity?: number;
-    children: ReactChild | ReactChild[];
+    useHardwareContext?: () => {
+        actions: {
+            updateHardware: (name: string, hardware: Hardware) => void;
+            updateHardwareChangeActions: (name: string, actions: HardwareChangeActions) => void;
+        };
+    };
 }
-declare function Motor(props: Props$d): JSX.Element;
+declare function MotorSimulator(props: Props$e): JSX.Element;
 
 interface MultipositionSchema extends Hardware {
     properties: {
@@ -954,11 +992,11 @@ interface MultipositionSchema extends Hardware {
         state: string;
     };
 }
-declare const Variants$f: HardwareVariant<MultipositionSchema>;
+declare const Variants$g: HardwareVariant<MultipositionSchema>;
 
 declare function Multiposition(props: HardwareWidgetProps<MultipositionSchema>): JSX.Element;
 
-declare const Mocks$b: {
+declare const Mocks$c: {
     default: {
         callables: string[];
         id: string;
@@ -982,6 +1020,8 @@ declare const Mocks$b: {
     };
 };
 
+declare function MultipositionSimulator(props: PropsWithSimulator): JSX.Element;
+
 /**
  * Hardware as exposed by Redux
  */
@@ -989,13 +1029,18 @@ interface OpticSchema extends Hardware {
     properties: {
         state: string;
         magnification: number;
-        available_magnifications: number[];
-        target_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$e: HardwareVariant<OpticSchema>;
+declare const Variants$f: HardwareVariant<OpticSchema>;
 
 interface OpticWidgetOptions extends HardwareWidgetOptions {
     readonly?: boolean;
@@ -1008,7 +1053,7 @@ declare function OpticState(props: {
     hardware: OpticSchema;
 }): JSX.Element;
 
-declare const Mocks$a: {
+declare const Mocks$b: {
     default: {
         callables: string[];
         id: string;
@@ -1016,7 +1061,6 @@ declare const Mocks$a: {
         online: boolean;
         properties: {
             state: string;
-            status: string;
             magnification: number;
             target_magnification: null;
             available_magnifications: number[];
@@ -1033,7 +1077,6 @@ declare const Mocks$a: {
         online: boolean;
         properties: {
             state: string;
-            status: string;
             magnification: number;
             target_magnification: null;
             available_magnifications: number[];
@@ -1050,7 +1093,6 @@ declare const Mocks$a: {
         online: boolean;
         properties: {
             state: string;
-            status: string;
             magnification: number;
             target_magnification: null;
             available_magnifications: number[];
@@ -1067,7 +1109,6 @@ declare const Mocks$a: {
         online: boolean;
         properties: {
             state: string;
-            status: string;
             magnification: number;
             target_magnification: null;
             available_magnifications: number[];
@@ -1079,6 +1120,11 @@ declare const Mocks$a: {
     };
 };
 
+interface Props$d {
+    kind: 'fixed' | 'range' | 'multi';
+}
+declare function OpticSimulator(props: PropsWithSimulator<Props$d>): JSX.Element;
+
 interface ProcedureSchema extends Hardware {
     properties: {
         state: string;
@@ -1087,7 +1133,7 @@ interface ProcedureSchema extends Hardware {
         parameters: Record<string, any>;
     };
 }
-declare const Variants$d: HardwareVariant<ProcedureSchema>;
+declare const Variants$e: HardwareVariant<ProcedureSchema>;
 
 interface HardwareFromProcedure {
     __type__: 'hardware';
@@ -1116,7 +1162,7 @@ declare function ProcedureState(props: {
     hardware: ProcedureSchema;
 }): JSX.Element;
 
-declare const Mocks$9: {
+declare const Mocks$a: {
     standby: {
         callables: string[];
         type: string;
@@ -1182,7 +1228,7 @@ interface ShutterSchema extends Hardware {
         closed_text: string;
     };
 }
-declare const Variants$c: HardwareVariant<ShutterSchema>;
+declare const Variants$d: HardwareVariant<ShutterSchema>;
 
 declare function ShutterDefault(props: HardwareWidgetProps<ShutterSchema, HardwareWidgetOptions>): JSX.Element;
 
@@ -1193,7 +1239,7 @@ declare function ShutterState(props: {
     useReadyState?: boolean;
 }): JSX.Element;
 
-declare const Mocks$8: {
+declare const Mocks$9: {
     default: {
         callables: string[];
         id: string;
@@ -1212,6 +1258,74 @@ declare const Mocks$8: {
     };
 };
 
+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
  */
@@ -1283,6 +1397,8 @@ declare const Mocks$6: {
     };
 };
 
+declare function PusherSimulator(props: PropsWithSimulator): JSX.Element;
+
 /**
  * Hardware as exposed by Redux
  */
@@ -1364,7 +1480,7 @@ declare const Mocks$4: {
             move_in_parallel: boolean;
             available_axes: string[];
             motion: {
-                axis: string;
+                axisRef: string;
                 absolute_position: null;
                 relative_position: number;
             }[];
@@ -1373,8 +1489,54 @@ declare const Mocks$4: {
         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
  */
@@ -1517,6 +1679,8 @@ declare const Mocks$1: {
     };
 };
 
+declare function TomoImagingSimulator(props: PropsWithSimulator): JSX.Element;
+
 /**
  * Hardware as exposed by Redux
  */
@@ -1750,6 +1914,59 @@ 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): JSX.Element;
+
+interface NoObjectProps$4 {
+    id: string;
+    name?: string;
+    options: {
+        header?: string;
+    };
+}
+declare function LoadingObject(props: NoObjectProps$4): JSX.Element;
+
+interface NoObjectProps$3 {
+    id: string;
+    name?: string;
+    options: {
+        header?: string;
+        emptyifnone?: boolean;
+    };
+}
+declare function MissingObject(props: NoObjectProps$3): JSX.Element;
+
+interface NoObjectProps$2 {
+    id: string;
+    name?: string;
+    properties?: {
+        message?: string;
+    };
+    options: {
+        header?: string;
+    };
+}
+declare function ErrorObject(props: NoObjectProps$2): JSX.Element;
+
+interface NoObjectProps$1 {
+    id: string;
+    name?: string;
+    type?: string;
+    options: {
+        variant?: string;
+        header?: string;
+        emptyifnone?: boolean;
+    };
+}
+declare function MissingComponentObject(props: NoObjectProps$1): JSX.Element;
+
 interface NoObjectProps {
     id: string;
     name?: string;
@@ -1810,6 +2027,10 @@ declare namespace Panel {
     var Contents: typeof PanelContents;
 }
 
+declare function Yaml$1(props: YamlComponent$2): JSX.Element;
+
+declare function Yaml(props: YamlComponent$2): JSX.Element;
+
 interface YamlNode {
     type: string;
     children?: YamlNode[];
@@ -2096,4 +2317,4 @@ interface MonitorPanelItemProps {
 }
 declare function MonitorPanelItem(props: PropsWithChildren<MonitorPanelItemProps>): JSX.Element;
 
-export { type ActuatorSchema, AirBearing, Mocks$j as AirBearingMocks, AirBearingProtected, type AirBearingSchema, AirBearingState, Variants$n as AirBearingVariants, type AnySchema, Info as BaseInfo, type BaseInfoWidgetOptions, Mocks$k as BaseMocks, Name as BaseName, type BaseNameWidgetOptions, Property as BaseProperty, type BasePropertyWidgetOptions, DefaultState as BaseState, Variants$o as BaseVariants, type ExceptionFromProcedure, formatting_d as Formatting, Frontend, Mocks$i as FrontendMocks, type FrontendSchema, Variants$m as FrontendVariants, FullSizer, Gauge, Mocks$h as GaugeMocks, type GaugeSchema, Variants$l 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$f as LaserHeatingMocks, type LaserHeatingSchema, Variants$j as LaserHeatingVariants, type LaserHeatingWidgetOptions, Mocks$g as LaserMocks, type LaserSchema, Variants$k as LaserVariants, type LaserWidgetOptions, Light, Mocks$e as LightMocks, type LightSchema, Variants$i as LightVariants, LimaBinning, LimaDefault, TomoDetectorSize$3 as LimaDescription, TomoDetectorSize$2 as LimaImageRoi, Mocks$d as LimaMocks, type LimaSchema, TomoDetectorSize$1 as LimaSize, LimaState, TomoDetectorSize as LimaTransformation, Variants$h as LimaVariants, type MeasurementGroupSchema, MissingKeysError, Motor as MockMotor, type Monitor, MonitorHardware, MonitorPanel, MonitorPanelItem, type MonitorPanelProps, MotorDefault, type MotorDefaultOptions, Mocks$c as MotorMocks, type MotorSchema, MotorState, MotorText, Variants$g as MotorVariants, Multiposition, Mocks$b as MultipositionMocks, type MultipositionSchema, Variants$f as MultipositionVariants, NoObject, NumericStep, Optic as OpticDefault, Mocks$a as OpticMocks, type OpticSchema, OpticState, Variants$e as OpticVariants, type OpticWidgetOptions, Panel, ProcedureExecution, ProcedureManage, Mocks$9 as ProcedureMocks, type ProcedureSchema, ProcedureState, ProcedureValidate, Variants$d as ProcedureVariants, Pump as PumpDefault, Mocks$7 as PumpMocks, type PumpSchema, Variants$b as PumpVariants, Pusher as PusherDefault, Mocks$6 as PusherMocks, type PusherSchema, PusherState, Variants$a as PusherVariants, type ScanFromProcedure, ServiceDefault, Mocks$5 as ServiceMocks, ServiceProtected, type ServiceSchema, ServiceState, Variants$9 as ServiceVariants, ShutterDefault, Mocks$8 as ShutterMocks, ShutterProtected, type ShutterSchema, ShutterState, Variants$c as ShutterVariants, 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, 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, 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, Wrapper, 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 };
+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, ErrorObject, 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, LoadingObject, MeasurementGroup as MeasurementGroupDefault, Mocks$e as MeasurementGroupMocks, type MeasurementGroupSchema, MeasurementGroupSimulator, Variants$i as MeasurementGroupVariants, MissingComponentObject, MissingKeysError, MissingObject, 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$1 as NoObject, Yaml as None, NoObject as NullObject, 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, Yaml$1 as Todo, 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 };