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

package/v2/api.ts

@@ -1724,21 +1724,6 @@ export interface ForwardKinematicsValidationError {
      */
     'data'?: ErrorInvalidJointCount;
 }
-/**
- * 
- * @export
- * @interface GetModeResponse
- */
-export interface GetModeResponse {
-    /**
-     * 
-     * @type {RobotSystemMode}
-     * @memberof GetModeResponse
-     */
-    'robot_system_mode': RobotSystemMode;
-}
-
-
 /**
  * 
  * @export
@@ -4423,6 +4408,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}
@@ -4469,17 +4466,17 @@ export interface RobotControllerState {
 
 
 /**
- * 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'
 } as const;
 
 export type RobotSystemMode = typeof RobotSystemMode[keyof typeof RobotSystemMode];
@@ -5365,7 +5362,7 @@ export interface VirtualController {
      * @type {string}
      * @memberof VirtualController
      */
-    'position'?: string;
+    'initial_joint_position'?: string;
 }
 
 export const VirtualControllerKindEnum = {
@@ -5415,6 +5412,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',
@@ -5422,6 +5420,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',
@@ -8173,52 +8172,6 @@ export const ControllerApiAxiosParamCreator = function (configuration?: Configur
 
 
     
-            setSearchParams(localVarUrlObj, localVarQueryParameter);
-            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
-
-            return {
-                url: toPathString(localVarUrlObj),
-                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: string, controller: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
-            // 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 = {} as any;
-            const localVarQueryParameter = {} as any;
-
-            // 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};
@@ -8518,15 +8471,16 @@ export const ControllerApiAxiosParamCreator = function (configuration?: Configur
             };
         },
         /**
-         * <!-- 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: string, controller: string, responseRate?: number, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+        streamRobotControllerState: async (cell: string, controller: string, responseRate?: number, addControllerTimeout?: number, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
             // verify required parameter 'cell' is not null or undefined
             assertParamExists('streamRobotControllerState', 'cell', cell)
             // verify required parameter 'controller' is not null or undefined
@@ -8557,6 +8511,10 @@ export const ControllerApiAxiosParamCreator = function (configuration?: Configur
                 localVarQueryParameter['response_rate'] = responseRate;
             }
 
+            if (addControllerTimeout !== undefined) {
+                localVarQueryParameter['add_controller_timeout'] = addControllerTimeout;
+            }
+
 
     
             setSearchParams(localVarUrlObj, localVarQueryParameter);
@@ -8723,20 +8681,6 @@ export const ControllerApiFp = function(configuration?: 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: string, controller: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<GetModeResponse>> {
-            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
@@ -8824,16 +8768,17 @@ export const ControllerApiFp = function(configuration?: 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: string, controller: string, responseRate?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<RobotControllerState>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.streamRobotControllerState(cell, controller, responseRate, options);
+        async streamRobotControllerState(cell: string, controller: string, responseRate?: number, addControllerTimeout?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<RobotControllerState>> {
+            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);
@@ -8934,17 +8879,6 @@ export const ControllerApiFactory = function (configuration?: Configuration, bas
         getCurrentRobotControllerState(cell: string, controller: string, options?: RawAxiosRequestConfig): AxiosPromise<RobotControllerState> {
             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: string, controller: string, options?: RawAxiosRequestConfig): AxiosPromise<GetModeResponse> {
-            return localVarFp.getMode(cell, controller, options).then((request) => request(axios, basePath));
-        },
         /**
          * Get the configuration for a robot controller. 
          * @summary Robot Controller
@@ -9014,16 +8948,17 @@ export const ControllerApiFactory = function (configuration?: Configuration, bas
             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: string, controller: string, responseRate?: number, options?: RawAxiosRequestConfig): AxiosPromise<RobotControllerState> {
-            return localVarFp.streamRobotControllerState(cell, controller, responseRate, options).then((request) => request(axios, basePath));
+        streamRobotControllerState(cell: string, controller: string, responseRate?: number, addControllerTimeout?: number, options?: RawAxiosRequestConfig): AxiosPromise<RobotControllerState> {
+            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. 
@@ -9130,19 +9065,6 @@ export class ControllerApi extends BaseAPI {
         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
-     */
-    public getMode(cell: string, controller: string, options?: RawAxiosRequestConfig) {
-        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
@@ -9224,17 +9146,18 @@ export class ControllerApi extends BaseAPI {
     }
 
     /**
-     * <!-- 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
      */
-    public streamRobotControllerState(cell: string, controller: string, responseRate?: number, options?: RawAxiosRequestConfig) {
-        return ControllerApiFp(this.configuration).streamRobotControllerState(cell, controller, responseRate, options).then((request) => request(this.axios, this.basePath));
+    public streamRobotControllerState(cell: string, controller: string, responseRate?: number, addControllerTimeout?: number, options?: RawAxiosRequestConfig) {
+        return ControllerApiFp(this.configuration).streamRobotControllerState(cell, controller, responseRate, addControllerTimeout, options).then((request) => request(this.axios, this.basePath));
     }
 
     /**