@esrf/daiquiri-lib 4.0.1 → 5.0.0

package/dist/index.d.ts

@@ -1,9 +1,9 @@
 /// <reference types="react" />
 import { JSONSchema7 } from 'json-schema';
-import * as React$1 from 'react';
-import React__default, { ComponentType, ReactElement, PropsWithChildren, ReactNode, ChangeEvent, KeyboardEvent, Component } from 'react';
+import * as react from 'react';
+import react__default, { ComponentType, ReactElement, PropsWithChildren, ReactNode, ChangeEvent, KeyboardEvent, Component } from 'react';
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import { YamlComponent as YamlComponent$2 } from '@esrf/daiquiri-lib';
+import { YamlComponent as YamlComponent$1 } from '@esrf/daiquiri-lib';
 
 interface HardwareError {
     property: string;
@@ -14,6 +14,19 @@ interface HardwareSchemaDescription {
     properties: JSONSchema7;
     callables: JSONSchema7;
 }
+interface LockDescription {
+    /**
+     * A unique key for identification purpose.
+     *
+     * It actually mangles BLISS object id, role,
+     * and PID of the owner process.
+     *
+     * For example `srot_move,pid:26567`
+     *
+     * In the future this will be split into meaningful information.
+     */
+    reason: string;
+}
 interface BaseHardware<O = boolean, P extends Record<string, any> = Record<string, never>> {
     /** Object name */
     name: string;
@@ -28,7 +41,7 @@ interface BaseHardware<O = boolean, P extends Record<string, any> = Record<strin
     /** Whether the device is available */
     online: O;
     /** The reason why the hardware is locked, else null */
-    locked: string | null;
+    locked: LockDescription | null;
     /** The object type as defined by the REST API */
     type: string;
     /** Any potential errors initialising this object */
@@ -75,10 +88,39 @@ interface HardwareWidgetProps<H extends Hardware = Hardware, O extends HardwareW
     /** True if the session have the control */
     operator: boolean;
 }
+/**
+ * Options propagated from the monitor yaml description.
+ *
+ * It is used for the monitor defined by the hardware.
+ *
+ * FIXME: Rework the hardware variant variants to specialize
+ * and drop HardwareWidgetOptions.
+ */
+interface HardwareMonitorOptions extends HardwareWidgetOptions {
+    /**
+     * Override the name of the hardware.
+     */
+    name?: string;
+}
 type HardwareComponentType<H extends Hardware = Hardware> = ComponentType<HardwareWidgetProps<H, any>>;
 interface HardwareVariant<H extends Hardware = Hardware> {
     [name: string]: HardwareComponentType<H>;
 }
+/**
+ * TODO: Add a description
+ */
+interface HardwareObjectProps {
+    id: string;
+    options: {
+        variant?: string;
+        header?: string;
+        width?: number;
+        colWidth?: number;
+        emptyifnone?: boolean;
+    };
+    propertiesSchema?: Record<string, unknown>;
+    callablesSchema?: Record<string, unknown>;
+}
 
 type types_d_AnyHardware = AnyHardware;
 type types_d_BaseHardware<O = boolean, P extends Record<string, any> = Record<string, never>> = BaseHardware<O, P>;
@@ -87,14 +129,17 @@ type types_d_EditableHardwareWidgetOptions = EditableHardwareWidgetOptions;
 type types_d_Hardware<P extends Record<string, unknown> = Record<string, any>> = Hardware<P>;
 type types_d_HardwareChangeActions = HardwareChangeActions;
 type types_d_HardwareComponentType<H extends Hardware = Hardware> = HardwareComponentType<H>;
+type types_d_HardwareMonitorOptions = HardwareMonitorOptions;
+type types_d_HardwareObjectProps = HardwareObjectProps;
 type types_d_HardwareSchemaDescription = HardwareSchemaDescription;
 type types_d_HardwareVariant<H extends Hardware = Hardware> = HardwareVariant<H>;
 type types_d_HardwareWidgetOptions = HardwareWidgetOptions;
 type types_d_HardwareWidgetProps<H extends Hardware = Hardware, O extends HardwareWidgetOptions = HardwareWidgetOptions> = HardwareWidgetProps<H, O>;
+type types_d_LockDescription = LockDescription;
 type types_d_OfflineHardware = OfflineHardware;
 type types_d_OnlineHardware<P extends Record<string, any> = Record<string, never>> = OnlineHardware<P>;
 declare namespace types_d {
-  export type { types_d_AnyHardware as AnyHardware, types_d_BaseHardware as BaseHardware, types_d_EditableHardware as EditableHardware, types_d_EditableHardwareWidgetOptions as EditableHardwareWidgetOptions, types_d_Hardware as Hardware, types_d_HardwareChangeActions as HardwareChangeActions, types_d_HardwareComponentType as HardwareComponentType, types_d_HardwareSchemaDescription as HardwareSchemaDescription, types_d_HardwareVariant as HardwareVariant, types_d_HardwareWidgetOptions as HardwareWidgetOptions, types_d_HardwareWidgetProps as HardwareWidgetProps, types_d_OfflineHardware as OfflineHardware, types_d_OnlineHardware as OnlineHardware };
+  export type { types_d_AnyHardware as AnyHardware, types_d_BaseHardware as BaseHardware, types_d_EditableHardware as EditableHardware, types_d_EditableHardwareWidgetOptions as EditableHardwareWidgetOptions, types_d_Hardware as Hardware, types_d_HardwareChangeActions as HardwareChangeActions, types_d_HardwareComponentType as HardwareComponentType, types_d_HardwareMonitorOptions as HardwareMonitorOptions, types_d_HardwareObjectProps as HardwareObjectProps, types_d_HardwareSchemaDescription as HardwareSchemaDescription, types_d_HardwareVariant as HardwareVariant, types_d_HardwareWidgetOptions as HardwareWidgetOptions, types_d_HardwareWidgetProps as HardwareWidgetProps, types_d_LockDescription as LockDescription, types_d_OfflineHardware as OfflineHardware, types_d_OnlineHardware as OnlineHardware };
 }
 
 /**
@@ -113,9 +158,9 @@ declare namespace schema_d {
   export type { schema_d_AnySchema as AnySchema, schema_d_GenericSchema as GenericSchema };
 }
 
-declare const Variants$q: HardwareVariant<AnySchema>;
+declare const Variants$r: HardwareVariant<AnySchema>;
 
-declare const Mocks$m: {
+declare const Mocks$n: {
     default: {
         response: {
             callables: never[];
@@ -253,7 +298,7 @@ type ActuatorSchema = Hardware<{
 type AirBearingSchema = Hardware<{
     state: string;
 }>;
-declare const Variants$p: HardwareVariant<AirBearingSchema>;
+declare const Variants$q: HardwareVariant<AirBearingSchema>;
 
 declare function AirBearing(props: HardwareWidgetProps<AirBearingSchema, HardwareWidgetOptions>): react_jsx_runtime.JSX.Element;
 
@@ -263,7 +308,7 @@ declare function AirBearingState(props: {
     hardware: AirBearingSchema;
 }): react_jsx_runtime.JSX.Element;
 
-declare const Mocks$l: {
+declare const Mocks$m: {
     default: {
         callables: string[];
         id: string;
@@ -291,6 +336,40 @@ type PropsWithSimulator<P = Record<string, never>> = P & {
 
 declare function AirBearingSimulator(props: PropsWithSimulator): react_jsx_runtime.JSX.Element;
 
+type EnergyManagerSchema = Hardware<{
+    energy: number | null;
+    unit: string;
+    available_source_names: string[];
+    source: string;
+}>;
+declare const Variants$p: HardwareVariant<EnergyManagerSchema>;
+
+declare function EnergyManagerDefault(props: HardwareWidgetProps<EnergyManagerSchema>): react_jsx_runtime.JSX.Element;
+
+declare function EnergyManagerState(props: {
+    hardware: EnergyManagerSchema;
+}): react_jsx_runtime.JSX.Element;
+
+declare const Mocks$l: {
+    default: {
+        callables: never[];
+        id: string;
+        name: string;
+        online: boolean;
+        properties: {
+            energy: number;
+            unit: string;
+            available_source_names: string[];
+            source: string;
+        };
+        protocol: string;
+        require_staff: boolean;
+        type: string;
+    };
+};
+
+declare function EnergyManagerSimulator(props: PropsWithSimulator): react_jsx_runtime.JSX.Element;
+
 type FrontendSchema = Hardware<{
     state: string;
     status: string;
@@ -349,7 +428,7 @@ interface GaugeWidgetOptions extends HardwareWidgetOptions {
     /** Precision to show, default 3 */
     precision?: number;
 }
-declare function Gauge(props: HardwareWidgetProps<GaugeSchema, GaugeWidgetOptions>): react_jsx_runtime.JSX.Element;
+declare function Gauge$1(props: HardwareWidgetProps<GaugeSchema, GaugeWidgetOptions>): react_jsx_runtime.JSX.Element;
 
 declare const Mocks$j: {
     default: {
@@ -808,6 +887,18 @@ declare function isMotorHardware(entity: Hardware): entity is MotorSchema;
  */
 declare function useMotorHardware(name: string | null): MotorSchema | null;
 declare const Variants$h: HardwareVariant<MotorSchema>;
+/**
+ * True if the motor positon is clock wise.
+ *
+ * This is based on dial metadata, and user sign.
+ */
+declare function isMotorClockWise(hardware: MotorSchema, options?: {
+    clockwise?: boolean;
+}): boolean;
+/**
+ * Normalize the limits as finite values or `undefined`.
+ */
+declare function motorLimits(hardware: MotorSchema): [number | undefined, number | undefined];
 
 interface MotorDefaultOptions extends HardwareWidgetOptions {
     /** Default step size to use for up / down arrows */
@@ -834,6 +925,12 @@ interface MotorDefaultOptions extends HardwareWidgetOptions {
     horizontalarrows?: boolean;
     /** Show large step arrows */
     largearrows?: boolean;
+    /**
+     * Enforce the way the positive direction is displayed.
+     *
+     * For example this can change the behavior of a knob representation.
+     */
+    clockwise?: boolean;
 }
 
 /**
@@ -846,6 +943,8 @@ declare function MotorDefault(props: HardwareWidgetProps<MotorSchema, MotorDefau
  */
 declare function MotorText(props: HardwareWidgetProps<MotorSchema, MotorDefaultOptions>): react_jsx_runtime.JSX.Element;
 
+declare function MotorRotation(props: HardwareWidgetProps<MotorSchema, MotorDefaultOptions>): react_jsx_runtime.JSX.Element;
+
 /**
  * A motor have a set of flags as state.
  *
@@ -994,7 +1093,7 @@ declare function createMotorMock(name: string, position: number): {
     online: boolean;
 };
 
-interface Props$d {
+interface Props$9 {
     name?: string;
     minLimit?: number;
     maxLimit?: number;
@@ -1007,7 +1106,7 @@ interface Props$d {
         };
     };
 }
-declare function MotorSimulator(props: Props$d): react_jsx_runtime.JSX.Element;
+declare function MotorSimulator(props: Props$9): react_jsx_runtime.JSX.Element;
 
 type MultipositionSchema = Hardware<{
     position: string;
@@ -1149,10 +1248,10 @@ declare const Mocks$b: {
     };
 };
 
-interface Props$c {
+interface Props$8 {
     kind: 'fixed' | 'range' | 'multi';
 }
-declare function OpticSimulator(props: PropsWithSimulator<Props$c>): react_jsx_runtime.JSX.Element;
+declare function OpticSimulator(props: PropsWithSimulator<Props$8>): react_jsx_runtime.JSX.Element;
 
 type ProcedureSchema = Hardware<{
     state: string;
@@ -1188,7 +1287,20 @@ declare function useProcedureHardware(name: string | null): ProcedureSchema | nu
 
 declare function ProcedureExecution(props: HardwareWidgetProps<ProcedureSchema>): react_jsx_runtime.JSX.Element;
 
-declare function ProcedureManage(props: HardwareWidgetProps<ProcedureSchema>): react_jsx_runtime.JSX.Element;
+interface ProcedureOptions extends HardwareWidgetOptions {
+    /**
+     * If true, execute the procedure in the BLISS session foreground.
+     *
+     * As result, the terminal first have to be available to
+     * start the procedure, else it fails.
+     *
+     * Also, as it takes the prompt, it is visible by the users,
+     * so they have to kill or to wait for the end before doing
+     * anything else.
+     */
+    foreground?: boolean;
+}
+declare function ProcedureManage(props: HardwareWidgetProps<ProcedureSchema, ProcedureOptions>): react_jsx_runtime.JSX.Element;
 
 declare function ProcedureValidate(props: HardwareWidgetProps<ProcedureSchema>): react_jsx_runtime.JSX.Element;
 
@@ -1288,6 +1400,22 @@ declare const Mocks$9: {
         require_staff: boolean;
         type: string;
     };
+    closed: {
+        callables: string[];
+        id: string;
+        name: string;
+        online: boolean;
+        properties: {
+            closed_text: string;
+            open_text: string;
+            state: string;
+            status: string;
+            valid: boolean;
+        };
+        protocol: string;
+        require_staff: boolean;
+        type: string;
+    };
 };
 
 declare function ShutterSimulator(props: PropsWithSimulator): react_jsx_runtime.JSX.Element;
@@ -1796,7 +1924,7 @@ declare const Mocks: {
     };
 };
 
-interface Props$b {
+interface Props$7 {
     online: boolean;
     activeMessage?: string;
     inactiveMessage?: string;
@@ -1804,9 +1932,9 @@ interface Props$b {
     icon: string;
     name: string;
 }
-declare function TypeIcon(props: Props$b): react_jsx_runtime.JSX.Element;
+declare function TypeIcon(props: Props$7): react_jsx_runtime.JSX.Element;
 
-interface Props$a {
+interface Props$6 {
     hardware: Hardware;
     headerMode?: string;
     widgetIcon: ReactElement;
@@ -1817,7 +1945,7 @@ interface Props$a {
  * Normalized way to compose hardware component in order to provide the same
  * kind of layout
  */
-declare function HardwareTemplate(props: Props$a): react_jsx_runtime.JSX.Element;
+declare function HardwareTemplate(props: Props$6): react_jsx_runtime.JSX.Element;
 
 /**
  * Input number synchronized with a hardware.
@@ -1882,7 +2010,7 @@ declare function HardwareNumericStep(props: {
  * If `minWidth` is pecified (in `em`) it ensure the widget width will stay the
  * same when the state change
  */
-declare function HardwareState(props: {
+declare function State$1(props: {
     state: string;
     variant: string;
     minWidth?: number;
@@ -1898,19 +2026,13 @@ declare function HardwareState(props: {
  * If `minWidth` is pecified (in `em`) it ensure the widget width will stay the
  * same when the state change
  */
-declare function HardwareMultiState(props: {
+declare function MultiState(props: {
     states: string[];
     variants?: Record<string, string>;
     descriptions?: Record<string, string>;
     minWidth?: number;
 }): react_jsx_runtime.JSX.Element;
 
-declare const State_d_HardwareMultiState: typeof HardwareMultiState;
-declare const State_d_HardwareState: typeof HardwareState;
-declare namespace State_d {
-  export { State_d_HardwareMultiState as HardwareMultiState, State_d_HardwareState as HardwareState };
-}
-
 declare function formatEng(scalar: number): {
     scalar: number;
     prefix: string;
@@ -1996,12 +2118,42 @@ interface NoObjectProps {
 }
 declare function NoObject(props: NoObjectProps): react_jsx_runtime.JSX.Element;
 
-interface Props$9 {
+interface Props$5 {
     className?: string;
 }
-declare function FullSizer(props: PropsWithChildren<Props$9>): react_jsx_runtime.JSX.Element;
+declare function FullSizer(props: PropsWithChildren<Props$5>): react_jsx_runtime.JSX.Element;
 
-interface Props$8 {
+interface Props$4 {
+    size: number;
+    value?: number | null;
+    target?: number | null;
+    min?: number;
+    max?: number;
+    disabled?: boolean;
+    readOnly?: boolean;
+    origin?: 'up' | 'down' | 'left' | 'right';
+    direction?: 'clockwise' | 'anticlockwise';
+    onChange?: (value: number) => void;
+    onInteractiveChange?: (value: number) => void;
+    className: string;
+}
+/**
+ * Widget to handle cyclic angle value in degree displayed as an infinite knob
+ */
+declare function InfiniteKnob360(props: Props$4): react_jsx_runtime.JSX.Element;
+
+declare function Gauge(props: {
+    size: number;
+    value: number | null;
+    min: number;
+    max: number;
+    lowWarning?: number;
+    hiWarning?: number;
+    lowDanger?: number;
+    hiDanger?: number;
+}): react_jsx_runtime.JSX.Element;
+
+interface Props$3 {
     step?: number | string;
     steps?: (number | string)[];
     disabled: boolean;
@@ -2024,7 +2176,7 @@ interface Props$8 {
     }) => void;
     onKeyDown?: (e: KeyboardEvent<HTMLInputElement>) => void;
 }
-declare const NumericStep: React$1.ForwardRefExoticComponent<Props$8 & React$1.RefAttributes<HTMLInputElement>>;
+declare const NumericStep: react.ForwardRefExoticComponent<Props$3 & react.RefAttributes<HTMLInputElement>>;
 
 declare function PanelHeader(props: PropsWithChildren<{
     style?: Record<string, any>;
@@ -2033,20 +2185,33 @@ declare function PanelContents(props: PropsWithChildren<{
     style?: Record<string, any>;
     className?: string;
 }>): react_jsx_runtime.JSX.Element;
-interface Props$7 {
+interface Props$2 {
     style?: Record<string, any>;
     scroll?: boolean;
     className?: string;
 }
-declare function Panel(props: PropsWithChildren<Props$7>): react_jsx_runtime.JSX.Element;
+declare function Panel(props: PropsWithChildren<Props$2>): react_jsx_runtime.JSX.Element;
 declare namespace Panel {
     var Header: typeof PanelHeader;
     var Contents: typeof PanelContents;
 }
 
-declare function Yaml$1(props: YamlComponent$2): react_jsx_runtime.JSX.Element;
+declare function Yaml$1(props: YamlComponent$1): react_jsx_runtime.JSX.Element;
+
+declare function Yaml(props: YamlComponent$1): react_jsx_runtime.JSX.Element;
 
-declare function Yaml(props: YamlComponent$2): react_jsx_runtime.JSX.Element;
+/**
+ * Component which display the state of a hardware.
+ *
+ * It is based on the type of the hardware, and fallback to the
+ * `AnyHardwareState` component if no components are available.
+ */
+declare function HardwareState(props: {
+    hardware: AnyHardware | null;
+    options?: {
+        emptyifnone?: boolean;
+    };
+}): react_jsx_runtime.JSX.Element;
 
 interface YamlNode {
     type: string;
@@ -2061,127 +2226,12 @@ interface YamlRoot extends YamlNode {
 interface AnyYamlNode extends YamlNode {
     [key: string]: any;
 }
-interface YamlComponent$1 {
+interface YamlComponent {
     providers?: Record<string, any>;
     yamlNode: YamlNode;
     [option: string]: unknown;
 }
 
-interface Props$6 {
-    yamlNode: AnyYamlNode;
-    panel: boolean;
-}
-declare function YamlRow({ yamlNode, panel }: Props$6): react_jsx_runtime.JSX.Element;
-
-interface Props$5 {
-    yamlNode: AnyYamlNode;
-    panel: boolean;
-}
-declare function YamlCol({ yamlNode, panel }: Props$5): react_jsx_runtime.JSX.Element;
-
-declare const componentMap: Record<string, React__default.ComponentType<any>>;
-declare function registerComponent(name: string, component: React__default.ComponentType<any>): void;
-declare function registerComponents(map: Record<string, React__default.ComponentType<any>>): void;
-interface YamlComponentNode extends YamlNode {
-    type: string;
-    [name: string]: any;
-    scroll?: boolean;
-    style?: Record<string, any>;
-    title?: string;
-}
-declare function YamlComponent(props: {
-    yamlNode: YamlComponentNode;
-    panel: boolean;
-}): react_jsx_runtime.JSX.Element;
-
-interface Props$4 {
-    yamlNode: {
-        children: any[];
-        options?: Record<string, any>;
-    };
-    panel: boolean;
-}
-declare function YamlContainer({ yamlNode, panel }: Props$4): react_jsx_runtime.JSX.Element;
-
-interface Props$3 {
-    yamlNode: {
-        children: any[];
-        options?: Record<string, any>;
-        title?: string;
-    };
-    panel: boolean;
-}
-declare function YamlPanel(props: Props$3): ReactElement;
-
-interface Props$2 {
-    yamlNode: {
-        children: any[];
-        options?: Record<string, any>;
-        title: string;
-    };
-    panel: boolean;
-}
-declare function YamlTabs({ yamlNode, panel }: Props$2): react_jsx_runtime.JSX.Element;
-
-interface YamlFormHeaderNode extends YamlNode {
-    type: 'formheader';
-    title?: string;
-}
-interface YamlFormRowNode extends YamlNode {
-    type: string;
-    title: string;
-    component?: string;
-    stateinheader?: boolean;
-    titlealign?: string;
-    id?: string;
-    variant?: string;
-    options?: Record<string, any>;
-    even: boolean;
-}
-interface YamlFormNode extends YamlNode {
-    children: (YamlFormHeaderNode | YamlFormRowNode)[];
-    title?: string;
-    [key: string]: any;
-}
-declare function YamlForm(props: {
-    yamlNode: YamlFormNode;
-    panel: boolean;
-}): react_jsx_runtime.JSX.Element;
-
-interface YamlGridNode extends YamlNode {
-    children: YamlGridCellNode[];
-    title?: string;
-    columns?: string;
-    rows?: string;
-}
-interface YamlGridCellNode extends YamlNode {
-    columnSpan?: number;
-    rowSpan?: number;
-}
-declare function YamlGrid(props: {
-    yamlNode: YamlGridNode;
-    panel: boolean;
-}): react_jsx_runtime.JSX.Element;
-
-declare const yamlContainers: {
-    row: typeof YamlRow;
-    col: typeof YamlCol;
-    container: typeof YamlContainer;
-    panel: typeof YamlPanel;
-    tabs: typeof YamlTabs;
-    form: typeof YamlForm;
-    grid: typeof YamlGrid;
-};
-declare const yamlMap: {
-    component: typeof YamlComponent;
-    row: typeof YamlRow;
-    col: typeof YamlCol;
-    container: typeof YamlContainer;
-    panel: typeof YamlPanel;
-    tabs: typeof YamlTabs;
-    form: typeof YamlForm;
-    grid: typeof YamlGrid;
-};
 interface Props$1 {
     testid: string;
     layout: YamlRoot;
@@ -2199,7 +2249,7 @@ interface State {
 interface Props {
     resetKey?: any;
     unhandledComponentDidCatch?: (error: Error, setStateCallback: (data: Record<string, any>) => void) => void;
-    UnhandledErrorComponent?: React__default.ComponentType<any>;
+    UnhandledErrorComponent?: react__default.ComponentType<any>;
 }
 declare class ErrorBoundary extends Component<PropsWithChildren<Props>, State> {
     constructor(props: Props);
@@ -2209,13 +2259,9 @@ declare class ErrorBoundary extends Component<PropsWithChildren<Props>, State> {
     private readonly reload;
     componentDidCatch(error: Error): void;
     componentDidUpdate(prevProps: Props, prevState: State): void;
-    render(): string | number | boolean | react_jsx_runtime.JSX.Element | Iterable<React__default.ReactNode> | null | undefined;
+    render(): string | number | boolean | react_jsx_runtime.JSX.Element | Iterable<react__default.ReactNode> | null | undefined;
 }
 
-/**
- * Register the Yaml type with the component used to render this Yaml node.
- */
-declare function registerYamlType(name: string, component: React.ComponentType<any>): void;
 /**
  * Render a Yaml node using registred component from the node type
  */
@@ -2234,6 +2280,29 @@ declare class KeyError extends LayoutError {
     constructor(yamlNode: YamlNode, key: string, message: string);
 }
 
+/**
+ * Store the mapping from Yaml `type` to React component handling the
+ * rendering of such Yaml node
+ */
+declare const yamlContainers: Record<string, ComponentType<any>>;
+/**
+ * Register the Yaml type with the component used to render this Yaml node.
+ */
+declare function registerYamlContainer(name: string, component: ComponentType<any>): void;
+declare const yamlComponents: Record<string, ComponentType<any>>;
+/**
+ * Register a yaml component.
+ *
+ * Such component is wrapped inside a `Panel`.
+ */
+declare function registerYamlComponent(name: string, component: ComponentType<any>): void;
+/**
+ * Register multiple yaml components.
+ *
+ * Such components are wrapped inside a `Panel`.
+ */
+declare function registerYamlComponents(map: Record<string, ComponentType<any>>): void;
+
 type Defined<T> = T extends undefined ? never : T;
 declare function assertKeyExpected<T>(yamlNode: YamlNode | undefined, key: string, value: T): asserts value is Defined<T>;
 declare function assertString(yamlNode: YamlNode, key: string, value: any): asserts value is string;
@@ -2250,14 +2319,52 @@ declare function assertOptionalListOfType<Y>(yamlNode: YamlNode, key: string, va
 declare function assertNoUnknownKeys(yamlNode: YamlNode | undefined, remainingContent: Record<string, any>): void;
 declare function assertDataCollectionId(yamlNode: YamlNode, key: string, value: unknown): asserts value is number | 'last';
 declare function assertOptionalBackend(yamlNode: YamlNode, key: string, value: unknown): asserts value is 'plotly' | 'h5web' | undefined;
-
+/**
+ * Assert function for generic 'args' as used in python
+ * function with `*args`.
+ *
+ * The argument is validated as a list of unknown items.
+ */
+declare function assertOptionalArgs(yamlNode: YamlNode, key: string, value: unknown): asserts value is unknown[] | undefined;
+/**
+ * Assert function for generic 'kwargs' as used in python
+ * function with `**kwargs`.
+ *
+ * The argument is validated as a record from string to unknown values.
+ */
+declare function assertOptionalKwargs(yamlNode: YamlNode, key: string, value: unknown): asserts value is Record<string, unknown> | undefined;
+/**
+ * Type a schema from it;s typescript description.
+ *
+ * See `assertStringMappingRecord`
+ */
+type Schema<T> = Record<keyof T, (yamlNode: YamlNode, key: string, value: unknown) => void>;
+/**
+ * Assert function for generic record of string.
+ *
+ * Can be used as the basis of a specific assertion.
+ *
+ * The argument is validated as a record from string to unknown values.
+ *
+ * @param options: Parsing parameters
+ */
+declare function assertStringMappingRecord<T extends Partial<Record<string, any>>>(yamlNode: YamlNode, key: string, value: unknown, options: {
+    /** If true, the value can be `undefined` */
+    optional?: boolean;
+    /** Mapping from expected keys to the relative assert function */
+    schema: Record<string, (yamlNode: YamlNode, key: string, value: unknown) => void>;
+}): asserts value is T;
+
+type asserts_d_Schema<T> = Schema<T>;
 declare const asserts_d_assertBoolean: typeof assertBoolean;
 declare const asserts_d_assertDataCollectionId: typeof assertDataCollectionId;
 declare const asserts_d_assertKeyExpected: typeof assertKeyExpected;
 declare const asserts_d_assertNoUnknownKeys: typeof assertNoUnknownKeys;
 declare const asserts_d_assertNumber: typeof assertNumber;
+declare const asserts_d_assertOptionalArgs: typeof assertOptionalArgs;
 declare const asserts_d_assertOptionalBackend: typeof assertOptionalBackend;
 declare const asserts_d_assertOptionalBoolean: typeof assertOptionalBoolean;
+declare const asserts_d_assertOptionalKwargs: typeof assertOptionalKwargs;
 declare const asserts_d_assertOptionalListOfType: typeof assertOptionalListOfType;
 declare const asserts_d_assertOptionalNumber: typeof assertOptionalNumber;
 declare const asserts_d_assertOptionalNumberList: typeof assertOptionalNumberList;
@@ -2266,8 +2373,9 @@ declare const asserts_d_assertOptionalStringList: typeof assertOptionalStringLis
 declare const asserts_d_assertOptionalStringOrStringList: typeof assertOptionalStringOrStringList;
 declare const asserts_d_assertString: typeof assertString;
 declare const asserts_d_assertStringList: typeof assertStringList;
+declare const asserts_d_assertStringMappingRecord: typeof assertStringMappingRecord;
 declare namespace asserts_d {
-  export { 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_assertOptionalListOfType as assertOptionalListOfType, asserts_d_assertOptionalNumber as assertOptionalNumber, asserts_d_assertOptionalNumberList as assertOptionalNumberList, asserts_d_assertOptionalString as assertOptionalString, asserts_d_assertOptionalStringList as assertOptionalStringList, asserts_d_assertOptionalStringOrStringList as assertOptionalStringOrStringList, asserts_d_assertString as assertString, asserts_d_assertStringList as assertStringList };
+  export { type asserts_d_Schema as Schema, asserts_d_assertBoolean as assertBoolean, asserts_d_assertDataCollectionId as assertDataCollectionId, asserts_d_assertKeyExpected as assertKeyExpected, asserts_d_assertNoUnknownKeys as assertNoUnknownKeys, asserts_d_assertNumber as assertNumber, asserts_d_assertOptionalArgs as assertOptionalArgs, asserts_d_assertOptionalBackend as assertOptionalBackend, asserts_d_assertOptionalBoolean as assertOptionalBoolean, asserts_d_assertOptionalKwargs as assertOptionalKwargs, asserts_d_assertOptionalListOfType as assertOptionalListOfType, asserts_d_assertOptionalNumber as assertOptionalNumber, asserts_d_assertOptionalNumberList as assertOptionalNumberList, asserts_d_assertOptionalString as assertOptionalString, asserts_d_assertOptionalStringList as assertOptionalStringList, asserts_d_assertOptionalStringOrStringList as assertOptionalStringOrStringList, asserts_d_assertString as assertString, asserts_d_assertStringList as assertStringList, asserts_d_assertStringMappingRecord as assertStringMappingRecord };
 }
 
 interface RuntimeHooks {
@@ -2317,40 +2425,40 @@ declare function useOperator(): boolean;
  */
 declare function useScanRunning(): boolean;
 
-interface HardwareObjectProps {
-    id: string;
-    options: {
-        variant?: string;
-        header?: string;
-        width?: number;
-        colWidth?: number;
-        emptyifnone?: boolean;
-    };
-    propertiesSchema?: Record<string, unknown>;
-    callablesSchema?: Record<string, unknown>;
-}
-
-type HardwareObject_d_HardwareObjectProps = HardwareObjectProps;
-declare namespace HardwareObject_d {
-  export type { HardwareObject_d_HardwareObjectProps as HardwareObjectProps };
-}
-
-/**
- * Register the Yaml type with the component used to render this Yaml node.
- */
-declare function registerHardwareComponent(name: string, component: React.ComponentType<any>): void;
-
 interface Monitor {
+    /**
+     * Similar to a title
+     */
     name: string;
+    /**
+     * Describe the kind of widget.
+     *
+     * NOTE: New components can be registered with `registerMonitorComponent`
+     */
     type?: string;
+    /**
+     * For hardwareproperty monitor
+     */
     value: string;
     overlay?: string;
     comparator?: string;
     comparison?: any;
     unit?: string;
+    /**
+     * For hardware monitor
+     */
+    id?: string;
 }
 
 declare const dynamicOp: (op: string, a1: any, b1: any) => boolean | undefined;
+declare function MonitorHardwareProperty(props: {
+    monitor: Monitor;
+}): react_jsx_runtime.JSX.Element;
+
+/**
+ * HardwareMonitor which provide callback to get the
+ * component from the hardware type.
+ */
 declare function MonitorHardware(props: {
     monitor: Monitor;
 }): react_jsx_runtime.JSX.Element;
@@ -2362,8 +2470,40 @@ interface MonitorPanelProps {
     bg?: 'light' | null;
 }
 declare function MonitorPanel(props: MonitorPanelProps): react_jsx_runtime.JSX.Element;
+
 interface MonitorPanelItemProps {
+    className?: string;
+    style?: Record<string, unknown>;
 }
-declare function MonitorPanelItem(props: PropsWithChildren<MonitorPanelItemProps>): react_jsx_runtime.JSX.Element;
+/**
+ * Component for any item displayed in the monitor panel.
+ *
+ * The implementation with `forwardRef` and `...rest` allow
+ * to use it inside a `OverlayTrigger`
+ *
+ * @param rest: Passthough to allow to wrap the component inside
+ *              OverlayTrigger. It contains callbacks.
+ */
+declare const MonitorPanelItem: react.ForwardRefExoticComponent<MonitorPanelItemProps & {
+    children?: react.ReactNode;
+} & react.RefAttributes<HTMLDivElement>>;
+
+/**
+ * Register an hardware variant.
+ */
+declare function registerHardwareVariant(type: string, variant: string, component: HardwareComponentType<AnySchema>): void;
+/**
+ * Return a hardware variant component.
+ *
+ * - Check first if a hardware type and variant
+ *   is registered, return it.
+ * - Else, check if the 'base' type and variant
+ *   is registered, return it
+ * - Else, return null
+ *
+ * @param type: Type of the hardware
+ * @param variant: Variant requested
+ */
+declare function getHardwareVariantComponent(type: string, variant: string): HardwareComponentType | null;
 
-export { type ActuatorSchema, AirBearing, Mocks$l as AirBearingMocks, AirBearingProtected, type AirBearingSchema, AirBearingSimulator, AirBearingState, Variants$p as AirBearingVariants, type AnyHardware, type AnySchema, type BaseHardware, 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$2 as LimaDescription, TomoDetectorSize$1 as LimaImageRoi, Mocks$f as LimaMocks, type LimaSchema, LimaRoiShape as LimaShape, LimaSimulator, TomoDetectorSize as LimaSize, LimaState, 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$b 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, componentMap, createMotorMock, dynamicOp, isLimaHardware, isMotorHardware, isOpticHardware, isProcedureHardware, isTomoConfigHardware, isTomoDetectorHardware, isTomoDetectorsHardware, isTomoFlatMotionHardware, isTomoHoloHardware, isTomoReferencePositionHardware, isTomoSampleStageHardware, limaGuessSubframes, registerHardwareComponent, registerMonitorComponent, registerRuntimeHook, registerComponent as registerYamlComponent, registerComponents as registerYamlComponents, registerYamlType, renderYamlNode, useHardware, useHardwareChangeActions, useHardwareSchema, useLimaHardware, useMotorHardware, useMotorStates, useOperator, useProcedureHardware, useScanRunning, useTomoConfigHardware, useTomoDetectorHardware, useTomoDetectorsHardware, useTomoFlatMotionHardware, useTomoHoloHardware, useTomoSampleStageHardware, yamlContainers, yamlMap };
+export { type ActuatorSchema, AirBearing, Mocks$m as AirBearingMocks, AirBearingProtected, type AirBearingSchema, AirBearingSimulator, AirBearingState, Variants$q as AirBearingVariants, type AnyHardware, type AnySchema, type BaseHardware, Info as BaseInfo, type BaseInfoWidgetOptions, Mocks$n as BaseMocks, Name as BaseName, type BaseNameWidgetOptions, Property as BaseProperty, type BasePropertyWidgetOptions, DefaultState as BaseState, Variants$r as BaseVariants, EnergyManagerDefault, Mocks$l as EnergyManagerMocks, type EnergyManagerSchema, EnergyManagerSimulator, EnergyManagerState, Variants$p as EnergyManagerVariants, ErrorObject, type ExceptionFromProcedure, formatting_d as Formatting, Frontend, Mocks$k as FrontendMocks, type FrontendSchema, Variants$o as FrontendVariants, FullSizer, Gauge$1 as Gauge, Gauge as GaugeIndicator, Mocks$j as GaugeMocks, type GaugeSchema, Variants$n as GaugeVariants, type GaugeWidgetOptions, type GenericSchema, type Hardware, type HardwareComponentType, type HardwareFromProcedure, HardwareInputNumber, HardwareNumericStep, type HardwareObjectProps, schema_d as HardwareSchema, HardwareState, HardwareTemplate, types_d as HardwareTypes, type HardwareVariant, InfiniteKnob360, 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$2 as LimaDescription, TomoDetectorSize$1 as LimaImageRoi, Mocks$f as LimaMocks, type LimaSchema, LimaRoiShape as LimaShape, LimaSimulator, TomoDetectorSize as LimaSize, LimaState, 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, MonitorHardwareProperty, MonitorPanel, MonitorPanelItem, type MonitorPanelProps, MotorDefault, type MotorDefaultOptions, Mocks$d as MotorMocks, MotorRotation, type MotorSchema, MotorSimulator, MotorState, MotorText, Variants$h as MotorVariants, MultiState, 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, State$1 as State, 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$7 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, type YamlNode, createMotorMock, dynamicOp, getHardwareVariantComponent, isLimaHardware, isMotorClockWise, isMotorHardware, isOpticHardware, isProcedureHardware, isTomoConfigHardware, isTomoDetectorHardware, isTomoDetectorsHardware, isTomoFlatMotionHardware, isTomoHoloHardware, isTomoReferencePositionHardware, isTomoSampleStageHardware, limaGuessSubframes, motorLimits, registerHardwareVariant, registerMonitorComponent, registerRuntimeHook, registerYamlComponent, registerYamlComponents, registerYamlContainer, renderYamlNode, useHardware, useHardwareChangeActions, useHardwareSchema, useLimaHardware, useMotorHardware, useMotorStates, useOperator, useProcedureHardware, useScanRunning, useTomoConfigHardware, useTomoDetectorHardware, useTomoDetectorsHardware, useTomoFlatMotionHardware, useTomoHoloHardware, useTomoSampleStageHardware, yamlComponents, yamlContainers };