@wandelbots/nova-api 25.7.0-dev.27 → 25.7.0-dev.29

package/v1/api.ts

@@ -7528,6 +7528,7 @@ export const VirtualControllerTypes = {
     FanucCrx20ial: 'fanuc-crx20ial',
     FanucCrx25ia: 'fanuc-crx25ia',
     FanucCrx30ia: 'fanuc-crx30ia',
+    FanucCrx5ia: 'fanuc-crx5ia',
     FanucLrMate200iD: 'fanuc-lr_mate_200iD',
     FanucLrMate200iD4S: 'fanuc-lr_mate_200iD4S',
     FanucLrMate200iD7L: 'fanuc-lr_mate_200iD7L',
@@ -7535,6 +7536,7 @@ export const VirtualControllerTypes = {
     FanucM10iD16S: 'fanuc-m10iD16S',
     FanucM20iD25: 'fanuc-m20iD25',
     FanucM20iD35: 'fanuc-m20iD35',
+    FanucM710iC20L: 'fanuc-m710iC20L',
     FanucM900iB280L: 'fanuc-m900iB280L',
     FanucM900iB360E: 'fanuc-m900iB360E',
     FanucR2000ic125l: 'fanuc-r2000ic125l',
@@ -20633,6 +20635,7 @@ export const GetDefaultLinkChainMotionGroupModelEnum = {
     FanucM20iD12L: 'FANUC_M20iD12L',
     FanucM20iD25: 'FANUC_M20iD25',
     FanucM20iD35: 'FANUC_M20iD35',
+    FanucM710iC20L: 'FANUC_M710iC20L',
     FanucM900iB280L: 'FANUC_M900iB280L',
     FanucM900iB360E: 'FANUC_M900iB360E',
     FanucR2000iC125L: 'FANUC_R2000iC125L',

package/v2/api.d.ts

@@ -1650,19 +1650,6 @@ export interface ForwardKinematicsValidationError {
      */
     'data'?: ErrorInvalidJointCount;
 }
-/**
- *
- * @export
- * @interface GetModeResponse
- */
-export interface GetModeResponse {
-    /**
-     *
-     * @type {RobotSystemMode}
-     * @memberof GetModeResponse
-     */
-    'robot_system_mode': RobotSystemMode;
-}
 /**
  *
  * @export
@@ -4229,6 +4216,18 @@ export type RobotControllerConfiguration = AbbController | FanucController | Kuk
  * @interface RobotControllerState
  */
 export interface RobotControllerState {
+    /**
+     * Mode of communication and control between NOVA and the robot controller.
+     * @type {RobotSystemMode}
+     * @memberof RobotControllerState
+     */
+    'mode': RobotSystemMode;
+    /**
+     * Last error stack encountered during initialization process or after a controller disconnect. At this stage, it\'s unclear whether the error is fatal.  Evaluate `last_error` to decide whether to remove the controller using `deleteController`. Examples: - Delete required: Host resolution fails repeatedly due to an incorrect IP. - Delete not required: Temporary network delay caused a disconnect; the system will auto-reconnect.
+     * @type {Array<string>}
+     * @memberof RobotControllerState
+     */
+    'last_error'?: Array<string>;
     /**
      * Timestamp indicating when the represented information was received from the robot controller.
      * @type {string}
@@ -4273,16 +4272,16 @@ export interface RobotControllerState {
     'motion_groups': Array<MotionGroupState>;
 }
 /**
- * The system mode of the robot system.  ### ROBOT_SYSTEM_MODE_UNDEFINED  Indicates that the robot controller is currently performing a mode transition.  ### ROBOT_SYSTEM_MODE_DISCONNECT  There is no communication with the robot controller at all. All connections are closed. No command is sent to the robot controller while in this mode. No input/output interaction is possible in this mode! All move requests will be rejected in this mode!  ### ROBOT_SYSTEM_MODE_MONITOR  A connection to the robot controller is established to only read the robot controller state. No command is sent to the robot controller while in this mode. It is possible to receive input/output information. All move requests will be rejected in this mode!  ### ROBOT_SYSTEM_MODE_CONTROL  An active connection is established with the robot controller and the robot system is cyclic commanded to stay in its actual position. The robot controller state is received in the cycle time of the robot controller. Requests via the MotionService and JoggingService will be processed and executed in this mode. Input/Output interaction is possible in this mode! **In this mode the robot system can be commanded to move.**  ### ROBOT_SYSTEM_MODE_FREE_DRIVE  Like ROBOT_SYSTEM_MODE_MONITOR a connection to the robot controller is established to only read the robot controller state. The difference is that the motion groups can be moved by the user (Free Drive). Thus, the servo motors are turned on. All move requests will be rejected in this mode! **This mode is not supported by every robot!** Use [getSupportedModes](getSupportedModes) to evaluate if the device support free drive.
+ * Defines the current system mode of the robot system, including NOVA communicating with the robot controller.  ### MODE_CONTROLLER_NOT_CONFIGURED  No controller with the specified identifier is configured. Call [addRobotController](addRobotController) to register a controller.  ### MODE_INITIALIZING  Indicates that a connection to the robot controller is established or reestablished in case of a disconnect. On success, the controller is set to MODE_MONITOR. On failure, the initialization process is retried until successful or cancelled by the user.  ### MODE_MONITOR  Read-only mode with an active controller connection. - Receives robot state and I/O signals - Move requests are rejected - No commands are sent to the controller  ### MODE_CONTROL  Active control mode.  **Movement is possible in this mode**  The robot is cyclically commanded to hold its current position. The robot state is received in sync with the controller cycle. Motion and jogging requests are accepted and executed. Input/Output interaction is enabled.  ### MODE_FREE_DRIVE  Read-only mode with servo motors enabled for manual movement (Free Drive).  Move requests are rejected.  Not supported by all robots: Use [getSupportedModes](getSupportedModes) to check Free Drive availability.
  * @export
  * @enum {string}
  */
 export declare const RobotSystemMode: {
-    readonly RobotSystemModeUndefined: "ROBOT_SYSTEM_MODE_UNDEFINED";
-    readonly RobotSystemModeDisconnect: "ROBOT_SYSTEM_MODE_DISCONNECT";
-    readonly RobotSystemModeMonitor: "ROBOT_SYSTEM_MODE_MONITOR";
-    readonly RobotSystemModeControl: "ROBOT_SYSTEM_MODE_CONTROL";
-    readonly RobotSystemModeFreeDrive: "ROBOT_SYSTEM_MODE_FREE_DRIVE";
+    readonly ModeControllerNotConfigured: "MODE_CONTROLLER_NOT_CONFIGURED";
+    readonly ModeInitializing: "MODE_INITIALIZING";
+    readonly ModeMonitor: "MODE_MONITOR";
+    readonly ModeControl: "MODE_CONTROL";
+    readonly ModeFreeDrive: "MODE_FREE_DRIVE";
 };
 export type RobotSystemMode = typeof RobotSystemMode[keyof typeof RobotSystemMode];
 /**
@@ -5081,7 +5080,7 @@ export interface VirtualController {
      * @type {string}
      * @memberof VirtualController
      */
-    'position'?: string;
+    'initial_joint_position'?: string;
 }
 export declare const VirtualControllerKindEnum: {
     readonly VirtualController: "VirtualController";
@@ -5127,6 +5126,7 @@ export declare const VirtualControllerTypes: {
     readonly FanucCrx20ial: "fanuc-crx20ial";
     readonly FanucCrx25ia: "fanuc-crx25ia";
     readonly FanucCrx30ia: "fanuc-crx30ia";
+    readonly FanucCrx5ia: "fanuc-crx5ia";
     readonly FanucLrMate200iD: "fanuc-lr_mate_200iD";
     readonly FanucLrMate200iD4S: "fanuc-lr_mate_200iD4S";
     readonly FanucLrMate200iD7L: "fanuc-lr_mate_200iD7L";
@@ -5134,6 +5134,7 @@ export declare const VirtualControllerTypes: {
     readonly FanucM10iD16S: "fanuc-m10iD16S";
     readonly FanucM20iD25: "fanuc-m20iD25";
     readonly FanucM20iD35: "fanuc-m20iD35";
+    readonly FanucM710iC20L: "fanuc-m710iC20L";
     readonly FanucM900iB280L: "fanuc-m900iB280L";
     readonly FanucM900iB360E: "fanuc-m900iB360E";
     readonly FanucR2000ic125l: "fanuc-r2000ic125l";
@@ -6360,15 +6361,6 @@ export declare const ControllerApiAxiosParamCreator: (configuration?: Configurat
      * @throws {RequiredError}
      */
     getCurrentRobotControllerState: (cell: string, controller: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
-    /**
-     * Get the current robot system mode of a registered robot controller. The robot system mode indicates if a robot controller can be used. See [setDefaultMode](setDefaultMode) for more information about the different modes. The mode is influenced by the operating mode of the robot controller. The operating mode can be changed via [setDefaultMode](setDefaultMode). Request the current operating mode of the robot controller via [getCurrentRobotControllerState](getCurrentRobotControllerState).
-     * @summary Current Mode
-     * @param {string} cell Unique identifier addressing a cell in all API calls.
-     * @param {string} controller Unique identifier to address a controller in the cell.
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     */
-    getMode: (cell: string, controller: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
     /**
      * Get the configuration for a robot controller.
      * @summary Robot Controller
@@ -6426,15 +6418,16 @@ export declare const ControllerApiAxiosParamCreator: (configuration?: Configurat
      */
     streamFreeDrive: (cell: string, controller: string, responseRate?: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
     /**
-     * <!-- theme: danger -->  > Websocket endpoint  Receive updates of the state of a robot controller.
+     * <!-- theme: danger -->  > Websocket endpoint  Receive updates of the state of a robot controller.  The stream can be opened before the controller is registered. To register a controller, call [addRobotController](addRobotController).  While connecting, the stream sends initialization updates. Once the controller reaches `MODE_MONITOR`, it sends controller state updates.
      * @summary Stream State
      * @param {string} cell Unique identifier addressing a cell in all API calls.
      * @param {string} controller Unique identifier to address a controller in the cell.
      * @param {number} [responseRate]
+     * @param {number} [addControllerTimeout]
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      */
-    streamRobotControllerState: (cell: string, controller: string, responseRate?: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
+    streamRobotControllerState: (cell: string, controller: string, responseRate?: number, addControllerTimeout?: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
     /**
      * Update the configuration of a robot controller.  Reconfigure certain options of a robot controller, or deploy a specific container image of a robot controller.  <!-- theme: warning --> > **WARNING** > > Using it in conjunction with the settings app may lead to unpredictable behavior.
      * @summary Update Robot Controller
@@ -6510,15 +6503,6 @@ export declare const ControllerApiFp: (configuration?: Configuration) => {
      * @throws {RequiredError}
      */
     getCurrentRobotControllerState(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<RobotControllerState>>;
-    /**
-     * Get the current robot system mode of a registered robot controller. The robot system mode indicates if a robot controller can be used. See [setDefaultMode](setDefaultMode) for more information about the different modes. The mode is influenced by the operating mode of the robot controller. The operating mode can be changed via [setDefaultMode](setDefaultMode). Request the current operating mode of the robot controller via [getCurrentRobotControllerState](getCurrentRobotControllerState).
-     * @summary Current Mode
-     * @param {string} cell Unique identifier addressing a cell in all API calls.
-     * @param {string} controller Unique identifier to address a controller in the cell.
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     */
-    getMode(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<GetModeResponse>>;
     /**
      * Get the configuration for a robot controller.
      * @summary Robot Controller
@@ -6576,15 +6560,16 @@ export declare const ControllerApiFp: (configuration?: Configuration) => {
      */
     streamFreeDrive(cell: string, controller: string, responseRate?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<RobotControllerState>>;
     /**
-     * <!-- theme: danger -->  > Websocket endpoint  Receive updates of the state of a robot controller.
+     * <!-- theme: danger -->  > Websocket endpoint  Receive updates of the state of a robot controller.  The stream can be opened before the controller is registered. To register a controller, call [addRobotController](addRobotController).  While connecting, the stream sends initialization updates. Once the controller reaches `MODE_MONITOR`, it sends controller state updates.
      * @summary Stream State
      * @param {string} cell Unique identifier addressing a cell in all API calls.
      * @param {string} controller Unique identifier to address a controller in the cell.
      * @param {number} [responseRate]
+     * @param {number} [addControllerTimeout]
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      */
-    streamRobotControllerState(cell: string, controller: string, responseRate?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<RobotControllerState>>;
+    streamRobotControllerState(cell: string, controller: string, responseRate?: number, addControllerTimeout?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<RobotControllerState>>;
     /**
      * Update the configuration of a robot controller.  Reconfigure certain options of a robot controller, or deploy a specific container image of a robot controller.  <!-- theme: warning --> > **WARNING** > > Using it in conjunction with the settings app may lead to unpredictable behavior.
      * @summary Update Robot Controller
@@ -6660,15 +6645,6 @@ export declare const ControllerApiFactory: (configuration?: Configuration, baseP
      * @throws {RequiredError}
      */
     getCurrentRobotControllerState(cell: string, controller: string, options?: RawAxiosRequestConfig): AxiosPromise<RobotControllerState>;
-    /**
-     * Get the current robot system mode of a registered robot controller. The robot system mode indicates if a robot controller can be used. See [setDefaultMode](setDefaultMode) for more information about the different modes. The mode is influenced by the operating mode of the robot controller. The operating mode can be changed via [setDefaultMode](setDefaultMode). Request the current operating mode of the robot controller via [getCurrentRobotControllerState](getCurrentRobotControllerState).
-     * @summary Current Mode
-     * @param {string} cell Unique identifier addressing a cell in all API calls.
-     * @param {string} controller Unique identifier to address a controller in the cell.
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     */
-    getMode(cell: string, controller: string, options?: RawAxiosRequestConfig): AxiosPromise<GetModeResponse>;
     /**
      * Get the configuration for a robot controller.
      * @summary Robot Controller
@@ -6726,15 +6702,16 @@ export declare const ControllerApiFactory: (configuration?: Configuration, baseP
      */
     streamFreeDrive(cell: string, controller: string, responseRate?: number, options?: RawAxiosRequestConfig): AxiosPromise<RobotControllerState>;
     /**
-     * <!-- theme: danger -->  > Websocket endpoint  Receive updates of the state of a robot controller.
+     * <!-- theme: danger -->  > Websocket endpoint  Receive updates of the state of a robot controller.  The stream can be opened before the controller is registered. To register a controller, call [addRobotController](addRobotController).  While connecting, the stream sends initialization updates. Once the controller reaches `MODE_MONITOR`, it sends controller state updates.
      * @summary Stream State
      * @param {string} cell Unique identifier addressing a cell in all API calls.
      * @param {string} controller Unique identifier to address a controller in the cell.
      * @param {number} [responseRate]
+     * @param {number} [addControllerTimeout]
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      */
-    streamRobotControllerState(cell: string, controller: string, responseRate?: number, options?: RawAxiosRequestConfig): AxiosPromise<RobotControllerState>;
+    streamRobotControllerState(cell: string, controller: string, responseRate?: number, addControllerTimeout?: number, options?: RawAxiosRequestConfig): AxiosPromise<RobotControllerState>;
     /**
      * Update the configuration of a robot controller.  Reconfigure certain options of a robot controller, or deploy a specific container image of a robot controller.  <!-- theme: warning --> > **WARNING** > > Using it in conjunction with the settings app may lead to unpredictable behavior.
      * @summary Update Robot Controller
@@ -6818,16 +6795,6 @@ export declare class ControllerApi extends BaseAPI {
      * @memberof ControllerApi
      */
     getCurrentRobotControllerState(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<RobotControllerState, any>>;
-    /**
-     * Get the current robot system mode of a registered robot controller. The robot system mode indicates if a robot controller can be used. See [setDefaultMode](setDefaultMode) for more information about the different modes. The mode is influenced by the operating mode of the robot controller. The operating mode can be changed via [setDefaultMode](setDefaultMode). Request the current operating mode of the robot controller via [getCurrentRobotControllerState](getCurrentRobotControllerState).
-     * @summary Current Mode
-     * @param {string} cell Unique identifier addressing a cell in all API calls.
-     * @param {string} controller Unique identifier to address a controller in the cell.
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     * @memberof ControllerApi
-     */
-    getMode(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<GetModeResponse, any>>;
     /**
      * Get the configuration for a robot controller.
      * @summary Robot Controller
@@ -6891,16 +6858,17 @@ export declare class ControllerApi extends BaseAPI {
      */
     streamFreeDrive(cell: string, controller: string, responseRate?: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<RobotControllerState, any>>;
     /**
-     * <!-- theme: danger -->  > Websocket endpoint  Receive updates of the state of a robot controller.
+     * <!-- theme: danger -->  > Websocket endpoint  Receive updates of the state of a robot controller.  The stream can be opened before the controller is registered. To register a controller, call [addRobotController](addRobotController).  While connecting, the stream sends initialization updates. Once the controller reaches `MODE_MONITOR`, it sends controller state updates.
      * @summary Stream State
      * @param {string} cell Unique identifier addressing a cell in all API calls.
      * @param {string} controller Unique identifier to address a controller in the cell.
      * @param {number} [responseRate]
+     * @param {number} [addControllerTimeout]
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      * @memberof ControllerApi
      */
-    streamRobotControllerState(cell: string, controller: string, responseRate?: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<RobotControllerState, any>>;
+    streamRobotControllerState(cell: string, controller: string, responseRate?: number, addControllerTimeout?: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<RobotControllerState, any>>;
     /**
      * Update the configuration of a robot controller.  Reconfigure certain options of a robot controller, or deploy a specific container image of a robot controller.  <!-- theme: warning --> > **WARNING** > > Using it in conjunction with the settings app may lead to unpredictable behavior.
      * @summary Update Robot Controller

package/v2/api.js

@@ -374,16 +374,16 @@ export const ReleaseChannel = {
     Next: 'next'
 };
 /**
- * The system mode of the robot system.  ### ROBOT_SYSTEM_MODE_UNDEFINED  Indicates that the robot controller is currently performing a mode transition.  ### ROBOT_SYSTEM_MODE_DISCONNECT  There is no communication with the robot controller at all. All connections are closed. No command is sent to the robot controller while in this mode. No input/output interaction is possible in this mode! All move requests will be rejected in this mode!  ### ROBOT_SYSTEM_MODE_MONITOR  A connection to the robot controller is established to only read the robot controller state. No command is sent to the robot controller while in this mode. It is possible to receive input/output information. All move requests will be rejected in this mode!  ### ROBOT_SYSTEM_MODE_CONTROL  An active connection is established with the robot controller and the robot system is cyclic commanded to stay in its actual position. The robot controller state is received in the cycle time of the robot controller. Requests via the MotionService and JoggingService will be processed and executed in this mode. Input/Output interaction is possible in this mode! **In this mode the robot system can be commanded to move.**  ### ROBOT_SYSTEM_MODE_FREE_DRIVE  Like ROBOT_SYSTEM_MODE_MONITOR a connection to the robot controller is established to only read the robot controller state. The difference is that the motion groups can be moved by the user (Free Drive). Thus, the servo motors are turned on. All move requests will be rejected in this mode! **This mode is not supported by every robot!** Use [getSupportedModes](getSupportedModes) to evaluate if the device support free drive.
+ * Defines the current system mode of the robot system, including NOVA communicating with the robot controller.  ### MODE_CONTROLLER_NOT_CONFIGURED  No controller with the specified identifier is configured. Call [addRobotController](addRobotController) to register a controller.  ### MODE_INITIALIZING  Indicates that a connection to the robot controller is established or reestablished in case of a disconnect. On success, the controller is set to MODE_MONITOR. On failure, the initialization process is retried until successful or cancelled by the user.  ### MODE_MONITOR  Read-only mode with an active controller connection. - Receives robot state and I/O signals - Move requests are rejected - No commands are sent to the controller  ### MODE_CONTROL  Active control mode.  **Movement is possible in this mode**  The robot is cyclically commanded to hold its current position. The robot state is received in sync with the controller cycle. Motion and jogging requests are accepted and executed. Input/Output interaction is enabled.  ### MODE_FREE_DRIVE  Read-only mode with servo motors enabled for manual movement (Free Drive).  Move requests are rejected.  Not supported by all robots: Use [getSupportedModes](getSupportedModes) to check Free Drive availability.
  * @export
  * @enum {string}
  */
 export const RobotSystemMode = {
-    RobotSystemModeUndefined: 'ROBOT_SYSTEM_MODE_UNDEFINED',
-    RobotSystemModeDisconnect: 'ROBOT_SYSTEM_MODE_DISCONNECT',
-    RobotSystemModeMonitor: 'ROBOT_SYSTEM_MODE_MONITOR',
-    RobotSystemModeControl: 'ROBOT_SYSTEM_MODE_CONTROL',
-    RobotSystemModeFreeDrive: 'ROBOT_SYSTEM_MODE_FREE_DRIVE'
+    ModeControllerNotConfigured: 'MODE_CONTROLLER_NOT_CONFIGURED',
+    ModeInitializing: 'MODE_INITIALIZING',
+    ModeMonitor: 'MODE_MONITOR',
+    ModeControl: 'MODE_CONTROL',
+    ModeFreeDrive: 'MODE_FREE_DRIVE'
 };
 /**
  * Current safety state of the configured robot controller. Operation modes in which the attached motion groups can be moved are: - SAFETY_STATE_NORMAL - SAFETY_STATE_REDUCED All other modes are considered as non-operational.
@@ -571,6 +571,7 @@ export const VirtualControllerTypes = {
     FanucCrx20ial: 'fanuc-crx20ial',
     FanucCrx25ia: 'fanuc-crx25ia',
     FanucCrx30ia: 'fanuc-crx30ia',
+    FanucCrx5ia: 'fanuc-crx5ia',
     FanucLrMate200iD: 'fanuc-lr_mate_200iD',
     FanucLrMate200iD4S: 'fanuc-lr_mate_200iD4S',
     FanucLrMate200iD7L: 'fanuc-lr_mate_200iD7L',
@@ -578,6 +579,7 @@ export const VirtualControllerTypes = {
     FanucM10iD16S: 'fanuc-m10iD16S',
     FanucM20iD25: 'fanuc-m20iD25',
     FanucM20iD35: 'fanuc-m20iD35',
+    FanucM710iC20L: 'fanuc-m710iC20L',
     FanucM900iB280L: 'fanuc-m900iB280L',
     FanucM900iB360E: 'fanuc-m900iB360E',
     FanucR2000ic125l: 'fanuc-r2000ic125l',
@@ -2979,45 +2981,6 @@ export const ControllerApiAxiosParamCreator = function (configuration) {
                 options: localVarRequestOptions,
             };
         },
-        /**
-         * Get the current robot system mode of a registered robot controller. The robot system mode indicates if a robot controller can be used. See [setDefaultMode](setDefaultMode) for more information about the different modes. The mode is influenced by the operating mode of the robot controller. The operating mode can be changed via [setDefaultMode](setDefaultMode). Request the current operating mode of the robot controller via [getCurrentRobotControllerState](getCurrentRobotControllerState).
-         * @summary Current Mode
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} controller Unique identifier to address a controller in the cell.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        getMode: async (cell, controller, options = {}) => {
-            // verify required parameter 'cell' is not null or undefined
-            assertParamExists('getMode', 'cell', cell);
-            // verify required parameter 'controller' is not null or undefined
-            assertParamExists('getMode', 'controller', controller);
-            const localVarPath = `/cells/{cell}/controllers/{controller}/mode`
-                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
-                .replace(`{${"controller"}}`, encodeURIComponent(String(controller)));
-            // use dummy base URL string because the URL constructor only accepts absolute URLs.
-            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
-            let baseOptions;
-            if (configuration) {
-                baseOptions = configuration.baseOptions;
-            }
-            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
-            const localVarHeaderParameter = {};
-            const localVarQueryParameter = {};
-            // authentication BasicAuth required
-            // http basic authentication required
-            setBasicAuthToObject(localVarRequestOptions, configuration);
-            // authentication BearerAuth required
-            // http bearer authentication required
-            await setBearerAuthToObject(localVarHeaderParameter, configuration);
-            setSearchParams(localVarUrlObj, localVarQueryParameter);
-            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-            return {
-                url: toPathString(localVarUrlObj),
-                options: localVarRequestOptions,
-            };
-        },
         /**
          * Get the configuration for a robot controller.
          * @summary Robot Controller
@@ -3263,15 +3226,16 @@ export const ControllerApiAxiosParamCreator = function (configuration) {
             };
         },
         /**
-         * <!-- theme: danger -->  > Websocket endpoint  Receive updates of the state of a robot controller.
+         * <!-- theme: danger -->  > Websocket endpoint  Receive updates of the state of a robot controller.  The stream can be opened before the controller is registered. To register a controller, call [addRobotController](addRobotController).  While connecting, the stream sends initialization updates. Once the controller reaches `MODE_MONITOR`, it sends controller state updates.
          * @summary Stream State
          * @param {string} cell Unique identifier addressing a cell in all API calls.
          * @param {string} controller Unique identifier to address a controller in the cell.
          * @param {number} [responseRate]
+         * @param {number} [addControllerTimeout]
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        streamRobotControllerState: async (cell, controller, responseRate, options = {}) => {
+        streamRobotControllerState: async (cell, controller, responseRate, addControllerTimeout, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
             assertParamExists('streamRobotControllerState', 'cell', cell);
             // verify required parameter 'controller' is not null or undefined
@@ -3297,6 +3261,9 @@ export const ControllerApiAxiosParamCreator = function (configuration) {
             if (responseRate !== undefined) {
                 localVarQueryParameter['response_rate'] = responseRate;
             }
+            if (addControllerTimeout !== undefined) {
+                localVarQueryParameter['add_controller_timeout'] = addControllerTimeout;
+            }
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
@@ -3450,20 +3417,6 @@ export const ControllerApiFp = function (configuration) {
             const localVarOperationServerBasePath = operationServerMap['ControllerApi.getCurrentRobotControllerState']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
-        /**
-         * Get the current robot system mode of a registered robot controller. The robot system mode indicates if a robot controller can be used. See [setDefaultMode](setDefaultMode) for more information about the different modes. The mode is influenced by the operating mode of the robot controller. The operating mode can be changed via [setDefaultMode](setDefaultMode). Request the current operating mode of the robot controller via [getCurrentRobotControllerState](getCurrentRobotControllerState).
-         * @summary Current Mode
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} controller Unique identifier to address a controller in the cell.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        async getMode(cell, controller, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.getMode(cell, controller, options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['ControllerApi.getMode']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
-        },
         /**
          * Get the configuration for a robot controller.
          * @summary Robot Controller
@@ -3551,16 +3504,17 @@ export const ControllerApiFp = function (configuration) {
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
-         * <!-- theme: danger -->  > Websocket endpoint  Receive updates of the state of a robot controller.
+         * <!-- theme: danger -->  > Websocket endpoint  Receive updates of the state of a robot controller.  The stream can be opened before the controller is registered. To register a controller, call [addRobotController](addRobotController).  While connecting, the stream sends initialization updates. Once the controller reaches `MODE_MONITOR`, it sends controller state updates.
          * @summary Stream State
          * @param {string} cell Unique identifier addressing a cell in all API calls.
          * @param {string} controller Unique identifier to address a controller in the cell.
          * @param {number} [responseRate]
+         * @param {number} [addControllerTimeout]
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async streamRobotControllerState(cell, controller, responseRate, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.streamRobotControllerState(cell, controller, responseRate, options);
+        async streamRobotControllerState(cell, controller, responseRate, addControllerTimeout, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.streamRobotControllerState(cell, controller, responseRate, addControllerTimeout, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
             const localVarOperationServerBasePath = operationServerMap['ControllerApi.streamRobotControllerState']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
@@ -3660,17 +3614,6 @@ export const ControllerApiFactory = function (configuration, basePath, axios) {
         getCurrentRobotControllerState(cell, controller, options) {
             return localVarFp.getCurrentRobotControllerState(cell, controller, options).then((request) => request(axios, basePath));
         },
-        /**
-         * Get the current robot system mode of a registered robot controller. The robot system mode indicates if a robot controller can be used. See [setDefaultMode](setDefaultMode) for more information about the different modes. The mode is influenced by the operating mode of the robot controller. The operating mode can be changed via [setDefaultMode](setDefaultMode). Request the current operating mode of the robot controller via [getCurrentRobotControllerState](getCurrentRobotControllerState).
-         * @summary Current Mode
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} controller Unique identifier to address a controller in the cell.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        getMode(cell, controller, options) {
-            return localVarFp.getMode(cell, controller, options).then((request) => request(axios, basePath));
-        },
         /**
          * Get the configuration for a robot controller.
          * @summary Robot Controller
@@ -3740,16 +3683,17 @@ export const ControllerApiFactory = function (configuration, basePath, axios) {
             return localVarFp.streamFreeDrive(cell, controller, responseRate, options).then((request) => request(axios, basePath));
         },
         /**
-         * <!-- theme: danger -->  > Websocket endpoint  Receive updates of the state of a robot controller.
+         * <!-- theme: danger -->  > Websocket endpoint  Receive updates of the state of a robot controller.  The stream can be opened before the controller is registered. To register a controller, call [addRobotController](addRobotController).  While connecting, the stream sends initialization updates. Once the controller reaches `MODE_MONITOR`, it sends controller state updates.
          * @summary Stream State
          * @param {string} cell Unique identifier addressing a cell in all API calls.
          * @param {string} controller Unique identifier to address a controller in the cell.
          * @param {number} [responseRate]
+         * @param {number} [addControllerTimeout]
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        streamRobotControllerState(cell, controller, responseRate, options) {
-            return localVarFp.streamRobotControllerState(cell, controller, responseRate, options).then((request) => request(axios, basePath));
+        streamRobotControllerState(cell, controller, responseRate, addControllerTimeout, options) {
+            return localVarFp.streamRobotControllerState(cell, controller, responseRate, addControllerTimeout, options).then((request) => request(axios, basePath));
         },
         /**
          * Update the configuration of a robot controller.  Reconfigure certain options of a robot controller, or deploy a specific container image of a robot controller.  <!-- theme: warning --> > **WARNING** > > Using it in conjunction with the settings app may lead to unpredictable behavior.
@@ -3849,18 +3793,6 @@ export class ControllerApi extends BaseAPI {
     getCurrentRobotControllerState(cell, controller, options) {
         return ControllerApiFp(this.configuration).getCurrentRobotControllerState(cell, controller, options).then((request) => request(this.axios, this.basePath));
     }
-    /**
-     * Get the current robot system mode of a registered robot controller. The robot system mode indicates if a robot controller can be used. See [setDefaultMode](setDefaultMode) for more information about the different modes. The mode is influenced by the operating mode of the robot controller. The operating mode can be changed via [setDefaultMode](setDefaultMode). Request the current operating mode of the robot controller via [getCurrentRobotControllerState](getCurrentRobotControllerState).
-     * @summary Current Mode
-     * @param {string} cell Unique identifier addressing a cell in all API calls.
-     * @param {string} controller Unique identifier to address a controller in the cell.
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     * @memberof ControllerApi
-     */
-    getMode(cell, controller, options) {
-        return ControllerApiFp(this.configuration).getMode(cell, controller, options).then((request) => request(this.axios, this.basePath));
-    }
     /**
      * Get the configuration for a robot controller.
      * @summary Robot Controller
@@ -3936,17 +3868,18 @@ export class ControllerApi extends BaseAPI {
         return ControllerApiFp(this.configuration).streamFreeDrive(cell, controller, responseRate, options).then((request) => request(this.axios, this.basePath));
     }
     /**
-     * <!-- theme: danger -->  > Websocket endpoint  Receive updates of the state of a robot controller.
+     * <!-- theme: danger -->  > Websocket endpoint  Receive updates of the state of a robot controller.  The stream can be opened before the controller is registered. To register a controller, call [addRobotController](addRobotController).  While connecting, the stream sends initialization updates. Once the controller reaches `MODE_MONITOR`, it sends controller state updates.
      * @summary Stream State
      * @param {string} cell Unique identifier addressing a cell in all API calls.
      * @param {string} controller Unique identifier to address a controller in the cell.
      * @param {number} [responseRate]
+     * @param {number} [addControllerTimeout]
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      * @memberof ControllerApi
      */
-    streamRobotControllerState(cell, controller, responseRate, options) {
-        return ControllerApiFp(this.configuration).streamRobotControllerState(cell, controller, responseRate, options).then((request) => request(this.axios, this.basePath));
+    streamRobotControllerState(cell, controller, responseRate, addControllerTimeout, options) {
+        return ControllerApiFp(this.configuration).streamRobotControllerState(cell, controller, responseRate, addControllerTimeout, options).then((request) => request(this.axios, this.basePath));
     }
     /**
      * Update the configuration of a robot controller.  Reconfigure certain options of a robot controller, or deploy a specific container image of a robot controller.  <!-- theme: warning --> > **WARNING** > > Using it in conjunction with the settings app may lead to unpredictable behavior.