import * as _$axios from "axios"; import { AxiosInstance, AxiosPromise, RawAxiosRequestConfig } from "axios"; //#region v2/configuration.d.ts /** * Wandelbots NOVA API * Interact with robots in an easy and intuitive way. * * The version of the OpenAPI document: 2.5.0 * * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). * https://openapi-generator.tech * Do not edit the class manually. */ interface AWSv4Configuration { options?: { region?: string; service?: string; }; credentials?: { accessKeyId?: string; secretAccessKey?: string; sessionToken?: string; }; } interface ConfigurationParameters { apiKey?: string | Promise | ((name: string) => string) | ((name: string) => Promise); username?: string; password?: string; accessToken?: string | Promise | ((name?: string, scopes?: string[]) => string) | ((name?: string, scopes?: string[]) => Promise); awsv4?: AWSv4Configuration; basePath?: string; serverIndex?: number; baseOptions?: any; formDataCtor?: new () => any; } declare class Configuration { /** * parameter for apiKey security * @param name security name */ apiKey?: string | Promise | ((name: string) => string) | ((name: string) => Promise); /** * parameter for basic security */ username?: string; /** * parameter for basic security */ password?: string; /** * parameter for oauth2 security * @param name security name * @param scopes oauth2 scope */ accessToken?: string | Promise | ((name?: string, scopes?: string[]) => string) | ((name?: string, scopes?: string[]) => Promise); /** * parameter for aws4 signature security * @param {Object} AWS4Signature - AWS4 Signature security * @param {string} options.region - aws region * @param {string} options.service - name of the service. * @param {string} credentials.accessKeyId - aws access key id * @param {string} credentials.secretAccessKey - aws access key * @param {string} credentials.sessionToken - aws session token * @memberof Configuration */ awsv4?: AWSv4Configuration; /** * override base path */ basePath?: string; /** * override server index */ serverIndex?: number; /** * base options for axios calls */ baseOptions?: any; /** * The FormData constructor that will be used to create multipart form data * requests. You can inject this here so that execution environments that * do not support the FormData class can still run the generated client. * * @type {new () => FormData} */ formDataCtor?: new () => any; constructor(param?: ConfigurationParameters); /** * Check if the given MIME is a JSON MIME. * JSON MIME examples: * application/json * application/json; charset=UTF8 * APPLICATION/JSON * application/vnd.company+json * @param mime - MIME (Multipurpose Internet Mail Extensions) * @return True if the given MIME is JSON, false otherwise. */ isJsonMime(mime: string): boolean; } //#endregion //#region v2/base.d.ts declare const BASE_PATH: string; declare const COLLECTION_FORMATS: { csv: string; ssv: string; tsv: string; pipes: string; }; interface RequestArgs { url: string; options: RawAxiosRequestConfig; } declare class BaseAPI { protected basePath: string; protected axios: AxiosInstance; protected configuration: Configuration | undefined; constructor(configuration?: Configuration, basePath?: string, axios?: AxiosInstance); } declare class RequiredError extends Error { field: string; constructor(field: string, msg?: string); } interface ServerMap { [key: string]: { url: string; description: string; }[]; } declare const operationServerMap: ServerMap; //#endregion //#region v2/api.d.ts interface AbbConfdata { /** * Quadrant number for axis 1. Quadrant n means the axis angle is in the interval [n*90deg, (n+1)*90deg). Can be negative. */ 'cf1': number; /** * Quadrant number for axis 4. Quadrant n means the axis angle is in the interval [n*90deg, (n+1)*90deg). Can be negative. */ 'cf4': number; /** * Quadrant number for axis 6. Quadrant n means the axis angle is in the interval [n*90deg, (n+1)*90deg). Can be negative. */ 'cf6': number; /** * 3 branch bits composing the kinematic configuration: - Bit 0 (Wrist): 0 = positive axis 5 angle `NO_FLIP`, 1 = negative `FLIP`. - Bit 1 (Elbow): 0 = in front of lower arm `DOWN`, 1 = behind `UP`. - Bit 2 (Shoulder): 0 = in front of axis 1 `LEFT`, 1 = behind `RIGHT`. */ 'cfx': number; } /** * A pose combined with ABB kinematic configuration data, `confdata`. */ interface AbbConfiguredPose { 'pose': AbbPose; 'confdata': AbbConfdata; } /** * The configuration of a physical ABB robot controller has to contain IP address. Additionally an EGM server configuration has to be specified in order to control the robot. Deploying the server is a functionality of this API. */ interface AbbController { 'kind': AbbControllerKindEnum; 'controller_ip': string; /** * Default values: 80, 443. If custom value is set, field is required. */ 'controller_port': number; 'egm_server': AbbControllerEgmServer; } declare const AbbControllerKindEnum: { readonly AbbController: "AbbController"; }; type AbbControllerKindEnum = typeof AbbControllerKindEnum[keyof typeof AbbControllerKindEnum]; /** * The EGM server runs inside of the cell, thus its IP must be in the same network as the \'controller_ip\' */ interface AbbControllerEgmServer { 'ip': string; 'port': number; } /** * ABB pose with position (`x`, `y`, `z`) and quaternion orientation (`q1`, `q2`, `q3`, `q4`). */ interface AbbPose { 'x': number; 'y': number; 'z': number; 'q1': number; 'q2': number; 'q3': number; 'q4': number; } /** * The authentication token to fetch the license from the license server. */ interface ActivateLicenseRequest { 'owner_refresh_token': string; } interface AddTrajectoryError { 'message'?: string; /** * - The location is a scalar value that defines a position along a path, typically ranging from 0 to `n`, where `n` denotes the number of motion commands - Each integer value of the location corresponds to a specific motion command, while non-integer values interpolate positions within the segments. - The location is calculated from the joint path */ 'location'?: number; 'data'?: AddTrajectoryErrorData; } /** * @type AddTrajectoryErrorData */ type AddTrajectoryErrorData = { kind: 'CollisionError'; } & CollisionError | { kind: 'InconsistentTrajectorySizeError'; } & InconsistentTrajectorySizeError | { kind: 'InvalidDofError'; } & InvalidDofError | { kind: 'JointLimitExceededError'; } & JointLimitExceededError | { kind: 'NanValueError'; } & NanValueError | { kind: 'TcpRequiredError'; } & TcpRequiredError | { kind: 'TorqueExceededError'; } & TorqueExceededError; interface AddTrajectoryRequest { /** * Unique identifier of the motion group the trajectory is planned for. */ 'motion_group': string; /** * The trajectory consisting of a list of joint positions and an equal number of corresponding timestamps. */ 'trajectory': JointTrajectory; /** * Unique identifier of the tool the trajectory is planned for. */ 'tcp'?: string; } /** * The response signals if the trajectory is valid or faulty, resulting in an executable, partially executable or non-executable state. - valid trajectory: response contains only the unique identifier for the trajectory - trajectory has error on path: response contains the unique identifier for the trajectory and information about the failure. It is executable up to the point of failure. - trajectory has error at start or invalid data: response contains only information about the failure. To execute the trajectory, use the unique identifier for calling [executeTrajectory](#/operations/executeTrajectory). If you want to validate your trajectory before execution, execute it with a virtual motion group and check the state in the response stream of [executeTrajectory](#/operations/executeTrajectory). */ interface AddTrajectoryResponse { /** * The unique identifier of the trajectory. Use this identifier to execute the trajectory with the [executeTrajectory](#/operations/executeTrajectory) endpoint. */ 'trajectory'?: string; /** * Always check this field first. If this field is present, the trajectory has an error and is only partially or not executable. */ 'error'?: AddTrajectoryError; } /** * @type AddVirtualControllerMotionGroupRequest * Request body wrapper for `addVirtualControllerMotionGroup`. Allow callers to either reference a predefined motion group model or upload a full JSON configuration that the backend extracts into a motion group description. */ type AddVirtualControllerMotionGroupRequest = MotionGroupFromJson | MotionGroupFromType; interface ApiVersion { /** * The version of the API. */ 'version': string; } /** * An App is defined by a webserver, packed inside a container, serving a web-application. */ interface App { /** * The name of the provided application. The name must be unique within the cell and is used as a identifier for addressing the application in all API calls , e.g., when updating the application. It also defines where the application is reachable (/$cell/$name). It must be a valid k8s label name as defined by [RFC 1035](https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#rfc-1035-label-names). */ 'name': string; /** * The path of the icon for the App (/$cell/$name/$app_icon). */ 'app_icon': string; 'container_image': ContainerImage; /** * The port the containerized webserver is listening on. */ 'port'?: number; /** * A list of environment variables with name and their value. These can be used to configure the containerized application, and turn features on or off. */ 'environment'?: Array; 'storage'?: ContainerStorage; 'resources'?: ContainerResources; /** * Defines the URL path suffix used to check the application\'s health status. The complete health check URL is constructed as `/$cell/$name/$health_path`. When the application is working as expected, the endpoint returns an HTTP 200 status code. If not specified, the system will default to using the application icon path suffix (the value of `app_icon`) as the health check endpoint, resulting in `/$cell/$name/$app_icon`. If the health check fails (no response or non-200 status code), the system will automatically restart the application container to restore service. */ 'health_path'?: string; /** * Defines the URL path suffix used to provide an endpoint for diagnosis data collection. The complete diagnosis check URL is constructed as `/$cell/$name/$diagnosis_path`. The endpoint is called when a diagnosis package is requested via the diagnosis API. The endpoint needs to return the data within a zip file `application/zip` response. */ 'diagnosis_path'?: string; } /** * Per-joint constraint beyond the 8 inverse kinematic branches. Maps a joint index (0-based) to an allowed angle interval (in radians). */ interface AxisRange { 'axis': number; 'range': LimitRange; } /** * ## BEHAVIOR_AUTOMATIC This is the default behavior. The motion groups of the controller take commanded joint configuration as actual joint state. Configures the compliance of the virtual robot with the normal ControllerState cycle time. If set, the virtual robot will act like a physical one, e.g., with a cycle time of 8ms to respond to a new joint state command. ## BEHAVIOR_AUTOMATIC_NOT_COMPLY_WITH_CYCLETIME Configures the compliance of the virtual robot with the normal ControllerState cycle time. If set, the robot will respond as fast as possible, limited only by software execution speed. Because of that, the execution of a movement requires less time than with BEHAVIOR_AUTOMATIC. ## BEHAVIOR_EXTERNAL_SOURCE The external client is the only source of actual joint state changes. This mode is used to enable third party software indicating the current joint state via [externalJointsStream](#/operations/externalJointsStream). */ declare const Behavior: { readonly BehaviorAutomatic: "BEHAVIOR_AUTOMATIC"; readonly BehaviorAutomaticNotComplyWithCycletime: "BEHAVIOR_AUTOMATIC_NOT_COMPLY_WITH_CYCLETIME"; readonly BehaviorExternalSource: "BEHAVIOR_EXTERNAL_SOURCE"; }; type Behavior = typeof Behavior[keyof typeof Behavior]; interface BlendingAuto { /** * Auto-blending is used to keep a constant velocity when blending between two motion commands. To use auto-blending, the TCP velocity limit must be set. It changes the TCP path around the target point of the motion command. The value represents the percentage of the original velocity. Auto-blending is always performed in cartesian space. */ 'min_velocity_in_percent'?: number; 'blending_name': BlendingAutoBlendingNameEnum; } declare const BlendingAutoBlendingNameEnum: { readonly BlendingAuto: "BlendingAuto"; }; type BlendingAutoBlendingNameEnum = typeof BlendingAutoBlendingNameEnum[keyof typeof BlendingAutoBlendingNameEnum]; interface BlendingPosition { /** * Specifies the maximum radius in [mm] around the motion command\'s target point where the TCP path can be altered to blend the motion command into the following one. If auto-blending blends too much of the resulting trajectory, use position-blending to restrict the blending zone radius. */ 'position_zone_radius'?: number; /** * Specifies the maximum blending percentage based on the trajectory length in position space around the motion command\'s target point. Percentage indicated in 0.0 - 100.0. */ 'position_zone_percentage'?: number; /** * Specifies the maximum radius in [rad] for orientation blending around the motion command\'s target orientation. At the target\'s orientation, the TCP orientation can be altered to blend into the following motion. */ 'orientation_zone_radius'?: number; /** * Specifies the maximum blending percentage for orientation blending based on the trajectory length in orientation space. Percentage indicated in 0.0 - 100.0. */ 'orientation_zone_percentage'?: number; /** * Specifies the maximum radius in [rad] for joint space blending around the motion command\'s target joint configuration. At the target joint configuration, the joint path can be altered to blend into the following motion. */ 'joints_zone_radius'?: number; /** * Specifies the maximum blending percentage for joint space blending based on the trajectory length in joint space. Percentage indicated in 0.0 to 100.0. */ 'joints_zone_percentage'?: number; /** * Defines the space in which blending is performed. */ 'space'?: BlendingSpace; 'blending_name': BlendingPositionBlendingNameEnum; } declare const BlendingPositionBlendingNameEnum: { readonly BlendingPosition: "BlendingPosition"; }; type BlendingPositionBlendingNameEnum = typeof BlendingPositionBlendingNameEnum[keyof typeof BlendingPositionBlendingNameEnum]; /** * Defines the space in which blending is performed. - `JOINT`: Zone blending is performed in joint space - `CARTESIAN`: Auto-blending is performed in cartesian space */ declare const BlendingSpace: { readonly Joint: "JOINT"; readonly Cartesian: "CARTESIAN"; }; type BlendingSpace = typeof BlendingSpace[keyof typeof BlendingSpace]; /** * Value of a digital input/output. */ interface BooleanValue { 'value': boolean; 'value_type': BooleanValueValueTypeEnum; } declare const BooleanValueValueTypeEnum: { readonly Boolean: "boolean"; }; type BooleanValueValueTypeEnum = typeof BooleanValueValueTypeEnum[keyof typeof BooleanValueValueTypeEnum]; /** * Defines a cuboid shape centred around an origin. If a margin is applied to the box type full, it is added to all size values. The shape will keep its edges. The hollow box type consists of thin boxes that make up its walls. If a margin is applied to the box type hollow, its size values are reduced by the margin. */ interface Box { 'shape_type': BoxShapeTypeEnum; /** * The dimension in x-direction in [mm]. */ 'size_x': number; /** * The dimension in y-direction in [mm]. */ 'size_y': number; /** * The dimension in z-direction in [mm]. */ 'size_z': number; /** * The box type defines if the box is hollow or full. */ 'box_type': BoxBoxTypeEnum; } declare const BoxShapeTypeEnum: { readonly Box: "box"; }; type BoxShapeTypeEnum = typeof BoxShapeTypeEnum[keyof typeof BoxShapeTypeEnum]; declare const BoxBoxTypeEnum: { readonly Hollow: "HOLLOW"; readonly Full: "FULL"; }; type BoxBoxTypeEnum = typeof BoxBoxTypeEnum[keyof typeof BoxBoxTypeEnum]; interface BusIODescription { /** * Unique identifier of the input/output. */ 'io': string; /** * Name of the input/output. Customize it using the respective BUS service, e.g., [addProfinetIO](#/operations/addProfinetIO) for PROFINET service. */ 'name': string; 'direction': IODirection; 'value_type': IOValueType; 'unit'?: UnitType; 'min'?: IOBoundary; 'max'?: IOBoundary; } /** * MODBUS client inputs/outputs service configuration. */ interface BusIOModbusClient { 'bus_type': BusIOModbusClientBusTypeEnum; 'network': BusIOModbusTCPClient; } declare const BusIOModbusClientBusTypeEnum: { readonly ModbusClient: "modbus_client"; }; type BusIOModbusClientBusTypeEnum = typeof BusIOModbusClientBusTypeEnum[keyof typeof BusIOModbusClientBusTypeEnum]; /** * MODBUS server inputs/outputs service configuration. */ interface BusIOModbusServer { 'bus_type': BusIOModbusServerBusTypeEnum; 'network': BusIOModbusTCPServer; /** * Number of connections this MODBUS server can handle. */ 'connections': number; /** * Size of the Coils memory area. */ 'coils_size': number; /** * Size of the Discrete Inputs memory area. */ 'discrete_inputs_size': number; /** * Size of the Holding Registers memory area. */ 'holding_registers_size': number; /** * Size of the Input Registers memory area. */ 'input_registers_size': number; } declare const BusIOModbusServerBusTypeEnum: { readonly ModbusServer: "modbus_server"; }; type BusIOModbusServerBusTypeEnum = typeof BusIOModbusServerBusTypeEnum[keyof typeof BusIOModbusServerBusTypeEnum]; interface BusIOModbusTCPClient { 'network_type'?: BusIOModbusTCPClientNetworkTypeEnum; /** * IP address of the MODBUS server to establish communication with. */ 'ip': string; /** * Port number of the MODBUS server to establish communication with. */ 'port': number; } declare const BusIOModbusTCPClientNetworkTypeEnum: { readonly Tcp: "tcp"; }; type BusIOModbusTCPClientNetworkTypeEnum = typeof BusIOModbusTCPClientNetworkTypeEnum[keyof typeof BusIOModbusTCPClientNetworkTypeEnum]; interface BusIOModbusTCPServer { 'network_type'?: BusIOModbusTCPServerNetworkTypeEnum; /** * Port number of the MODBUS server to establish communication with. */ 'port': number; } declare const BusIOModbusTCPServerNetworkTypeEnum: { readonly Tcp: "tcp"; }; type BusIOModbusTCPServerNetworkTypeEnum = typeof BusIOModbusTCPServerNetworkTypeEnum[keyof typeof BusIOModbusTCPServerNetworkTypeEnum]; /** * Virtual MODBUS inputs/outputs service configuration. */ interface BusIOModbusVirtual { 'bus_type': BusIOModbusVirtualBusTypeEnum; } declare const BusIOModbusVirtualBusTypeEnum: { readonly ModbusVirtual: "modbus_virtual"; }; type BusIOModbusVirtualBusTypeEnum = typeof BusIOModbusVirtualBusTypeEnum[keyof typeof BusIOModbusVirtualBusTypeEnum]; /** * PROFINET BUS inputs/outputs service configuration. */ interface BusIOProfinet { 'bus_type': BusIOProfinetBusTypeEnum; /** * Used to enable IP communication through the same physical ethernet interface while PROFINET driver is active. Optional for SR-IOV-based bus I/O recreation. If omitted and an existing PROFINET bus I/O configuration for the same MAC address already exists, the previous network settings are reused. */ 'network_config'?: BusIOProfinetNetwork; /** * IP address of the PLC to establish PROFINET communication with. The IP address is used to configure the host machine\'s firewall. The firewall configuration is applied while the BUS input/output service is active. Without proper firewall configuration, PROFINET device discovery, configuration exchanges, and real-time cyclic data communication will fail. */ 'plc_ip': string; /** * MAC address of the physical ethernet interface that you want to use for PROFINET communication. */ 'mac': string; /** * Optional PROFINET slot configuration. If not provided, the default configuration is used for backward compatibility: one slot with a size of 64 bytes. */ 'slots'?: Array; /** * @deprecated */ 'default_route'?: BusIOProfinetDefaultRoute; } declare const BusIOProfinetBusTypeEnum: { readonly Profinet: "profinet"; }; type BusIOProfinetBusTypeEnum = typeof BusIOProfinetBusTypeEnum[keyof typeof BusIOProfinetBusTypeEnum]; /** * Current default route configuration of your NOVA instance. The default route is a setting that tells data where to go if there isn’t a specific path already known for its destination. Usually this will be the path to your router, enabling accessing the internet. On Linux, use `ip route show` to view your default routes and match the output `default via dev ...` to get your gateway and interface. */ interface BusIOProfinetDefaultRoute { /** * Gateway for the default route. */ 'gateway': string; /** * Interface for the default route. */ 'interface': string; } /** * Network configuration or IPv4 record of the virtual ethernet interface (pnio1) created by the PROFINET driver. The IPv4 record is used in combination with the Name of Station (NoS) to identify your device in the PROFINET network. The `ip_config` will be used as IPv4 record if no REMA XML file is already present on your machine and no `rema_xml_content` is provided. */ interface BusIOProfinetIpConfig { /** * IP address for the device\'s virtual ethernet interface (pnio1). */ 'ip': string; /** * Network mask for the device\'s virtual ethernet interface (pnio1). */ 'netmask': string; /** * Gateway for connections to other devices outside of the virtual ethernet interface\'s subnet. */ 'gateway': string; } interface BusIOProfinetNetwork { /** * Name of Station (NoS) of the PROFINET device. The NoS is used in combination with IPv4 record to identify your device in the PROFINET network. The `device_name` will be used as NoS if no REMA XML file is already present on your machine and no `rema_xml_content` is provided. */ 'device_name'?: string; 'ip_config'?: BusIOProfinetIpConfig; /** * Content of the PROFINET REMA XML file. Is used when PROFINET service is added for the first time to create the REMA XML file that holds data to be kept for the next session. Stores information like IP address, Name of Station (NoS) and hardware configuration. If you use a PROFINET controller to assign an IP address to the PROFINET device, this information will be written to the REMA XML file. Refer to the PDF version of the \"PN Driver I/O Base programming interface\" documentation for more information and an example REMA file. */ 'rema_xml_content'?: string; } /** * Configuration for one PROFINET process data slot. */ interface BusIOProfinetSlot { /** * Slot identifier on the PROFINET device. */ 'slot': number; /** * Process data size in bytes for the input direction (device → controller). */ 'input_size_bytes': number; /** * Process data size in bytes for the output direction (controller → device). */ 'output_size_bytes': number; } /** * Virtual PROFINET BUS inputs/outputs service configuration. */ interface BusIOProfinetVirtual { 'bus_type': BusIOProfinetVirtualBusTypeEnum; } declare const BusIOProfinetVirtualBusTypeEnum: { readonly ProfinetVirtual: "profinet_virtual"; }; type BusIOProfinetVirtualBusTypeEnum = typeof BusIOProfinetVirtualBusTypeEnum[keyof typeof BusIOProfinetVirtualBusTypeEnum]; /** * Snap7 BUS inputs/outputs service configuration. */ interface BusIOSnap7 { 'bus_type': BusIOSnap7BusTypeEnum; /** * IP address or hostname of the Siemens PLC or PLCSIM Advanced endpoint. */ 'address': string; /** * Rack number of the PLC CPU. Standard value for S7-1200/1500 is 0. */ 'rack'?: number; /** * Slot number of the PLC CPU. Standard value for S7-1200/1500 is 1. */ 'slot'?: number; } declare const BusIOSnap7BusTypeEnum: { readonly Snap7: "snap7"; }; type BusIOSnap7BusTypeEnum = typeof BusIOSnap7BusTypeEnum[keyof typeof BusIOSnap7BusTypeEnum]; /** * @type BusIOType */ type BusIOType = { bus_type: 'modbus_client'; } & BusIOModbusClient | { bus_type: 'modbus_server'; } & BusIOModbusServer | { bus_type: 'modbus_virtual'; } & BusIOModbusVirtual | { bus_type: 'profinet'; } & BusIOProfinet | { bus_type: 'profinet_virtual'; } & BusIOProfinetVirtual | { bus_type: 'snap7'; } & BusIOSnap7; interface BusIOsState { 'state': BusIOsStateEnum; /** * A message providing additional information on the input/output service, e.g., BUS service status, encountered errors. May be empty if no additional information is available. */ 'message'?: string; } /** * Current state of the BUS input/output service. */ declare const BusIOsStateEnum: { readonly BusIosStateUnknown: "BUS_IOS_STATE_UNKNOWN"; readonly BusIosStateInitializing: "BUS_IOS_STATE_INITIALIZING"; readonly BusIosStateConnected: "BUS_IOS_STATE_CONNECTED"; readonly BusIosStateDisconnected: "BUS_IOS_STATE_DISCONNECTED"; }; type BusIOsStateEnum = typeof BusIOsStateEnum[keyof typeof BusIOsStateEnum]; /** * A capability granted to the authenticated user. If `resource_ids` is absent or empty, the capability is granted globally without resource restriction. */ interface CapabilityEntry { /** * Capability relation name. */ 'capability': string; /** * Resource identifiers the capability is scoped to. Absent or empty means the capability is granted globally. Resource IDs are deduplicated and sorted in ascending order. */ 'resource_ids'?: Array; } /** * Defines a cylindrical shape with 2 semi-spheres on the top and bottom. Centred around origin, symmetric around z-axis. */ interface Capsule { 'shape_type': CapsuleShapeTypeEnum; /** * The radius of the cylinder and semi-spheres in [mm]. */ 'radius': number; /** * The height of the inner cylinder in [mm]. */ 'cylinder_height': number; } declare const CapsuleShapeTypeEnum: { readonly Capsule: "capsule"; }; type CapsuleShapeTypeEnum = typeof CapsuleShapeTypeEnum[keyof typeof CapsuleShapeTypeEnum]; interface CartesianLimits { 'velocity'?: number; 'acceleration'?: number; /** * > **NOTE** > > This limit type is experimental and its behavior may change in future releases. */ 'jerk'?: number; 'orientation_velocity'?: number; 'orientation_acceleration'?: number; /** * > **NOTE** > > This limit type is experimental and its behavior may change in future releases. */ 'orientation_jerk'?: number; } /** * To create a robot cell, only a valid name is required. Once created, a robot cell provides access to the Wandelbots NOVA foundation services. The configuration can be customized, e.g., robot controllers, also within apps. */ interface Cell { [key: string]: any; /** * A unique name for the cell used as an identifier for addressing the cell in all API calls. It must be a valid k8s label name as defined by [RFC 1123](https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#dns-label-names). */ 'name': string; /** * Wandelbots NOVA version of the cell. This version must not exceed the current system version. */ 'version'?: string; /** * A description of the cell. */ 'description'?: string; 'controllers'?: Array; 'apps'?: Array; } /** * @type CloudConfigStatus */ type CloudConfigStatus = { status: 'configured'; } & CloudConfigStatusConfigured | { status: 'not_configured'; } & CloudConfigStatusNotConfigured; interface CloudConfigStatusConfigured { 'status': CloudConfigStatusConfiguredStatusEnum; 'config': CloudConfiguration; } declare const CloudConfigStatusConfiguredStatusEnum: { readonly Configured: "configured"; }; type CloudConfigStatusConfiguredStatusEnum = typeof CloudConfigStatusConfiguredStatusEnum[keyof typeof CloudConfigStatusConfiguredStatusEnum]; interface CloudConfigStatusNotConfigured { 'status': CloudConfigStatusNotConfiguredStatusEnum; } declare const CloudConfigStatusNotConfiguredStatusEnum: { readonly NotConfigured: "not_configured"; }; type CloudConfigStatusNotConfiguredStatusEnum = typeof CloudConfigStatusNotConfiguredStatusEnum[keyof typeof CloudConfigStatusNotConfiguredStatusEnum]; interface CloudConfiguration { 'cloud_hostname': string; /** * Instance identifier received from cloud registration */ 'instance': number; } interface CloudConnectionError { 'error': CloudConnectionErrorError; } /** * @type CloudConnectionErrorError */ type CloudConnectionErrorError = { code: 'invalid_cloud_token'; } & CloudConnectionErrorInvalidToken | { code: 'leafnode_connection_error'; } & CloudConnectionErrorLeafnodeConnectionError | { code: 'leafnode_connection_timeout'; } & CloudConnectionErrorLeafnodeConnectionTimeout | { code: 'leafnode_restart_timeout'; } & CloudConnectionErrorLeafnodeRestartTimeout | { code: 'nats_connection_failed'; } & CloudConnectionErrorNatsFailed | { code: 'unexpected_cloud_response'; } & CloudConnectionErrorUnexpectedResponse; interface CloudConnectionErrorInvalidToken { 'code': CloudConnectionErrorInvalidTokenCodeEnum; 'message': string; 'details': CloudConnectionErrorInvalidTokenDetails; } declare const CloudConnectionErrorInvalidTokenCodeEnum: { readonly InvalidCloudToken: "invalid_cloud_token"; }; type CloudConnectionErrorInvalidTokenCodeEnum = typeof CloudConnectionErrorInvalidTokenCodeEnum[keyof typeof CloudConnectionErrorInvalidTokenCodeEnum]; interface CloudConnectionErrorInvalidTokenDetails { 'cloud_response': CloudConnectionErrorInvalidTokenDetailsCloudResponse; } interface CloudConnectionErrorInvalidTokenDetailsCloudResponse { 'status': number; 'headers'?: any; 'body': string; } interface CloudConnectionErrorLeafnodeConnectionError { 'code': CloudConnectionErrorLeafnodeConnectionErrorCodeEnum; 'message': string; 'details': CloudConnectionErrorLeafnodeConnectionErrorDetails; } declare const CloudConnectionErrorLeafnodeConnectionErrorCodeEnum: { readonly LeafnodeConnectionError: "leafnode_connection_error"; }; type CloudConnectionErrorLeafnodeConnectionErrorCodeEnum = typeof CloudConnectionErrorLeafnodeConnectionErrorCodeEnum[keyof typeof CloudConnectionErrorLeafnodeConnectionErrorCodeEnum]; interface CloudConnectionErrorLeafnodeConnectionErrorDetails { 'log_line': string; } interface CloudConnectionErrorLeafnodeConnectionTimeout { 'code': CloudConnectionErrorLeafnodeConnectionTimeoutCodeEnum; 'message': string; } declare const CloudConnectionErrorLeafnodeConnectionTimeoutCodeEnum: { readonly LeafnodeConnectionTimeout: "leafnode_connection_timeout"; }; type CloudConnectionErrorLeafnodeConnectionTimeoutCodeEnum = typeof CloudConnectionErrorLeafnodeConnectionTimeoutCodeEnum[keyof typeof CloudConnectionErrorLeafnodeConnectionTimeoutCodeEnum]; interface CloudConnectionErrorLeafnodeRestartTimeout { 'code': CloudConnectionErrorLeafnodeRestartTimeoutCodeEnum; 'message': string; } declare const CloudConnectionErrorLeafnodeRestartTimeoutCodeEnum: { readonly LeafnodeRestartTimeout: "leafnode_restart_timeout"; }; type CloudConnectionErrorLeafnodeRestartTimeoutCodeEnum = typeof CloudConnectionErrorLeafnodeRestartTimeoutCodeEnum[keyof typeof CloudConnectionErrorLeafnodeRestartTimeoutCodeEnum]; interface CloudConnectionErrorNatsFailed { 'code': CloudConnectionErrorNatsFailedCodeEnum; 'message': string; 'details': CloudConnectionErrorNatsFailedDetails; } declare const CloudConnectionErrorNatsFailedCodeEnum: { readonly NatsConnectionFailed: "nats_connection_failed"; }; type CloudConnectionErrorNatsFailedCodeEnum = typeof CloudConnectionErrorNatsFailedCodeEnum[keyof typeof CloudConnectionErrorNatsFailedCodeEnum]; interface CloudConnectionErrorNatsFailedDetails { 'nats_server_url': string; 'nats_error_message': string; } interface CloudConnectionErrorUnexpectedResponse { 'code': CloudConnectionErrorUnexpectedResponseCodeEnum; 'message': string; 'details': CloudConnectionErrorUnexpectedResponseDetails; } declare const CloudConnectionErrorUnexpectedResponseCodeEnum: { readonly UnexpectedCloudResponse: "unexpected_cloud_response"; }; type CloudConnectionErrorUnexpectedResponseCodeEnum = typeof CloudConnectionErrorUnexpectedResponseCodeEnum[keyof typeof CloudConnectionErrorUnexpectedResponseCodeEnum]; interface CloudConnectionErrorUnexpectedResponseDetails { 'cloud_response': CloudConnectionErrorUnexpectedResponseDetailsCloudResponse; } interface CloudConnectionErrorUnexpectedResponseDetailsCloudResponse { 'status': number; 'headers': { [key: string]: any; }; 'body': string; } interface CloudConnectionRequest { 'cloud_hostname': string; /** * Auth token of the user registering the instance. This must be a valid oauth token granting access to the NOVA Cloud API. */ 'token': string; /** * Human-readable name to identify the instance in the fleet manager dashboard. */ 'instance_name': string; /** * Optional local network url for the instance, used to link users directly from the fleet manager. If not specified, will be inferred from the request URL. */ 'instance_url'?: string; } interface CloudDisconnectionError { 'error': CloudConnectionErrorLeafnodeRestartTimeout; } interface CloudDisconnectionStatusDisconnected { 'status': CloudDisconnectionStatusDisconnectedStatusEnum; } declare const CloudDisconnectionStatusDisconnectedStatusEnum: { readonly Disconnected: "disconnected"; }; type CloudDisconnectionStatusDisconnectedStatusEnum = typeof CloudDisconnectionStatusDisconnectedStatusEnum[keyof typeof CloudDisconnectionStatusDisconnectedStatusEnum]; interface CloudDisconnectionStatusDisconnecting { 'status': CloudDisconnectionStatusDisconnectingStatusEnum; } declare const CloudDisconnectionStatusDisconnectingStatusEnum: { readonly Disconnecting: "disconnecting"; }; type CloudDisconnectionStatusDisconnectingStatusEnum = typeof CloudDisconnectionStatusDisconnectingStatusEnum[keyof typeof CloudDisconnectionStatusDisconnectingStatusEnum]; interface CloudRegistrationSuccessResponse { /** * Instance identifier received from cloud registration */ 'instance': number; } /** * Defines a collider with a single shape. A collider is an object that is used for collision detection. It defines the `shape` that is attached with the offset of `pose` to a reference frame. Use colliders to: - Define the shape of a workpiece. The reference frame is the scene origin. - Define the shape of a link in a motion group. The reference frame is the link coordinate system. - Define the shape of a tool. The reference frame is the flange coordinate system. */ interface Collider { 'shape': ColliderShape; 'pose'?: Pose; /** * Increases the shape\'s size in all dimensions. Applied in [mm]. Can be used to keep a safe distance to the shape. */ 'margin'?: number; } /** * @type ColliderShape */ type ColliderShape = { shape_type: 'box'; } & Box | { shape_type: 'capsule'; } & Capsule | { shape_type: 'convex_hull'; } & ConvexHull | { shape_type: 'cylinder'; } & Cylinder | { shape_type: 'plane'; } & Plane | { shape_type: 'rectangle'; } & Rectangle | { shape_type: 'rectangular_capsule'; } & RectangularCapsule | { shape_type: 'sphere'; } & Sphere; /** * An inline Collider object wrapped for discriminator support. */ interface ColliderValue { /** * Discriminator value indicating an inline value. */ 'source': ColliderValueSourceEnum; /** * The inline Collider definition. */ 'collider': Collider; } declare const ColliderValueSourceEnum: { readonly Value: "value"; }; type ColliderValueSourceEnum = typeof ColliderValueSourceEnum[keyof typeof ColliderValueSourceEnum]; /** * @type ColliderValueOrKey * Either an inline Collider object or a storage key referencing a stored Collider. Discriminated by the \"source\" property. */ type ColliderValueOrKey = { source: 'key'; } & StorageKey | { source: 'value'; } & ColliderValue; interface Collision { 'id_of_a'?: string; 'id_of_b'?: string; 'id_of_layer'?: string; /** * A three-dimensional vector [x, y, z] with double precision. */ 'normal_root_on_b'?: Array; 'position_on_a'?: CollisionContact; 'position_on_b'?: CollisionContact; } interface CollisionContact { /** * A three-dimensional vector [x, y, z] with double precision. */ 'local'?: Array; /** * A three-dimensional vector [x, y, z] with double precision. */ 'root'?: Array; } interface CollisionError { 'kind': CollisionErrorKindEnum; 'collision'?: FeedbackCollision; } declare const CollisionErrorKindEnum: { readonly CollisionError: "CollisionError"; }; type CollisionErrorKindEnum = typeof CollisionErrorKindEnum[keyof typeof CollisionErrorKindEnum]; /** * @type CollisionFreeAlgorithm * Configuration for collision-free path planning algorithms. Different algorithms may have different parameters and behavior. Recommendation: - For **cells with many obstacles**, use the RRTConnect algorithm. Use it as a starting point. - For **simple cells with very few obstacles** and when a faster solution is needed, try the MidpointInsertion algorithm. */ type CollisionFreeAlgorithm = MidpointInsertionAlgorithm | RRTConnectAlgorithm; interface CollisionMotionGroup { /** * A link chain is a kinematic chain of links that is connected via joints. A motion group can be used to control the motion of the joints in a link chain. A link is a group of colliders that is attached to the link reference frame. The reference frame of a link is obtained after applying all sets of Denavit-Hartenberg-parameters from base to (including) the link index. This means that the reference frame of the link is on the rotation axis of the next joint in the kinematic chain. Example: For a motion group with 2 joints, the collider reference frame (CRF) for link 1 is on the rotation axis of joint 2. The chain looks like: - Origin >> Mounting >> Base >> (CRF Base) Joint 0 >> Link 0 >> (CRF Link 0) Joint 1 >> Link 1 >> (CRF Link 1) Flange (CRF Tool) >> TCP Adjacent links in the kinematic chain of the motion group are not checked for mutual collision. */ 'link_chain'?: Array<{ [key: string]: Collider; }>; /** * Defines the shape of a tool. A tool is a dictionary of colliders. All colliders that make up a tool are attached to the flange frame of the motion group. */ 'tool'?: { [key: string]: Collider; }; /** * If true, self-collision detection is enabled for the motion group. Self-collision detection checks if links in the kinematic chain of the motion group collide with each other. Adjacent links in the kinematic chain of the motion group are not checked for mutual collision. The tool is treated like a link at the end of the kinematic chain. It is checked against all links except the last one. Default is true. */ 'self_collision_detection'?: boolean; } interface CollisionSetup { /** * A collection of identifiable colliders. */ 'colliders'?: { [key: string]: Collider; }; /** * A link chain is a kinematic chain of links that is connected via joints. A motion group can be used to control the motion of the joints in a link chain. A link is a group of colliders that is attached to the link reference frame. The reference frame of a link is obtained after applying all sets of Denavit-Hartenberg-parameters from base to (including) the link index. This means that the reference frame of the link is on the rotation axis of the next joint in the kinematic chain. Example: For a motion group with 2 joints, the collider reference frame (CRF) for link 1 is on the rotation axis of joint 2. The chain looks like: - Origin >> Mounting >> Base >> (CRF Base) Joint 0 >> Link 0 >> (CRF Link 0) Joint 1 >> Link 1 >> (CRF Link 1) Flange (CRF Tool) >> TCP Adjacent links in the kinematic chain of the motion group are not checked for mutual collision. */ 'link_chain'?: Array<{ [key: string]: Collider; }>; /** * Defines the shape of a tool. A tool is a dictionary of colliders. All colliders that make up a tool are attached to the flange frame of the motion group. */ 'tool'?: { [key: string]: Collider; }; /** * If true, self-collision detection is enabled for the motion group. Self-collision detection checks if links in the kinematic chain of the motion group collide with each other. Adjacent links in the kinematic chain of the motion group are not checked for mutual collision. The tool is treated like a link at the end of the kinematic chain. It is checked against all links except the last one. Default is true. */ 'self_collision_detection'?: boolean; } /** * An inline collision setup wrapped for discriminator support. Colliders, tool, and link_chain can each be either inline values or storage key references. */ interface CollisionSetupValue { /** * Discriminator value indicating an inline value. */ 'source': CollisionSetupValueSourceEnum; /** * A dictionary of colliders where each value is either an inline Collider object or a string key referencing a stored Collider. */ 'colliders'?: { [key: string]: ColliderValueOrKey; }; /** * The shape of the motion group links. Either an inline LinkChain or a store key. */ 'link_chain'?: LinkChainValueOrKey; /** * Shape of the tool. Either an inline tool collider or a store key. */ 'tool'?: ToolValueOrKey; /** * If true, self-collision detection is enabled. Default is true. */ 'self_collision_detection'?: boolean; } declare const CollisionSetupValueSourceEnum: { readonly Value: "value"; }; type CollisionSetupValueSourceEnum = typeof CollisionSetupValueSourceEnum[keyof typeof CollisionSetupValueSourceEnum]; /** * @type CollisionSetupValueOrKey * Either an inline collision setup or a storage key referencing a complete stored CollisionSetup. Discriminated by the \"source\" property. */ type CollisionSetupValueOrKey = { source: 'key'; } & StorageKey | { source: 'value'; } & CollisionSetupValue; /** * Comparator for the comparison of two values. The comparator is used to compare two values and return a boolean result. The default comparator is unknown. */ declare const Comparator: { readonly ComparatorEquals: "COMPARATOR_EQUALS"; readonly ComparatorNotEquals: "COMPARATOR_NOT_EQUALS"; readonly ComparatorGreater: "COMPARATOR_GREATER"; readonly ComparatorGreaterEqual: "COMPARATOR_GREATER_EQUAL"; readonly ComparatorLess: "COMPARATOR_LESS"; readonly ComparatorLessEqual: "COMPARATOR_LESS_EQUAL"; }; type Comparator = typeof Comparator[keyof typeof Comparator]; /** * @type ConfigurationArchiveStatus * Result of a backup operation. */ type ConfigurationArchiveStatus = { status: 'creating'; } & ConfigurationArchiveStatusCreating | { status: 'error'; } & ConfigurationArchiveStatusError | { status: 'success'; } & ConfigurationArchiveStatusSuccess; interface ConfigurationArchiveStatusCreating { /** * Backup is in progress. */ 'status': ConfigurationArchiveStatusCreatingStatusEnum; /** * Current completion ratio (0 – 1). */ 'progress': number; } declare const ConfigurationArchiveStatusCreatingStatusEnum: { readonly Creating: "creating"; }; type ConfigurationArchiveStatusCreatingStatusEnum = typeof ConfigurationArchiveStatusCreatingStatusEnum[keyof typeof ConfigurationArchiveStatusCreatingStatusEnum]; interface ConfigurationArchiveStatusError { 'status': ConfigurationArchiveStatusErrorStatusEnum; /** * Human-readable explanation of the failure. */ 'message': string; } declare const ConfigurationArchiveStatusErrorStatusEnum: { readonly Error: "error"; }; type ConfigurationArchiveStatusErrorStatusEnum = typeof ConfigurationArchiveStatusErrorStatusEnum[keyof typeof ConfigurationArchiveStatusErrorStatusEnum]; interface ConfigurationArchiveStatusSuccess { /** * Backup successfully created. */ 'status': ConfigurationArchiveStatusSuccessStatusEnum; } declare const ConfigurationArchiveStatusSuccessStatusEnum: { readonly Success: "success"; }; type ConfigurationArchiveStatusSuccessStatusEnum = typeof ConfigurationArchiveStatusSuccessStatusEnum[keyof typeof ConfigurationArchiveStatusSuccessStatusEnum]; /** * Configuration resource object. */ interface ConfigurationResource { /** * Identifier of a configuration resource. */ 'id': string; /** * Human-readable name of the configuration resource. */ 'name': string; /** * Array of configuration resources. */ 'children'?: Array; } interface ConfiguredPose { 'pose': Pose; 'kinematic_configuration': KinematicConfiguration; } interface ConfiguredPoseInverse422Response { 'detail'?: Array; } interface ConfiguredPoseInverseFailedResponse { 'joint_positions': Array>; 'feedbacks'?: Array; } interface ConfiguredPoseInverseRequest { /** * Identifies a single motion group model. See [getMotionGroupModels](#/operations/getMotionGroupModels) for supported types. */ 'motion_group_model': string; 'tcp_poses': Array; 'tcp_offset'?: Pose; /** * Offset from the world frame to the motion group base. */ 'mounting'?: Pose; /** * Joint position limits, indexed starting from base. The unit depends on the type of joint: For revolute joints, the limit is given in [rad]; for prismatic joints, it is given in [mm]. */ 'joint_position_limits'?: Array; /** * Collision layers to be respected by the motion planner when planning for a single motion group. Each setup represents one layer, e.g., the safety zones and shapes or a fine grained tool and workpiece model. Layers are checked individually along the trajectory and independently of other layers. To respect the safety zones of the controller and check for collision: 1. Fetch the safety zones, link and tool shapes from the controller. 2. Add the fetched zones, links and tools to a layer. 3. Create other layers from your own 3D data as needed. 4. Plan trajectory. 5. The response highlights the layer in which a collision was detected by key. */ 'collision_setups'?: { [key: string]: CollisionSetup; }; } interface ConfiguredPoseInverseResponse { 'response': ConfiguredPoseInverseResponseResponse; } /** * @type ConfiguredPoseInverseResponseResponse */ type ConfiguredPoseInverseResponseResponse = Array> | ConfiguredPoseInverseFailedResponse; /** * Defines a rotationally constrained pose in 3D space. The orientation is constrained to rotations around a single axis. */ interface ConstrainedPose { /** * A three-dimensional vector [x, y, z] with double precision. */ 'position': Array; 'orientation': number; } interface ContainerEnvironmentInner { 'name': string; 'value': string; } /** * A user provided, custom container image and the required credentials to pull it from a registry. */ interface ContainerImage { /** * The location of a container image in the form of `/:`. */ 'image': string; 'credentials'?: ImageCredentials; /** * Known secrets for authentication with the container registry. */ 'secrets'?: Array; } interface ContainerImageSecretsInner { 'name': string; } /** * Additional resources that the application requires. */ interface ContainerResources { /** * Number of GPUs the application requires. */ 'intel_gpu'?: number; /** * The maximum memory allocated to this application. */ 'memory_limit'?: string; } /** * The path and capacity of a volume that retains data across application restarts. The maximal requestable capacity is 300Mi. If you need more capacity consider using [storeObject](#/operations/storeObject). */ interface ContainerStorage { 'mount_path': string; /** * The amount of requested storage capacity. */ 'capacity': string; } /** * The data type to describe a robot controller. */ interface ControllerDescription { 'connected_motion_groups': Array; /** * Can this controller be moved through freedrive (true), or not (false). */ 'supports_freedrive': boolean; /** * Can this controller be controlled with NOVA (true) or is it only possible to read data (false). */ 'supports_control': boolean; /** * True if NOVA supports reading safety zone-, tool- and link-geometries for this motion group. Safety zones are used to define areas where the robot should slow down or stop. If false, NOVA can\'t guarantee that the executed motions respect safety zones defined on the controller. */ 'supports_safety_zones': boolean; } interface ConvertVendorConfiguredPose422Response { 'detail'?: Array; } interface ConvertVendorConfiguredPoseRequest { 'vendor_configured_poses': ConvertVendorConfiguredPoseRequestVendorConfiguredPoses; } /** * @type ConvertVendorConfiguredPoseRequestVendorConfiguredPoses */ type ConvertVendorConfiguredPoseRequestVendorConfiguredPoses = Array | Array; /** * Defines a convex hull encapsulating a set of vertices. */ interface ConvexHull { 'shape_type': ConvexHullShapeTypeEnum; /** * The list of encapsulated points. */ 'vertices': Array>; } declare const ConvexHullShapeTypeEnum: { readonly ConvexHull: "convex_hull"; }; type ConvexHullShapeTypeEnum = typeof ConvexHullShapeTypeEnum[keyof typeof ConvexHullShapeTypeEnum]; interface CoordinateSystem { /** * Human readable name of this coordinate system. */ 'name'?: string; /** * The identifier of the reference coordinate system. Empty if world is used. */ 'reference_coordinate_system'?: string; /** * A three-dimensional vector [x, y, z] with double precision. */ 'position'?: Array; /** * Describes an orientation in 3D space. A tree-to-four-dimensional vector [x, y, z, w] with double precision. */ 'orientation'?: Array; 'orientation_type'?: OrientationType; /** * Unique identifier of the coordinate system. */ 'coordinate_system': string; } interface CoordinateSystemData { /** * Human readable name of this coordinate system. */ 'name'?: string; /** * The identifier of the reference coordinate system. Empty if world is used. */ 'reference_coordinate_system'?: string; /** * A three-dimensional vector [x, y, z] with double precision. */ 'position'?: Array; /** * Describes an orientation in 3D space. A tree-to-four-dimensional vector [x, y, z, w] with double precision. */ 'orientation'?: Array; 'orientation_type'?: OrientationType; } /** * Request body for copying a motion group model under a new name. */ interface CopyMotionGroupModelRequest { /** * The name to register the copied motion group model with. */ 'name': string; } interface CubicSplineParameter { 'pose': Pose; 'path_parameter': number; } interface CycleTime { /** * Cycle time of controller communication in [ms]. */ 'cycle_time_ms': number; } /** * Defines a cylindrical shape. Centred around origin, symmetric around z-axis. If a margin is applied, it is added to radius and height. The shape will keep its edges. */ interface Cylinder { 'shape_type': CylinderShapeTypeEnum; /** * The radius of the cylinder in [mm]. */ 'radius': number; /** * The height of the cylinder in [mm]. */ 'height': number; } declare const CylinderShapeTypeEnum: { readonly Cylinder: "cylinder"; }; type CylinderShapeTypeEnum = typeof CylinderShapeTypeEnum[keyof typeof CylinderShapeTypeEnum]; /** * A single set of DH parameters. */ interface DHParameter { /** * Angle about x-axis in [rad]. */ 'alpha'?: number; /** * Angle about z-axis in [rad]. */ 'theta'?: number; /** * Offset along x-axis in [mm]. */ 'a'?: number; /** * Offset along z-axis in [mm]. */ 'd'?: number; /** * True, if rotation direction of joint is reversed. */ 'reverse_rotation_direction'?: boolean; 'type'?: JointTypeEnum; } /** * The direction in which the trajectory is executed. Default: Forward. */ declare const Direction: { readonly DirectionForward: "DIRECTION_FORWARD"; readonly DirectionBackward: "DIRECTION_BACKWARD"; }; type Direction = typeof Direction[keyof typeof Direction]; /** * A direction constraint is defined by a vector in world frame and a vector in the TCP frame. The direction constraint is satisfied when the vectors are aligned with each other, which the planner attempts to achieve. Example: If the world vector is [0, 0, 1] and the TCP vector is [0, 0, -1], the planner will try to keep the TCP facing downward during the motion. The constraint vectors must be normalized. */ interface DirectionConstraint { /** * A three-dimensional vector [x, y, z] with double precision. */ 'world': Array; /** * A three-dimensional vector [x, y, z] with double precision. */ 'tcp': Array; /** * The tolerance in degrees for the direction constraint. The planner will try to satisfy the constraint within this tolerance. Start and target orientations must also satisfy it within this tolerance. */ 'tolerance': number; 'constraint_name': DirectionConstraintConstraintNameEnum; } declare const DirectionConstraintConstraintNameEnum: { readonly DirectionConstraint: "DirectionConstraint"; }; type DirectionConstraintConstraintNameEnum = typeof DirectionConstraintConstraintNameEnum[keyof typeof DirectionConstraintConstraintNameEnum]; interface DynamicModel { /** * Mass of the link in kg */ 'mass'?: number; /** * Center of mass coordinates [x, y, z] in mm */ 'center_of_mass'?: Array; 'inertia'?: InertiaTensor; /** * Actuator moment of inertia in kg⋅mm² */ 'actuator_inertia'?: number; /** * Static friction coefficient */ 'static_friction'?: number; /** * Viscous friction coefficient */ 'viscous_friction'?: number; } /** * A reference joint position (start or target) violates the direction constraint. */ interface ErrorDirectionConstraintNotMet { 'joint_position'?: Array; 'error_feedback_name': ErrorDirectionConstraintNotMetErrorFeedbackNameEnum; } declare const ErrorDirectionConstraintNotMetErrorFeedbackNameEnum: { readonly ErrorDirectionConstraintNotMet: "ErrorDirectionConstraintNotMet"; }; type ErrorDirectionConstraintNotMetErrorFeedbackNameEnum = typeof ErrorDirectionConstraintNotMetErrorFeedbackNameEnum[keyof typeof ErrorDirectionConstraintNotMetErrorFeedbackNameEnum]; /** * The provided direction constraint is not normalized. */ interface ErrorDirectionConstraintNotNormalized { /** * A three-dimensional vector [x, y, z] with double precision. */ 'direction_constraint'?: Array; 'error_feedback_name': ErrorDirectionConstraintNotNormalizedErrorFeedbackNameEnum; } declare const ErrorDirectionConstraintNotNormalizedErrorFeedbackNameEnum: { readonly ErrorDirectionConstraintNotNormalized: "ErrorDirectionConstraintNotNormalized"; }; type ErrorDirectionConstraintNotNormalizedErrorFeedbackNameEnum = typeof ErrorDirectionConstraintNotNormalizedErrorFeedbackNameEnum[keyof typeof ErrorDirectionConstraintNotNormalizedErrorFeedbackNameEnum]; /** * The provided joint data does not match the expected number of joints for this motion group. */ interface ErrorInvalidJointCount { /** * The expected number of joints for this motion group. */ 'expected_joint_count': number; /** * The number of provided joints. */ 'provided_joint_count': number; 'error_feedback_name': ErrorInvalidJointCountErrorFeedbackNameEnum; } declare const ErrorInvalidJointCountErrorFeedbackNameEnum: { readonly ErrorInvalidJointCount: "ErrorInvalidJointCount"; }; type ErrorInvalidJointCountErrorFeedbackNameEnum = typeof ErrorInvalidJointCountErrorFeedbackNameEnum[keyof typeof ErrorInvalidJointCountErrorFeedbackNameEnum]; /** * A reference joint position (start or target) exceeds the configured joint limits. */ interface ErrorJointLimitExceeded { /** * Index of the joint exceeding its limits (0-based). */ 'joint_index'?: number; 'joint_position'?: Array; 'error_feedback_name': ErrorJointLimitExceededErrorFeedbackNameEnum; } declare const ErrorJointLimitExceededErrorFeedbackNameEnum: { readonly ErrorJointLimitExceeded: "ErrorJointLimitExceeded"; }; type ErrorJointLimitExceededErrorFeedbackNameEnum = typeof ErrorJointLimitExceededErrorFeedbackNameEnum[keyof typeof ErrorJointLimitExceededErrorFeedbackNameEnum]; /** * A reference joint position, e.g., start or target joint position, results in collisions that prevent processing. */ interface ErrorJointPositionCollision { 'collisions'?: Array; 'joint_position'?: Array; 'error_feedback_name': ErrorJointPositionCollisionErrorFeedbackNameEnum; } declare const ErrorJointPositionCollisionErrorFeedbackNameEnum: { readonly ErrorJointPositionCollision: "ErrorJointPositionCollision"; }; type ErrorJointPositionCollisionErrorFeedbackNameEnum = typeof ErrorJointPositionCollisionErrorFeedbackNameEnum[keyof typeof ErrorJointPositionCollisionErrorFeedbackNameEnum]; /** * The collision-free planning algorithm reached its maximum iteration limit without finding a valid path. Increase max_iterations or modify the start/target positions. */ interface ErrorMaxIterationsExceeded { /** * The maximum number of iterations that was reached. */ 'max_iterations'?: number; 'error_feedback_name': ErrorMaxIterationsExceededErrorFeedbackNameEnum; } declare const ErrorMaxIterationsExceededErrorFeedbackNameEnum: { readonly ErrorMaxIterationsExceeded: "ErrorMaxIterationsExceeded"; }; type ErrorMaxIterationsExceededErrorFeedbackNameEnum = typeof ErrorMaxIterationsExceededErrorFeedbackNameEnum[keyof typeof ErrorMaxIterationsExceededErrorFeedbackNameEnum]; interface ErrorMotionGroupKeyMismatch { /** * Motion group keys that have no matching motion group setup. */ 'invalid_motion_group_keys'?: Array; } /** * The operation requested is not supported. */ interface ErrorUnsupportedOperation { 'error_feedback_name': ErrorUnsupportedOperationErrorFeedbackNameEnum; } declare const ErrorUnsupportedOperationErrorFeedbackNameEnum: { readonly ErrorUnsupportedOperation: "ErrorUnsupportedOperation"; }; type ErrorUnsupportedOperationErrorFeedbackNameEnum = typeof ErrorUnsupportedOperationErrorFeedbackNameEnum[keyof typeof ErrorUnsupportedOperationErrorFeedbackNameEnum]; /** * Details about the state of the motion execution. The details are either for a jogging or a trajectory. If NOVA is not controlling this motion group at the moment, this field is omitted. */ interface Execute { /** * Commanded joint position of each joint. This command was sent in the time step the corresponding state was received. The unit depends on the type of joint: For revolute joints, the angle is given in [rad]; for prismatic joints, the displacement is given in [mm]. */ 'joint_position': Array; 'details'?: ExecuteDetails; } /** * @type ExecuteDetails */ type ExecuteDetails = { kind: 'JOGGING'; } & JoggingDetails | { kind: 'TRAJECTORY'; } & TrajectoryDetails; /** * @type ExecuteJoggingRequest */ type ExecuteJoggingRequest = InitializeJoggingRequest | JointVelocityRequest | PauseJoggingRequest | TcpVelocityRequest; /** * @type ExecuteJoggingResponse */ type ExecuteJoggingResponse = { kind: 'INITIALIZE_RECEIVED'; } & InitializeJoggingResponse | { kind: 'JOINT_VELOCITY_RECEIVED'; } & JointVelocityResponse | { kind: 'MOTION_ERROR'; } & MovementErrorResponse | { kind: 'PAUSE_RECEIVED'; } & PauseJoggingResponse | { kind: 'TCP_VELOCITY_RECEIVED'; } & TcpVelocityResponse; /** * @type ExecuteTrajectoryRequest */ type ExecuteTrajectoryRequest = InitializeMovementRequest | PauseMovementRequest | PlaybackSpeedRequest | StartMovementRequest; /** * @type ExecuteTrajectoryResponse */ type ExecuteTrajectoryResponse = { kind: 'INITIALIZE_RECEIVED'; } & InitializeMovementResponse | { kind: 'MOTION_ERROR'; } & MovementErrorResponse | { kind: 'PAUSE_RECEIVED'; } & PauseMovementResponse | { kind: 'PLAYBACK_SPEED_RECEIVED'; } & PlaybackSpeedResponse | { kind: 'START_RECEIVED'; } & StartMovementResponse; /** * @type ExecuteWaypointJoggingRequest */ type ExecuteWaypointJoggingRequest = InitializeJoggingRequest | JointWaypointsRequest | PauseJoggingRequest | PoseWaypointsRequest; /** * @type ExecuteWaypointJoggingResponse */ type ExecuteWaypointJoggingResponse = { kind: 'INITIALIZE_RECEIVED'; } & InitializeJoggingResponse | { kind: 'JOINT_WAYPOINTS_RECEIVED'; } & JointWaypointsResponse | { kind: 'MOTION_ERROR'; } & MovementErrorResponse | { kind: 'PAUSE_RECEIVED'; } & PauseJoggingResponse | { kind: 'POSE_WAYPOINTS_RECEIVED'; } & PoseWaypointsResponse; /** * A datapoint inside external joint stream. */ interface ExternalJointStreamDatapoint { /** * The unique identifier of the motion group. */ 'motion_group': string; 'value': MotionGroupJoints; } interface ExternalJointStreamRequest { 'states': Array; } /** * The configuration of a physical FANUC robot controller has to contain IP address of the controller. */ interface FanucController { 'kind': FanucControllerKindEnum; 'controller_ip': string; } declare const FanucControllerKindEnum: { readonly FanucController: "FanucController"; }; type FanucControllerKindEnum = typeof FanucControllerKindEnum[keyof typeof FanucControllerKindEnum]; /** * This error is returned when a joint position limit is exceeded. The joint index denotes which joint is out of its limits, starting with 0 and followed by the full joint position. */ interface FeedbackAxisRangeExceeded { 'joint_index'?: number; 'joint_position'?: Array; 'error_feedback_name': FeedbackAxisRangeExceededErrorFeedbackNameEnum; } declare const FeedbackAxisRangeExceededErrorFeedbackNameEnum: { readonly FeedbackAxisRangeExceeded: "FeedbackAxisRangeExceeded"; }; type FeedbackAxisRangeExceededErrorFeedbackNameEnum = typeof FeedbackAxisRangeExceededErrorFeedbackNameEnum[keyof typeof FeedbackAxisRangeExceededErrorFeedbackNameEnum]; interface FeedbackCollision { 'collisions'?: Array; 'joint_position'?: Array; 'tcp_pose'?: Pose; 'error_feedback_name': FeedbackCollisionErrorFeedbackNameEnum; } declare const FeedbackCollisionErrorFeedbackNameEnum: { readonly FeedbackCollision: "FeedbackCollision"; }; type FeedbackCollisionErrorFeedbackNameEnum = typeof FeedbackCollisionErrorFeedbackNameEnum[keyof typeof FeedbackCollisionErrorFeedbackNameEnum]; /** * No commands have been provided in the plan request. */ interface FeedbackCommandsMissing { 'error_feedback_name': FeedbackCommandsMissingErrorFeedbackNameEnum; } declare const FeedbackCommandsMissingErrorFeedbackNameEnum: { readonly FeedbackCommandsMissing: "FeedbackCommandsMissing"; }; type FeedbackCommandsMissingErrorFeedbackNameEnum = typeof FeedbackCommandsMissingErrorFeedbackNameEnum[keyof typeof FeedbackCommandsMissingErrorFeedbackNameEnum]; /** * The path parameter provided in the cubic spline command is not increasing at a certain index. */ interface FeedbackCubicSplineIsNotIncreasing { 'index'?: number; 'previous_value'?: number; 'current_value'?: number; 'error_feedback_name': FeedbackCubicSplineIsNotIncreasingErrorFeedbackNameEnum; } declare const FeedbackCubicSplineIsNotIncreasingErrorFeedbackNameEnum: { readonly FeedbackCubicSplineIsNotIncreasing: "FeedbackCubicSplineIsNotIncreasing"; }; type FeedbackCubicSplineIsNotIncreasingErrorFeedbackNameEnum = typeof FeedbackCubicSplineIsNotIncreasingErrorFeedbackNameEnum[keyof typeof FeedbackCubicSplineIsNotIncreasingErrorFeedbackNameEnum]; /** * The first pose provided in the cubic spline command is not the same as the end pose of the preceeding command. */ interface FeedbackCubicSplineNotAtStartPose { 'first_spline_pose'?: Pose; 'start_pose'?: Pose; 'error_feedback_name': FeedbackCubicSplineNotAtStartPoseErrorFeedbackNameEnum; } declare const FeedbackCubicSplineNotAtStartPoseErrorFeedbackNameEnum: { readonly FeedbackCubicSplineNotAtStartPose: "FeedbackCubicSplineNotAtStartPose"; }; type FeedbackCubicSplineNotAtStartPoseErrorFeedbackNameEnum = typeof FeedbackCubicSplineNotAtStartPoseErrorFeedbackNameEnum[keyof typeof FeedbackCubicSplineNotAtStartPoseErrorFeedbackNameEnum]; /** * No ptp motion to the target exists that fulfills the direction constraint. */ interface FeedbackDirectionConstraintNoSolutionExists { 'target_joint_position'?: Array; 'error_feedback_name': FeedbackDirectionConstraintNoSolutionExistsErrorFeedbackNameEnum; } declare const FeedbackDirectionConstraintNoSolutionExistsErrorFeedbackNameEnum: { readonly FeedbackDirectionConstraintNoSolutionExists: "FeedbackDirectionConstraintNoSolutionExists"; }; type FeedbackDirectionConstraintNoSolutionExistsErrorFeedbackNameEnum = typeof FeedbackDirectionConstraintNoSolutionExistsErrorFeedbackNameEnum[keyof typeof FeedbackDirectionConstraintNoSolutionExistsErrorFeedbackNameEnum]; /** * The provided joint position does not satisfy the direction constraint. */ interface FeedbackDirectionConstraintNotMet { 'invalid_joint_position'?: Array; 'error_feedback_name': FeedbackDirectionConstraintNotMetErrorFeedbackNameEnum; } declare const FeedbackDirectionConstraintNotMetErrorFeedbackNameEnum: { readonly FeedbackDirectionConstraintNotMet: "FeedbackDirectionConstraintNotMet"; }; type FeedbackDirectionConstraintNotMetErrorFeedbackNameEnum = typeof FeedbackDirectionConstraintNotMetErrorFeedbackNameEnum[keyof typeof FeedbackDirectionConstraintNotMetErrorFeedbackNameEnum]; /** * The provided direction constraint is not normalized. */ interface FeedbackDirectionConstraintNotNormalized { /** * A three-dimensional vector [x, y, z] with double precision. */ 'direction_constraint'?: Array; 'error_feedback_name': FeedbackDirectionConstraintNotNormalizedErrorFeedbackNameEnum; } declare const FeedbackDirectionConstraintNotNormalizedErrorFeedbackNameEnum: { readonly FeedbackDirectionConstraintNotNormalized: "FeedbackDirectionConstraintNotNormalized"; }; type FeedbackDirectionConstraintNotNormalizedErrorFeedbackNameEnum = typeof FeedbackDirectionConstraintNotNormalizedErrorFeedbackNameEnum[keyof typeof FeedbackDirectionConstraintNotNormalizedErrorFeedbackNameEnum]; /** * Some vector provided in the plan command has an invalid number of entries. */ interface FeedbackInvalidDof { /** * This structure describes a set of joint values, e.g., positions, currents, torques, of a motion group. Float precision is the default. */ 'joint_position'?: Array; 'motion_group_dof'?: number; 'error_feedback_name': FeedbackInvalidDofErrorFeedbackNameEnum; } declare const FeedbackInvalidDofErrorFeedbackNameEnum: { readonly FeedbackInvalidDof: "FeedbackInvalidDof"; }; type FeedbackInvalidDofErrorFeedbackNameEnum = typeof FeedbackInvalidDofErrorFeedbackNameEnum[keyof typeof FeedbackInvalidDofErrorFeedbackNameEnum]; /** * Some vector provided in the plan command contains not-a-number (NaN). */ interface FeedbackInvalidNanValue { 'value'?: Array; 'error_feedback_name': FeedbackInvalidNanValueErrorFeedbackNameEnum; } declare const FeedbackInvalidNanValueErrorFeedbackNameEnum: { readonly FeedbackInvalidNanValue: "FeedbackInvalidNanValue"; }; type FeedbackInvalidNanValueErrorFeedbackNameEnum = typeof FeedbackInvalidNanValueErrorFeedbackNameEnum[keyof typeof FeedbackInvalidNanValueErrorFeedbackNameEnum]; /** * The provided sampling time is invalid. It has to be a positive number. */ interface FeedbackInvalidSamplingTime { 'sampling_time'?: number; 'error_feedback_name': FeedbackInvalidSamplingTimeErrorFeedbackNameEnum; } declare const FeedbackInvalidSamplingTimeErrorFeedbackNameEnum: { readonly FeedbackInvalidSamplingTime: "FeedbackInvalidSamplingTime"; }; type FeedbackInvalidSamplingTimeErrorFeedbackNameEnum = typeof FeedbackInvalidSamplingTimeErrorFeedbackNameEnum[keyof typeof FeedbackInvalidSamplingTimeErrorFeedbackNameEnum]; /** * This error is returned when a joint position limit is exceeded. The joint index denotes which joint is out of its limits, starting with 0 and followed by the full joint position. */ interface FeedbackJointLimitExceeded { 'joint_index'?: number; 'joint_position'?: Array; 'error_feedback_name': FeedbackJointLimitExceededErrorFeedbackNameEnum; } declare const FeedbackJointLimitExceededErrorFeedbackNameEnum: { readonly FeedbackJointLimitExceeded: "FeedbackJointLimitExceeded"; }; type FeedbackJointLimitExceededErrorFeedbackNameEnum = typeof FeedbackJointLimitExceededErrorFeedbackNameEnum[keyof typeof FeedbackJointLimitExceededErrorFeedbackNameEnum]; /** * Moving to the requested TCP pose would change the robot\'s configuration. */ interface FeedbackNoSolutionInCurrentConfiguration { 'invalid_tcp_pose'?: Pose; 'error_feedback_name': FeedbackNoSolutionInCurrentConfigurationErrorFeedbackNameEnum; } declare const FeedbackNoSolutionInCurrentConfigurationErrorFeedbackNameEnum: { readonly FeedbackNoSolutionInCurrentConfiguration: "FeedbackNoSolutionInCurrentConfiguration"; }; type FeedbackNoSolutionInCurrentConfigurationErrorFeedbackNameEnum = typeof FeedbackNoSolutionInCurrentConfigurationErrorFeedbackNameEnum[keyof typeof FeedbackNoSolutionInCurrentConfigurationErrorFeedbackNameEnum]; /** * Requested TCP pose is outside of motion group\'s workspace. */ interface FeedbackOutOfWorkspace { 'invalid_tcp_pose'?: Pose; 'error_feedback_name': FeedbackOutOfWorkspaceErrorFeedbackNameEnum; } declare const FeedbackOutOfWorkspaceErrorFeedbackNameEnum: { readonly FeedbackOutOfWorkspace: "FeedbackOutOfWorkspace"; }; type FeedbackOutOfWorkspaceErrorFeedbackNameEnum = typeof FeedbackOutOfWorkspaceErrorFeedbackNameEnum[keyof typeof FeedbackOutOfWorkspaceErrorFeedbackNameEnum]; /** * A singularity is a point in the robot\'s workspace where the robot loses one or more degrees of freedom with regards to moving its TCP. This means the robot cannot move or rotate the TCP in a certain direction from this specific point. Use PTP motions if possible. They will almost never fail due to singularities (only if the target point is at a singularity). Alternatively change the robot TCP\'s path to avoid moving through this point or try to move the TCP through this point in a different direction. */ interface FeedbackSingularity { 'singularity_type'?: SingularityTypeEnum; 'singular_joint_position'?: Array; 'error_feedback_name': FeedbackSingularityErrorFeedbackNameEnum; } declare const FeedbackSingularityErrorFeedbackNameEnum: { readonly FeedbackSingularity: "FeedbackSingularity"; }; type FeedbackSingularityErrorFeedbackNameEnum = typeof FeedbackSingularityErrorFeedbackNameEnum[keyof typeof FeedbackSingularityErrorFeedbackNameEnum]; /** * The provided start joints have an incorrect dimension. */ interface FeedbackStartJointsMissing { 'start_joints_dof'?: number; 'motion_group_dof'?: number; 'error_feedback_name': FeedbackStartJointsMissingErrorFeedbackNameEnum; } declare const FeedbackStartJointsMissingErrorFeedbackNameEnum: { readonly FeedbackStartJointsMissing: "FeedbackStartJointsMissing"; }; type FeedbackStartJointsMissingErrorFeedbackNameEnum = typeof FeedbackStartJointsMissingErrorFeedbackNameEnum[keyof typeof FeedbackStartJointsMissingErrorFeedbackNameEnum]; /** * The trajectory cannot be planned because the torque limit would be exceeded. */ interface FeedbackTorqueExceeded { 'torque_value'?: number; 'torque_limit'?: number; 'error_feedback_name': FeedbackTorqueExceededErrorFeedbackNameEnum; } declare const FeedbackTorqueExceededErrorFeedbackNameEnum: { readonly FeedbackTorqueExceeded: "FeedbackTorqueExceeded"; }; type FeedbackTorqueExceededErrorFeedbackNameEnum = typeof FeedbackTorqueExceededErrorFeedbackNameEnum[keyof typeof FeedbackTorqueExceededErrorFeedbackNameEnum]; interface Flag { 'active': boolean; } interface FlangePayload { /** * A readable name for the flange payload. */ 'name': string; /** * Mass of payload in [kg]. */ 'mass': number; /** * A three-dimensional vector [x, y, z] with double precision. */ 'center_of_mass'?: Array; /** * A three-dimensional vector [x, y, z] with double precision. */ 'moment_of_inertia'?: Array; } interface FloatValue { /** * Value of an analog input/output in floating number representation. */ 'value': number; 'value_type': FloatValueValueTypeEnum; } declare const FloatValueValueTypeEnum: { readonly Float: "float"; }; type FloatValueValueTypeEnum = typeof FloatValueValueTypeEnum[keyof typeof FloatValueValueTypeEnum]; interface ForwardKinematics422Response { 'detail'?: Array; } interface ForwardKinematicsRequest { /** * Identifies a single motion group model. See [getMotionGroupModels](#/operations/getMotionGroupModels) for supported types. */ 'motion_group_model': string; /** * List of joint positions for which TCP poses are computed. The unit depends on the type of joint: For revolute joints, the angle is given in [rad]; for prismatic joints, the displacement is given in [mm]. */ 'joint_positions': Array>; 'tcp_offset'?: Pose; /** * Offset from the world frame to the motion group base. */ 'mounting'?: Pose; } interface ForwardKinematicsResponse { /** * List of computed TCP poses corresponding to the input joint positions. */ 'tcp_poses': Array; } interface ForwardKinematicsValidationError { 'loc': Array; 'msg': string; 'type': string; 'input': { [key: string]: any; }; 'data'?: ErrorInvalidJointCount; } interface GetTrajectoryResponse { /** * Unique identifier of the motion group the trajectory is planned for. */ 'motion_group': string; /** * The trajectory consisting of a list of joint positions and an equal number of corresponding timestamps. */ 'trajectory': JointTrajectory; /** * Unique identifier of the tool the trajectory is planned for. */ 'tcp': string; } interface HTTPValidationError { 'detail'?: Array; } /** * Input/Output boolean value representation. */ interface IOBooleanValue { /** * Unique identifier of the input/output. */ 'io': string; /** * Value of a digital input/output. */ 'value': boolean; 'value_type': IOBooleanValueValueTypeEnum; } declare const IOBooleanValueValueTypeEnum: { readonly Boolean: "boolean"; }; type IOBooleanValueValueTypeEnum = typeof IOBooleanValueValueTypeEnum[keyof typeof IOBooleanValueValueTypeEnum]; /** * @type IOBoundary */ type IOBoundary = { value_type: 'boolean'; } & BooleanValue | { value_type: 'float'; } & FloatValue | { value_type: 'integer'; } & IntegerValue; interface IODescription { /** * Unique identifier of the input/output. */ 'io': string; /** * Name of the input/output. Customize it on the physical controller or in the virtual robot specification. */ 'name': string; /** * Name of the input/output group. Customize it on the physical controller or in the virtual robot specification. */ 'group'?: string; 'direction': IODirection; 'value_type': IOValueType; 'unit'?: UnitType; 'min'?: IOBoundary; 'max'?: IOBoundary; } /** * Identifies the input/output type. */ declare const IODirection: { readonly IoTypeInput: "IO_TYPE_INPUT"; readonly IoTypeOutput: "IO_TYPE_OUTPUT"; }; type IODirection = typeof IODirection[keyof typeof IODirection]; interface IOFloatValue { /** * Unique identifier of the input/output. */ 'io': string; /** * Value of an analog input/output in floating number representation. */ 'value': number; 'value_type': IOFloatValueValueTypeEnum; } declare const IOFloatValueValueTypeEnum: { readonly Float: "float"; }; type IOFloatValueValueTypeEnum = typeof IOFloatValueValueTypeEnum[keyof typeof IOFloatValueValueTypeEnum]; interface IOIntegerValue { /** * Unique identifier of the input/output. */ 'io': string; /** * Value of an input/output with integer representation. > The integral value is transmitted as a string to avoid precision loss during conversion to JSON. > Recommended: Use int64 in your implementation. If you want to interact with int64 in numbers, > JS bigint libraries can help you to parse the string into an integral value. */ 'value': string; 'value_type': IOIntegerValueValueTypeEnum; } declare const IOIntegerValueValueTypeEnum: { readonly Integer: "integer"; }; type IOIntegerValueValueTypeEnum = typeof IOIntegerValueValueTypeEnum[keyof typeof IOIntegerValueValueTypeEnum]; /** * States the source of the input/output signal. */ declare const IOOrigin: { readonly Controller: "CONTROLLER"; readonly BusIo: "BUS_IO"; }; type IOOrigin = typeof IOOrigin[keyof typeof IOOrigin]; /** * @type IOValue */ type IOValue = { value_type: 'boolean'; } & IOBooleanValue | { value_type: 'float'; } & IOFloatValue | { value_type: 'integer'; } & IOIntegerValue; /** * Data type of the input/output. */ declare const IOValueType: { readonly IoValueBoolean: "IO_VALUE_BOOLEAN"; readonly IoValueAnalogFloat: "IO_VALUE_ANALOG_FLOAT"; readonly IoValueAnalogInteger: "IO_VALUE_ANALOG_INTEGER"; }; type IOValueType = typeof IOValueType[keyof typeof IOValueType]; /** * User provided credentials for creating a secret to pull an image from a registry. */ interface ImageCredentials { 'registry': string; 'user': string; 'password': string; } /** * Indicates that the trajectory contains an inconsistent number of joint positions, times, or locations. */ interface InconsistentTrajectorySizeError { 'kind': InconsistentTrajectorySizeErrorKindEnum; 'inconsistent_trajectory_size'?: InconsistentTrajectorySizeErrorInconsistentTrajectorySize; } declare const InconsistentTrajectorySizeErrorKindEnum: { readonly InconsistentTrajectorySizeError: "InconsistentTrajectorySizeError"; }; type InconsistentTrajectorySizeErrorKindEnum = typeof InconsistentTrajectorySizeErrorKindEnum[keyof typeof InconsistentTrajectorySizeErrorKindEnum]; interface InconsistentTrajectorySizeErrorInconsistentTrajectorySize { 'joint_position_size'?: number; 'times_size'?: number; 'locations_size'?: number; } /** * Inertia tensor components in kg⋅mm² */ interface InertiaTensor { /** * Inertia tensor component Ixx */ 'xx': number; /** * Inertia tensor component Iyy */ 'yy': number; /** * Inertia tensor component Izz */ 'zz': number; /** * Inertia tensor component Ixy */ 'xy': number; /** * Inertia tensor component Ixz */ 'xz': number; /** * Inertia tensor component Iyz */ 'yz': number; } /** * Send this message to start jogging a motion group. */ interface InitializeJoggingRequest { /** * Type specifier for server, set automatically. */ 'message_type': InitializeJoggingRequestMessageTypeEnum; /** * Identifier of the motion group. */ 'motion_group': string; /** * Identifier of the tool. Required for robots (all limits, including TCP limits, are respected at all times regardless of the motion). Not required for external axes. */ 'tcp'?: string; } declare const InitializeJoggingRequestMessageTypeEnum: { readonly InitializeJoggingRequest: "InitializeJoggingRequest"; }; type InitializeJoggingRequestMessageTypeEnum = typeof InitializeJoggingRequestMessageTypeEnum[keyof typeof InitializeJoggingRequestMessageTypeEnum]; /** * Acknowledgment to an InitializeJoggingRequest. */ interface InitializeJoggingResponse { /** * Error message in case of invalid InitializeJoggingRequest. */ 'message'?: string; 'kind': InitializeJoggingResponseKindEnum; } declare const InitializeJoggingResponseKindEnum: { readonly InitializeReceived: "INITIALIZE_RECEIVED"; }; type InitializeJoggingResponseKindEnum = typeof InitializeJoggingResponseKindEnum[keyof typeof InitializeJoggingResponseKindEnum]; /** * Sets up connection by locking a trajectory for execution. The robot controller mode is set to control mode. ATTENTION: This request has to be sent before any StartMovementRequest is sent. If initializing the movement was successful, no further movements can be initialized. To execute another trajectory, another connection has to be established. */ interface InitializeMovementRequest { /** * Type specifier for server, set automatically. */ 'message_type': InitializeMovementRequestMessageTypeEnum; 'trajectory': InitializeMovementRequestTrajectory; /** * - The location is a scalar value that defines a position along a path, typically ranging from 0 to `n`, where `n` denotes the number of motion commands - Each integer value of the location corresponds to a specific motion command, while non-integer values interpolate positions within the segments. - The location is calculated from the joint path */ 'initial_location'?: number; /** * Unique identifier addressing a coordinate system to which the responses are transformed. If not set, world coordinate system is used. */ 'response_coordinate_system'?: string; /** * If the flag is `true`, controller limits are ignored. Changes to controller limits are not applied to the trajectory. */ 'ignore_controller_limits'?: boolean; } declare const InitializeMovementRequestMessageTypeEnum: { readonly InitializeMovementRequest: "InitializeMovementRequest"; }; type InitializeMovementRequestMessageTypeEnum = typeof InitializeMovementRequestMessageTypeEnum[keyof typeof InitializeMovementRequestMessageTypeEnum]; /** * @type InitializeMovementRequestTrajectory * The trajectory which should be executed and locked to the connection. */ type InitializeMovementRequestTrajectory = TrajectoryData | TrajectoryId; /** * Response for InitializeMovementRequest message. */ interface InitializeMovementResponse { /** * Error message in case of invalid InitializeMovementRequest. */ 'message'?: string; /** * Error can occur if joint trajectory was added by InitializeMovementRequest and the trajectory is invalid. */ 'add_trajectory_error'?: AddTrajectoryError; 'kind': InitializeMovementResponseKindEnum; } declare const InitializeMovementResponseKindEnum: { readonly InitializeReceived: "INITIALIZE_RECEIVED"; }; type InitializeMovementResponseKindEnum = typeof InitializeMovementResponseKindEnum[keyof typeof InitializeMovementResponseKindEnum]; /** * Value of an input/output with integer representation. > The integral value is transmitted as a string to avoid precision loss during conversion to JSON. > Recommended: Use int64 in your implementation. If you want to interact with int64 in numbers, > JS bigint libraries can help you to parse the string into an integral value. */ interface IntegerValue { 'value': string; 'value_type': IntegerValueValueTypeEnum; } declare const IntegerValueValueTypeEnum: { readonly Integer: "integer"; }; type IntegerValueValueTypeEnum = typeof IntegerValueValueTypeEnum[keyof typeof IntegerValueValueTypeEnum]; interface InvalidDofError { 'kind': InvalidDofErrorKindEnum; 'invalid_dof'?: InvalidDofErrorInvalidDof; } declare const InvalidDofErrorKindEnum: { readonly InvalidDofError: "InvalidDofError"; }; type InvalidDofErrorKindEnum = typeof InvalidDofErrorKindEnum[keyof typeof InvalidDofErrorKindEnum]; interface InvalidDofErrorInvalidDof { /** * The valid degrees of freedom for the motion group. */ 'valid_dof'?: number; /** * The joint position that is out of its limits. */ 'joint_position'?: Array; } interface InverseFeedbackAtIndex { 'error_feedback': InverseFeedbackAtIndexErrorFeedback; 'error_index': number; } /** * @type InverseFeedbackAtIndexErrorFeedback */ type InverseFeedbackAtIndexErrorFeedback = FeedbackAxisRangeExceeded | FeedbackCollision | FeedbackJointLimitExceeded | FeedbackOutOfWorkspace | FeedbackSingularity; interface InverseKinematics422Response { 'detail'?: Array; } interface InverseKinematicsRequest { /** * Identifies a single motion group model. See [getMotionGroupModels](#/operations/getMotionGroupModels) for supported types. */ 'motion_group_model': string; /** * List of TCP poses for which the inverse solutions are computed. */ 'tcp_poses': Array; 'tcp_offset'?: Pose; /** * Offset from the world frame to the motion group base. */ 'mounting'?: Pose; /** * Joint position limits, indexed starting from base. The unit depends on the type of joint: For revolute joints, the limit is given in [rad]; for prismatic joints, it is given in [mm]. */ 'joint_position_limits'?: Array; /** * Collision layers to be respected by the motion planner when planning for a single motion group. Each setup represents one layer, e.g., the safety zones and shapes or a fine grained tool and workpiece model. Layers are checked individually along the trajectory and independently of other layers. To respect the safety zones of the controller and check for collision: 1. Fetch the safety zones, link and tool shapes from the controller. 2. Add the fetched zones, links and tools to a layer. 3. Create other layers from your own 3D data as needed. 4. Plan trajectory. 5. The response highlights the layer in which a collision was detected by key. */ 'collision_setups'?: { [key: string]: CollisionSetup; }; 'reference_joint_position'?: Array; } interface InverseKinematicsResponse { 'joints': Array>>; } interface InverseKinematicsValidationError { 'loc': Array; 'msg': string; 'type': string; 'input': { [key: string]: any; }; 'data'?: InverseKinematicsValidationErrorAllOfData; } /** * @type InverseKinematicsValidationErrorAllOfData * Optional data further specifying the validation error. */ type InverseKinematicsValidationErrorAllOfData = ErrorInvalidJointCount | ErrorJointLimitExceeded; /** * State of jogging execution. This state is sent during jogging movement, response-rate closest to the nearest multiple of controller step-rate but not exceeding the configured rate. The jogging state can be one of the following: - RUNNING: Jogging is active. - PAUSED_BY_USER: User has paused jogging. - PAUSED_NEAR_JOINT_LIMIT: Jogging was paused because a joint is near its limit. - PAUSED_NEAR_COLLISION: Jogging was paused because the motion group neared a collision. - PAUSED_NEAR_SINGULARITY: Jogging was paused because the motion group neared a singularity or the workspace boundary. - PAUSED_ON_IO: Jogging was paused because of an I/O event. */ interface JoggingDetails { 'state': JoggingDetailsState; /** * Timestamp of the current jogger session in milliseconds. Only waypoint sessions are supported. Other sessions return 0. > **NOTE** > > This field is experimental and its behavior may change in future releases. */ 'jogger_session_timestamp_ms'?: number; 'kind': JoggingDetailsKindEnum; } declare const JoggingDetailsKindEnum: { readonly Jogging: "JOGGING"; }; type JoggingDetailsKindEnum = typeof JoggingDetailsKindEnum[keyof typeof JoggingDetailsKindEnum]; /** * @type JoggingDetailsState */ type JoggingDetailsState = { kind: 'PAUSED_BY_USER'; } & JoggingPausedByUser | { kind: 'PAUSED_NEAR_COLLISION'; } & JoggingPausedNearCollision | { kind: 'PAUSED_NEAR_JOINT_LIMIT'; } & JoggingPausedNearJointLimit | { kind: 'PAUSED_NEAR_SINGULARITY'; } & JoggingPausedNearSingularity | { kind: 'PAUSED_ON_IO'; } & JoggingPausedOnIO | { kind: 'RUNNING'; } & JoggingRunning; /** * User has paused jogging. */ interface JoggingPausedByUser { 'kind': JoggingPausedByUserKindEnum; } declare const JoggingPausedByUserKindEnum: { readonly PausedByUser: "PAUSED_BY_USER"; }; type JoggingPausedByUserKindEnum = typeof JoggingPausedByUserKindEnum[keyof typeof JoggingPausedByUserKindEnum]; /** * Jogging was paused because the motion group neared a collision. */ interface JoggingPausedNearCollision { 'kind': JoggingPausedNearCollisionKindEnum; 'description': string; } declare const JoggingPausedNearCollisionKindEnum: { readonly PausedNearCollision: "PAUSED_NEAR_COLLISION"; }; type JoggingPausedNearCollisionKindEnum = typeof JoggingPausedNearCollisionKindEnum[keyof typeof JoggingPausedNearCollisionKindEnum]; /** * Jogging was paused because a joint is near its limit. */ interface JoggingPausedNearJointLimit { 'kind': JoggingPausedNearJointLimitKindEnum; 'joint_indices': Array; } declare const JoggingPausedNearJointLimitKindEnum: { readonly PausedNearJointLimit: "PAUSED_NEAR_JOINT_LIMIT"; }; type JoggingPausedNearJointLimitKindEnum = typeof JoggingPausedNearJointLimitKindEnum[keyof typeof JoggingPausedNearJointLimitKindEnum]; /** * Jogging was paused because the motion group neared a singularity or the workspace boundary. */ interface JoggingPausedNearSingularity { 'kind': JoggingPausedNearSingularityKindEnum; 'description': string; } declare const JoggingPausedNearSingularityKindEnum: { readonly PausedNearSingularity: "PAUSED_NEAR_SINGULARITY"; }; type JoggingPausedNearSingularityKindEnum = typeof JoggingPausedNearSingularityKindEnum[keyof typeof JoggingPausedNearSingularityKindEnum]; /** * Jogging was paused because of an I/O event. */ interface JoggingPausedOnIO { 'kind': JoggingPausedOnIOKindEnum; } declare const JoggingPausedOnIOKindEnum: { readonly PausedOnIo: "PAUSED_ON_IO"; }; type JoggingPausedOnIOKindEnum = typeof JoggingPausedOnIOKindEnum[keyof typeof JoggingPausedOnIOKindEnum]; /** * Jogging is active. */ interface JoggingRunning { 'kind': JoggingRunningKindEnum; } declare const JoggingRunningKindEnum: { readonly Running: "RUNNING"; }; type JoggingRunningKindEnum = typeof JoggingRunningKindEnum[keyof typeof JoggingRunningKindEnum]; interface JointLimitExceededError { 'kind': JointLimitExceededErrorKindEnum; 'joint_limit_exceeded'?: FeedbackJointLimitExceeded; } declare const JointLimitExceededErrorKindEnum: { readonly JointLimitExceededError: "JointLimitExceededError"; }; type JointLimitExceededErrorKindEnum = typeof JointLimitExceededErrorKindEnum[keyof typeof JointLimitExceededErrorKindEnum]; interface JointLimits { 'position'?: LimitRange; 'velocity'?: number; 'acceleration'?: number; /** * > **NOTE** > > This limit type is experimental and its behavior may change in future releases. */ 'jerk'?: number; 'torque'?: number; } interface JointPTPMotion { 'start_joint_position': Array; 'target_joint_position': Array; 'limits_override'?: LimitsOverride; } interface JointTrajectory { /** * List of joint positions for each sample. The number of samples must match the number of timestamps provided in the times field. The unit depends on the type of joint: For revolute joints, the angle is given in [rad]; for prismatic joints, the displacement is given in [mm]. */ 'joint_positions': Array>; /** * Timestamp for each sample [s]. */ 'times': Array; 'locations': Array; } declare const JointTypeEnum: { readonly RevoluteJoint: "REVOLUTE_JOINT"; readonly PrismaticJoint: "PRISMATIC_JOINT"; }; type JointTypeEnum = typeof JointTypeEnum[keyof typeof JointTypeEnum]; /** * Sets target joint velocities for jogging a motion group. */ interface JointVelocityRequest { /** * Type specifier for server, set automatically. */ 'message_type': JointVelocityRequestMessageTypeEnum; /** * This structure describes a set of joint values, e.g., positions, currents, torques, of a motion group. Float precision is the default. */ 'velocity': Array; } declare const JointVelocityRequestMessageTypeEnum: { readonly JointVelocityRequest: "JointVelocityRequest"; }; type JointVelocityRequestMessageTypeEnum = typeof JointVelocityRequestMessageTypeEnum[keyof typeof JointVelocityRequestMessageTypeEnum]; /** * Acknowledgment to a JointVelocityRequest. */ interface JointVelocityResponse { /** * Error message in case of invalid JointVelocityRequest. */ 'message'?: string; 'kind': JointVelocityResponseKindEnum; } declare const JointVelocityResponseKindEnum: { readonly JointVelocityReceived: "JOINT_VELOCITY_RECEIVED"; }; type JointVelocityResponseKindEnum = typeof JointVelocityResponseKindEnum[keyof typeof JointVelocityResponseKindEnum]; /** * A waypoint in joint space for jogging. > **NOTE** > > This type is experimental and its behavior may change in future releases. */ interface JointWaypoint { /** * Time since session start for when this waypoint should be reached [ms]. */ 'timestamp': number; /** * This structure describes a set of joint values, e.g., positions, currents, torques, of a motion group. Float precision is the default. */ 'joints': Array; } /** * Adds joint waypoints to the jogging queue. The robot will try to move through each waypoint by best effort. Existing waypoints in the queue that are older than the first new timestamp will be removed. The first message of this kind starts an internal clock. The current session timestamp is reported in `execute.details.jogger_session_timestamp_ms` of the [streamRobotControllerState](#/operations/streamRobotControllerState) endpoint. This can be used for realtime action chunk streaming, e.g., from a Vision-Language-Action (VLA) model. > **NOTE** > > This jogging type is experimental and its behavior may change in future releases. */ interface JointWaypointsRequest { /** * Type specifier for server, set automatically. */ 'message_type': JointWaypointsRequestMessageTypeEnum; /** * List of joint waypoints. */ 'waypoints': Array; } declare const JointWaypointsRequestMessageTypeEnum: { readonly JointWaypointsRequest: "JointWaypointsRequest"; }; type JointWaypointsRequestMessageTypeEnum = typeof JointWaypointsRequestMessageTypeEnum[keyof typeof JointWaypointsRequestMessageTypeEnum]; /** * Acknowledgment to a JointWaypointsRequest. */ interface JointWaypointsResponse { /** * Error message in case of invalid JointWaypointsRequest. */ 'message'?: string; 'kind': JointWaypointsResponseKindEnum; } declare const JointWaypointsResponseKindEnum: { readonly JointWaypointsReceived: "JOINT_WAYPOINTS_RECEIVED"; }; type JointWaypointsResponseKindEnum = typeof JointWaypointsResponseKindEnum[keyof typeof JointWaypointsResponseKindEnum]; /** * A 6-DOF robot with spherical wrist has up to 8 inverse kinematics solutions for a given TCP pose (2^3 branches). Each branch represents one side of a kinematic singularity boundary. The three binary choices are shoulder, elbow, and wrist. > **NOTE** > > `FRONT`/`BACK`, `UP`/`DOWN`, `NO_FLIP`/`FLIP` are conventional > labels for the two sides of each branch. The labels describe the > typical geometric interpretation for common poses, but are not absolute spatial > directions. The labels are consistent within a given solver: The same physical > arm shape maps to the same branch value. The branch values are purely > geometric and describe the same physical configuration regardless of > vendor convention. */ interface KinematicBranch { 'wrist_branch': KinematicBranchWrist; 'elbow_branch': KinematicBranchElbow; 'shoulder_branch': KinematicBranchShoulder; } declare const KinematicBranchElbow: { readonly Up: "UP"; readonly Down: "DOWN"; }; type KinematicBranchElbow = typeof KinematicBranchElbow[keyof typeof KinematicBranchElbow]; declare const KinematicBranchShoulder: { readonly Front: "FRONT"; readonly Back: "BACK"; }; type KinematicBranchShoulder = typeof KinematicBranchShoulder[keyof typeof KinematicBranchShoulder]; declare const KinematicBranchWrist: { readonly Flip: "FLIP"; readonly NoFlip: "NO_FLIP"; }; type KinematicBranchWrist = typeof KinematicBranchWrist[keyof typeof KinematicBranchWrist]; /** * Vendor-independent kinematic configuration for 6-DOF industrial robots with spherical wrist. Combines the discrete branch selection with optional per-joint axis range constraints. */ interface KinematicConfiguration { 'kinematic_branch': KinematicBranch; 'axis_ranges'?: Array; } /** * Kinematics model described by Denavit-Hartenberg parameters. */ interface KinematicModel { 'dh_parameters'?: Array; /** * Constant coordinate transformation between the motion group base frame and the start of the kinematic chain modeled by Denavit-Hartenberg parameters. */ 'kinematic_chain_offset'?: Pose; /** * Constant coordinate transformation between the end of the kinematic chain modelled by Denavit-Hartenberg parameters and the flange frame. This can be used, e.g., to ensure that the flange frame has a certain orientation. */ 'flange_offset'?: Pose; /** * Optional name of the inverse kinematics solver. */ 'inverse_solver'?: string; } /** * A KUKA E6POS pose combined with status/turn kinematic configuration data. */ interface KukaConfiguredPose { 'pose': KukaPose; 'status_and_turn_bits': KukaStatusAndTurnBits; } /** * The configuration of a physical KUKA robot controller has to contain an IP address. Additionally an RSI server configuration has to be specified in order to control the robot. Deploying the server is a functionality of this API. */ interface KukaController { 'kind': KukaControllerKindEnum; 'controller_ip': string; 'controller_port': number; 'rsi_server': KukaControllerRsiServer; /** * If true, uses slower cycle time of 12ms instead of 4ms. */ 'slow_cycle_rate'?: boolean; } declare const KukaControllerKindEnum: { readonly KukaController: "KukaController"; }; type KukaControllerKindEnum = typeof KukaControllerKindEnum[keyof typeof KukaControllerKindEnum]; /** * The RSI server runs inside of the cell. */ interface KukaControllerRsiServer { 'ip': string; 'port': number; } /** * KUKA E6POS position and Euler ZYX intrinsic orientation. Position in [mm], orientation as A (Z), B (Y\'), C (X\'\') in degrees. */ interface KukaPose { /** * X position in mm. */ 'x': number; /** * Y position in mm. */ 'y': number; /** * Z position in mm. */ 'z': number; /** * Rotation around Z axis in degrees. */ 'a': number; /** * Rotation around Y\' axis in degrees. */ 'b': number; /** * Rotation around X\'\' axis in degrees. */ 'c': number; } /** * KUKA status/turn kinematic configuration bits. S (3-bit status): Encodes shoulder, elbow, and wrist configuration. T (6-bit turn): Encodes axis angle signs for A1-A6. */ interface KukaStatusAndTurnBits { /** * 3 status bits: - Bit 0 (Shoulder): 0 = `LEFT`, 1 = `RIGHT` - Bit 1 (Elbow): 0 = `UP`, 1 = `DOWN` - Bit 2 (Wrist): 0 = `NO_FLIP`, 1 = `FLIP` */ 's': number; /** * 6 turn bits: - Bits 0-5: Encode the sign of axes A1-A6. - Bit N = 0: axis N+1 angle >= 0 deg - Bit N = 1: axis N+1 angle < 0 deg */ 't': number; } interface License { /** * Name of the licensed product. */ 'product_name': string; /** * Mail address of the license owner. */ 'owner_email': string; /** * Identification key of the license. */ 'license_key': string; /** * Expiration date of the license. */ 'license_expiry_date'?: string; /** * End date of grace period, given if instance is not connected to internet. */ 'grace_period_expiry_date': string; /** * Amount of times the license was activated. */ 'consumed_activations': number; /** * Amount of times the license can be activated. */ 'allowed_activations': number; /** * Feature limitations of the license. */ 'feature_limitations'?: { [key: string]: number; }; /** * Features enabled by a license. */ 'feature_flags'?: Array; 'status': LicenseStatus; } /** * Status of the license. */ interface LicenseStatus { 'status': LicenseStatusEnum; 'message': string; } declare const LicenseStatusEnum: { readonly Ok: "OK"; readonly Expired: "EXPIRED"; readonly Suspended: "SUSPENDED"; readonly GracePeriodOver: "GRACE_PERIOD_OVER"; readonly NotFound: "NOT_FOUND"; }; type LicenseStatusEnum = typeof LicenseStatusEnum[keyof typeof LicenseStatusEnum]; /** * The upper_limit must be greater then the lower_limit. */ interface LimitRange { 'lower_limit'?: number; 'upper_limit'?: number; } interface LimitSet { 'joints'?: Array; 'tcp'?: CartesianLimits; 'elbow'?: CartesianLimits; 'flange'?: CartesianLimits; 'coupled_shoulder_elbow_joint'?: JointLimits; } /** * If a limit is not set, the default value will be used. */ interface LimitsOverride { /** * Maximum joint velocity in [rad/s] for each joint. Either leave this field empty or set a value for each joint. */ 'joint_velocity_limits'?: Array; /** * Maximum joint acceleration in [rad/s^2] for each joint. Either leave this field empty or set a value for each joint. */ 'joint_acceleration_limits'?: Array; /** * Maximum joint jerk in [rad/s^3] for each joint. Either leave this field empty or set a value for each joint. > **NOTE** > > This limit type is experimental and its behavior may change in future releases. */ 'joint_jerk_limits'?: Array; /** * Maximum allowed TCP velocity in [mm/s]. */ 'tcp_velocity_limit'?: number; /** * Maximum allowed TCP acceleration in [mm/s^2]. */ 'tcp_acceleration_limit'?: number; /** * Maximum allowed TCP jerk in [mm/s^3]. > **NOTE** > > This limit type is experimental and its behavior may change in future releases. */ 'tcp_jerk_limit'?: number; /** * Maximum allowed TCP rotation velocity in [rad/s]. */ 'tcp_orientation_velocity_limit'?: number; /** * Maximum allowed TCP rotation acceleration in [rad/s^2]. */ 'tcp_orientation_acceleration_limit'?: number; /** * Maximum allowed TCP rotation jerk in [rad/s^3]. > **NOTE** > > This limit type is experimental and its behavior may change in future releases. */ 'tcp_orientation_jerk_limit'?: number; } /** * An inline link chain wrapped for discriminator support. */ interface LinkChainValue { /** * Discriminator value indicating an inline value. */ 'source': LinkChainValueSourceEnum; /** * A link chain is a kinematic chain of links that is connected via joints. A motion group can be used to control the motion of the joints in a link chain. A link is a group of colliders that is attached to the link reference frame. The reference frame of a link is obtained after applying all sets of Denavit-Hartenberg-parameters from base to (including) the link index. This means that the reference frame of the link is on the rotation axis of the next joint in the kinematic chain. Example: For a motion group with 2 joints, the collider reference frame (CRF) for link 1 is on the rotation axis of joint 2. The chain looks like: - Origin >> Mounting >> Base >> (CRF Base) Joint 0 >> Link 0 >> (CRF Link 0) Joint 1 >> Link 1 >> (CRF Link 1) Flange (CRF Tool) >> TCP Adjacent links in the kinematic chain of the motion group are not checked for mutual collision. */ 'link_chain': Array<{ [key: string]: Collider; }>; } declare const LinkChainValueSourceEnum: { readonly Value: "value"; }; type LinkChainValueSourceEnum = typeof LinkChainValueSourceEnum[keyof typeof LinkChainValueSourceEnum]; /** * @type LinkChainValueOrKey * Either an inline link chain or a storage key referencing a stored link chain. Discriminated by the \"source\" property. */ type LinkChainValueOrKey = { source: 'key'; } & StorageKey | { source: 'value'; } & LinkChainValue; interface ListTrajectoriesResponse { /** * Identifiers of trajectories which are currently cached. Use [addTrajectory](#/operations/addTrajectory) to add a new trajectory. Adding trajectories is necessary to execute them. Trajectories are removed if the corresponding motion group or controller disconnects. */ 'trajectories'?: Array; } declare const Manufacturer: { readonly Abb: "abb"; readonly Fanuc: "fanuc"; readonly Kuka: "kuka"; readonly Staubli: "staubli"; readonly Universalrobots: "universalrobots"; readonly Yaskawa: "yaskawa"; }; type Manufacturer = typeof Manufacturer[keyof typeof Manufacturer]; interface MergeTrajectories422Response { 'detail'?: Array; } interface MergeTrajectoriesError { 'error_feedback': MergeTrajectoriesErrorErrorFeedback; /** * - The location is a scalar value that defines a position along a path, typically ranging from 0 to `n`, where `n` denotes the number of motion commands - Each integer value of the location corresponds to a specific motion command, while non-integer values interpolate positions within the segments. - The location is calculated from the joint path */ 'error_location_on_trajectory': number; } /** * @type MergeTrajectoriesErrorErrorFeedback */ type MergeTrajectoriesErrorErrorFeedback = FeedbackCollision | FeedbackJointLimitExceeded | FeedbackOutOfWorkspace | FeedbackSingularity; interface MergeTrajectoriesRequest { /** * The motion group setup required for collision checking and timescaling. */ 'motion_group_setup': MotionGroupSetup; /** * List of trajectory segments to merge together. Each segment contains a trajectory with its own limits override, blending configuration and collision setup. */ 'trajectory_segments': Array; } interface MergeTrajectoriesResponse { /** * The merged joint trajectory. If a blending was requested on a segment but could not be applied, the trajectory is merged without blending. The feedback will contain further information on why blending could not be applied. */ 'joint_trajectory'?: JointTrajectory; /** * For each blending, feedback will either contain the section in which the trajectory deviates from the original path, or an error message stating why blending could not be applied. The response will include `trajectory_segments` - 1 elements. If no blending was requested at the corresponding segment, the feedback will be a null section where `start_location == end_location`. */ 'feedback'?: Array; } /** * @type MergeTrajectoriesResponseFeedbackInner */ type MergeTrajectoriesResponseFeedbackInner = MergeTrajectoriesError | TrajectorySection; interface MergeTrajectoriesSegment { /** * The trajectory segment to merge. Both the time and location arrays must start at 0 and be strictly increasing. */ 'trajectory': JointTrajectory; /** * Limits override is used to override the global limits of the motion group for the blending at the end of this segment. */ 'limits_override'?: LimitsOverride; /** * Blending configuration for merging this trajectory segment with the next one. Specifies how the end of this trajectory should be blended with the start of the next trajectory. Ignored for the last segment. */ 'blending'?: BlendingPosition; /** * Collision layers to be respected by the motion planner when planning for a single motion group. Each setup represents one layer, e.g., the safety zones and shapes or a fine grained tool and workpiece model. Layers are checked individually along the trajectory and independently of other layers. To respect the safety zones of the controller and check for collision: 1. Fetch the safety zones, link and tool shapes from the controller. 2. Add the fetched zones, links and tools to a layer. 3. Create other layers from your own 3D data as needed. 4. Plan trajectory. 5. The response highlights the layer in which a collision was detected by key. */ 'collision_setups'?: { [key: string]: CollisionSetup; }; } interface MergeTrajectoriesValidationError { 'loc': Array; 'msg': string; 'type': string; 'input': { [key: string]: any; }; /** * Optional data further specifying the merge validation error. */ 'data'?: ErrorInvalidJointCount; } interface MidpointInsertionAlgorithm { /** * Algorithm discriminator. Midpoint insertion algorithm configuration for collision-free path planning. This algorithm adds a single midpoint between the start and target joint position to find collision-free paths. */ 'algorithm_name': MidpointInsertionAlgorithmAlgorithmNameEnum; /** * Maximum number of iterations for the midpoint insertion algorithm. Higher values increase likelyhood of success, but also computation time (linear). */ 'max_iterations'?: number; } declare const MidpointInsertionAlgorithmAlgorithmNameEnum: { readonly MidpointInsertionAlgorithm: "MidpointInsertionAlgorithm"; }; type MidpointInsertionAlgorithmAlgorithmNameEnum = typeof MidpointInsertionAlgorithmAlgorithmNameEnum[keyof typeof MidpointInsertionAlgorithmAlgorithmNameEnum]; interface ModbusIO { /** * Descriptive name or note for the input/output variable. */ 'description': string; /** * The byte address of the input/output variable in the MODBUS device, e.g., NOVA\'s MODBUS service. Used to locate the input/output variable within the device\'s memory or data structure. */ 'address': number; 'type': ModbusIOTypeEnum; /** * The byte sequence of the input/output variable, indicating the order of bytes in memory for the MODBUS device, e.g., NOVA\'s MODBUS service. */ 'byte_order': ModbusIOByteOrder; /** * The area of the input/output variable, indicating the memory region it belongs to for the MODBUS device, e.g., NOVA\'s MODBUS service. */ 'area': ModbusIOArea; /** * The unique identifier for the input/output value. Used to reference the input/output variable in the MODBUS device, e.g., NOVA\'s MODBUS service. */ 'io': string; } /** * Area of the MODBUS input/output variable. Is used to interpret the corresponding bits correctly. */ declare const ModbusIOArea: { readonly ModbusIoAreaUnknown: "MODBUS_IO_AREA_UNKNOWN"; readonly ModbusIoAreaCoils: "MODBUS_IO_AREA_COILS"; readonly ModbusIoAreaDiscreteInputs: "MODBUS_IO_AREA_DISCRETE_INPUTS"; readonly ModbusIoAreaHoldingRegisters: "MODBUS_IO_AREA_HOLDING_REGISTERS"; readonly ModbusIoAreaInputRegisters: "MODBUS_IO_AREA_INPUT_REGISTERS"; }; type ModbusIOArea = typeof ModbusIOArea[keyof typeof ModbusIOArea]; /** * Byte order of the MODBUS input/output variable. Used to interpret the corresponding bits correctly. */ declare const ModbusIOByteOrder: { readonly ModbusIoByteOrderUnknown: "MODBUS_IO_BYTE_ORDER_UNKNOWN"; readonly ModbusIoByteOrderAbcd: "MODBUS_IO_BYTE_ORDER_ABCD"; readonly ModbusIoByteOrderBadc: "MODBUS_IO_BYTE_ORDER_BADC"; readonly ModbusIoByteOrderCdab: "MODBUS_IO_BYTE_ORDER_CDAB"; readonly ModbusIoByteOrderDcba: "MODBUS_IO_BYTE_ORDER_DCBA"; }; type ModbusIOByteOrder = typeof ModbusIOByteOrder[keyof typeof ModbusIOByteOrder]; interface ModbusIOData { /** * Descriptive name or note for the input/output variable. */ 'description': string; /** * The byte address of the input/output variable in the MODBUS device, e.g., NOVA\'s MODBUS service. Used to locate the input/output variable within the device\'s memory or data structure. */ 'address': number; 'type': ModbusIOTypeEnum; /** * The byte sequence of the input/output variable, indicating the order of bytes in memory for the MODBUS device, e.g., NOVA\'s MODBUS service. */ 'byte_order': ModbusIOByteOrder; /** * The area of the input/output variable, indicating the memory region it belongs to for the MODBUS device, e.g., NOVA\'s MODBUS service. */ 'area': ModbusIOArea; } /** * Value type of the MODBUS input/output variable. Used to interpret the corresponding bits correctly. */ declare const ModbusIOTypeEnum: { readonly ModbusIoTypeUnknown: "MODBUS_IO_TYPE_UNKNOWN"; readonly ModbusIoTypeBool: "MODBUS_IO_TYPE_BOOL"; readonly ModbusIoTypeUint16: "MODBUS_IO_TYPE_UINT16"; readonly ModbusIoTypeFloat32: "MODBUS_IO_TYPE_FLOAT32"; }; type ModbusIOTypeEnum = typeof ModbusIOTypeEnum[keyof typeof ModbusIOTypeEnum]; interface ModelError { 'code'?: string; 'message': string; } interface MotionCommand { 'blending'?: MotionCommandBlending; /** * Limits override is used to override the global limits of the motion group for this segment of the motion. */ 'limits_override'?: LimitsOverride; 'path': MotionCommandPath; } /** * @type MotionCommandBlending * Blending alters the TCP path at the target point of a motion command to ensure that the velocity does not drop to zero between two motion commands. */ type MotionCommandBlending = BlendingAuto | BlendingPosition; /** * @type MotionCommandPath */ type MotionCommandPath = PathCartesianPTP | PathCircle | PathCubicSpline | PathDirectionConstrainedCartesianPTP | PathDirectionConstrainedJointPTP | PathJointPTP | PathLine; /** * The configuration of a motion-group used for motion planning. The parameters `mounting`, `kinematic_chain_offset`, `dh_parameters`, `flange_offset` and `tcp_offset` are used to model the kinematic structure of the motion group. They can be used to compute the coordinate transformations from world to tcp frame: [world frame] -> mounting -> [base frame] -> kinematic chain offset + motion group kinematics (Denavit-Hartenberg parameters) -> [end of kinematic chain frame] -> flange_offset -> [flange frame] -> tcp_offset -> [tcp frame]. */ interface MotionGroupDescription { /** * Identifies a single motion group model. See [getMotionGroupModels](#/operations/getMotionGroupModels) for supported types. */ 'motion_group_model': string; /** * The offset from the world frame to the motion group base. */ 'mounting'?: Pose; /** * Maps a TCP name to its offset relative to the flange coordinate system. Key must be a TCP identifier. Values are TcpOffsets. */ 'tcps'?: { [key: string]: TcpOffset; }; /** * A collection of identifiable colliders. */ 'safety_zones'?: { [key: string]: Collider; }; /** * The shape of the MotionGroups links to validate against safety zones. Indexed along the kinematic chain, starting with a static base shape before first joint. */ 'safety_link_colliders'?: Array<{ [key: string]: Collider; }>; /** * Maps a TCP name to its tool collider. Key must be a TCP identifier. Values are ColliderDictionaries that make up the shape of one tool to validate against safety zones. */ 'safety_tool_colliders'?: { [key: string]: { [key: string]: Collider; }; }; 'operation_limits': OperationLimits; /** * Maps a payload name to its configuration. Key must be a payload identifier. Values are payload objects. */ 'payloads'?: { [key: string]: Payload; }; /** * [ms] cycle time of the motion group controller. A trajectory for this motion group should be computed to this resolution. */ 'cycle_time'?: number; /** * The Denavit-Hartenberg parameters describing the motion group kinematics. */ 'dh_parameters'?: Array; /** * Constant coordinate transformation between the motion group base frame and the start of the kinematic chain modelled by Denavit-Hartenberg parameters. Unlike the mounting, which is used to set the actual position and orientation of the motion group within a cell, this offset is fixed. It is part of the description of the kinematical structure of the motion group. */ 'kinematic_chain_offset'?: Pose; /** * Constant coordinate transformation between the end of the kinematic chain modelled by Denavit-Hartenberg parameters and the flange frame. This can be used, e.g., to ensure that the flange frame has a certain orientation. */ 'flange_offset'?: Pose; /** * The serial number of the motion group, if available. If not available, the serial number of the robot controller. If not available, empty. */ 'serial_number'?: string; /** * Revision number of the motion group description. The revision is incremented whenever the motion group description changes due to a modification of the tools or the payloads in the robot configuration. The robot controller is polled every 10 s in Monitoring Mode to detect those changes. Use to detect changes since the last retrieval. */ 'description_revision'?: number; } interface MotionGroupFromJson { /** * Unique identifier for the motion group to be added. */ 'motion_group': string; /** * Full JSON configuration of the virtual robot controller. This can be obtained from the physical controller\'s configuration via [getVirtualControllerConfiguration](#/operations/getVirtualControllerConfiguration). */ 'json_data': string; /** * The identifier of the motion group that needs to be extracted from the provided JSON configuration. */ 'extracted_motion_group_id': string; /** * Initial joint position of the added motion group. Provides the joint position as a JSON array of float values in radians, where the array length must match the robot\'s degrees of freedom (DOF), e.g., `\"[0, 0, 0, 0, 0, 0]\"` for a 6-DOF robot. If the provided array length does not match the robot\'s DOF, the array will be adjusted: if it is longer, extra values will be truncated; if it is shorter, missing values will be filled with zeros. */ 'initial_joint_position'?: string; } interface MotionGroupFromType { /** * Unique identifier for the motion group to be added. */ 'motion_group': string; /** * Identifies a single motion group model. See [getMotionGroupModels](#/operations/getMotionGroupModels) for supported types. */ 'motion_group_model': string; /** * Initial joint position of the added motion group. Provides the joint position as a JSON array of float values in radians, where the array length must match the robot\'s degrees of freedom (DOF), e.g., `\"[0, 0, 0, 0, 0, 0]\"` for a 6-DOF robot. If the provided array length does not match the robot\'s DOF, the array will be adjusted; if it is longer, extra values will be truncated; if it is shorter, missing values will be filled with zeros. */ 'initial_joint_position'?: string; } interface MotionGroupInfo { /** * The unique identifier of the motion group. Use it to refer to the motion group in other calls. */ 'motion_group': string; /** * The name of the motion group for display purposes. */ 'name': string; /** * The number of joints aka degrees of freedom in the motion group. */ 'dof': number; } /** * Ensure to provide one value for each joint. See [getMotionGroups](#/operations/getMotionGroups) for the number of joints. Everything but positions is optional. */ interface MotionGroupJoints { /** * The joint positions of the motion group. */ 'positions': Array; /** * The joint velocities of the motion group. */ 'velocities'?: Array; /** * The joint accelerations of the motion group. */ 'accelerations'?: Array; /** * The joint torques of the motion group. */ 'torques'?: Array; } /** * Metadata about a motion group model. */ interface MotionGroupModelDescription { /** * Identifier of the motion group model. */ 'name': string; 'manufacturer': Manufacturer; /** * Readable name for the motion group model. */ 'readable_name'?: string; /** * Indicates whether this motion group model is a user-defined custom model or a built-in base model. */ 'is_custom': boolean; } interface MotionGroupSetup { /** * Identifies a single motion group model. See [getMotionGroupModels](#/operations/getMotionGroupModels) for supported types. */ 'motion_group_model': string; /** * [ms] cycle time of the motion group controller. A trajectory for this motion group should be computed to this resolution. */ 'cycle_time': number; /** * The offset from the world frame to the motion group base. */ 'mounting'?: Pose; 'tcp_offset'?: Pose; 'global_limits'?: LimitSet; 'payload'?: Payload; /** * Collision layers to be respected by the motion planner when planning for a single motion group. Each setup represents one layer, e.g., the safety zones and shapes or a fine grained tool and workpiece model. Layers are checked individually along the trajectory and independently of other layers. To respect the safety zones of the controller and check for collision: 1. Fetch the safety zones, link and tool shapes from the controller. 2. Add the fetched zones, links and tools to a layer. 3. Create other layers from your own 3D data as needed. 4. Plan trajectory. 5. The response highlights the layer in which a collision was detected by key. */ 'collision_setups'?: { [key: string]: CollisionSetup; }; } /** * Presents the current state of the motion group. */ interface MotionGroupState { /** * Timestamp for when data was received from the robot controller. */ 'timestamp': string; /** * Sequence number of the controller state. It starts with 0 upon establishing the connection with a physical controller. The sequence number is reset when the connection to the physical controller is closed and re-established. */ 'sequence_number': number; /** * Identifier of the motion group. */ 'motion_group': string; /** * Convenience: Identifier of the robot controller the motion group is attached to. */ 'controller': string; /** * This structure describes a set of joint values, e.g., positions, currents, torques, of a motion group. Float precision is the default. */ 'joint_position': Array; /** * Indicates whether the joint is in a limit for all joints of the motion group. */ 'joint_limit_reached': MotionGroupStateJointLimitReached; /** * This structure describes a set of joint values, e.g., positions, currents, torques, of a motion group. Float precision is the default. */ 'joint_torque'?: Array; /** * This structure describes a set of joint values, e.g., positions, currents, torques, of a motion group. Float precision is the default. */ 'joint_current'?: Array; /** * Pose of the flange. Positions are in [mm]. Orientations are in [rad]. The pose is relative to the response_coordinate_system specified in the request. For robot arms, a flange pose is always returned. For positioners, the flange might not be available, depending on the model. */ 'flange_pose'?: Pose; /** * Unique identifier addressing the active TCP. Might not be returned for positioners as some do not support TCPs, depending on the model. */ 'tcp'?: string; /** * Pose of the TCP selected on the robot control panel. Positions are in [mm]. Orientations are in [rad]. The pose is relative to the response_coordinate_system specified in the request. Might not be returned for positioners as some do not support TCPs, depending on the model. */ 'tcp_pose'?: Pose; /** * Unique identifier addressing the reference coordinate system of the cartesian data. Might not be returned for positioners as some do not support TCPs, depending on the model. Default: world coordinate system of corresponding controller. */ 'coordinate_system'?: string; /** * Unique identifier addressing the active payload. Only fetchable via GET endpoint, not available in WebSocket. */ 'payload'?: string; /** * Indicates whether the motion group is in standstill. Convenience: Signals that NOVA treats measured joint velocities as 0. */ 'standstill': boolean; /** * Data that was commanded to the motion group. Includes additional data on NOVA\'s execution components for executing trajectories and jogging. This is a convenience field to indicate the last command sent to the motion group. It is not available in all cases, e.g., if the motion group is not moved by NOVA. */ 'execute'?: Execute; /** * Revision number of the motion group description. The revision is incremented whenever the motion group description changes due to a modification of the tools or the payloads in the robot configuration. The robot controller is polled every 10 s during Monitoring Mode to detect those changes. Use to trigger fetching based on robot configuration changes. */ 'description_revision': number; } /** * Indicates which joint of the motion group is in a limit. If a joint is in its limit, only this joint can be moved. Movements that affect any other joints are not executed. */ interface MotionGroupStateJointLimitReached { /** * If true, operational (soft) jointLimit is reached for specific joint. */ 'limit_reached': Array; } /** * Error message in case an error occurs during movement execution. */ interface MovementErrorResponse { /** * Detailed error message describing the issue encountered during movement execution. */ 'message': string; 'kind': MovementErrorResponseKindEnum; } declare const MovementErrorResponseKindEnum: { readonly MotionError: "MOTION_ERROR"; }; type MovementErrorResponseKindEnum = typeof MovementErrorResponseKindEnum[keyof typeof MovementErrorResponseKindEnum]; interface MultiCollisionSetup { /** * A collection of collision motion groups. */ 'collision_motion_groups_by_motion_group_key'?: { [key: string]: CollisionMotionGroup; }; /** * A collection of identifiable colliders. */ 'colliders'?: { [key: string]: Collider; }; } /** * The provided joint data does not match the expected number of joints for the respective motion group. */ interface MultiErrorInvalidJointCount { 'invalid_joint_count_errors_by_motion_group_key'?: { [key: string]: ErrorInvalidJointCount; }; } /** * A reference joint position (start or target) exceeds the configured joint limits of the respective motion group. */ interface MultiErrorJointLimitExceeded { 'joint_limit_exceeded_errors_by_motion_group_key'?: { [key: string]: ErrorJointLimitExceeded; }; } /** * A reference joint position, e.g., start or target joint position, results in collisions that prevent processing. */ interface MultiErrorJointPositionCollision { 'collisions'?: Array; /** * A collection of single joint positions. */ 'joint_positions_by_motion_group_key'?: { [key: string]: Array; }; } interface MultiJointTrajectory { /** * A collection of joint position arrays. */ 'joint_positions_by_motion_group_key': { [key: string]: Array>; }; /** * Timestamp for each sample [s]. */ 'times': Array; 'locations': Array; } interface MultiSearchCollisionFree422Response { 'detail'?: Array; } interface MultiSearchCollisionFreeRequest { /** * A collection of motion group setups. */ 'motion_group_setups_by_motion_group_key': { [key: string]: MotionGroupSetup; }; /** * A collection of joint PTP path definitions. */ 'path_definitions_by_motion_group_key': { [key: string]: JointPTPMotion; }; /** * A collection of multi collision setups. */ 'collision_setups'?: { [key: string]: MultiCollisionSetup; }; /** * Configuration for the RRT-Connect algorithm (Rapidly-exploring Random Trees). */ 'algorithm_settings'?: RRTConnectAlgorithm; } interface MultiSearchCollisionFreeResponse { 'response'?: MultiSearchCollisionFreeResponseResponse; } /** * @type MultiSearchCollisionFreeResponseResponse * Dictionary of joint trajectories. */ type MultiSearchCollisionFreeResponseResponse = MultiJointTrajectory | PlanCollisionFreeFailedResponse; interface MultiSearchCollisionFreeValidationError { 'loc': Array; 'msg': string; 'type': string; 'input': { [key: string]: any; }; 'data'?: MultiSearchCollisionFreeValidationErrorAllOfData; } /** * @type MultiSearchCollisionFreeValidationErrorAllOfData * Optional data further specifying the validation error. */ type MultiSearchCollisionFreeValidationErrorAllOfData = ErrorMotionGroupKeyMismatch | MultiErrorInvalidJointCount | MultiErrorJointLimitExceeded | MultiErrorJointPositionCollision; interface NanValueError { 'kind': NanValueErrorKindEnum; 'nan_value'?: NanValueErrorNanValue; } declare const NanValueErrorKindEnum: { readonly NanValueError: "NanValueError"; }; type NanValueErrorKindEnum = typeof NanValueErrorKindEnum[keyof typeof NanValueErrorKindEnum]; /** * Requested joint position contains NaN values. */ interface NanValueErrorNanValue { /** * The joint position that is out of its limits. */ 'joint_position'?: Array; } interface NetworkDevice { /** * The IPv4 address assigned to the network device. */ 'ip': string; /** * The MAC address of the network device. */ 'mac': string; /** * The vendor of the network device. */ 'vendor'?: string; } interface NetworkInterface { /** * The name of the network interface. */ 'name': string; /** * The IPv4 address assigned to the network interface. */ 'ip': string; /** * The MAC address of the network interface. */ 'mac': string; /** * The CIDR notation of the network interface. Example: \"192.168.1.0/24\" */ 'cidr': string; } interface NetworkState { /** * Indicates whether the system is connected to the internet. */ 'internet_connected': boolean; /** * Type of the active network link (e.g., ethernet, wifi, cellular, vpn, unknown). */ 'connection_type'?: NetworkStateConnectionTypeEnum; /** * Received signal strength in dBm for wireless interfaces; negative values indicate weaker signals. */ 'signal_strength'?: number; /** * Normalized link quality metric from 0 (poor) to 1 (excellent) when provided by the interface. */ 'link_quality'?: number; /** * Round-trip latency to the probe endpoint measured in milliseconds. */ 'latency_ms'?: number; /** * Estimated downstream bandwidth in megabits per second based on the probe. */ 'bandwidth_mbps'?: number; } declare const NetworkStateConnectionTypeEnum: { readonly Ethernet: "ethernet"; readonly Wifi: "wifi"; readonly Cellular: "cellular"; readonly Vpn: "vpn"; readonly Unknown: "unknown"; }; type NetworkStateConnectionTypeEnum = typeof NetworkStateConnectionTypeEnum[keyof typeof NetworkStateConnectionTypeEnum]; /** * Controllers have two operating modes: AUTOMATIC and MANUAL. MANUAL mode is mainly used for teaching a robot application. To ensure safe operation the velocity of the robot is limited to 250 mm/s. Running the finished application is done in AUTOMATIC operating mode without the limited velocity of the MANUAL mode. */ interface OpMode { 'mode': OperationMode; } /** * The operating state. */ declare const OperatingState: { readonly Active: "ACTIVE"; readonly Inactive: "INACTIVE"; }; type OperatingState = typeof OperatingState[keyof typeof OperatingState]; interface OperationLimits { 'auto_limits'?: LimitSet; 'manual_limits'?: LimitSet; 'manual_t1_limits'?: LimitSet; 'manual_t2_limits'?: LimitSet; /** * Flag to indicate whether the TCP velocity limit is also applied for the elbow and flange in auto mode. */ 'safety_limit_elbow_flange_velocity_in_auto'?: boolean; } /** * Current operation mode of the configured robot controller. Operation modes in which the attached motion groups can be moved are: - OPERATION_MODE_MANUAL (if enabling switch is pressed) - OPERATION_MODE_MANUAL_T1 (if enabling switch is pressed) - OPERATION_MODE_MANUAL_T2 (if enabling switch is pressed) - OPERATION_MODE_AUTO (without needing to press enabling switch) All other modes are considered as non-operational. */ declare const OperationMode: { readonly OperationModeUnknown: "OPERATION_MODE_UNKNOWN"; readonly OperationModeNoController: "OPERATION_MODE_NO_CONTROLLER"; readonly OperationModeDisconnected: "OPERATION_MODE_DISCONNECTED"; readonly OperationModePowerOn: "OPERATION_MODE_POWER_ON"; readonly OperationModePending: "OPERATION_MODE_PENDING"; readonly OperationModeManual: "OPERATION_MODE_MANUAL"; readonly OperationModeManualT1: "OPERATION_MODE_MANUAL_T1"; readonly OperationModeManualT2: "OPERATION_MODE_MANUAL_T2"; readonly OperationModeAuto: "OPERATION_MODE_AUTO"; readonly OperationModeRecovery: "OPERATION_MODE_RECOVERY"; }; type OperationMode = typeof OperationMode[keyof typeof OperationMode]; /** * The type of rotation description that is used to specify the orientation. **Rotation Vector notation** * The rotation is represented using an axis-angle representation: > axis = Vector[0:2] > angle = |axis| in [rad] > axis.normalized * angle **Quaternion notation** * The rotation is represented using a unit quaternion: [x, y, z, w]. * The vector part [x, y, z] is the imaginary part of the quaternion, and the scalar part [w] is the real part. **Euler notation** * *extrinsic* fixed external reference system * *intrinsic* reference system fixed to rotation body > angles = Vector[0:2] in [rad]. * ZYX, ZXZ,... - mapping of the given angles values to the (either intrinsic or extrinsic) axes in the stated order. > Example ZYX: Z = Vector[0], Y = Vector[1], X = Vector[2]. */ declare const OrientationType: { readonly RotationVector: "ROTATION_VECTOR"; readonly Quaternion: "QUATERNION"; readonly EulerAnglesIntrinsicZxz: "EULER_ANGLES_INTRINSIC_ZXZ"; readonly EulerAnglesIntrinsicXyx: "EULER_ANGLES_INTRINSIC_XYX"; readonly EulerAnglesIntrinsicYzy: "EULER_ANGLES_INTRINSIC_YZY"; readonly EulerAnglesIntrinsicZyz: "EULER_ANGLES_INTRINSIC_ZYZ"; readonly EulerAnglesIntrinsicXzx: "EULER_ANGLES_INTRINSIC_XZX"; readonly EulerAnglesIntrinsicYxy: "EULER_ANGLES_INTRINSIC_YXY"; readonly EulerAnglesIntrinsicXyz: "EULER_ANGLES_INTRINSIC_XYZ"; readonly EulerAnglesIntrinsicYzx: "EULER_ANGLES_INTRINSIC_YZX"; readonly EulerAnglesIntrinsicZxy: "EULER_ANGLES_INTRINSIC_ZXY"; readonly EulerAnglesIntrinsicXzy: "EULER_ANGLES_INTRINSIC_XZY"; readonly EulerAnglesIntrinsicZyx: "EULER_ANGLES_INTRINSIC_ZYX"; readonly EulerAnglesIntrinsicYxz: "EULER_ANGLES_INTRINSIC_YXZ"; readonly EulerAnglesExtrinsicZxz: "EULER_ANGLES_EXTRINSIC_ZXZ"; readonly EulerAnglesExtrinsicXyx: "EULER_ANGLES_EXTRINSIC_XYX"; readonly EulerAnglesExtrinsicYzy: "EULER_ANGLES_EXTRINSIC_YZY"; readonly EulerAnglesExtrinsicZyz: "EULER_ANGLES_EXTRINSIC_ZYZ"; readonly EulerAnglesExtrinsicXzx: "EULER_ANGLES_EXTRINSIC_XZX"; readonly EulerAnglesExtrinsicYxy: "EULER_ANGLES_EXTRINSIC_YXY"; readonly EulerAnglesExtrinsicZyx: "EULER_ANGLES_EXTRINSIC_ZYX"; readonly EulerAnglesExtrinsicXzy: "EULER_ANGLES_EXTRINSIC_XZY"; readonly EulerAnglesExtrinsicYxz: "EULER_ANGLES_EXTRINSIC_YXZ"; readonly EulerAnglesExtrinsicYzx: "EULER_ANGLES_EXTRINSIC_YZX"; readonly EulerAnglesExtrinsicXyz: "EULER_ANGLES_EXTRINSIC_XYZ"; readonly EulerAnglesExtrinsicZxy: "EULER_ANGLES_EXTRINSIC_ZXY"; }; type OrientationType = typeof OrientationType[keyof typeof OrientationType]; /** * A cartesian point-to-point is representing a joint point-to-point motion from start point to the indicated target pose. The target pose is a joint point-to-point given in cartesian space. The target joint configuration will be calculated to be in the same kinematic configuration as the start point is. If that is not possible, planning will fail. Alternatively, a kinematic configuration can be provided to specify the target kinematic branch and axis ranges. The kinematic configuration can be obtained from [convertVendorConfiguredPose](#/operations/convertVendorConfiguredPose). > **NOTE** > > The `kinematic_configuration` property is experimental and its structure or behavior may change in future releases. */ interface PathCartesianPTP { 'target_pose': Pose; 'kinematic_configuration'?: KinematicConfiguration; 'path_definition_name': PathCartesianPTPPathDefinitionNameEnum; } declare const PathCartesianPTPPathDefinitionNameEnum: { readonly PathCartesianPtp: "PathCartesianPTP"; }; type PathCartesianPTPPathDefinitionNameEnum = typeof PathCartesianPTPPathDefinitionNameEnum[keyof typeof PathCartesianPTPPathDefinitionNameEnum]; /** * A circular constructs a circle in translative space from 1) the start position which is provided via position, and 2) the indicated target position. The orientation is calculated via a [bezier spline](https://en.wikipedia.org/wiki/B%C3%A9zier_curve) from start orientation to the indicated target orientation. The via point defines the control point for the bezier spline. Therefore, the control point will not be hit directly. */ interface PathCircle { 'via_pose': Pose; 'target_pose': Pose; 'path_definition_name': PathCirclePathDefinitionNameEnum; } declare const PathCirclePathDefinitionNameEnum: { readonly PathCircle: "PathCircle"; }; type PathCirclePathDefinitionNameEnum = typeof PathCirclePathDefinitionNameEnum[keyof typeof PathCirclePathDefinitionNameEnum]; /** * A [cubic spline](https://de.wikipedia.org/wiki/Spline-Interpolation) represents a cartesian cubic spline in translative and orientational space from start point to indicated target pose via control points. */ interface PathCubicSpline { 'parameters': Array; 'path_definition_name': PathCubicSplinePathDefinitionNameEnum; } declare const PathCubicSplinePathDefinitionNameEnum: { readonly PathCubicSpline: "PathCubicSpline"; }; type PathCubicSplinePathDefinitionNameEnum = typeof PathCubicSplinePathDefinitionNameEnum[keyof typeof PathCubicSplinePathDefinitionNameEnum]; /** * A direction-constrained cartesian point-to-point motion is a joint point-to-point motion to a target pose in cartesian space while satisfying a direction constraint. The direction constraint is defined by a vector in the world frame and a vector in the TCP frame. The constraint is satisfied when the vectors are aligned with each other. The vectors must be normalized. > **NOTE** > > This motion type is experimental and its behavior may change in future releases. */ interface PathDirectionConstrainedCartesianPTP { 'target_pose': ConstrainedPose; 'constraint': DirectionConstraint; 'path_definition_name': PathDirectionConstrainedCartesianPTPPathDefinitionNameEnum; } declare const PathDirectionConstrainedCartesianPTPPathDefinitionNameEnum: { readonly DirectionConstrainedCartesianPtp: "DirectionConstrainedCartesianPTP"; }; type PathDirectionConstrainedCartesianPTPPathDefinitionNameEnum = typeof PathDirectionConstrainedCartesianPTPPathDefinitionNameEnum[keyof typeof PathDirectionConstrainedCartesianPTPPathDefinitionNameEnum]; /** * A direction-constrained joint point-to-point motion is a direct motion in joint space while satisfying a direction constraint. The direction constraint is defined by a vector in the world frame and a vector in the TCP frame. The constraint is satisfied when the vectors are aligned with each other. The vectors must be normalized. > **NOTE** > > This motion type is experimental and its behavior may change in future releases. */ interface PathDirectionConstrainedJointPTP { 'target_joint_position': Array; 'constraint': DirectionConstraint; 'path_definition_name': PathDirectionConstrainedJointPTPPathDefinitionNameEnum; } declare const PathDirectionConstrainedJointPTPPathDefinitionNameEnum: { readonly DirectionConstrainedJointPtp: "DirectionConstrainedJointPTP"; }; type PathDirectionConstrainedJointPTPPathDefinitionNameEnum = typeof PathDirectionConstrainedJointPTPPathDefinitionNameEnum[keyof typeof PathDirectionConstrainedJointPTPPathDefinitionNameEnum]; /** * A joint point-to-point represents a line in joint space. All joints will be moved synchronously. */ interface PathJointPTP { 'target_joint_position': Array; 'path_definition_name': PathJointPTPPathDefinitionNameEnum; } declare const PathJointPTPPathDefinitionNameEnum: { readonly PathJointPtp: "PathJointPTP"; }; type PathJointPTPPathDefinitionNameEnum = typeof PathJointPTPPathDefinitionNameEnum[keyof typeof PathJointPTPPathDefinitionNameEnum]; /** * A line represents a straight line from start position to indicated target position. The orientation is calculated via a quaternion [slerp](https://en.wikipedia.org/wiki/Slerp) from start orientation to indicated target orientation. */ interface PathLine { 'target_pose': Pose; 'path_definition_name': PathLinePathDefinitionNameEnum; } declare const PathLinePathDefinitionNameEnum: { readonly PathLine: "PathLine"; }; type PathLinePathDefinitionNameEnum = typeof PathLinePathDefinitionNameEnum[keyof typeof PathLinePathDefinitionNameEnum]; /** * Request to pause jogging. If successful, `execute` jogging state in [MotionGroupState](MotionGroupState.yaml) is set to `PAUSED_BY_USER`. */ interface PauseJoggingRequest { /** * Type specifier for server, set automatically. */ 'message_type': PauseJoggingRequestMessageTypeEnum; } declare const PauseJoggingRequestMessageTypeEnum: { readonly PauseJoggingRequest: "PauseJoggingRequest"; }; type PauseJoggingRequestMessageTypeEnum = typeof PauseJoggingRequestMessageTypeEnum[keyof typeof PauseJoggingRequestMessageTypeEnum]; /** * Acknowledgment to a PauseJoggingRequest. */ interface PauseJoggingResponse { /** * Error message in case of invalid PauseJoggingRequest. */ 'message'?: string; 'kind': PauseJoggingResponseKindEnum; } declare const PauseJoggingResponseKindEnum: { readonly PauseReceived: "PAUSE_RECEIVED"; }; type PauseJoggingResponseKindEnum = typeof PauseJoggingResponseKindEnum[keyof typeof PauseJoggingResponseKindEnum]; /** * Request to pause the movement execution. Movement pauses as soon as a [Standstill](Standstill.yaml) is sent back to the client. Resume movement with StartMovementRequest. */ interface PauseMovementRequest { /** * Type specifier for server, set automatically. */ 'message_type': PauseMovementRequestMessageTypeEnum; } declare const PauseMovementRequestMessageTypeEnum: { readonly PauseMovementRequest: "PauseMovementRequest"; }; type PauseMovementRequestMessageTypeEnum = typeof PauseMovementRequestMessageTypeEnum[keyof typeof PauseMovementRequestMessageTypeEnum]; /** * Acknowledgment for PauseMovementRequest message. ATTENTION: No confirmation that the movement was paused. Confirmation that the PauseMovementRequest was received and is processed. End of movement execution is signalled by [state stream](#/operations/streamMotionGroupState) response. See TrajectoryDetails of details in execute. */ interface PauseMovementResponse { /** * Error message in case of invalid PauseMovementRequest. */ 'message'?: string; 'kind': PauseMovementResponseKindEnum; } declare const PauseMovementResponseKindEnum: { readonly PauseReceived: "PAUSE_RECEIVED"; }; type PauseMovementResponseKindEnum = typeof PauseMovementResponseKindEnum[keyof typeof PauseMovementResponseKindEnum]; /** * Defines an input/output that the motion will be paused for. The motion will stop gracefully on path. */ interface PauseOnIO { 'io': IOValue; /** * Comparator for the comparison of two values. Use the measured I/O as the base value (a) and the expected input/output value as the comparator (b): e.g., a > b. */ 'comparator': Comparator; 'io_origin': IOOrigin; } interface Payload { 'name': string; /** * Mass of payload in [kg]. */ 'payload': number; /** * A three-dimensional vector [x, y, z] with double precision. */ 'center_of_mass'?: Array; /** * A three-dimensional vector [x, y, z] with double precision. */ 'moment_of_inertia'?: Array; } interface Plan422Response { 'detail'?: Array; } /** * Response when collision-free trajectory planning fails. Contains specific feedback about why the planning failed. */ interface PlanCollisionFreeFailedResponse { 'error_feedback': ErrorMaxIterationsExceeded; } interface PlanCollisionFreeRequest { /** * The data to assemble the robot setup can be retrieved from the [getMotionGroupDescription](#/operations/getMotionGroupDescription) endpoint. */ 'motion_group_setup': MotionGroupSetup; /** * Collision layers with support for storage references. Each value is either a store key referencing a stored CollisionSetup, or an inline collision setup object with optional store key references. All storage keys are resolved against the {cell} path parameter of the request URL, which determines the storage bucket. If set on the request, overrides motion_group_setup.collision_setups. */ 'collision_setups'?: { [key: string]: CollisionSetupValueOrKey; }; 'start_joint_position': Array; 'target': Array; /** * Optional constraint for the motion. If provided, the motion will be constrained accordingly. > **NOTE** > > Constraints are experimental and their behavior may change in future releases. */ 'constraint'?: DirectionConstraint; 'algorithm': CollisionFreeAlgorithm; } /** * Response from collision-free trajectory planning. Contains either a successful joint trajectory or failure information. */ interface PlanCollisionFreeResponse { 'response': PlanCollisionFreeResponseResponse; } /** * @type PlanCollisionFreeResponseResponse */ type PlanCollisionFreeResponseResponse = JointTrajectory | PlanCollisionFreeFailedResponse; interface PlanTrajectoryFailedResponse { 'error_feedback': PlanTrajectoryFailedResponseErrorFeedback; /** * - The location is a scalar value that defines a position along a path, typically ranging from 0 to `n`, where `n` denotes the number of motion commands - Each integer value of the location corresponds to a specific motion command, while non-integer values interpolate positions within the segments. - The location is calculated from the joint path */ 'error_location_on_trajectory': number; /** * The joint trajectory from the start joint position to the error. */ 'joint_trajectory'?: JointTrajectory; } /** * @type PlanTrajectoryFailedResponseErrorFeedback */ type PlanTrajectoryFailedResponseErrorFeedback = FeedbackCollision | FeedbackCommandsMissing | FeedbackCubicSplineIsNotIncreasing | FeedbackCubicSplineNotAtStartPose | FeedbackDirectionConstraintNoSolutionExists | FeedbackDirectionConstraintNotMet | FeedbackDirectionConstraintNotNormalized | FeedbackInvalidDof | FeedbackInvalidNanValue | FeedbackInvalidSamplingTime | FeedbackJointLimitExceeded | FeedbackNoSolutionInCurrentConfiguration | FeedbackOutOfWorkspace | FeedbackSingularity | FeedbackStartJointsMissing | FeedbackTorqueExceeded; interface PlanTrajectoryRequest { /** * The data to assemble the robot setup can be retrieved from [getMotionGroupDescription](#/operations/getMotionGroupDescription) endpoint. */ 'motion_group_setup': MotionGroupSetup; 'start_joint_position': Array; /** * List of motion commands. A command consists of a path definition (line, circle, joint_ptp, cartesian_ptp, cubic_spline), blending, and limits override. */ 'motion_commands': Array; } interface PlanTrajectoryResponse { 'response': PlanTrajectoryResponseResponse; } /** * @type PlanTrajectoryResponseResponse */ type PlanTrajectoryResponseResponse = JointTrajectory | PlanTrajectoryFailedResponse; interface PlanValidationError { 'loc': Array; 'msg': string; 'type': string; 'input': { [key: string]: any; }; 'data'?: PlanValidationErrorAllOfData; } /** * @type PlanValidationErrorAllOfData * Optional data further specifying the validation error. */ type PlanValidationErrorAllOfData = ErrorDirectionConstraintNotMet | ErrorDirectionConstraintNotNormalized | ErrorInvalidJointCount | ErrorJointLimitExceeded | ErrorJointPositionCollision | ErrorUnsupportedOperation; /** * Defines an x/y-plane with infinite size. */ interface Plane { 'shape_type': PlaneShapeTypeEnum; } declare const PlaneShapeTypeEnum: { readonly Plane: "plane"; }; type PlaneShapeTypeEnum = typeof PlaneShapeTypeEnum[keyof typeof PlaneShapeTypeEnum]; /** * Sets velocity for executed movements of the motion, in percent. Send after initializing the connection with InitializeMovementRequest. */ interface PlaybackSpeedRequest { /** * Type specifier for server, set automatically. */ 'message_type': PlaybackSpeedRequestMessageTypeEnum; /** * Sets velocity for executed movements of the trajectory, in percent. 100% means that the motion group moves as fast as possible without violating any planning and motion group limits. Setting this value does not affect the overall shape of the velocity profile. The velocity profile of the trajectory is scaled down by the same factor. Therefore, this should only be used for teaching and trajectory evaluation purposes. To maintain a specific velocity, set the respective limits when planning the trajectory. */ 'playback_speed_in_percent': number; } declare const PlaybackSpeedRequestMessageTypeEnum: { readonly PlaybackSpeedRequest: "PlaybackSpeedRequest"; }; type PlaybackSpeedRequestMessageTypeEnum = typeof PlaybackSpeedRequestMessageTypeEnum[keyof typeof PlaybackSpeedRequestMessageTypeEnum]; /** * Acknowledgment for PlaybackSpeedRequest message. */ interface PlaybackSpeedResponse { /** * Error message in case of invalid PlaybackSpeedRequest. */ 'message'?: string; 'kind': PlaybackSpeedResponseKindEnum; } declare const PlaybackSpeedResponseKindEnum: { readonly PlaybackSpeedReceived: "PLAYBACK_SPEED_RECEIVED"; }; type PlaybackSpeedResponseKindEnum = typeof PlaybackSpeedResponseKindEnum[keyof typeof PlaybackSpeedResponseKindEnum]; /** * Defines a pose in 3D space. A pose is a combination of a position and an orientation. The position is applied before the orientation. */ interface Pose { /** * A three-dimensional vector [x, y, z] with double precision. */ 'position'?: Array; /** * Defines a rotation in 3D space. A three-dimensional Vector [rx, ry, rz] with double precision. Rotation is applied around the vector. The angle of rotation equals the length of the vector. */ 'orientation'?: Array; } /** * A waypoint in Cartesian space for jogging. > **NOTE** > > This type is experimental and its behavior may change in future releases. */ interface PoseWaypoint { /** * Time since session start for when this waypoint should be reached [ms]. */ 'timestamp': number; /** * Cartesian pose for this waypoint. */ 'pose': Pose; } /** * Adds pose waypoints to the jogging queue. The robot will try to move through each waypoint by best effort. Existing waypoints in the queue that are older than the first new timestamp will be removed. The first message of this kind starts an internal clock. The current session timestamp is reported in `execute.details.jogger_session_timestamp_ms` of the [streamRobotControllerState](#/operations/streamRobotControllerState) endpoint. This can be used for realtime action chunk streaming, e.g., from a Vision-Language-Action (VLA) model. > **NOTE** > > This jogging type is experimental and its behavior may change in future releases. */ interface PoseWaypointsRequest { /** * Type specifier for server, set automatically. */ 'message_type': PoseWaypointsRequestMessageTypeEnum; /** * List of pose waypoints. */ 'waypoints': Array; } declare const PoseWaypointsRequestMessageTypeEnum: { readonly PoseWaypointsRequest: "PoseWaypointsRequest"; }; type PoseWaypointsRequestMessageTypeEnum = typeof PoseWaypointsRequestMessageTypeEnum[keyof typeof PoseWaypointsRequestMessageTypeEnum]; /** * Acknowledgment to a PoseWaypointsRequest. */ interface PoseWaypointsResponse { /** * Error message in case of invalid PoseWaypointsRequest. */ 'message'?: string; 'kind': PoseWaypointsResponseKindEnum; } declare const PoseWaypointsResponseKindEnum: { readonly PoseWaypointsReceived: "POSE_WAYPOINTS_RECEIVED"; }; type PoseWaypointsResponseKindEnum = typeof PoseWaypointsResponseKindEnum[keyof typeof PoseWaypointsResponseKindEnum]; interface ProfinetDescription { /** * The vendor identifier of the PROFINET device, identifying the manufacturer. */ 'vendor_id': string; /** * The device identifier of the PROFINET device, identifying the specific device within the vendor\'s range. */ 'device_id': string; 'slots'?: Array; /** * Name of Station (NoS) of the PROFINET device. The NoS is used in combination with IPv4 record to identify your device in the PROFINET network. The `device_name` will be used as NoS if no REMA XML file is already present on your NOVA instance and no `rema_xml_content` is provided. */ 'device_name'?: string; 'ip_config'?: BusIOProfinetIpConfig; } interface ProfinetIO { /** * Descriptive name or note for the input/output variable. */ 'description': string; 'type': ProfinetIOTypeEnum; /** * The direction of the input/output variable, indicating whether it is an input or output for the PROFINET device, e.g., NOVA\'s PROFINET service. */ 'direction': ProfinetIODirection; /** * The byte address in the PROFINET device\'s process image, with offset 0. The slot is automatically determined based on this address and the configured slot layout. For example, with two slots of 64 bytes each: - Bytes 0-63: Slot 1 - Bytes 64-127: Slot 2 When importing from a tag table, e.g., TIA Portal, use `input_offset`/`output_offset` to convert global PLC addresses to device-local addresses: `device_byte_address` = `plc_byte_address` - offset */ 'byte_address': number; /** * The bit offset within the byte specified by `byte_address`. Only relevant for boolean/bit-type variables. Valid values are 0-7 (8 bits per byte). For byte/word/dword types, this field is typically omitted or set to 0. */ 'bit_address'?: number; /** * The unique identifier for the input/output value. This identifier is used to reference the specific input/output variable in the PROFINET device, e.g., NOVA\'s PROFINET service. */ 'io': string; } interface ProfinetIOData { /** * Descriptive name or note for the input/output variable. */ 'description': string; 'type': ProfinetIOTypeEnum; /** * The direction of the input/output variable, indicating whether it is an input or output for the PROFINET device, e.g., NOVA\'s PROFINET service. */ 'direction': ProfinetIODirection; /** * The byte address in the PROFINET device\'s process image, with offset 0. The slot is automatically determined based on this address and the configured slot layout. For example, with two slots of 64 bytes each: - Bytes 0-63: Slot 1 - Bytes 64-127: Slot 2 When importing from a tag table, e.g., TIA Portal, use `input_offset`/`output_offset` to convert global PLC addresses to device-local addresses: `device_byte_address` = `plc_byte_address` - offset */ 'byte_address': number; /** * The bit offset within the byte specified by `byte_address`. Only relevant for boolean/bit-type variables. Valid values are 0-7 (8 bits per byte). For byte/word/dword types, this field is typically omitted or set to 0. */ 'bit_address'?: number; } /** * The direction of the input/output variable, indicating whether it is an input or output for the PROFINET device, e.g., NOVA\'s PROFINET service. */ declare const ProfinetIODirection: { readonly ProfinetIoDirectionInput: "PROFINET_IO_DIRECTION_INPUT"; readonly ProfinetIoDirectionOutput: "PROFINET_IO_DIRECTION_OUTPUT"; readonly ProfinetIoDirectionInout: "PROFINET_IO_DIRECTION_INOUT"; }; type ProfinetIODirection = typeof ProfinetIODirection[keyof typeof ProfinetIODirection]; /** * Value type of the PROFINET input/output variable. Is used to interpret the corresponding bits correctly. */ declare const ProfinetIOTypeEnum: { readonly ProfinetIoTypeUnknown: "PROFINET_IO_TYPE_UNKNOWN"; readonly ProfinetIoTypeBool: "PROFINET_IO_TYPE_BOOL"; readonly ProfinetIoTypeUsint: "PROFINET_IO_TYPE_USINT"; readonly ProfinetIoTypeSint: "PROFINET_IO_TYPE_SINT"; readonly ProfinetIoTypeUint: "PROFINET_IO_TYPE_UINT"; readonly ProfinetIoTypeInt: "PROFINET_IO_TYPE_INT"; readonly ProfinetIoTypeUdint: "PROFINET_IO_TYPE_UDINT"; readonly ProfinetIoTypeDint: "PROFINET_IO_TYPE_DINT"; readonly ProfinetIoTypeReal: "PROFINET_IO_TYPE_REAL"; readonly ProfinetIoTypeLreal: "PROFINET_IO_TYPE_LREAL"; }; type ProfinetIOTypeEnum = typeof ProfinetIOTypeEnum[keyof typeof ProfinetIOTypeEnum]; interface ProfinetInputOutputConfig { /** * Content of the input/output variable configuration XML file. The XML File has to be embedded as a string by escaping quotes, line breaks and so forth. */ 'config': string; /** * Offset in bytes for the address of the input (perspective of the controller) variables. The offset will be subtracted from to the byte addresses of the sent XML content. */ 'input_offset': number; /** * Offset in bytes for the address of the output (perspective of the controller) variables. The offset will be subtracted from to the byte addresses of the sent XML content. */ 'output_offset': number; } /** * An array of PROFINET slots. PROFINET models each device’s input/output hardware as a hierarchy of slots (modules) and subslots (submodules). A slot can represent a physical or virtual input/output card and each subslot one of its individual channels or functions. Every slot and subslot has unique identifiers that the controller uses to map cyclic input/output data and parameter records to its process image. This slot/subslot separation enables e.g., addressing each input/output stream when establishing input/output application relations (I/O-AR). */ interface ProfinetSlotDescription { /** * The number/index of the PROFINET slot. Per default, slot 0 is reserved for the device access point (DAP). Slots that are part of the cyclic input/output data exchange start at number 1. */ 'number': number; /** * The application process identifier (API) number of the PROFINET input. The API identifies the application relation (AR) that is using the slot. */ 'api': number; /** * An array of PROFINET subslots. */ 'subslots': Array; } interface ProfinetSubSlotDescription { /** * The number/index of the PROFINET subslot. */ 'number': number; /** * The amount of bytes allocated for the subslot in the input process image buffer. */ 'input_length': number; /** * The amount of bytes allocated for the subslot in the output process image buffer. */ 'output_length': number; } /** * A program is a collection of instructions that are executed in the robot cell. */ interface Program { 'program': string; 'name'?: string; 'description'?: string; 'app': string; 'input_schema'?: object; 'preconditions'?: object; } /** * Holds the state of a program run. */ interface ProgramRun { /** * Unique identifier of the program run */ 'run': string; /** * Unique identifier of the program */ 'program': string; /** * Identifier of the app that produced the program run */ 'app'?: string; /** * State of the program run */ 'state': ProgramRunState; /** * Logs of the program run */ 'logs'?: string; /** * Stdout of the program run */ 'stdout'?: string; /** * Stderr of the program run */ 'stderr'?: string; /** * Error message of the program run, if any */ 'error'?: string; /** * Traceback of the program run, if any */ 'traceback'?: string; /** * Start time of the program run in RFC3339 format */ 'start_time'?: string; /** * End time of the program run in RFC3339 format */ 'end_time'?: string; /** * Input data of the program run */ 'input_data'?: object; } /** * The state of a program run. */ declare const ProgramRunState: { readonly Preparing: "PREPARING"; readonly Running: "RUNNING"; readonly Completed: "COMPLETED"; readonly Failed: "FAILED"; readonly Stopped: "STOPPED"; }; type ProgramRunState = typeof ProgramRunState[keyof typeof ProgramRunState]; /** * The state of a program run. */ interface ProgramStartRequest { /** * The arguments to pass to the program. */ 'arguments': object; } interface ProjectJointPositionDirectionConstraint422Response { 'detail'?: Array; } interface ProjectJointPositionDirectionConstraintRequest { /** * Identifies a single motion group model. See [getMotionGroupModels](#/operations/getMotionGroupModels) for supported types. */ 'motion_group_model': string; /** * List of joint positions for which the direction constraint is applied. */ 'joint_positions': Array>; 'constraint': DirectionConstraint; 'tcp_offset'?: Pose; /** * Offset from the world frame to the motion group base. */ 'mounting'?: Pose; /** * Joint position limits, indexed starting from base. The unit depends on the type of joint: For revolute joints, the limit is given in [rad]; for prismatic joints, it is given in [mm]. */ 'joint_position_limits'?: Array; /** * Collision layers to be respected by the motion planner when planning for a single motion group. Each setup represents one layer, e.g., the safety zones and shapes or a fine grained tool and workpiece model. Layers are checked individually along the trajectory and independently of other layers. To respect the safety zones of the controller and check for collision: 1. Fetch the safety zones, link and tool shapes from the controller. 2. Add the fetched zones, links and tools to a layer. 3. Create other layers from your own 3D data as needed. 4. Plan trajectory. 5. The response highlights the layer in which a collision was detected by key. */ 'collision_setups'?: { [key: string]: CollisionSetup; }; } interface ProjectJointPositionDirectionConstraintResponse { /** * List of projected joint positions. If the resulting joint position is in collision or violates joint limits, the corresponding entry is null. */ 'projected_joint_positions': Array | null>; } interface ProjectJointPositionDirectionConstraintValidationError { 'loc': Array; 'msg': string; 'type': string; 'input': { [key: string]: any; }; 'data'?: ProjectJointPositionDirectionConstraintValidationErrorAllOfData; } /** * @type ProjectJointPositionDirectionConstraintValidationErrorAllOfData * Optional data further specifying the validation error. */ type ProjectJointPositionDirectionConstraintValidationErrorAllOfData = ErrorDirectionConstraintNotNormalized | ErrorInvalidJointCount | ErrorUnsupportedOperation; interface RRTConnectAlgorithm { /** * Algorithm discriminator. RRT Connect algorithm configuration for collision-free path planning. Rapidly-exploring Random Trees (RRT) builds trees of valid configurations by randomly sampling the joint space and connecting feasible points with JointPTP motions. RRT Connect grows two trees simultaneously from start and target positions until they meet. This is a custom implementation optimized for manipulator kinematics and collision checking in industrial contexts. */ 'algorithm_name': RRTConnectAlgorithmAlgorithmNameEnum; /** * Maximum number of iterations for the RRT Connect algorithm. Higher values increase likelihood of success, but also computation time. */ 'max_iterations'?: number; /** * Deprecated in favor of [step_size]. Maximum step size for tree extension in joint space. * @deprecated */ 'max_step_size'?: number; /** * Deprecated in favor of [step_size]. Adjust the maximum step size during the search based on the recent success rate of tree expansion. * @deprecated */ 'adaptive_step_size'?: boolean; 'step_size'?: RRTConnectAlgorithmStepSize | null; /** * Apply smoothing after the search has succeeded. This will remove as many intermediate points as possible while keeping the path valid. */ 'apply_smoothing'?: boolean; /** * Apply blending after the search has succeeded and smoothing has been applied. This will apply the largest viable blending at each intermediate point. */ 'apply_blending'?: boolean; } declare const RRTConnectAlgorithmAlgorithmNameEnum: { readonly RrtConnectAlgorithm: "RRTConnectAlgorithm"; }; type RRTConnectAlgorithmAlgorithmNameEnum = typeof RRTConnectAlgorithmAlgorithmNameEnum[keyof typeof RRTConnectAlgorithmAlgorithmNameEnum]; /** * @type RRTConnectAlgorithmStepSize * Step size for tree extension in joint space. If a range is given, the step size is adaptively adjusted based on the recent success rate. */ type RRTConnectAlgorithmStepSize = Range | number; /** * Inclusive range defined by minimum and maximum. [max] must be greater than [min]. */ interface Range { 'min': number; 'max': number; } /** * Defines an x/y-plane with finite size. Centred around the z-axis. */ interface Rectangle { 'shape_type': RectangleShapeTypeEnum; /** * The dimension in x-direction in [mm]. */ 'size_x': number; /** * The dimension in y-direction in [mm]. */ 'size_y': number; } declare const RectangleShapeTypeEnum: { readonly Rectangle: "rectangle"; }; type RectangleShapeTypeEnum = typeof RectangleShapeTypeEnum[keyof typeof RectangleShapeTypeEnum]; /** * Convex hull around four spheres. Sphere center points in x/y-plane, offset by either combination \"+/- sizeX\" or \"+/- sizeY\". Alternative description: Rectangle in x/y-plane with a 3D padding. */ interface RectangularCapsule { 'shape_type': RectangularCapsuleShapeTypeEnum; /** * The radius of the inner spheres in [mm]. */ 'radius': number; /** * The distance of the sphere center in x-direction in [mm]. */ 'sphere_center_distance_x': number; /** * The distance of the sphere center in y-direction in [mm]. */ 'sphere_center_distance_y': number; } declare const RectangularCapsuleShapeTypeEnum: { readonly RectangularCapsule: "rectangular_capsule"; }; type RectangularCapsuleShapeTypeEnum = typeof RectangularCapsuleShapeTypeEnum[keyof typeof RectangularCapsuleShapeTypeEnum]; /** * The channel that defines what a new Wandelbots NOVA version is. * `next` the latest version * `stable` newest patch of the current version */ declare const ReleaseChannel: { readonly Stable: "stable"; readonly Next: "next"; }; type ReleaseChannel = typeof ReleaseChannel[keyof typeof ReleaseChannel]; /** * The configuration of a physical or virtual robot controller. */ interface RobotController { /** * Unique name of controller within the cell. It must be a valid k8s label name as defined by [RFC 1035](https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#rfc-1035-label-names). */ 'name': string; 'configuration': RobotControllerConfiguration; } /** * @type RobotControllerConfiguration */ type RobotControllerConfiguration = AbbController | FanucController | KukaController | UniversalrobotsController | VirtualController | YaskawaController; /** * Information to generate all robot controller configurations that match a given ARP scan result. */ interface RobotControllerConfigurationRequest { /** * The IPv4 address assigned to the network interface where the ARP scan was performed. */ 'ip': string; /** * Array of network devices. */ 'network_devices': Array; } /** * Returns the whole current state of robot controller. */ interface RobotControllerState { /** * Mode of communication and control between NOVA and the robot controller. */ '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. */ 'last_error'?: Array; /** * Timestamp indicating when the represented information was received from the robot controller. */ 'timestamp': string; /** * Sequence number of the controller state. It starts with 0 upon establishing the connection with a physical controller. The sequence number is reset when the connection to the physical controller is closed and re-established. */ 'sequence_number': number; /** * Identifier of the configured robot controller. */ 'controller': string; 'operation_mode': OperationMode; 'safety_state': SafetyStateType; /** * If made available by the robot controller, returns the current velocity override in [percentage] for movements adjusted on robot control panel. Valid value range: 1 - 100. */ 'velocity_override'?: number; /** * State of indicated motion groups. In case of state request via controller all configured motion groups are returned. In case of executing a motion only the affected motion groups are returned. */ 'motion_groups': Array; } /** * 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](#/operations/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](#/operations/getSupportedModes) to check Free Drive availability. */ declare const RobotSystemMode: { readonly ModeControllerNotConfigured: "MODE_CONTROLLER_NOT_CONFIGURED"; readonly ModeInitializing: "MODE_INITIALIZING"; readonly ModeMonitor: "MODE_MONITOR"; readonly ModeControl: "MODE_CONTROL"; readonly ModeFreeDrive: "MODE_FREE_DRIVE"; }; type RobotSystemMode = typeof RobotSystemMode[keyof typeof RobotSystemMode]; interface RobotTcp { /** * A readable and changeable name for frontend visualization. */ 'name'?: string; /** * A three-dimensional vector [x, y, z] with double precision. */ 'position': Array; /** * Describes an orientation in 3D space. A tree-to-four-dimensional vector [x, y, z, w] with double precision. */ 'orientation'?: Array; 'orientation_type'?: OrientationType; 'payload'?: FlangePayload; /** * Identifier of this tcp. */ 'id': string; } interface RobotTcpData { /** * A readable and changeable name for frontend visualization. */ 'name'?: string; /** * A three-dimensional vector [x, y, z] with double precision. */ 'position': Array; /** * Describes an orientation in 3D space. A tree-to-four-dimensional vector [x, y, z, w] with double precision. */ 'orientation'?: Array; 'orientation_type'?: OrientationType; 'payload'?: FlangePayload; } /** * Geometric shape definition for a safety zone. Exactly one shape field (sphere, capsule, lozenge, box, prism, or plane) should be set. */ interface SafetyGeometry { /** * Unique identifier of this geometry. */ 'id': string; 'sphere'?: SafetyGeometrySphere; 'capsule'?: SafetyGeometryCapsule; 'lozenge'?: SafetyGeometryLozenge; 'box'?: SafetyGeometryBox; 'prism'?: SafetyGeometryPrism; 'plane'?: SafetyGeometryPlane; /** * If `true`, the geometry is inverted (outside is restricted, inside is safe). */ 'inverted': boolean; } /** * Box shape defined by a center point and three orthogonal edge midpoints. This representation matches the robot controller\'s internal format and the `Box` message in the virtual robot. Unlike a parametric size-and-pose box definition, this format can represent all box orientations produced by the robot controller, including left-handed coordinate systems. */ interface SafetyGeometryBox { /** * Center of the box as Vector3 [x, y, z] in [mm]. */ 'center': Array; /** * Three edge midpoint coordinates as a flattened array [x1, y1, z1, x2, y2, z2, x3, y3, z3] in [mm]. Each triplet represents the midpoint of one of the three orthogonal box edges originating from the center. Together, these points define an orthogonal basis that encodes the box’s orientation and size. The distance from the center to each midpoint equals half of the corresponding edge length. This representation supports arbitrary orientations, including left-handed coordinate systems used by robot controllers. */ 'neighbour': Array; } /** * Capsule shape defined by two axis endpoints and a radius. */ interface SafetyGeometryCapsule { /** * Top endpoint of the capsule axis as Vector3 [x, y, z] in [mm]. */ 'top': Array; /** * Bottom endpoint of the capsule axis as Vector3 [x, y, z] in [mm]. */ 'bottom': Array; /** * Radius of the capsule in [mm]. */ 'radius': number; } /** * Lozenge shape defined by a center pose, two dimensions, and a corner radius. */ interface SafetyGeometryLozenge { /** * Center pose of the lozenge (position and quaternion orientation). */ 'center': SafetyZonePose; /** * Dimension in x-direction in [mm]. */ 'x_dimension': number; /** * Dimension in y-direction in [mm]. */ 'y_dimension': number; /** * Corner radius in [mm]. */ 'radius': number; } /** * Mathematical half-space plane shape defined by its 3D vertices. A minimum of three coplanar points is required to define the plane\'s orientation. The plane extends infinitely in all directions parallel to the defined surface. For collision avoidance, planner implementations may approximate it using a large, thin box proxy. */ interface SafetyGeometryPlane { /** * Vertices defining a plane as a flattened array [x1, y1, z1, x2, y2, z2, x3, y3, z3, ...] in [mm]. Minimum 3 points required (9 values). Points define plane orientation and position; the plane is mathematically unbounded. */ 'point': Array; } /** * Prism (extruded polygon) shape. The base polygon is defined by 2D points in the XY plane, and the prism extends along the Z axis between the bottom and top Z coordinates. */ interface SafetyGeometryPrism { /** * 2D points defining the base polygon as a flattened array [x1, y1, x2, y2, ...] in [mm]. Minimum 3 points required (6 values). Points should form a closed polygon in the XY plane. */ 'point': Array; /** * Top z-coordinate of the prism in [mm]. */ 'top': number; /** * Bottom z-coordinate of the prism in [mm]. */ 'bottom': number; } /** * Sphere shape defined by a center point and a radius. */ interface SafetyGeometrySphere { /** * Center of the sphere as Vector3 [x, y, z] in [mm]. */ 'center': Array; /** * Radius of the sphere in [mm]. */ 'radius': number; } /** * 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. */ declare const SafetyStateType: { readonly SafetyStateUnknown: "SAFETY_STATE_UNKNOWN"; readonly SafetyStateFault: "SAFETY_STATE_FAULT"; readonly SafetyStateNormal: "SAFETY_STATE_NORMAL"; readonly SafetyStateMastering: "SAFETY_STATE_MASTERING"; readonly SafetyStateConfirmSafety: "SAFETY_STATE_CONFIRM_SAFETY"; readonly SafetyStateOperatorSafety: "SAFETY_STATE_OPERATOR_SAFETY"; readonly SafetyStateProtectiveStop: "SAFETY_STATE_PROTECTIVE_STOP"; readonly SafetyStateReduced: "SAFETY_STATE_REDUCED"; readonly SafetyStateStop: "SAFETY_STATE_STOP"; readonly SafetyStateStop0: "SAFETY_STATE_STOP_0"; readonly SafetyStateStop1: "SAFETY_STATE_STOP_1"; readonly SafetyStateStop2: "SAFETY_STATE_STOP_2"; readonly SafetyStateRecovery: "SAFETY_STATE_RECOVERY"; readonly SafetyStateDeviceEmergencyStop: "SAFETY_STATE_DEVICE_EMERGENCY_STOP"; readonly SafetyStateRobotEmergencyStop: "SAFETY_STATE_ROBOT_EMERGENCY_STOP"; readonly SafetyStateViolation: "SAFETY_STATE_VIOLATION"; }; type SafetyStateType = typeof SafetyStateType[keyof typeof SafetyStateType]; /** * Defines a safety zone with geometric boundaries and constraints. Safety zones are used to restrict robot motion or define protected areas. */ interface SafetyZone { /** * Unique identifier of the safety zone. */ 'id': number; /** * Name of the safety zone. */ 'name': string; /** * Priority of the safety zone. */ 'priority'?: number; /** * If `true`, the zone is restricted and the robot cannot enter it. */ 'restricted'?: boolean; /** * The geometric shape of the safety zone. */ 'geometry': SafetyGeometry; /** * UID of the motion group this safety zone is attached to. Must match an existing motion group UID on the controller. */ 'mg_uid'?: number; /** * UID of the coordinate system in which the geometry coordinates are expressed. The coordinate system must be defined on the controller beforehand. If empty (\"\"), the World coordinate system is used. */ 'uid_ref_cs'?: string; /** * If `true`, the safety zone is active. */ 'active'?: boolean; } /** * Pose with position (x, y, z) in [mm] and orientation as quaternion (qx, qy, qz, qw). */ interface SafetyZonePose { /** * X position in [mm]. */ 'x': number; /** * Y position in [mm]. */ 'y': number; /** * Z position in [mm]. */ 'z': number; /** * Quaternion X component. */ 'qx': number; /** * Quaternion Y component. */ 'qy': number; /** * Quaternion Z component. */ 'qz': number; /** * Quaternion W component. */ 'qw': number; } /** * Response containing all safety zones. */ interface SafetyZones { /** * List of all safety zones. */ 'safety_zones': Array; } declare const ServiceGroup: { readonly SystemService: "SystemService"; readonly CellService: "CellService"; readonly RobotController: "RobotController"; readonly App: "App"; }; type ServiceGroup = typeof ServiceGroup[keyof typeof ServiceGroup]; interface ServiceStatus { 'service': string; 'group': ServiceGroup; 'status': ServiceStatusStatus; } declare const ServiceStatusPhase: { readonly Terminating: "Terminating"; readonly Initialized: "Initialized"; readonly Running: "Running"; readonly NoReady: "NoReady"; readonly Completed: "Completed"; readonly ContainerCreating: "ContainerCreating"; readonly PodInitializing: "PodInitializing"; readonly Unknown: "Unknown"; readonly CrashLoopBackOff: "CrashLoopBackOff"; readonly Error: "Error"; readonly ImagePullBackOff: "ImagePullBackOff"; readonly OomKilled: "OOMKilled"; readonly Pending: "Pending"; readonly Evicted: "Evicted"; }; type ServiceStatusPhase = typeof ServiceStatusPhase[keyof typeof ServiceStatusPhase]; /** * Response containing both the overall operating state of the cell and detailed status information for each service within the cell. The operating state indicates whether the cell is active or inactive, while the service statuses provide specific health and operational information for individual service running in the cell. */ interface ServiceStatusResponse { 'operating_state': OperatingState; 'service_status': Array; } declare const ServiceStatusSeverity: { readonly Info: "INFO"; readonly Warning: "WARNING"; readonly Error: "ERROR"; }; type ServiceStatusSeverity = typeof ServiceStatusSeverity[keyof typeof ServiceStatusSeverity]; interface ServiceStatusStatus { 'severity': ServiceStatusSeverity; 'code': ServiceStatusPhase; 'reason'?: string; } /** * Session information including user identity, capabilities, and token lifetime metadata. On unmanaged instances (no authentication or authorization configured), a default anonymous session is returned with `session_id` \"default\", empty user fields, no capabilities, and zero-value timestamps. */ interface SessionResponse { /** * Unique identifier for the current session. For authenticated sessions this is derived from the access token. Unmanaged instances return \"default\". */ 'session_id': string; 'user': User; /** * Capability entries resolved for the user. Empty on unmanaged instances. */ 'capabilities': Array; /** * Timestamp when the underlying access token was issued. Zero-value on unmanaged instances. */ 'issued_at': string; /** * Timestamp when the underlying access token expires. Zero-value on unmanaged instances. */ 'expires_at': string; } /** * Defines an input/output that should be set upon reaching a specified location on the trajectory. */ interface SetIO { 'io': IOValue; /** * The location on the trajectory where the input/output should be set. */ 'location': number; 'io_origin': IOOrigin; } /** * Defines available system modes of the robot system. Short versions (no \"ROBOT_SYSTEM_\" prefix) are provided, reusing strings from [getMode](#/operations/getMode) responses. */ declare const SettableRobotSystemMode: { readonly RobotSystemModeMonitor: "ROBOT_SYSTEM_MODE_MONITOR"; readonly ModeMonitor: "MODE_MONITOR"; readonly RobotSystemModeControl: "ROBOT_SYSTEM_MODE_CONTROL"; readonly ModeControl: "MODE_CONTROL"; }; type SettableRobotSystemMode = typeof SettableRobotSystemMode[keyof typeof SettableRobotSystemMode]; declare const SingularityTypeEnum: { readonly Wrist: "WRIST"; readonly Elbow: "ELBOW"; readonly Shoulder: "SHOULDER"; }; type SingularityTypeEnum = typeof SingularityTypeEnum[keyof typeof SingularityTypeEnum]; interface Snap7IO { /** * Descriptive name or note for the input/output variable. */ 'description': string; /** * PLC memory area the variable resides in. */ 'area': Snap7IOArea; /** * Data block number. Only required when `area` is `SNAP7_IO_AREA_DATA_BLOCK`. */ 'db_number'?: number; /** * Byte offset within the selected PLC memory area or data block. */ 'byte_address': number; /** * Bit offset within the byte. Only relevant for `SNAP7_IO_TYPE_BOOL`. */ 'bit_address'?: number; 'type': Snap7IOTypeEnum; 'direction': Snap7IODirection; /** * Unique identifier for the input/output variable as used by this service. */ 'io': string; } /** * PLC memory area of the Snap7 input/output variable. */ declare const Snap7IOArea: { readonly Snap7IoAreaUnknown: "SNAP7_IO_AREA_UNKNOWN"; readonly Snap7IoAreaProcessInputs: "SNAP7_IO_AREA_PROCESS_INPUTS"; readonly Snap7IoAreaProcessOutputs: "SNAP7_IO_AREA_PROCESS_OUTPUTS"; readonly Snap7IoAreaMerkers: "SNAP7_IO_AREA_MERKERS"; readonly Snap7IoAreaDataBlock: "SNAP7_IO_AREA_DATA_BLOCK"; }; type Snap7IOArea = typeof Snap7IOArea[keyof typeof Snap7IOArea]; interface Snap7IOData { /** * Descriptive name or note for the input/output variable. */ 'description': string; /** * PLC memory area the variable resides in. */ 'area': Snap7IOArea; /** * Data block number. Only required when `area` is `SNAP7_IO_AREA_DATA_BLOCK`. */ 'db_number'?: number; /** * Byte offset within the selected PLC memory area or data block. */ 'byte_address': number; /** * Bit offset within the byte. Only relevant for `SNAP7_IO_TYPE_BOOL`. */ 'bit_address'?: number; 'type': Snap7IOTypeEnum; 'direction': Snap7IODirection; } /** * Direction of the Snap7 input/output variable from the perspective of this service. */ declare const Snap7IODirection: { readonly Snap7IoDirectionUnknown: "SNAP7_IO_DIRECTION_UNKNOWN"; readonly Snap7IoDirectionInput: "SNAP7_IO_DIRECTION_INPUT"; readonly Snap7IoDirectionOutput: "SNAP7_IO_DIRECTION_OUTPUT"; }; type Snap7IODirection = typeof Snap7IODirection[keyof typeof Snap7IODirection]; /** * PLC data type of the Snap7 input/output variable. Used to interpret the corresponding PLC memory correctly. */ declare const Snap7IOTypeEnum: { readonly Snap7IoTypeUnknown: "SNAP7_IO_TYPE_UNKNOWN"; readonly Snap7IoTypeBool: "SNAP7_IO_TYPE_BOOL"; readonly Snap7IoTypeByte: "SNAP7_IO_TYPE_BYTE"; readonly Snap7IoTypeWord: "SNAP7_IO_TYPE_WORD"; readonly Snap7IoTypeDword: "SNAP7_IO_TYPE_DWORD"; readonly Snap7IoTypeInt: "SNAP7_IO_TYPE_INT"; readonly Snap7IoTypeDint: "SNAP7_IO_TYPE_DINT"; readonly Snap7IoTypeReal: "SNAP7_IO_TYPE_REAL"; }; type Snap7IOTypeEnum = typeof Snap7IOTypeEnum[keyof typeof Snap7IOTypeEnum]; /** * Defines a spherical shape centred around the origin. */ interface Sphere { 'shape_type': SphereShapeTypeEnum; /** * The radius of the sphere in [mm]. */ 'radius': number; } declare const SphereShapeTypeEnum: { readonly Sphere: "sphere"; }; type SphereShapeTypeEnum = typeof SphereShapeTypeEnum[keyof typeof SphereShapeTypeEnum]; /** * Moves the motion group along a trajectory, added via [planTrajectory](#/operations/planTrajectory) or [planMotion](#/operations/planMotion). Trajectories can be executed forwards or backwards(\"in reverse\"). Pause the execution with PauseMovementRequest. Resume execution with StartMovementRequest. Precondition: To start execution, the motion group must be located at the trajectory\'s start location specified in InitializeMovementRequest. */ interface StartMovementRequest { /** * Type specifier for server, set automatically. */ 'message_type': StartMovementRequestMessageTypeEnum; 'direction'?: Direction; /** * - The location is a scalar value that defines a position along a path, typically ranging from 0 to `n`, where `n` denotes the number of motion commands - Each integer value of the location corresponds to a specific motion command, while non-integer values interpolate positions within the segments. - The location is calculated from the joint path */ 'target_location'?: number; /** * Attaches a list of output commands to the trajectory. The outputs are set to the specified values right after the specified location was reached. If the specified location is located before the start location (forward direction: value is smaller, backward direction: value is bigger), the output is not set. */ 'set_outputs'?: Array; /** * Defines an input/output that is listened to before the movement. Execution starts if the defined comparator evaluates to `true`. */ 'start_on_io'?: StartOnIO; /** * Defines an input/output that is listened to during the movement. Execution pauses if the defined comparator evaluates to `true`. */ 'pause_on_io'?: PauseOnIO; } declare const StartMovementRequestMessageTypeEnum: { readonly StartMovementRequest: "StartMovementRequest"; }; type StartMovementRequestMessageTypeEnum = typeof StartMovementRequestMessageTypeEnum[keyof typeof StartMovementRequestMessageTypeEnum]; /** * Acknowledgment for StartMovementRequest message. ATTENTION: No confirmation that the movement was started. Confirmation that the StartMovementRequest was received and is processed. Fields `execute` and `standstill` of response of [streamMotionGroupState](#/operations/streamMotionGroupState) signal start of movement execution. */ interface StartMovementResponse { /** * Error message in case of invalid StartMovementResquest. */ 'message'?: string; 'kind': StartMovementResponseKindEnum; } declare const StartMovementResponseKindEnum: { readonly StartReceived: "START_RECEIVED"; }; type StartMovementResponseKindEnum = typeof StartMovementResponseKindEnum[keyof typeof StartMovementResponseKindEnum]; /** * Defines an input/output that the motion should wait for to start the execution. */ interface StartOnIO { 'io': IOValue; /** * Comparator for the comparison of two values. Use the measured I/O as the base value (a) and the expected input/output value as the comparator (b): e.g., a > b. */ 'comparator': Comparator; 'io_origin': IOOrigin; } /** * A reference to an object stored in the storage service. The key is resolved against the appropriate S3 path prefix depending on context (e.g. collision/setups/, collision/colliders/). */ interface StorageKey { /** * Discriminator value indicating a storage reference. */ 'source': StorageKeySourceEnum; /** * The storage key identifying the object. Resolved against the storage service using the {cell} path parameter of the request URL as the storage bucket. Keys correspond to identifiers used in the Storage Service API (e.g. the {tool} parameter in GET /api/v2/cells/{cell}/store/collision/tools/{tool}). */ 'key': string; } declare const StorageKeySourceEnum: { readonly Key: "key"; }; type StorageKeySourceEnum = typeof StorageKeySourceEnum[keyof typeof StorageKeySourceEnum]; /** * Array of input/output values. */ interface StreamIOValuesResponse { 'io_values': Array; /** * Timestamp indicating when the represented information was received from the robot controller. */ 'timestamp': string; /** * Sequence number of the controller state. It starts with 0 upon establishing the connection with a physical controller. The sequence number is reset when the connection to the physical controller is closed and re-established. */ 'sequence_number': number; } interface TcpOffset { /** * A readable and changeable name for frontend visualization. */ 'name': string; 'pose': Pose; } /** * Requested motion group requires TCP to be defined. */ interface TcpRequiredError { 'kind': TcpRequiredErrorKindEnum; 'tcp_missing'?: any; } declare const TcpRequiredErrorKindEnum: { readonly TcpRequiredError: "TcpRequiredError"; }; type TcpRequiredErrorKindEnum = typeof TcpRequiredErrorKindEnum[keyof typeof TcpRequiredErrorKindEnum]; /** * Sets target TCP velocities for jogging a motion group. The motion group needs to have an inverse kinematic solver to be jogged by TCP velocities. Check `supports_inverse_kinematics` field in response of [listController](#/operations/listController) for the motion group. */ interface TcpVelocityRequest { /** * Type specifier for server, set automatically. */ 'message_type': TcpVelocityRequestMessageTypeEnum; /** * A three-dimensional vector [x, y, z] with double precision. */ 'translation': Array; /** * A three-dimensional vector [x, y, z] with double precision. */ 'rotation': Array; /** * If true, TCP velocities are interpreted in the tool coordinate system, specified by the TCP. If false, TCP velocities are interpreted in the world coordinate system. */ 'use_tool_coordinate_system'?: boolean; } declare const TcpVelocityRequestMessageTypeEnum: { readonly TcpVelocityRequest: "TcpVelocityRequest"; }; type TcpVelocityRequestMessageTypeEnum = typeof TcpVelocityRequestMessageTypeEnum[keyof typeof TcpVelocityRequestMessageTypeEnum]; /** * Acknowledgment to a TcpVelocityRequest. */ interface TcpVelocityResponse { /** * Error message in case of invalid TcpVelocityRequest. */ 'message'?: string; 'kind': TcpVelocityResponseKindEnum; } declare const TcpVelocityResponseKindEnum: { readonly TcpVelocityReceived: "TCP_VELOCITY_RECEIVED"; }; type TcpVelocityResponseKindEnum = typeof TcpVelocityResponseKindEnum[keyof typeof TcpVelocityResponseKindEnum]; /** * An inline tool collider wrapped for discriminator support. */ interface ToolValue { /** * Discriminator value indicating an inline value. */ 'source': ToolValueSourceEnum; /** * Defines the shape of a tool. A tool is a dictionary of colliders. All colliders that make up a tool are attached to the flange frame of the motion group. */ 'tool': { [key: string]: Collider; }; } declare const ToolValueSourceEnum: { readonly Value: "value"; }; type ToolValueSourceEnum = typeof ToolValueSourceEnum[keyof typeof ToolValueSourceEnum]; /** * @type ToolValueOrKey * Either an inline tool collider or a storage key referencing a stored tool. Discriminated by the \"source\" property. */ type ToolValueOrKey = { source: 'key'; } & StorageKey | { source: 'value'; } & ToolValue; interface TorqueExceededError { 'kind': TorqueExceededErrorKindEnum; 'torque_exceeded'?: TorqueExceededErrorTorqueExceeded; } declare const TorqueExceededErrorKindEnum: { readonly TorqueExceededError: "TorqueExceededError"; }; type TorqueExceededErrorKindEnum = typeof TorqueExceededErrorKindEnum[keyof typeof TorqueExceededErrorKindEnum]; interface TorqueExceededErrorTorqueExceeded { /** * The torque value that was exceeded. */ 'torque_value'?: number; /** * The value of the torque limit that was exceeded. */ 'torque_limit'?: number; } interface TrajectoryData { /** * Type specifier for server, set automatically. */ 'message_type': TrajectoryDataMessageTypeEnum; /** * Identifier of the motion-group. */ 'motion_group'?: string; /** * The trajectory consisting of a list of joint positions and an equal number of corresponding timestamps. */ 'data': JointTrajectory; /** * Unique identifier of the tool the trajectory is planned for. */ 'tcp'?: string; } declare const TrajectoryDataMessageTypeEnum: { readonly TrajectoryData: "TrajectoryData"; }; type TrajectoryDataMessageTypeEnum = typeof TrajectoryDataMessageTypeEnum[keyof typeof TrajectoryDataMessageTypeEnum]; /** * State of trajectory execution. This state is sent during trajectory movement, response-rate closest to the nearest multiple of controller step-rate but not exceeding the configured rate. The trajectory state can be one of the following: - RUNNING: Trajectory is being executed. - PAUSED_BY_USER: User has paused execution. - END_OF_TRAJECTORY: First or last sample (depending on direction) of trajectory has been sent. - WAIT_FOR_IO: Waiting for an I/O event to start execution. - PAUSED_ON_IO: Execution was paused because of an I/O event. */ interface TrajectoryDetails { /** * Unique identifier of the trajectory being executed. */ 'trajectory': string; /** * - The location is a scalar value that defines a position along a path, typically ranging from 0 to `n`, where `n` denotes the number of motion commands - Each integer value of the location corresponds to a specific motion command, while non-integer values interpolate positions within the segments. - The location is calculated from the joint path */ 'location': number; 'state': TrajectoryDetailsState; /** * Discriminator for OpenApi generators, which is always \"TRAJECTORY\" for this schema. */ 'kind': TrajectoryDetailsKindEnum; } declare const TrajectoryDetailsKindEnum: { readonly Trajectory: "TRAJECTORY"; }; type TrajectoryDetailsKindEnum = typeof TrajectoryDetailsKindEnum[keyof typeof TrajectoryDetailsKindEnum]; /** * @type TrajectoryDetailsState */ type TrajectoryDetailsState = { kind: 'END_OF_TRAJECTORY'; } & TrajectoryEnded | { kind: 'PAUSED_BY_USER'; } & TrajectoryPausedByUser | { kind: 'PAUSED_ON_IO'; } & TrajectoryPausedOnIO | { kind: 'RUNNING'; } & TrajectoryRunning | { kind: 'WAIT_FOR_IO'; } & TrajectoryWaitForIO; /** * First or last sample (depending on direction) of trajectory has been sent. */ interface TrajectoryEnded { 'kind': TrajectoryEndedKindEnum; } declare const TrajectoryEndedKindEnum: { readonly EndOfTrajectory: "END_OF_TRAJECTORY"; }; type TrajectoryEndedKindEnum = typeof TrajectoryEndedKindEnum[keyof typeof TrajectoryEndedKindEnum]; interface TrajectoryId { /** * Type specifier for server, set automatically. */ 'message_type': TrajectoryIdMessageTypeEnum; /** * The identifier of the trajectory which was returned by the [addTrajectory](#/operations/addTrajectory) endpoint. */ 'id': string; } declare const TrajectoryIdMessageTypeEnum: { readonly TrajectoryId: "TrajectoryId"; }; type TrajectoryIdMessageTypeEnum = typeof TrajectoryIdMessageTypeEnum[keyof typeof TrajectoryIdMessageTypeEnum]; /** * User has paused execution. */ interface TrajectoryPausedByUser { 'kind': TrajectoryPausedByUserKindEnum; } declare const TrajectoryPausedByUserKindEnum: { readonly PausedByUser: "PAUSED_BY_USER"; }; type TrajectoryPausedByUserKindEnum = typeof TrajectoryPausedByUserKindEnum[keyof typeof TrajectoryPausedByUserKindEnum]; /** * Execution was paused because of an I/O event. */ interface TrajectoryPausedOnIO { 'kind': TrajectoryPausedOnIOKindEnum; } declare const TrajectoryPausedOnIOKindEnum: { readonly PausedOnIo: "PAUSED_ON_IO"; }; type TrajectoryPausedOnIOKindEnum = typeof TrajectoryPausedOnIOKindEnum[keyof typeof TrajectoryPausedOnIOKindEnum]; /** * Trajectory is being executed. */ interface TrajectoryRunning { 'kind': TrajectoryRunningKindEnum; /** * Remaining time in milliseconds (ms) to reach the end of the motion. */ 'time_to_end': number; } declare const TrajectoryRunningKindEnum: { readonly Running: "RUNNING"; }; type TrajectoryRunningKindEnum = typeof TrajectoryRunningKindEnum[keyof typeof TrajectoryRunningKindEnum]; interface TrajectorySection { 'start_location': number; 'end_location': number; } /** * Waiting for an I/O event to start execution. */ interface TrajectoryWaitForIO { 'kind': TrajectoryWaitForIOKindEnum; } declare const TrajectoryWaitForIOKindEnum: { readonly WaitForIo: "WAIT_FOR_IO"; }; type TrajectoryWaitForIOKindEnum = typeof TrajectoryWaitForIOKindEnum[keyof typeof TrajectoryWaitForIOKindEnum]; /** * The unit of input/output value. */ declare const UnitType: { readonly UnitNone: "UNIT_NONE"; readonly UnitKilogram: "UNIT_KILOGRAM"; readonly UnitAmpere: "UNIT_AMPERE"; readonly UnitKelvin: "UNIT_KELVIN"; readonly UnitHertz: "UNIT_HERTZ"; readonly UnitNewton: "UNIT_NEWTON"; readonly UnitVolt: "UNIT_VOLT"; readonly UnitCelsius: "UNIT_CELSIUS"; readonly UnitNewtonMeter: "UNIT_NEWTON_METER"; readonly UnitMeter: "UNIT_METER"; }; type UnitType = typeof UnitType[keyof typeof UnitType]; /** * The configuration of a physical Universal Robots controller has to contain IP address of the controller. */ interface UniversalrobotsController { 'kind': UniversalrobotsControllerKindEnum; 'controller_ip': string; } declare const UniversalrobotsControllerKindEnum: { readonly UniversalrobotsController: "UniversalrobotsController"; }; type UniversalrobotsControllerKindEnum = typeof UniversalrobotsControllerKindEnum[keyof typeof UniversalrobotsControllerKindEnum]; /** * Update a single cell\'s Foundation chart version based on the indicated release channel. */ interface UpdateCellVersionRequest { 'channel': ReleaseChannel; } /** * An update is defined by the indicated Wandelbots NOVA release channel. */ interface UpdateNovaVersionRequest { 'channel': ReleaseChannel; /** * Update unpinned cells during system update. Cells with an explicit chart version are never updated by a system update, regardless of this setting. */ 'update_cells'?: boolean; } /** * Identity information for the session user. On unmanaged instances all fields are empty strings representing an anonymous user. */ interface User { /** * Subject identifier of the user. Empty on unmanaged instances. */ 'id': string; /** * Display name of the user. Empty on unmanaged instances. */ 'name': string; /** * Email address of the user. Empty on unmanaged instances. */ 'email': string; } interface ValidationError { 'loc': Array; 'msg': string; 'type': string; 'input': { [key: string]: any; }; } /** * A validation error of a program. */ interface ValidationError2 { 'loc': Array; 'msg': string; 'type': string; } /** * @type ValidationErrorLocInner */ type ValidationErrorLocInner = number | string; /** * The configuration of a virtual robot controller has to contain the manufacturer string, an optional joint position string array, and either a preset `type` **or** the complete JSON configuration. */ interface VirtualController { 'kind': VirtualControllerKindEnum; 'manufacturer': Manufacturer; /** * Preset type of the virtual robot controller. See [getRobotConfigurations](#/operations/getRobotConfigurations) for supported types. */ 'type'?: string; /** * Complete JSON configuration of the virtual robot controller. Can be obtained from the physical controller\'s configuration via [getVirtualControllerConfiguration](#/operations/getVirtualControllerConfiguration). If provided, the `type` field should not be used. */ 'json'?: string; /** * Initial joint position of the first motion group from the virtual robot controller. Provides the joint position as a JSON array of float values in radians, where the array length must match the robot\'s degrees of freedom (DOF), e.g., `\"[0, 0, 0, 0, 0, 0]\"` for a 6-DOF robot. If the provided array length does not match the robot\'s DOF, the array will be adjusted: if it is longer, extra values will be truncated; if it is shorter, missing values will be filled with zeros. */ 'initial_joint_position'?: string; } declare const VirtualControllerKindEnum: { readonly VirtualController: "VirtualController"; }; type VirtualControllerKindEnum = typeof VirtualControllerKindEnum[keyof typeof VirtualControllerKindEnum]; interface VirtualRobotConfiguration { /** * Name of the configuration file generated by the unique identifier of the controller and a time stamp. */ 'name': string; /** * Content of the configuration file. Copy & paste to the [addRobotController](#/operations/addRobotController) configuration.json parameter. */ 'content': string; } /** * The value to compare with the current value of the input/output. */ interface WaitForIOEventRequest { 'io': IOValue; /** * Comparator for the comparison of two values. Use the measured I/O as the base value (a) and the expected input/output value as the comparator (b): e.g., a > b. */ 'comparator': Comparator; } /** * The configuration of a physical Yaskawa robot controller has to contain IP address of the controller. */ interface YaskawaController { 'kind': YaskawaControllerKindEnum; 'controller_ip': string; } declare const YaskawaControllerKindEnum: { readonly YaskawaController: "YaskawaController"; }; type YaskawaControllerKindEnum = typeof YaskawaControllerKindEnum[keyof typeof YaskawaControllerKindEnum]; interface ZodValidationError { 'error': ZodValidationErrorError; } interface ZodValidationErrorError { 'code': ZodValidationErrorErrorCodeEnum; /** * Human-readable summary of the validation errors */ 'message': string; /** * Array of Zod issue objects describing the validation errors */ 'details': Array; } declare const ZodValidationErrorErrorCodeEnum: { readonly ValidationError: "validation_error"; }; type ZodValidationErrorErrorCodeEnum = typeof ZodValidationErrorErrorCodeEnum[keyof typeof ZodValidationErrorErrorCodeEnum]; interface ZodValidationErrorErrorDetailsInner { 'code': string; 'path': Array; 'message': string; } /** * @type ZodValidationErrorErrorDetailsInnerPathInner */ type ZodValidationErrorErrorDetailsInnerPathInner = number | string; /** * ApplicationApi - axios parameter creator */ declare const ApplicationApiAxiosParamCreator: (configuration?: Configuration) => { /** * **Required permissions:** `can_manage_apps` - Install, update, or remove applications ___ Install a basic, containerized web application to the cell to control robots with a customized frontend. #### Prerequisites - A Docker hub account or similar container registry account, with valid credentials. #### Workflow After adding the application to the cell, open the application on the Wandelbots NOVA home screen. Read [build your application](https://docs.wandelbots.io/latest/developing-introduction) for more information. #### Predefined environment variables > **NOTE** > - `NOVA_API`: The API endpoint accessible from within the application container. > - `NATS_BROKER`: The NATS broker endpoint accessible from within the application container. > - `BASE_PATH`: The application\'s root path, accessible at http://$host/$BASE_PATH > - `CELL_NAME`: The name of the cell hosting the deployed application. * @summary Add Application * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {App} app * @param {number} [completionTimeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ addApp: (cell: string, app: App, completionTimeout?: number, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_manage_apps` - Install, update, or remove applications ___ Delete all GUI applications from the cell. * @summary Clear Applications * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {number} [completionTimeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ clearApps: (cell: string, completionTimeout?: number, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_manage_apps` - Install, update, or remove applications ___ Delete a GUI application from the cell. * @summary Delete Application * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} app * @param {number} [completionTimeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteApp: (cell: string, app: string, completionTimeout?: number, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_access_apps` - View application configurations ___ Get the configuration for an active GUI application in the cell. To update the configuration of a GUI application in the cell, use this configuration with [updateApp](#/operations/updateApp). * @summary Configuration * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} app * @param {*} [options] Override http request option. * @throws {RequiredError} */ getApp: (cell: string, app: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_access_apps` - View application configurations ___ List all GUI applications that have been added to a cell with [addApp](#/operations/addApp). If the cell does not contain GUI applications, the list is returned empty. * @summary List Applications * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listApps: (cell: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_manage_apps` - Install, update, or remove applications ___ Update the configuration of a GUI application in the cell. * @summary Update Configuration * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} app * @param {App} app2 * @param {number} [completionTimeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ updateApp: (cell: string, app: string, app2: App, completionTimeout?: number, options?: RawAxiosRequestConfig) => Promise; }; /** * ApplicationApi - functional programming interface */ declare const ApplicationApiFp: (configuration?: Configuration) => { /** * **Required permissions:** `can_manage_apps` - Install, update, or remove applications ___ Install a basic, containerized web application to the cell to control robots with a customized frontend. #### Prerequisites - A Docker hub account or similar container registry account, with valid credentials. #### Workflow After adding the application to the cell, open the application on the Wandelbots NOVA home screen. Read [build your application](https://docs.wandelbots.io/latest/developing-introduction) for more information. #### Predefined environment variables > **NOTE** > - `NOVA_API`: The API endpoint accessible from within the application container. > - `NATS_BROKER`: The NATS broker endpoint accessible from within the application container. > - `BASE_PATH`: The application\'s root path, accessible at http://$host/$BASE_PATH > - `CELL_NAME`: The name of the cell hosting the deployed application. * @summary Add Application * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {App} app * @param {number} [completionTimeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ addApp(cell: string, app: App, completionTimeout?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_manage_apps` - Install, update, or remove applications ___ Delete all GUI applications from the cell. * @summary Clear Applications * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {number} [completionTimeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ clearApps(cell: string, completionTimeout?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_manage_apps` - Install, update, or remove applications ___ Delete a GUI application from the cell. * @summary Delete Application * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} app * @param {number} [completionTimeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteApp(cell: string, app: string, completionTimeout?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_access_apps` - View application configurations ___ Get the configuration for an active GUI application in the cell. To update the configuration of a GUI application in the cell, use this configuration with [updateApp](#/operations/updateApp). * @summary Configuration * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} app * @param {*} [options] Override http request option. * @throws {RequiredError} */ getApp(cell: string, app: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_access_apps` - View application configurations ___ List all GUI applications that have been added to a cell with [addApp](#/operations/addApp). If the cell does not contain GUI applications, the list is returned empty. * @summary List Applications * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listApps(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>>; /** * **Required permissions:** `can_manage_apps` - Install, update, or remove applications ___ Update the configuration of a GUI application in the cell. * @summary Update Configuration * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} app * @param {App} app2 * @param {number} [completionTimeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ updateApp(cell: string, app: string, app2: App, completionTimeout?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; }; /** * ApplicationApi - factory interface */ declare const ApplicationApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => { /** * **Required permissions:** `can_manage_apps` - Install, update, or remove applications ___ Install a basic, containerized web application to the cell to control robots with a customized frontend. #### Prerequisites - A Docker hub account or similar container registry account, with valid credentials. #### Workflow After adding the application to the cell, open the application on the Wandelbots NOVA home screen. Read [build your application](https://docs.wandelbots.io/latest/developing-introduction) for more information. #### Predefined environment variables > **NOTE** > - `NOVA_API`: The API endpoint accessible from within the application container. > - `NATS_BROKER`: The NATS broker endpoint accessible from within the application container. > - `BASE_PATH`: The application\'s root path, accessible at http://$host/$BASE_PATH > - `CELL_NAME`: The name of the cell hosting the deployed application. * @summary Add Application * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {App} app * @param {number} [completionTimeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ addApp(cell: string, app: App, completionTimeout?: number, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_manage_apps` - Install, update, or remove applications ___ Delete all GUI applications from the cell. * @summary Clear Applications * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {number} [completionTimeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ clearApps(cell: string, completionTimeout?: number, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_manage_apps` - Install, update, or remove applications ___ Delete a GUI application from the cell. * @summary Delete Application * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} app * @param {number} [completionTimeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteApp(cell: string, app: string, completionTimeout?: number, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_access_apps` - View application configurations ___ Get the configuration for an active GUI application in the cell. To update the configuration of a GUI application in the cell, use this configuration with [updateApp](#/operations/updateApp). * @summary Configuration * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} app * @param {*} [options] Override http request option. * @throws {RequiredError} */ getApp(cell: string, app: string, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_access_apps` - View application configurations ___ List all GUI applications that have been added to a cell with [addApp](#/operations/addApp). If the cell does not contain GUI applications, the list is returned empty. * @summary List Applications * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listApps(cell: string, options?: RawAxiosRequestConfig): AxiosPromise>; /** * **Required permissions:** `can_manage_apps` - Install, update, or remove applications ___ Update the configuration of a GUI application in the cell. * @summary Update Configuration * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} app * @param {App} app2 * @param {number} [completionTimeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ updateApp(cell: string, app: string, app2: App, completionTimeout?: number, options?: RawAxiosRequestConfig): AxiosPromise; }; /** * ApplicationApi - object-oriented interface */ declare class ApplicationApi extends BaseAPI { /** * **Required permissions:** `can_manage_apps` - Install, update, or remove applications ___ Install a basic, containerized web application to the cell to control robots with a customized frontend. #### Prerequisites - A Docker hub account or similar container registry account, with valid credentials. #### Workflow After adding the application to the cell, open the application on the Wandelbots NOVA home screen. Read [build your application](https://docs.wandelbots.io/latest/developing-introduction) for more information. #### Predefined environment variables > **NOTE** > - `NOVA_API`: The API endpoint accessible from within the application container. > - `NATS_BROKER`: The NATS broker endpoint accessible from within the application container. > - `BASE_PATH`: The application\'s root path, accessible at http://$host/$BASE_PATH > - `CELL_NAME`: The name of the cell hosting the deployed application. * @summary Add Application * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {App} app * @param {number} [completionTimeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ addApp(cell: string, app: App, completionTimeout?: number, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_manage_apps` - Install, update, or remove applications ___ Delete all GUI applications from the cell. * @summary Clear Applications * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {number} [completionTimeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ clearApps(cell: string, completionTimeout?: number, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_manage_apps` - Install, update, or remove applications ___ Delete a GUI application from the cell. * @summary Delete Application * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} app * @param {number} [completionTimeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteApp(cell: string, app: string, completionTimeout?: number, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_access_apps` - View application configurations ___ Get the configuration for an active GUI application in the cell. To update the configuration of a GUI application in the cell, use this configuration with [updateApp](#/operations/updateApp). * @summary Configuration * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} app * @param {*} [options] Override http request option. * @throws {RequiredError} */ getApp(cell: string, app: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_access_apps` - View application configurations ___ List all GUI applications that have been added to a cell with [addApp](#/operations/addApp). If the cell does not contain GUI applications, the list is returned empty. * @summary List Applications * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listApps(cell: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_manage_apps` - Install, update, or remove applications ___ Update the configuration of a GUI application in the cell. * @summary Update Configuration * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} app * @param {App} app2 * @param {number} [completionTimeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ updateApp(cell: string, app: string, app2: App, completionTimeout?: number, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; } /** * BUSInputsOutputsApi - axios parameter creator */ declare const BUSInputsOutputsApiAxiosParamCreator: (configuration?: Configuration) => { /** * **Required permissions:** `can_manage_bus_ios` - Manage BUS IO configuration ___ Add the BUS inputs/outputs service to the cell. Starts a containerized service that enables BUS connections via the specified ethernet port. * @summary Add Service * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {BusIOType} busIOType * @param {number} [completionTimeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ addBusIOService: (cell: string, busIOType: BusIOType, completionTimeout?: number, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_manage_bus_ios` - Manage BUS IO configuration ___ Adds an input/output variable to or updates an input/output variable on the MODBUS device, e.g., NOVA\'s MODBUS service. The inputs/outputs map variables to specific memory addresses in the process image. The NOVA\'s MODBUS service\'s configuration can be viewed via [listModbusIOs](#/operations/listModbusIOs). * @summary Add MODBUS Input/Output * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} io Unique identifier to address an Input/Output in the cell. * @param {ModbusIOData} modbusIOData * @param {*} [options] Override http request option. * @throws {RequiredError} */ addModbusIO: (cell: string, io: string, modbusIOData: ModbusIOData, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_manage_bus_ios` - Manage BUS IO configuration ___ Adds an input/output variable to or updates an input/output variable on the PROFINET device, e.g., NOVA\'s PROFINET service. The inputs/outputs map variables to specific memory addresses in the process image. The default process image has buffer lengths of 64 bytes for input and output. - The size of the buffer is determined by the `config_file_content` that is passed in [addBusIOService](#/operations/addBusIOService) and has to be in accordance with the GSDML file describing the PROFINET device. The PROFINET controller as well as NOVA\'s PROFINET service use an input/output variable configuration to interpret the bits of the input/output process image. - The NOVA\'s PROFINET service\'s configuration can be viewed via [listProfinetIOs](#/operations/listProfinetIOs). For the PROFINET controller, e.g., a connected PLC, refer to the corresponding third party software, e.g., TIA portal). * @summary Add PROFINET Input/Output * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} io Unique identifier to address an Input/Output in the cell. * @param {ProfinetIOData} profinetIOData * @param {*} [options] Override http request option. * @throws {RequiredError} */ addProfinetIO: (cell: string, io: string, profinetIOData: ProfinetIOData, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_manage_bus_ios` - Manage BUS IO configuration ___ Adds or updates an input/output variable on the Snap7 service. The inputs/outputs map variables to specific memory locations in a Siemens PLC or PLCSIM Advanced instance accessed via the S7 protocol. * @summary Add Snap7 Input/Output * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} io Unique identifier to address an Input/Output in the cell. * @param {Snap7IOData} snap7IOData * @param {*} [options] Override http request option. * @throws {RequiredError} */ addSnap7IO: (cell: string, io: string, snap7IOData: Snap7IOData, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_manage_bus_ios` - Manage BUS IO configuration ___ Remove the BUS inputs/outputs service from the cell. * @summary Clear Service * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {number} [completionTimeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ clearBusIOService: (cell: string, completionTimeout?: number, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_manage_bus_ios` - Manage BUS IO configuration ___ Removes all input/output variable configurations from the MODBUS device, e.g., NOVA\'s MODBUS service. * @summary Remove all MODBUS Input/Outputs * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteAllModbusIOs: (cell: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_manage_bus_ios` - Manage BUS IO configuration ___ Removes all input/output variable configurations from the PROFINET device, e.g., NOVA\'s PROFINET service. * @summary Remove all PROFINET Input/Outputs * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteAllProfinetIOs: (cell: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_manage_bus_ios` - Manage BUS IO configuration ___ Removes all input/output variable configurations from the Snap7 service. * @summary Remove all Snap7 Input/Outputs * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteAllSnap7IOs: (cell: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_manage_bus_ios` - Manage BUS IO configuration ___ Removes an input/output variable configuration from the MODBUS device, e.g., NOVA\'s MODBUS service. * @summary Remove MODBUS Input/Output * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} io Unique identifier to address an Input/Output in the cell. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteModbusIO: (cell: string, io: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_manage_bus_ios` - Manage BUS IO configuration ___ Removes an input/output variable configuration from the PROFINET device, e.g., NOVA\'s PROFINET service. * @summary Remove PROFINET Input/Ouptut * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} io Unique identifier to address an Input/Output in the cell. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteProfinetIO: (cell: string, io: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_manage_bus_ios` - Manage BUS IO configuration ___ Removes an input/output variable configuration from the Snap7 service. * @summary Remove Snap7 Input/Output * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} io Unique identifier to address an Input/Output in the cell. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteSnap7IO: (cell: string, io: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_bus_ios` - Read and write BUS IO values ___ Get deployed BUS inputs/outputs service. * @summary Get Service * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getBusIOService: (cell: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_bus_ios` - Read and write BUS IO values ___ Get the current state of the BUS Inputs/Outputs service. * @summary State * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getBusIOState: (cell: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_bus_ios` - Read and write BUS IO values ___ Retrieves the current values of inputs/outputs. The identifiers of the inputs/outputs must be provided in the request. Request all available input/output identifiers via [listBusIODescriptions](#/operations/listBusIODescriptions). * @summary Get Input/Output Values * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {Array} [ios] * @param {*} [options] Override http request option. * @throws {RequiredError} */ getBusIOValues: (cell: string, ios?: Array, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_bus_ios` - Read and write BUS IO values ___ Get description of NOVA as a PROFINET device. * @summary Get PROFINET Description * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getProfinetDescription: (cell: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_bus_ios` - Read and write BUS IO values ___ Returns the Generic Station Description Markup Language (GSDML) file for the PROFINET device. The GSDML file describes the PROFINET device configuration and capabilities, and can be imported into PROFINET engineering tools, e.g., TIA Portal, or other PLC programming environments. The returned GSDML file matches the current slot configuration of the PROFINET device. * @summary Get PROFINET GSDML File * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getProfinetGSDML: (cell: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_bus_ios` - Read and write BUS IO values ___ Get input/output variable configuration of the PROFINET device, e.g., NOVA\'s PROFINET service as file. You can specify byte offsets for the input and output variable addresses to get an XML tagmap that is ready to paste to the third party software, e.g., TIA portal. * @summary PROFINET Inputs/Outputs to File * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {number} [inputOffset] * @param {number} [outputOffset] * @param {*} [options] Override http request option. * @throws {RequiredError} */ getProfinetIOsFromFile: (cell: string, inputOffset?: number, outputOffset?: number, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_bus_ios` - Read and write BUS IO values ___ List all input/output descriptions for configured BUS services. The input/output descriptions contain information like name, type and unit. The input/output direction is given in perspective of the BUS service. * @summary List Descriptions * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listBusIODescriptions: (cell: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_bus_ios` - Read and write BUS IO values ___ List descriptions for all configured input/output variables of the MODBUS service. The input/output descriptions contain information like name, type, and address. The input/output direction is given in perspective of the active MODBUS type (service or client). - The byte and bit addresses are the locations in the MODBUS input/output process image the variable points to. - The MODBUS controller, as well as NOVA\'s MODBUS service, use an input/output variable configuration to interpret the bits of the input and output process image. - The NOVA MODBUS service\'s configuration is modified via [addModbusIO](#/operations/addModbusIO). * @summary List MODBUS Input/Output Configuration * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listModbusIOs: (cell: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_bus_ios` - Read and write BUS IO values ___ List descriptions for all configured input/output variables of the PROFINET service. The input/output descriptions contain information like name, type, and unit. The input/output direction is given in perspective of the PROFINET device, e.g., the configured PROFINET service. - The byte and bit addresses are the locations in the PROFINET input/output process image the variable points to. - The PROFINET controller, as well as NOVA\'s PROFINET service, use an input/output variable configuration to interpret the bits of the input and output process image. - The NOVA PROFINET service\'s configuration is modified via [addProfinetIO](#/operations/addProfinetIO) and [setProfinetIOsFromFile](#/operations/setProfinetIOsFromFile). For the PROFINET controller, e.g., a connected PLC, refer to the corresponding third party software, e.g., TIA portal. * @summary List PROFINET Input/Output Configuration * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listProfinetIOs: (cell: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_bus_ios` - Read and write BUS IO values ___ List descriptions for all configured input/output variables of the Snap7 service. The Snap7 service communicates with Siemens PLCs and PLCSIM Advanced instances via the S7 protocol. * @summary List Snap7 Input/Output Configuration * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listSnap7IOs: (cell: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_bus_ios` - Read and write BUS IO values ___ Set values of outputs. In case of virtual Bus Input/Outputs, also inputs can be set. All available output identifiers can be requested via [listBusIODescriptions](#/operations/listBusIODescriptions). The call will return once the values have been set and accepted by the service. * @summary Set Output Values * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {Array} iOValue * @param {*} [options] Override http request option. * @throws {RequiredError} */ setBusIOValues: (cell: string, iOValue: Array, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_manage_bus_ios` - Manage BUS IO configuration ___ Sets input/output variable configuration on the PROFINET device (i.e. NOVA\'s PROFINET service) from XML file. The inputs/outputs map variables to specific memory addresses in the process image. The default process image has buffer lengths of 64 bytes for input and output. - The size of the buffer is determined by the `config_file_content` that is passed in [addBusIOService](#/operations/addBusIOService) and has to be in accordance with the GSDML file describing the PROFINET device. The PROFINET controller, as well as NOVA\'s PROFINET service, use an input/output variable configuration to interpret the bits of the input/output process image. - The NOVA\'s PROFINET service\'s configuration can be viewed via [listProfinetIOs](#/operations/listProfinetIOs). For the PROFINET controller, e.g., a connected PLC, refer to the corresponding engineering system, e.g., TIA portal. #### Export variables You can export the variable configuration of the PROFINET controller as an XML file from your engineering system, e.g., TIA portal. - The endpoint is built so that the perspective of input and output (PROFINET Device\'s input is PROFINET Controller\'s output) is internally handled (PROFINET device input is PROFINET controller output), meaning that you can paste the exported XML file here without modifying. * @summary Set PROFINET Inputs/Outputs from File * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {ProfinetInputOutputConfig} profinetInputOutputConfig * @param {*} [options] Override http request option. * @throws {RequiredError} */ setProfinetIOsFromFile: (cell: string, profinetInputOutputConfig: ProfinetInputOutputConfig, options?: RawAxiosRequestConfig) => Promise; }; /** * BUSInputsOutputsApi - functional programming interface */ declare const BUSInputsOutputsApiFp: (configuration?: Configuration) => { /** * **Required permissions:** `can_manage_bus_ios` - Manage BUS IO configuration ___ Add the BUS inputs/outputs service to the cell. Starts a containerized service that enables BUS connections via the specified ethernet port. * @summary Add Service * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {BusIOType} busIOType * @param {number} [completionTimeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ addBusIOService(cell: string, busIOType: BusIOType, completionTimeout?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_manage_bus_ios` - Manage BUS IO configuration ___ Adds an input/output variable to or updates an input/output variable on the MODBUS device, e.g., NOVA\'s MODBUS service. The inputs/outputs map variables to specific memory addresses in the process image. The NOVA\'s MODBUS service\'s configuration can be viewed via [listModbusIOs](#/operations/listModbusIOs). * @summary Add MODBUS Input/Output * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} io Unique identifier to address an Input/Output in the cell. * @param {ModbusIOData} modbusIOData * @param {*} [options] Override http request option. * @throws {RequiredError} */ addModbusIO(cell: string, io: string, modbusIOData: ModbusIOData, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_manage_bus_ios` - Manage BUS IO configuration ___ Adds an input/output variable to or updates an input/output variable on the PROFINET device, e.g., NOVA\'s PROFINET service. The inputs/outputs map variables to specific memory addresses in the process image. The default process image has buffer lengths of 64 bytes for input and output. - The size of the buffer is determined by the `config_file_content` that is passed in [addBusIOService](#/operations/addBusIOService) and has to be in accordance with the GSDML file describing the PROFINET device. The PROFINET controller as well as NOVA\'s PROFINET service use an input/output variable configuration to interpret the bits of the input/output process image. - The NOVA\'s PROFINET service\'s configuration can be viewed via [listProfinetIOs](#/operations/listProfinetIOs). For the PROFINET controller, e.g., a connected PLC, refer to the corresponding third party software, e.g., TIA portal). * @summary Add PROFINET Input/Output * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} io Unique identifier to address an Input/Output in the cell. * @param {ProfinetIOData} profinetIOData * @param {*} [options] Override http request option. * @throws {RequiredError} */ addProfinetIO(cell: string, io: string, profinetIOData: ProfinetIOData, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_manage_bus_ios` - Manage BUS IO configuration ___ Adds or updates an input/output variable on the Snap7 service. The inputs/outputs map variables to specific memory locations in a Siemens PLC or PLCSIM Advanced instance accessed via the S7 protocol. * @summary Add Snap7 Input/Output * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} io Unique identifier to address an Input/Output in the cell. * @param {Snap7IOData} snap7IOData * @param {*} [options] Override http request option. * @throws {RequiredError} */ addSnap7IO(cell: string, io: string, snap7IOData: Snap7IOData, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_manage_bus_ios` - Manage BUS IO configuration ___ Remove the BUS inputs/outputs service from the cell. * @summary Clear Service * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {number} [completionTimeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ clearBusIOService(cell: string, completionTimeout?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_manage_bus_ios` - Manage BUS IO configuration ___ Removes all input/output variable configurations from the MODBUS device, e.g., NOVA\'s MODBUS service. * @summary Remove all MODBUS Input/Outputs * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteAllModbusIOs(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_manage_bus_ios` - Manage BUS IO configuration ___ Removes all input/output variable configurations from the PROFINET device, e.g., NOVA\'s PROFINET service. * @summary Remove all PROFINET Input/Outputs * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteAllProfinetIOs(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_manage_bus_ios` - Manage BUS IO configuration ___ Removes all input/output variable configurations from the Snap7 service. * @summary Remove all Snap7 Input/Outputs * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteAllSnap7IOs(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_manage_bus_ios` - Manage BUS IO configuration ___ Removes an input/output variable configuration from the MODBUS device, e.g., NOVA\'s MODBUS service. * @summary Remove MODBUS Input/Output * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} io Unique identifier to address an Input/Output in the cell. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteModbusIO(cell: string, io: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_manage_bus_ios` - Manage BUS IO configuration ___ Removes an input/output variable configuration from the PROFINET device, e.g., NOVA\'s PROFINET service. * @summary Remove PROFINET Input/Ouptut * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} io Unique identifier to address an Input/Output in the cell. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteProfinetIO(cell: string, io: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_manage_bus_ios` - Manage BUS IO configuration ___ Removes an input/output variable configuration from the Snap7 service. * @summary Remove Snap7 Input/Output * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} io Unique identifier to address an Input/Output in the cell. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteSnap7IO(cell: string, io: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_operate_bus_ios` - Read and write BUS IO values ___ Get deployed BUS inputs/outputs service. * @summary Get Service * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getBusIOService(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_operate_bus_ios` - Read and write BUS IO values ___ Get the current state of the BUS Inputs/Outputs service. * @summary State * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getBusIOState(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_operate_bus_ios` - Read and write BUS IO values ___ Retrieves the current values of inputs/outputs. The identifiers of the inputs/outputs must be provided in the request. Request all available input/output identifiers via [listBusIODescriptions](#/operations/listBusIODescriptions). * @summary Get Input/Output Values * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {Array} [ios] * @param {*} [options] Override http request option. * @throws {RequiredError} */ getBusIOValues(cell: string, ios?: Array, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>>; /** * **Required permissions:** `can_operate_bus_ios` - Read and write BUS IO values ___ Get description of NOVA as a PROFINET device. * @summary Get PROFINET Description * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getProfinetDescription(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_operate_bus_ios` - Read and write BUS IO values ___ Returns the Generic Station Description Markup Language (GSDML) file for the PROFINET device. The GSDML file describes the PROFINET device configuration and capabilities, and can be imported into PROFINET engineering tools, e.g., TIA Portal, or other PLC programming environments. The returned GSDML file matches the current slot configuration of the PROFINET device. * @summary Get PROFINET GSDML File * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getProfinetGSDML(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_operate_bus_ios` - Read and write BUS IO values ___ Get input/output variable configuration of the PROFINET device, e.g., NOVA\'s PROFINET service as file. You can specify byte offsets for the input and output variable addresses to get an XML tagmap that is ready to paste to the third party software, e.g., TIA portal. * @summary PROFINET Inputs/Outputs to File * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {number} [inputOffset] * @param {number} [outputOffset] * @param {*} [options] Override http request option. * @throws {RequiredError} */ getProfinetIOsFromFile(cell: string, inputOffset?: number, outputOffset?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_operate_bus_ios` - Read and write BUS IO values ___ List all input/output descriptions for configured BUS services. The input/output descriptions contain information like name, type and unit. The input/output direction is given in perspective of the BUS service. * @summary List Descriptions * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listBusIODescriptions(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>>; /** * **Required permissions:** `can_operate_bus_ios` - Read and write BUS IO values ___ List descriptions for all configured input/output variables of the MODBUS service. The input/output descriptions contain information like name, type, and address. The input/output direction is given in perspective of the active MODBUS type (service or client). - The byte and bit addresses are the locations in the MODBUS input/output process image the variable points to. - The MODBUS controller, as well as NOVA\'s MODBUS service, use an input/output variable configuration to interpret the bits of the input and output process image. - The NOVA MODBUS service\'s configuration is modified via [addModbusIO](#/operations/addModbusIO). * @summary List MODBUS Input/Output Configuration * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listModbusIOs(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>>; /** * **Required permissions:** `can_operate_bus_ios` - Read and write BUS IO values ___ List descriptions for all configured input/output variables of the PROFINET service. The input/output descriptions contain information like name, type, and unit. The input/output direction is given in perspective of the PROFINET device, e.g., the configured PROFINET service. - The byte and bit addresses are the locations in the PROFINET input/output process image the variable points to. - The PROFINET controller, as well as NOVA\'s PROFINET service, use an input/output variable configuration to interpret the bits of the input and output process image. - The NOVA PROFINET service\'s configuration is modified via [addProfinetIO](#/operations/addProfinetIO) and [setProfinetIOsFromFile](#/operations/setProfinetIOsFromFile). For the PROFINET controller, e.g., a connected PLC, refer to the corresponding third party software, e.g., TIA portal. * @summary List PROFINET Input/Output Configuration * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listProfinetIOs(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>>; /** * **Required permissions:** `can_operate_bus_ios` - Read and write BUS IO values ___ List descriptions for all configured input/output variables of the Snap7 service. The Snap7 service communicates with Siemens PLCs and PLCSIM Advanced instances via the S7 protocol. * @summary List Snap7 Input/Output Configuration * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listSnap7IOs(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>>; /** * **Required permissions:** `can_operate_bus_ios` - Read and write BUS IO values ___ Set values of outputs. In case of virtual Bus Input/Outputs, also inputs can be set. All available output identifiers can be requested via [listBusIODescriptions](#/operations/listBusIODescriptions). The call will return once the values have been set and accepted by the service. * @summary Set Output Values * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {Array} iOValue * @param {*} [options] Override http request option. * @throws {RequiredError} */ setBusIOValues(cell: string, iOValue: Array, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_manage_bus_ios` - Manage BUS IO configuration ___ Sets input/output variable configuration on the PROFINET device (i.e. NOVA\'s PROFINET service) from XML file. The inputs/outputs map variables to specific memory addresses in the process image. The default process image has buffer lengths of 64 bytes for input and output. - The size of the buffer is determined by the `config_file_content` that is passed in [addBusIOService](#/operations/addBusIOService) and has to be in accordance with the GSDML file describing the PROFINET device. The PROFINET controller, as well as NOVA\'s PROFINET service, use an input/output variable configuration to interpret the bits of the input/output process image. - The NOVA\'s PROFINET service\'s configuration can be viewed via [listProfinetIOs](#/operations/listProfinetIOs). For the PROFINET controller, e.g., a connected PLC, refer to the corresponding engineering system, e.g., TIA portal. #### Export variables You can export the variable configuration of the PROFINET controller as an XML file from your engineering system, e.g., TIA portal. - The endpoint is built so that the perspective of input and output (PROFINET Device\'s input is PROFINET Controller\'s output) is internally handled (PROFINET device input is PROFINET controller output), meaning that you can paste the exported XML file here without modifying. * @summary Set PROFINET Inputs/Outputs from File * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {ProfinetInputOutputConfig} profinetInputOutputConfig * @param {*} [options] Override http request option. * @throws {RequiredError} */ setProfinetIOsFromFile(cell: string, profinetInputOutputConfig: ProfinetInputOutputConfig, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; }; /** * BUSInputsOutputsApi - factory interface */ declare const BUSInputsOutputsApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => { /** * **Required permissions:** `can_manage_bus_ios` - Manage BUS IO configuration ___ Add the BUS inputs/outputs service to the cell. Starts a containerized service that enables BUS connections via the specified ethernet port. * @summary Add Service * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {BusIOType} busIOType * @param {number} [completionTimeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ addBusIOService(cell: string, busIOType: BusIOType, completionTimeout?: number, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_manage_bus_ios` - Manage BUS IO configuration ___ Adds an input/output variable to or updates an input/output variable on the MODBUS device, e.g., NOVA\'s MODBUS service. The inputs/outputs map variables to specific memory addresses in the process image. The NOVA\'s MODBUS service\'s configuration can be viewed via [listModbusIOs](#/operations/listModbusIOs). * @summary Add MODBUS Input/Output * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} io Unique identifier to address an Input/Output in the cell. * @param {ModbusIOData} modbusIOData * @param {*} [options] Override http request option. * @throws {RequiredError} */ addModbusIO(cell: string, io: string, modbusIOData: ModbusIOData, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_manage_bus_ios` - Manage BUS IO configuration ___ Adds an input/output variable to or updates an input/output variable on the PROFINET device, e.g., NOVA\'s PROFINET service. The inputs/outputs map variables to specific memory addresses in the process image. The default process image has buffer lengths of 64 bytes for input and output. - The size of the buffer is determined by the `config_file_content` that is passed in [addBusIOService](#/operations/addBusIOService) and has to be in accordance with the GSDML file describing the PROFINET device. The PROFINET controller as well as NOVA\'s PROFINET service use an input/output variable configuration to interpret the bits of the input/output process image. - The NOVA\'s PROFINET service\'s configuration can be viewed via [listProfinetIOs](#/operations/listProfinetIOs). For the PROFINET controller, e.g., a connected PLC, refer to the corresponding third party software, e.g., TIA portal). * @summary Add PROFINET Input/Output * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} io Unique identifier to address an Input/Output in the cell. * @param {ProfinetIOData} profinetIOData * @param {*} [options] Override http request option. * @throws {RequiredError} */ addProfinetIO(cell: string, io: string, profinetIOData: ProfinetIOData, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_manage_bus_ios` - Manage BUS IO configuration ___ Adds or updates an input/output variable on the Snap7 service. The inputs/outputs map variables to specific memory locations in a Siemens PLC or PLCSIM Advanced instance accessed via the S7 protocol. * @summary Add Snap7 Input/Output * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} io Unique identifier to address an Input/Output in the cell. * @param {Snap7IOData} snap7IOData * @param {*} [options] Override http request option. * @throws {RequiredError} */ addSnap7IO(cell: string, io: string, snap7IOData: Snap7IOData, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_manage_bus_ios` - Manage BUS IO configuration ___ Remove the BUS inputs/outputs service from the cell. * @summary Clear Service * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {number} [completionTimeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ clearBusIOService(cell: string, completionTimeout?: number, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_manage_bus_ios` - Manage BUS IO configuration ___ Removes all input/output variable configurations from the MODBUS device, e.g., NOVA\'s MODBUS service. * @summary Remove all MODBUS Input/Outputs * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteAllModbusIOs(cell: string, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_manage_bus_ios` - Manage BUS IO configuration ___ Removes all input/output variable configurations from the PROFINET device, e.g., NOVA\'s PROFINET service. * @summary Remove all PROFINET Input/Outputs * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteAllProfinetIOs(cell: string, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_manage_bus_ios` - Manage BUS IO configuration ___ Removes all input/output variable configurations from the Snap7 service. * @summary Remove all Snap7 Input/Outputs * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteAllSnap7IOs(cell: string, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_manage_bus_ios` - Manage BUS IO configuration ___ Removes an input/output variable configuration from the MODBUS device, e.g., NOVA\'s MODBUS service. * @summary Remove MODBUS Input/Output * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} io Unique identifier to address an Input/Output in the cell. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteModbusIO(cell: string, io: string, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_manage_bus_ios` - Manage BUS IO configuration ___ Removes an input/output variable configuration from the PROFINET device, e.g., NOVA\'s PROFINET service. * @summary Remove PROFINET Input/Ouptut * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} io Unique identifier to address an Input/Output in the cell. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteProfinetIO(cell: string, io: string, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_manage_bus_ios` - Manage BUS IO configuration ___ Removes an input/output variable configuration from the Snap7 service. * @summary Remove Snap7 Input/Output * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} io Unique identifier to address an Input/Output in the cell. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteSnap7IO(cell: string, io: string, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_operate_bus_ios` - Read and write BUS IO values ___ Get deployed BUS inputs/outputs service. * @summary Get Service * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getBusIOService(cell: string, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_operate_bus_ios` - Read and write BUS IO values ___ Get the current state of the BUS Inputs/Outputs service. * @summary State * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getBusIOState(cell: string, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_operate_bus_ios` - Read and write BUS IO values ___ Retrieves the current values of inputs/outputs. The identifiers of the inputs/outputs must be provided in the request. Request all available input/output identifiers via [listBusIODescriptions](#/operations/listBusIODescriptions). * @summary Get Input/Output Values * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {Array} [ios] * @param {*} [options] Override http request option. * @throws {RequiredError} */ getBusIOValues(cell: string, ios?: Array, options?: RawAxiosRequestConfig): AxiosPromise>; /** * **Required permissions:** `can_operate_bus_ios` - Read and write BUS IO values ___ Get description of NOVA as a PROFINET device. * @summary Get PROFINET Description * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getProfinetDescription(cell: string, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_operate_bus_ios` - Read and write BUS IO values ___ Returns the Generic Station Description Markup Language (GSDML) file for the PROFINET device. The GSDML file describes the PROFINET device configuration and capabilities, and can be imported into PROFINET engineering tools, e.g., TIA Portal, or other PLC programming environments. The returned GSDML file matches the current slot configuration of the PROFINET device. * @summary Get PROFINET GSDML File * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getProfinetGSDML(cell: string, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_operate_bus_ios` - Read and write BUS IO values ___ Get input/output variable configuration of the PROFINET device, e.g., NOVA\'s PROFINET service as file. You can specify byte offsets for the input and output variable addresses to get an XML tagmap that is ready to paste to the third party software, e.g., TIA portal. * @summary PROFINET Inputs/Outputs to File * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {number} [inputOffset] * @param {number} [outputOffset] * @param {*} [options] Override http request option. * @throws {RequiredError} */ getProfinetIOsFromFile(cell: string, inputOffset?: number, outputOffset?: number, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_operate_bus_ios` - Read and write BUS IO values ___ List all input/output descriptions for configured BUS services. The input/output descriptions contain information like name, type and unit. The input/output direction is given in perspective of the BUS service. * @summary List Descriptions * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listBusIODescriptions(cell: string, options?: RawAxiosRequestConfig): AxiosPromise>; /** * **Required permissions:** `can_operate_bus_ios` - Read and write BUS IO values ___ List descriptions for all configured input/output variables of the MODBUS service. The input/output descriptions contain information like name, type, and address. The input/output direction is given in perspective of the active MODBUS type (service or client). - The byte and bit addresses are the locations in the MODBUS input/output process image the variable points to. - The MODBUS controller, as well as NOVA\'s MODBUS service, use an input/output variable configuration to interpret the bits of the input and output process image. - The NOVA MODBUS service\'s configuration is modified via [addModbusIO](#/operations/addModbusIO). * @summary List MODBUS Input/Output Configuration * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listModbusIOs(cell: string, options?: RawAxiosRequestConfig): AxiosPromise>; /** * **Required permissions:** `can_operate_bus_ios` - Read and write BUS IO values ___ List descriptions for all configured input/output variables of the PROFINET service. The input/output descriptions contain information like name, type, and unit. The input/output direction is given in perspective of the PROFINET device, e.g., the configured PROFINET service. - The byte and bit addresses are the locations in the PROFINET input/output process image the variable points to. - The PROFINET controller, as well as NOVA\'s PROFINET service, use an input/output variable configuration to interpret the bits of the input and output process image. - The NOVA PROFINET service\'s configuration is modified via [addProfinetIO](#/operations/addProfinetIO) and [setProfinetIOsFromFile](#/operations/setProfinetIOsFromFile). For the PROFINET controller, e.g., a connected PLC, refer to the corresponding third party software, e.g., TIA portal. * @summary List PROFINET Input/Output Configuration * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listProfinetIOs(cell: string, options?: RawAxiosRequestConfig): AxiosPromise>; /** * **Required permissions:** `can_operate_bus_ios` - Read and write BUS IO values ___ List descriptions for all configured input/output variables of the Snap7 service. The Snap7 service communicates with Siemens PLCs and PLCSIM Advanced instances via the S7 protocol. * @summary List Snap7 Input/Output Configuration * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listSnap7IOs(cell: string, options?: RawAxiosRequestConfig): AxiosPromise>; /** * **Required permissions:** `can_operate_bus_ios` - Read and write BUS IO values ___ Set values of outputs. In case of virtual Bus Input/Outputs, also inputs can be set. All available output identifiers can be requested via [listBusIODescriptions](#/operations/listBusIODescriptions). The call will return once the values have been set and accepted by the service. * @summary Set Output Values * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {Array} iOValue * @param {*} [options] Override http request option. * @throws {RequiredError} */ setBusIOValues(cell: string, iOValue: Array, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_manage_bus_ios` - Manage BUS IO configuration ___ Sets input/output variable configuration on the PROFINET device (i.e. NOVA\'s PROFINET service) from XML file. The inputs/outputs map variables to specific memory addresses in the process image. The default process image has buffer lengths of 64 bytes for input and output. - The size of the buffer is determined by the `config_file_content` that is passed in [addBusIOService](#/operations/addBusIOService) and has to be in accordance with the GSDML file describing the PROFINET device. The PROFINET controller, as well as NOVA\'s PROFINET service, use an input/output variable configuration to interpret the bits of the input/output process image. - The NOVA\'s PROFINET service\'s configuration can be viewed via [listProfinetIOs](#/operations/listProfinetIOs). For the PROFINET controller, e.g., a connected PLC, refer to the corresponding engineering system, e.g., TIA portal. #### Export variables You can export the variable configuration of the PROFINET controller as an XML file from your engineering system, e.g., TIA portal. - The endpoint is built so that the perspective of input and output (PROFINET Device\'s input is PROFINET Controller\'s output) is internally handled (PROFINET device input is PROFINET controller output), meaning that you can paste the exported XML file here without modifying. * @summary Set PROFINET Inputs/Outputs from File * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {ProfinetInputOutputConfig} profinetInputOutputConfig * @param {*} [options] Override http request option. * @throws {RequiredError} */ setProfinetIOsFromFile(cell: string, profinetInputOutputConfig: ProfinetInputOutputConfig, options?: RawAxiosRequestConfig): AxiosPromise; }; /** * BUSInputsOutputsApi - object-oriented interface */ declare class BUSInputsOutputsApi extends BaseAPI { /** * **Required permissions:** `can_manage_bus_ios` - Manage BUS IO configuration ___ Add the BUS inputs/outputs service to the cell. Starts a containerized service that enables BUS connections via the specified ethernet port. * @summary Add Service * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {BusIOType} busIOType * @param {number} [completionTimeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ addBusIOService(cell: string, busIOType: BusIOType, completionTimeout?: number, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_manage_bus_ios` - Manage BUS IO configuration ___ Adds an input/output variable to or updates an input/output variable on the MODBUS device, e.g., NOVA\'s MODBUS service. The inputs/outputs map variables to specific memory addresses in the process image. The NOVA\'s MODBUS service\'s configuration can be viewed via [listModbusIOs](#/operations/listModbusIOs). * @summary Add MODBUS Input/Output * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} io Unique identifier to address an Input/Output in the cell. * @param {ModbusIOData} modbusIOData * @param {*} [options] Override http request option. * @throws {RequiredError} */ addModbusIO(cell: string, io: string, modbusIOData: ModbusIOData, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_manage_bus_ios` - Manage BUS IO configuration ___ Adds an input/output variable to or updates an input/output variable on the PROFINET device, e.g., NOVA\'s PROFINET service. The inputs/outputs map variables to specific memory addresses in the process image. The default process image has buffer lengths of 64 bytes for input and output. - The size of the buffer is determined by the `config_file_content` that is passed in [addBusIOService](#/operations/addBusIOService) and has to be in accordance with the GSDML file describing the PROFINET device. The PROFINET controller as well as NOVA\'s PROFINET service use an input/output variable configuration to interpret the bits of the input/output process image. - The NOVA\'s PROFINET service\'s configuration can be viewed via [listProfinetIOs](#/operations/listProfinetIOs). For the PROFINET controller, e.g., a connected PLC, refer to the corresponding third party software, e.g., TIA portal). * @summary Add PROFINET Input/Output * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} io Unique identifier to address an Input/Output in the cell. * @param {ProfinetIOData} profinetIOData * @param {*} [options] Override http request option. * @throws {RequiredError} */ addProfinetIO(cell: string, io: string, profinetIOData: ProfinetIOData, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_manage_bus_ios` - Manage BUS IO configuration ___ Adds or updates an input/output variable on the Snap7 service. The inputs/outputs map variables to specific memory locations in a Siemens PLC or PLCSIM Advanced instance accessed via the S7 protocol. * @summary Add Snap7 Input/Output * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} io Unique identifier to address an Input/Output in the cell. * @param {Snap7IOData} snap7IOData * @param {*} [options] Override http request option. * @throws {RequiredError} */ addSnap7IO(cell: string, io: string, snap7IOData: Snap7IOData, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_manage_bus_ios` - Manage BUS IO configuration ___ Remove the BUS inputs/outputs service from the cell. * @summary Clear Service * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {number} [completionTimeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ clearBusIOService(cell: string, completionTimeout?: number, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_manage_bus_ios` - Manage BUS IO configuration ___ Removes all input/output variable configurations from the MODBUS device, e.g., NOVA\'s MODBUS service. * @summary Remove all MODBUS Input/Outputs * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteAllModbusIOs(cell: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_manage_bus_ios` - Manage BUS IO configuration ___ Removes all input/output variable configurations from the PROFINET device, e.g., NOVA\'s PROFINET service. * @summary Remove all PROFINET Input/Outputs * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteAllProfinetIOs(cell: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_manage_bus_ios` - Manage BUS IO configuration ___ Removes all input/output variable configurations from the Snap7 service. * @summary Remove all Snap7 Input/Outputs * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteAllSnap7IOs(cell: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_manage_bus_ios` - Manage BUS IO configuration ___ Removes an input/output variable configuration from the MODBUS device, e.g., NOVA\'s MODBUS service. * @summary Remove MODBUS Input/Output * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} io Unique identifier to address an Input/Output in the cell. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteModbusIO(cell: string, io: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_manage_bus_ios` - Manage BUS IO configuration ___ Removes an input/output variable configuration from the PROFINET device, e.g., NOVA\'s PROFINET service. * @summary Remove PROFINET Input/Ouptut * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} io Unique identifier to address an Input/Output in the cell. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteProfinetIO(cell: string, io: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_manage_bus_ios` - Manage BUS IO configuration ___ Removes an input/output variable configuration from the Snap7 service. * @summary Remove Snap7 Input/Output * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} io Unique identifier to address an Input/Output in the cell. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteSnap7IO(cell: string, io: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_bus_ios` - Read and write BUS IO values ___ Get deployed BUS inputs/outputs service. * @summary Get Service * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getBusIOService(cell: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_bus_ios` - Read and write BUS IO values ___ Get the current state of the BUS Inputs/Outputs service. * @summary State * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getBusIOState(cell: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_bus_ios` - Read and write BUS IO values ___ Retrieves the current values of inputs/outputs. The identifiers of the inputs/outputs must be provided in the request. Request all available input/output identifiers via [listBusIODescriptions](#/operations/listBusIODescriptions). * @summary Get Input/Output Values * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {Array} [ios] * @param {*} [options] Override http request option. * @throws {RequiredError} */ getBusIOValues(cell: string, ios?: Array, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_bus_ios` - Read and write BUS IO values ___ Get description of NOVA as a PROFINET device. * @summary Get PROFINET Description * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getProfinetDescription(cell: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_bus_ios` - Read and write BUS IO values ___ Returns the Generic Station Description Markup Language (GSDML) file for the PROFINET device. The GSDML file describes the PROFINET device configuration and capabilities, and can be imported into PROFINET engineering tools, e.g., TIA Portal, or other PLC programming environments. The returned GSDML file matches the current slot configuration of the PROFINET device. * @summary Get PROFINET GSDML File * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getProfinetGSDML(cell: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_bus_ios` - Read and write BUS IO values ___ Get input/output variable configuration of the PROFINET device, e.g., NOVA\'s PROFINET service as file. You can specify byte offsets for the input and output variable addresses to get an XML tagmap that is ready to paste to the third party software, e.g., TIA portal. * @summary PROFINET Inputs/Outputs to File * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {number} [inputOffset] * @param {number} [outputOffset] * @param {*} [options] Override http request option. * @throws {RequiredError} */ getProfinetIOsFromFile(cell: string, inputOffset?: number, outputOffset?: number, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_bus_ios` - Read and write BUS IO values ___ List all input/output descriptions for configured BUS services. The input/output descriptions contain information like name, type and unit. The input/output direction is given in perspective of the BUS service. * @summary List Descriptions * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listBusIODescriptions(cell: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_bus_ios` - Read and write BUS IO values ___ List descriptions for all configured input/output variables of the MODBUS service. The input/output descriptions contain information like name, type, and address. The input/output direction is given in perspective of the active MODBUS type (service or client). - The byte and bit addresses are the locations in the MODBUS input/output process image the variable points to. - The MODBUS controller, as well as NOVA\'s MODBUS service, use an input/output variable configuration to interpret the bits of the input and output process image. - The NOVA MODBUS service\'s configuration is modified via [addModbusIO](#/operations/addModbusIO). * @summary List MODBUS Input/Output Configuration * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listModbusIOs(cell: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_bus_ios` - Read and write BUS IO values ___ List descriptions for all configured input/output variables of the PROFINET service. The input/output descriptions contain information like name, type, and unit. The input/output direction is given in perspective of the PROFINET device, e.g., the configured PROFINET service. - The byte and bit addresses are the locations in the PROFINET input/output process image the variable points to. - The PROFINET controller, as well as NOVA\'s PROFINET service, use an input/output variable configuration to interpret the bits of the input and output process image. - The NOVA PROFINET service\'s configuration is modified via [addProfinetIO](#/operations/addProfinetIO) and [setProfinetIOsFromFile](#/operations/setProfinetIOsFromFile). For the PROFINET controller, e.g., a connected PLC, refer to the corresponding third party software, e.g., TIA portal. * @summary List PROFINET Input/Output Configuration * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listProfinetIOs(cell: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_bus_ios` - Read and write BUS IO values ___ List descriptions for all configured input/output variables of the Snap7 service. The Snap7 service communicates with Siemens PLCs and PLCSIM Advanced instances via the S7 protocol. * @summary List Snap7 Input/Output Configuration * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listSnap7IOs(cell: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_bus_ios` - Read and write BUS IO values ___ Set values of outputs. In case of virtual Bus Input/Outputs, also inputs can be set. All available output identifiers can be requested via [listBusIODescriptions](#/operations/listBusIODescriptions). The call will return once the values have been set and accepted by the service. * @summary Set Output Values * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {Array} iOValue * @param {*} [options] Override http request option. * @throws {RequiredError} */ setBusIOValues(cell: string, iOValue: Array, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_manage_bus_ios` - Manage BUS IO configuration ___ Sets input/output variable configuration on the PROFINET device (i.e. NOVA\'s PROFINET service) from XML file. The inputs/outputs map variables to specific memory addresses in the process image. The default process image has buffer lengths of 64 bytes for input and output. - The size of the buffer is determined by the `config_file_content` that is passed in [addBusIOService](#/operations/addBusIOService) and has to be in accordance with the GSDML file describing the PROFINET device. The PROFINET controller, as well as NOVA\'s PROFINET service, use an input/output variable configuration to interpret the bits of the input/output process image. - The NOVA\'s PROFINET service\'s configuration can be viewed via [listProfinetIOs](#/operations/listProfinetIOs). For the PROFINET controller, e.g., a connected PLC, refer to the corresponding engineering system, e.g., TIA portal. #### Export variables You can export the variable configuration of the PROFINET controller as an XML file from your engineering system, e.g., TIA portal. - The endpoint is built so that the perspective of input and output (PROFINET Device\'s input is PROFINET Controller\'s output) is internally handled (PROFINET device input is PROFINET controller output), meaning that you can paste the exported XML file here without modifying. * @summary Set PROFINET Inputs/Outputs from File * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {ProfinetInputOutputConfig} profinetInputOutputConfig * @param {*} [options] Override http request option. * @throws {RequiredError} */ setProfinetIOsFromFile(cell: string, profinetInputOutputConfig: ProfinetInputOutputConfig, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; } /** * CellApi - axios parameter creator */ declare const CellApiAxiosParamCreator: (configuration?: Configuration) => { /** * **Required permissions:** `can_manage_cells` - Create, update, or delete cells ___ Check if a more recent Wandelbots NOVA version is available for the cell. Updates greater than the system version are ignored. * @summary Check Cell Update * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {ReleaseChannel} channel * @param {*} [options] Override http request option. * @throws {RequiredError} */ checkCellVersionUpdate: (cell: string, channel: ReleaseChannel, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_manage_cells` - Create, update, or delete cells ___ Delete an entire cell. * @summary Delete Cell * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {number} [completionTimeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteCell: (cell: string, completionTimeout?: number, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_manage_cells` - Create, update, or delete cells ___ Deploy an entire cell with all its resources. A cell can be used to deploy a robot controller, one or more robots, as well as custom applications. Refer to the [Wandelbots NOVA documentation](https://docs.wandelbots.io/latest/setup-cell) for more information. * @summary Add Cell * @param {Cell} cell * @param {number} [completionTimeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ deployCell: (cell: Cell, completionTimeout?: number, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ List all cell resources. * @summary Configuration * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getCell: (cell: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ List the status of all cell resources. * @summary Service Status * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getCellStatus: (cell: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ List all deployed cell names. If no cells are deployed, an empty list is returned. * @summary List Cells * @param {*} [options] Override http request option. * @throws {RequiredError} */ listCells: (options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_manage_cells` - Create, update, or delete cells ___ Deactivate or activate the services of a cell. * @summary Operating State * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {OperatingState} operatingState Set state of the cell. Active or inactive. * @param {*} [options] Override http request option. * @throws {RequiredError} */ setCellStatus: (cell: string, operatingState: OperatingState, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_manage_cells` - Create, update, or delete cells ___ Update the definition of the entire cell. > **NOTE** > > This endpoint replaces the full cell configuration and is not a partial update. > To change only one field: > 1. Get the current configuration via [Cell > Configuration](#/operations/getCell). > 2. Send the full configuration with your intended changes via [Cell > Update Configuration](#/operations/updateCell). Omitting existing sections may reset or remove their current configuration. * @summary Update Configuration * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {Cell} cell2 * @param {number} [completionTimeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ updateCell: (cell: string, cell2: Cell, completionTimeout?: number, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_manage_cells` - Create, update, or delete cells ___ Update the Foundation chart version for a single cell based on a release channel. The resulting version is capped at the current system version. * @summary Update Cell Version * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {UpdateCellVersionRequest} updateCellVersionRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ updateCellVersion: (cell: string, updateCellVersionRequest: UpdateCellVersionRequest, options?: RawAxiosRequestConfig) => Promise; }; /** * CellApi - functional programming interface */ declare const CellApiFp: (configuration?: Configuration) => { /** * **Required permissions:** `can_manage_cells` - Create, update, or delete cells ___ Check if a more recent Wandelbots NOVA version is available for the cell. Updates greater than the system version are ignored. * @summary Check Cell Update * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {ReleaseChannel} channel * @param {*} [options] Override http request option. * @throws {RequiredError} */ checkCellVersionUpdate(cell: string, channel: ReleaseChannel, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_manage_cells` - Create, update, or delete cells ___ Delete an entire cell. * @summary Delete Cell * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {number} [completionTimeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteCell(cell: string, completionTimeout?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_manage_cells` - Create, update, or delete cells ___ Deploy an entire cell with all its resources. A cell can be used to deploy a robot controller, one or more robots, as well as custom applications. Refer to the [Wandelbots NOVA documentation](https://docs.wandelbots.io/latest/setup-cell) for more information. * @summary Add Cell * @param {Cell} cell * @param {number} [completionTimeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ deployCell(cell: Cell, completionTimeout?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ List all cell resources. * @summary Configuration * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getCell(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ List the status of all cell resources. * @summary Service Status * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getCellStatus(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ List all deployed cell names. If no cells are deployed, an empty list is returned. * @summary List Cells * @param {*} [options] Override http request option. * @throws {RequiredError} */ listCells(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>>; /** * **Required permissions:** `can_manage_cells` - Create, update, or delete cells ___ Deactivate or activate the services of a cell. * @summary Operating State * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {OperatingState} operatingState Set state of the cell. Active or inactive. * @param {*} [options] Override http request option. * @throws {RequiredError} */ setCellStatus(cell: string, operatingState: OperatingState, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_manage_cells` - Create, update, or delete cells ___ Update the definition of the entire cell. > **NOTE** > > This endpoint replaces the full cell configuration and is not a partial update. > To change only one field: > 1. Get the current configuration via [Cell > Configuration](#/operations/getCell). > 2. Send the full configuration with your intended changes via [Cell > Update Configuration](#/operations/updateCell). Omitting existing sections may reset or remove their current configuration. * @summary Update Configuration * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {Cell} cell2 * @param {number} [completionTimeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ updateCell(cell: string, cell2: Cell, completionTimeout?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_manage_cells` - Create, update, or delete cells ___ Update the Foundation chart version for a single cell based on a release channel. The resulting version is capped at the current system version. * @summary Update Cell Version * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {UpdateCellVersionRequest} updateCellVersionRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ updateCellVersion(cell: string, updateCellVersionRequest: UpdateCellVersionRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; }; /** * CellApi - factory interface */ declare const CellApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => { /** * **Required permissions:** `can_manage_cells` - Create, update, or delete cells ___ Check if a more recent Wandelbots NOVA version is available for the cell. Updates greater than the system version are ignored. * @summary Check Cell Update * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {ReleaseChannel} channel * @param {*} [options] Override http request option. * @throws {RequiredError} */ checkCellVersionUpdate(cell: string, channel: ReleaseChannel, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_manage_cells` - Create, update, or delete cells ___ Delete an entire cell. * @summary Delete Cell * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {number} [completionTimeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteCell(cell: string, completionTimeout?: number, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_manage_cells` - Create, update, or delete cells ___ Deploy an entire cell with all its resources. A cell can be used to deploy a robot controller, one or more robots, as well as custom applications. Refer to the [Wandelbots NOVA documentation](https://docs.wandelbots.io/latest/setup-cell) for more information. * @summary Add Cell * @param {Cell} cell * @param {number} [completionTimeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ deployCell(cell: Cell, completionTimeout?: number, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ List all cell resources. * @summary Configuration * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getCell(cell: string, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ List the status of all cell resources. * @summary Service Status * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getCellStatus(cell: string, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ List all deployed cell names. If no cells are deployed, an empty list is returned. * @summary List Cells * @param {*} [options] Override http request option. * @throws {RequiredError} */ listCells(options?: RawAxiosRequestConfig): AxiosPromise>; /** * **Required permissions:** `can_manage_cells` - Create, update, or delete cells ___ Deactivate or activate the services of a cell. * @summary Operating State * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {OperatingState} operatingState Set state of the cell. Active or inactive. * @param {*} [options] Override http request option. * @throws {RequiredError} */ setCellStatus(cell: string, operatingState: OperatingState, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_manage_cells` - Create, update, or delete cells ___ Update the definition of the entire cell. > **NOTE** > > This endpoint replaces the full cell configuration and is not a partial update. > To change only one field: > 1. Get the current configuration via [Cell > Configuration](#/operations/getCell). > 2. Send the full configuration with your intended changes via [Cell > Update Configuration](#/operations/updateCell). Omitting existing sections may reset or remove their current configuration. * @summary Update Configuration * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {Cell} cell2 * @param {number} [completionTimeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ updateCell(cell: string, cell2: Cell, completionTimeout?: number, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_manage_cells` - Create, update, or delete cells ___ Update the Foundation chart version for a single cell based on a release channel. The resulting version is capped at the current system version. * @summary Update Cell Version * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {UpdateCellVersionRequest} updateCellVersionRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ updateCellVersion(cell: string, updateCellVersionRequest: UpdateCellVersionRequest, options?: RawAxiosRequestConfig): AxiosPromise; }; /** * CellApi - object-oriented interface */ declare class CellApi extends BaseAPI { /** * **Required permissions:** `can_manage_cells` - Create, update, or delete cells ___ Check if a more recent Wandelbots NOVA version is available for the cell. Updates greater than the system version are ignored. * @summary Check Cell Update * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {ReleaseChannel} channel * @param {*} [options] Override http request option. * @throws {RequiredError} */ checkCellVersionUpdate(cell: string, channel: ReleaseChannel, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_manage_cells` - Create, update, or delete cells ___ Delete an entire cell. * @summary Delete Cell * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {number} [completionTimeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteCell(cell: string, completionTimeout?: number, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_manage_cells` - Create, update, or delete cells ___ Deploy an entire cell with all its resources. A cell can be used to deploy a robot controller, one or more robots, as well as custom applications. Refer to the [Wandelbots NOVA documentation](https://docs.wandelbots.io/latest/setup-cell) for more information. * @summary Add Cell * @param {Cell} cell * @param {number} [completionTimeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ deployCell(cell: Cell, completionTimeout?: number, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ List all cell resources. * @summary Configuration * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getCell(cell: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ List the status of all cell resources. * @summary Service Status * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getCellStatus(cell: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ List all deployed cell names. If no cells are deployed, an empty list is returned. * @summary List Cells * @param {*} [options] Override http request option. * @throws {RequiredError} */ listCells(options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_manage_cells` - Create, update, or delete cells ___ Deactivate or activate the services of a cell. * @summary Operating State * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {OperatingState} operatingState Set state of the cell. Active or inactive. * @param {*} [options] Override http request option. * @throws {RequiredError} */ setCellStatus(cell: string, operatingState: OperatingState, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_manage_cells` - Create, update, or delete cells ___ Update the definition of the entire cell. > **NOTE** > > This endpoint replaces the full cell configuration and is not a partial update. > To change only one field: > 1. Get the current configuration via [Cell > Configuration](#/operations/getCell). > 2. Send the full configuration with your intended changes via [Cell > Update Configuration](#/operations/updateCell). Omitting existing sections may reset or remove their current configuration. * @summary Update Configuration * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {Cell} cell2 * @param {number} [completionTimeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ updateCell(cell: string, cell2: Cell, completionTimeout?: number, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_manage_cells` - Create, update, or delete cells ___ Update the Foundation chart version for a single cell based on a release channel. The resulting version is capped at the current system version. * @summary Update Cell Version * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {UpdateCellVersionRequest} updateCellVersionRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ updateCellVersion(cell: string, updateCellVersionRequest: UpdateCellVersionRequest, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; } /** * ControllerApi - axios parameter creator */ declare const ControllerApiAxiosParamCreator: (configuration?: Configuration) => { /** * **Required permissions:** `can_manage_controllers` - Create, update, or delete robot controllers ___ Add a robot controller to the cell. * @summary Add Robot Controller * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {RobotController} robotController * @param {number} [completionTimeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ addRobotController: (cell: string, robotController: RobotController, completionTimeout?: number, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_manage_controllers` - Create, update, or delete robot controllers ___ Delete all robot controllers from the cell. To replace all robot controllers in a cell, use this endpoint in combination with [addRobotController](#/operations/addRobotController). * @summary Clear Robot Controllers * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {number} [completionTimeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ clearRobotControllers: (cell: string, completionTimeout?: number, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_manage_controllers` - Create, update, or delete robot controllers ___ Delete a robot controller from the cell. * @summary Delete Robot Controller * @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} [completionTimeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteRobotController: (cell: string, controller: string, completionTimeout?: number, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Get description of a configured robot controller including a list of connected motion group identifiers. Use [getMotionGroupDescription](#/operations/getMotionGroupDescription) to get more information about the motion group. * @summary Description * @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} */ getControllerDescription: (cell: string, controller: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Request a coordinate system specification for a given identifier. Use parameter `orientation_type` to get the orientation part of the transformation offset of the coordinate system returned in the requested orientation notation. If parameter `orientation_type` is not set, the orientation part of the transformation offset of the coordinate system is returned in rotation vector notation. The coordinate systems from the robot controller are loaded when the motion group associated with the coordinate system is activated. With deactivation of the motion group, the associated coordinate systems are removed from NOVA. The unique identifier of the coordinate systems from the robot controllers are suffixed with `On` + the unique identifier of the robot controller. * @summary Coordinate System * @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 {string} coordinateSystem Unique identifier addressing a coordinate system. * @param {OrientationType} [orientationType] * @param {*} [options] Override http request option. * @throws {RequiredError} */ getCoordinateSystem: (cell: string, controller: string, coordinateSystem: string, orientationType?: OrientationType, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Get the current state of a robot controller. * @summary 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 {*} [options] Override http request option. * @throws {RequiredError} */ getCurrentRobotControllerState: (cell: string, controller: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Get the configuration for a robot controller. * @summary Robot Controller * @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} */ getRobotController: (cell: string, controller: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Receive data to configure a virtual robot controller based on another controller. This can be used to create a virtual clone of a specific physical robot. When adding a virtual controller, use the Virtual configuration variant of [addRobotController](#/operations/addRobotController) and pass the content string from this endpoint as the `json` field. Omit the `type` field that selects a preset configuration, which is not required when providing a complete configuration. * @summary Virtual Controller Configuration * @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} */ getVirtualControllerConfiguration: (cell: string, controller: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Lists all specifications of coordinate systems from robot controllers. Use parameter `orientation_type` to get the orientation part of the transformation offset of the coordinate system returned in the requested orientation notation. If parameter `orientation_type` is not set, the orientation part of the transformation offset of the coordinate system is returned in rotation vector notation. The coordinate systems from the robot controller are loaded when the motion group associated with the coordinate system is activated. With deactivation of the motion group, the associated coordinate systems are removed from NOVA. The unique identifier of the coordinate systems from the robot controllers are suffixed with `On` + the unique identifier of the robot controller. * @summary List Coordinate Systems * @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 {OrientationType} [orientationType] * @param {*} [options] Override http request option. * @throws {RequiredError} */ listCoordinateSystems: (cell: string, controller: string, orientationType?: OrientationType, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ List the names of all deployed robot controllers. * @summary List Robot Controllers * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listRobotControllers: (cell: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Switch between monitor and control usage as default for a robot controller. Monitoring mode is used to read information from the robot controller and control mode is used to command the robot system. As long as the robot controller is connected via network, monitoring mode is always possible. To switch to control mode the robot controller must be in `automatic` or `manual` operating mode and safety state `normal` or `reduced`. If the robot controller is in `manual` operating mode, you have to manually confirm the control usage activation on the robot control panel. This manual confirmation can\'t be replaced with this API. Without manual confirmation the robot controller will stay in monitor mode. The robot system will try to activate the required operation mode for the requested usage unless no active call requires a different mode. > **NOTE** > > `setDefaultMode` enables the robot controller to stay in control mode to keep the motors activated. > This allows for faster execution of sequential movements as no mode switches are required. > **NOTE** > > Some robot controllers prevent the external activation of automatic operating mode. In this case, changing the operating mode manually at the robot controller is mandatory. > **NOTE** > > The current operation mode and safety state can be requested via [getCurrentRobotControllerState](#/operations/getCurrentRobotControllerState). If a mode change is not possible, the response lists reasons for the failed change. * @summary Set Default 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 {SettableRobotSystemMode} mode * @param {*} [options] Override http request option. * @throws {RequiredError} */ setDefaultMode: (cell: string, controller: string, mode: SettableRobotSystemMode, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ > Websocket endpoint Sets the robot controller into freedrive mode and stays in freedrive until the websocket connection is closed by the client. In freedrive mode, it is possible to move the attached motion groups by hand. This is a blocking call. As long as the websocket connection is open, no other endpoint can control or move the robot. > **DANGER** > > Danger caused by robot. Improper assessment by the integrator of the application-specific hazards can result in people being > crushed, drawn in or caught due to the robot\'s complex movement sequences. Before opening the websocket, ensure that > > - The robot is in a safe state, > - The right payload is set, > - No humans or object are within the robot\'s reach or within the cell. As long as the websocket connection is open you will get the current state of the robot system in the response in the specified `response_rate`. If the activation failed, the returned status will return possible reasons for the failure. Free drive mode is only available for robot controllers that support it, in particular cobots. Use [listRobotControllers](#/operations/listRobotControllers) to check if the robot controller supports free drive mode. * @summary Stream Free Drive * @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 {*} [options] Override http request option. * @throws {RequiredError} */ streamFreeDrive: (cell: string, controller: string, responseRate?: number, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ > 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](#/operations/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, addControllerTimeout?: number, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_manage_controllers` - Create, update, or delete robot controllers ___ Update the configuration of a robot controller. Reconfigure certain options of a robot controller, or deploy a specific container image of a robot controller. To update a virtual controller, the previous controller will be deleted and a new one created. Changes to the configuration, e.g., TCPs, coordinate systems, mounting, are **not** transferred to the new robot. > **NOTE** > > An update is not a reset. To do a reset: > 1. Get the current configuration via [getRobotController](#/operations/getRobotController). > 2. Delete the existing virtual robot controller via [deleteRobotController](#/operations/deleteRobotController). > 3. Add a virtual robot controller with [addRobotController](#/operations/addRobotController). * @summary Update Robot Controller * @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 {RobotController} robotController * @param {number} [completionTimeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ updateRobotController: (cell: string, controller: string, robotController: RobotController, completionTimeout?: number, options?: RawAxiosRequestConfig) => Promise; }; /** * ControllerApi - functional programming interface */ declare const ControllerApiFp: (configuration?: Configuration) => { /** * **Required permissions:** `can_manage_controllers` - Create, update, or delete robot controllers ___ Add a robot controller to the cell. * @summary Add Robot Controller * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {RobotController} robotController * @param {number} [completionTimeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ addRobotController(cell: string, robotController: RobotController, completionTimeout?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_manage_controllers` - Create, update, or delete robot controllers ___ Delete all robot controllers from the cell. To replace all robot controllers in a cell, use this endpoint in combination with [addRobotController](#/operations/addRobotController). * @summary Clear Robot Controllers * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {number} [completionTimeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ clearRobotControllers(cell: string, completionTimeout?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_manage_controllers` - Create, update, or delete robot controllers ___ Delete a robot controller from the cell. * @summary Delete Robot Controller * @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} [completionTimeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteRobotController(cell: string, controller: string, completionTimeout?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Get description of a configured robot controller including a list of connected motion group identifiers. Use [getMotionGroupDescription](#/operations/getMotionGroupDescription) to get more information about the motion group. * @summary Description * @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} */ getControllerDescription(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Request a coordinate system specification for a given identifier. Use parameter `orientation_type` to get the orientation part of the transformation offset of the coordinate system returned in the requested orientation notation. If parameter `orientation_type` is not set, the orientation part of the transformation offset of the coordinate system is returned in rotation vector notation. The coordinate systems from the robot controller are loaded when the motion group associated with the coordinate system is activated. With deactivation of the motion group, the associated coordinate systems are removed from NOVA. The unique identifier of the coordinate systems from the robot controllers are suffixed with `On` + the unique identifier of the robot controller. * @summary Coordinate System * @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 {string} coordinateSystem Unique identifier addressing a coordinate system. * @param {OrientationType} [orientationType] * @param {*} [options] Override http request option. * @throws {RequiredError} */ getCoordinateSystem(cell: string, controller: string, coordinateSystem: string, orientationType?: OrientationType, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Get the current state of a robot controller. * @summary 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 {*} [options] Override http request option. * @throws {RequiredError} */ getCurrentRobotControllerState(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Get the configuration for a robot controller. * @summary Robot Controller * @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} */ getRobotController(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Receive data to configure a virtual robot controller based on another controller. This can be used to create a virtual clone of a specific physical robot. When adding a virtual controller, use the Virtual configuration variant of [addRobotController](#/operations/addRobotController) and pass the content string from this endpoint as the `json` field. Omit the `type` field that selects a preset configuration, which is not required when providing a complete configuration. * @summary Virtual Controller Configuration * @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} */ getVirtualControllerConfiguration(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Lists all specifications of coordinate systems from robot controllers. Use parameter `orientation_type` to get the orientation part of the transformation offset of the coordinate system returned in the requested orientation notation. If parameter `orientation_type` is not set, the orientation part of the transformation offset of the coordinate system is returned in rotation vector notation. The coordinate systems from the robot controller are loaded when the motion group associated with the coordinate system is activated. With deactivation of the motion group, the associated coordinate systems are removed from NOVA. The unique identifier of the coordinate systems from the robot controllers are suffixed with `On` + the unique identifier of the robot controller. * @summary List Coordinate Systems * @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 {OrientationType} [orientationType] * @param {*} [options] Override http request option. * @throws {RequiredError} */ listCoordinateSystems(cell: string, controller: string, orientationType?: OrientationType, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>>; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ List the names of all deployed robot controllers. * @summary List Robot Controllers * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listRobotControllers(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>>; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Switch between monitor and control usage as default for a robot controller. Monitoring mode is used to read information from the robot controller and control mode is used to command the robot system. As long as the robot controller is connected via network, monitoring mode is always possible. To switch to control mode the robot controller must be in `automatic` or `manual` operating mode and safety state `normal` or `reduced`. If the robot controller is in `manual` operating mode, you have to manually confirm the control usage activation on the robot control panel. This manual confirmation can\'t be replaced with this API. Without manual confirmation the robot controller will stay in monitor mode. The robot system will try to activate the required operation mode for the requested usage unless no active call requires a different mode. > **NOTE** > > `setDefaultMode` enables the robot controller to stay in control mode to keep the motors activated. > This allows for faster execution of sequential movements as no mode switches are required. > **NOTE** > > Some robot controllers prevent the external activation of automatic operating mode. In this case, changing the operating mode manually at the robot controller is mandatory. > **NOTE** > > The current operation mode and safety state can be requested via [getCurrentRobotControllerState](#/operations/getCurrentRobotControllerState). If a mode change is not possible, the response lists reasons for the failed change. * @summary Set Default 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 {SettableRobotSystemMode} mode * @param {*} [options] Override http request option. * @throws {RequiredError} */ setDefaultMode(cell: string, controller: string, mode: SettableRobotSystemMode, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ > Websocket endpoint Sets the robot controller into freedrive mode and stays in freedrive until the websocket connection is closed by the client. In freedrive mode, it is possible to move the attached motion groups by hand. This is a blocking call. As long as the websocket connection is open, no other endpoint can control or move the robot. > **DANGER** > > Danger caused by robot. Improper assessment by the integrator of the application-specific hazards can result in people being > crushed, drawn in or caught due to the robot\'s complex movement sequences. Before opening the websocket, ensure that > > - The robot is in a safe state, > - The right payload is set, > - No humans or object are within the robot\'s reach or within the cell. As long as the websocket connection is open you will get the current state of the robot system in the response in the specified `response_rate`. If the activation failed, the returned status will return possible reasons for the failure. Free drive mode is only available for robot controllers that support it, in particular cobots. Use [listRobotControllers](#/operations/listRobotControllers) to check if the robot controller supports free drive mode. * @summary Stream Free Drive * @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 {*} [options] Override http request option. * @throws {RequiredError} */ streamFreeDrive(cell: string, controller: string, responseRate?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ > 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](#/operations/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, addControllerTimeout?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_manage_controllers` - Create, update, or delete robot controllers ___ Update the configuration of a robot controller. Reconfigure certain options of a robot controller, or deploy a specific container image of a robot controller. To update a virtual controller, the previous controller will be deleted and a new one created. Changes to the configuration, e.g., TCPs, coordinate systems, mounting, are **not** transferred to the new robot. > **NOTE** > > An update is not a reset. To do a reset: > 1. Get the current configuration via [getRobotController](#/operations/getRobotController). > 2. Delete the existing virtual robot controller via [deleteRobotController](#/operations/deleteRobotController). > 3. Add a virtual robot controller with [addRobotController](#/operations/addRobotController). * @summary Update Robot Controller * @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 {RobotController} robotController * @param {number} [completionTimeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ updateRobotController(cell: string, controller: string, robotController: RobotController, completionTimeout?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; }; /** * ControllerApi - factory interface */ declare const ControllerApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => { /** * **Required permissions:** `can_manage_controllers` - Create, update, or delete robot controllers ___ Add a robot controller to the cell. * @summary Add Robot Controller * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {RobotController} robotController * @param {number} [completionTimeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ addRobotController(cell: string, robotController: RobotController, completionTimeout?: number, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_manage_controllers` - Create, update, or delete robot controllers ___ Delete all robot controllers from the cell. To replace all robot controllers in a cell, use this endpoint in combination with [addRobotController](#/operations/addRobotController). * @summary Clear Robot Controllers * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {number} [completionTimeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ clearRobotControllers(cell: string, completionTimeout?: number, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_manage_controllers` - Create, update, or delete robot controllers ___ Delete a robot controller from the cell. * @summary Delete Robot Controller * @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} [completionTimeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteRobotController(cell: string, controller: string, completionTimeout?: number, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Get description of a configured robot controller including a list of connected motion group identifiers. Use [getMotionGroupDescription](#/operations/getMotionGroupDescription) to get more information about the motion group. * @summary Description * @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} */ getControllerDescription(cell: string, controller: string, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Request a coordinate system specification for a given identifier. Use parameter `orientation_type` to get the orientation part of the transformation offset of the coordinate system returned in the requested orientation notation. If parameter `orientation_type` is not set, the orientation part of the transformation offset of the coordinate system is returned in rotation vector notation. The coordinate systems from the robot controller are loaded when the motion group associated with the coordinate system is activated. With deactivation of the motion group, the associated coordinate systems are removed from NOVA. The unique identifier of the coordinate systems from the robot controllers are suffixed with `On` + the unique identifier of the robot controller. * @summary Coordinate System * @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 {string} coordinateSystem Unique identifier addressing a coordinate system. * @param {OrientationType} [orientationType] * @param {*} [options] Override http request option. * @throws {RequiredError} */ getCoordinateSystem(cell: string, controller: string, coordinateSystem: string, orientationType?: OrientationType, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Get the current state of a robot controller. * @summary 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 {*} [options] Override http request option. * @throws {RequiredError} */ getCurrentRobotControllerState(cell: string, controller: string, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Get the configuration for a robot controller. * @summary Robot Controller * @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} */ getRobotController(cell: string, controller: string, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Receive data to configure a virtual robot controller based on another controller. This can be used to create a virtual clone of a specific physical robot. When adding a virtual controller, use the Virtual configuration variant of [addRobotController](#/operations/addRobotController) and pass the content string from this endpoint as the `json` field. Omit the `type` field that selects a preset configuration, which is not required when providing a complete configuration. * @summary Virtual Controller Configuration * @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} */ getVirtualControllerConfiguration(cell: string, controller: string, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Lists all specifications of coordinate systems from robot controllers. Use parameter `orientation_type` to get the orientation part of the transformation offset of the coordinate system returned in the requested orientation notation. If parameter `orientation_type` is not set, the orientation part of the transformation offset of the coordinate system is returned in rotation vector notation. The coordinate systems from the robot controller are loaded when the motion group associated with the coordinate system is activated. With deactivation of the motion group, the associated coordinate systems are removed from NOVA. The unique identifier of the coordinate systems from the robot controllers are suffixed with `On` + the unique identifier of the robot controller. * @summary List Coordinate Systems * @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 {OrientationType} [orientationType] * @param {*} [options] Override http request option. * @throws {RequiredError} */ listCoordinateSystems(cell: string, controller: string, orientationType?: OrientationType, options?: RawAxiosRequestConfig): AxiosPromise>; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ List the names of all deployed robot controllers. * @summary List Robot Controllers * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listRobotControllers(cell: string, options?: RawAxiosRequestConfig): AxiosPromise>; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Switch between monitor and control usage as default for a robot controller. Monitoring mode is used to read information from the robot controller and control mode is used to command the robot system. As long as the robot controller is connected via network, monitoring mode is always possible. To switch to control mode the robot controller must be in `automatic` or `manual` operating mode and safety state `normal` or `reduced`. If the robot controller is in `manual` operating mode, you have to manually confirm the control usage activation on the robot control panel. This manual confirmation can\'t be replaced with this API. Without manual confirmation the robot controller will stay in monitor mode. The robot system will try to activate the required operation mode for the requested usage unless no active call requires a different mode. > **NOTE** > > `setDefaultMode` enables the robot controller to stay in control mode to keep the motors activated. > This allows for faster execution of sequential movements as no mode switches are required. > **NOTE** > > Some robot controllers prevent the external activation of automatic operating mode. In this case, changing the operating mode manually at the robot controller is mandatory. > **NOTE** > > The current operation mode and safety state can be requested via [getCurrentRobotControllerState](#/operations/getCurrentRobotControllerState). If a mode change is not possible, the response lists reasons for the failed change. * @summary Set Default 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 {SettableRobotSystemMode} mode * @param {*} [options] Override http request option. * @throws {RequiredError} */ setDefaultMode(cell: string, controller: string, mode: SettableRobotSystemMode, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ > Websocket endpoint Sets the robot controller into freedrive mode and stays in freedrive until the websocket connection is closed by the client. In freedrive mode, it is possible to move the attached motion groups by hand. This is a blocking call. As long as the websocket connection is open, no other endpoint can control or move the robot. > **DANGER** > > Danger caused by robot. Improper assessment by the integrator of the application-specific hazards can result in people being > crushed, drawn in or caught due to the robot\'s complex movement sequences. Before opening the websocket, ensure that > > - The robot is in a safe state, > - The right payload is set, > - No humans or object are within the robot\'s reach or within the cell. As long as the websocket connection is open you will get the current state of the robot system in the response in the specified `response_rate`. If the activation failed, the returned status will return possible reasons for the failure. Free drive mode is only available for robot controllers that support it, in particular cobots. Use [listRobotControllers](#/operations/listRobotControllers) to check if the robot controller supports free drive mode. * @summary Stream Free Drive * @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 {*} [options] Override http request option. * @throws {RequiredError} */ streamFreeDrive(cell: string, controller: string, responseRate?: number, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ > 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](#/operations/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, addControllerTimeout?: number, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_manage_controllers` - Create, update, or delete robot controllers ___ Update the configuration of a robot controller. Reconfigure certain options of a robot controller, or deploy a specific container image of a robot controller. To update a virtual controller, the previous controller will be deleted and a new one created. Changes to the configuration, e.g., TCPs, coordinate systems, mounting, are **not** transferred to the new robot. > **NOTE** > > An update is not a reset. To do a reset: > 1. Get the current configuration via [getRobotController](#/operations/getRobotController). > 2. Delete the existing virtual robot controller via [deleteRobotController](#/operations/deleteRobotController). > 3. Add a virtual robot controller with [addRobotController](#/operations/addRobotController). * @summary Update Robot Controller * @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 {RobotController} robotController * @param {number} [completionTimeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ updateRobotController(cell: string, controller: string, robotController: RobotController, completionTimeout?: number, options?: RawAxiosRequestConfig): AxiosPromise; }; /** * ControllerApi - object-oriented interface */ declare class ControllerApi extends BaseAPI { /** * **Required permissions:** `can_manage_controllers` - Create, update, or delete robot controllers ___ Add a robot controller to the cell. * @summary Add Robot Controller * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {RobotController} robotController * @param {number} [completionTimeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ addRobotController(cell: string, robotController: RobotController, completionTimeout?: number, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_manage_controllers` - Create, update, or delete robot controllers ___ Delete all robot controllers from the cell. To replace all robot controllers in a cell, use this endpoint in combination with [addRobotController](#/operations/addRobotController). * @summary Clear Robot Controllers * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {number} [completionTimeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ clearRobotControllers(cell: string, completionTimeout?: number, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_manage_controllers` - Create, update, or delete robot controllers ___ Delete a robot controller from the cell. * @summary Delete Robot Controller * @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} [completionTimeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteRobotController(cell: string, controller: string, completionTimeout?: number, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Get description of a configured robot controller including a list of connected motion group identifiers. Use [getMotionGroupDescription](#/operations/getMotionGroupDescription) to get more information about the motion group. * @summary Description * @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} */ getControllerDescription(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Request a coordinate system specification for a given identifier. Use parameter `orientation_type` to get the orientation part of the transformation offset of the coordinate system returned in the requested orientation notation. If parameter `orientation_type` is not set, the orientation part of the transformation offset of the coordinate system is returned in rotation vector notation. The coordinate systems from the robot controller are loaded when the motion group associated with the coordinate system is activated. With deactivation of the motion group, the associated coordinate systems are removed from NOVA. The unique identifier of the coordinate systems from the robot controllers are suffixed with `On` + the unique identifier of the robot controller. * @summary Coordinate System * @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 {string} coordinateSystem Unique identifier addressing a coordinate system. * @param {OrientationType} [orientationType] * @param {*} [options] Override http request option. * @throws {RequiredError} */ getCoordinateSystem(cell: string, controller: string, coordinateSystem: string, orientationType?: OrientationType, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Get the current state of a robot controller. * @summary 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 {*} [options] Override http request option. * @throws {RequiredError} */ getCurrentRobotControllerState(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Get the configuration for a robot controller. * @summary Robot Controller * @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} */ getRobotController(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Receive data to configure a virtual robot controller based on another controller. This can be used to create a virtual clone of a specific physical robot. When adding a virtual controller, use the Virtual configuration variant of [addRobotController](#/operations/addRobotController) and pass the content string from this endpoint as the `json` field. Omit the `type` field that selects a preset configuration, which is not required when providing a complete configuration. * @summary Virtual Controller Configuration * @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} */ getVirtualControllerConfiguration(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Lists all specifications of coordinate systems from robot controllers. Use parameter `orientation_type` to get the orientation part of the transformation offset of the coordinate system returned in the requested orientation notation. If parameter `orientation_type` is not set, the orientation part of the transformation offset of the coordinate system is returned in rotation vector notation. The coordinate systems from the robot controller are loaded when the motion group associated with the coordinate system is activated. With deactivation of the motion group, the associated coordinate systems are removed from NOVA. The unique identifier of the coordinate systems from the robot controllers are suffixed with `On` + the unique identifier of the robot controller. * @summary List Coordinate Systems * @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 {OrientationType} [orientationType] * @param {*} [options] Override http request option. * @throws {RequiredError} */ listCoordinateSystems(cell: string, controller: string, orientationType?: OrientationType, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ List the names of all deployed robot controllers. * @summary List Robot Controllers * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listRobotControllers(cell: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Switch between monitor and control usage as default for a robot controller. Monitoring mode is used to read information from the robot controller and control mode is used to command the robot system. As long as the robot controller is connected via network, monitoring mode is always possible. To switch to control mode the robot controller must be in `automatic` or `manual` operating mode and safety state `normal` or `reduced`. If the robot controller is in `manual` operating mode, you have to manually confirm the control usage activation on the robot control panel. This manual confirmation can\'t be replaced with this API. Without manual confirmation the robot controller will stay in monitor mode. The robot system will try to activate the required operation mode for the requested usage unless no active call requires a different mode. > **NOTE** > > `setDefaultMode` enables the robot controller to stay in control mode to keep the motors activated. > This allows for faster execution of sequential movements as no mode switches are required. > **NOTE** > > Some robot controllers prevent the external activation of automatic operating mode. In this case, changing the operating mode manually at the robot controller is mandatory. > **NOTE** > > The current operation mode and safety state can be requested via [getCurrentRobotControllerState](#/operations/getCurrentRobotControllerState). If a mode change is not possible, the response lists reasons for the failed change. * @summary Set Default 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 {SettableRobotSystemMode} mode * @param {*} [options] Override http request option. * @throws {RequiredError} */ setDefaultMode(cell: string, controller: string, mode: SettableRobotSystemMode, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ > Websocket endpoint Sets the robot controller into freedrive mode and stays in freedrive until the websocket connection is closed by the client. In freedrive mode, it is possible to move the attached motion groups by hand. This is a blocking call. As long as the websocket connection is open, no other endpoint can control or move the robot. > **DANGER** > > Danger caused by robot. Improper assessment by the integrator of the application-specific hazards can result in people being > crushed, drawn in or caught due to the robot\'s complex movement sequences. Before opening the websocket, ensure that > > - The robot is in a safe state, > - The right payload is set, > - No humans or object are within the robot\'s reach or within the cell. As long as the websocket connection is open you will get the current state of the robot system in the response in the specified `response_rate`. If the activation failed, the returned status will return possible reasons for the failure. Free drive mode is only available for robot controllers that support it, in particular cobots. Use [listRobotControllers](#/operations/listRobotControllers) to check if the robot controller supports free drive mode. * @summary Stream Free Drive * @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 {*} [options] Override http request option. * @throws {RequiredError} */ streamFreeDrive(cell: string, controller: string, responseRate?: number, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ > 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](#/operations/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, addControllerTimeout?: number, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_manage_controllers` - Create, update, or delete robot controllers ___ Update the configuration of a robot controller. Reconfigure certain options of a robot controller, or deploy a specific container image of a robot controller. To update a virtual controller, the previous controller will be deleted and a new one created. Changes to the configuration, e.g., TCPs, coordinate systems, mounting, are **not** transferred to the new robot. > **NOTE** > > An update is not a reset. To do a reset: > 1. Get the current configuration via [getRobotController](#/operations/getRobotController). > 2. Delete the existing virtual robot controller via [deleteRobotController](#/operations/deleteRobotController). > 3. Add a virtual robot controller with [addRobotController](#/operations/addRobotController). * @summary Update Robot Controller * @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 {RobotController} robotController * @param {number} [completionTimeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ updateRobotController(cell: string, controller: string, robotController: RobotController, completionTimeout?: number, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; } /** * ControllerInputsOutputsApi - axios parameter creator */ declare const ControllerInputsOutputsApiAxiosParamCreator: (configuration?: Configuration) => { /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Lists the input/output descriptions of the robot controller. The input/output descriptions contain information like name, type and unit.\\ Available inputs/outputs are defined by the robot controller\\ Each input/output has a unique identifier. - If no identifiers and no filters are specified in the request, all available inputs/outputs are retrieved by this endpoint. - If a filter, e.g., `direction`, `value_type`, `group` is applied, only matching inputs/outputs are returned. * @summary List Descriptions * @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 {Array} [ios] * @param {IODirection} [direction] Return only inputs/outputs with the specified direction. * @param {IOValueType} [valueType] Return only inputs/outputs with the specified value type. * @param {string} [group] Return only inputs/outputs from the specified group. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listIODescriptions: (cell: string, controller: string, ios?: Array, direction?: IODirection, valueType?: IOValueType, group?: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Retrieves the current values of inputs/outputs. The identifiers of the inputs/outputs must be provided in the request. Request all available input/output identifiers via [listIODescriptions](#/operations/listIODescriptions). * @summary Get Input/Output Values * @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 {Array} [ios] * @param {*} [options] Override http request option. * @throws {RequiredError} */ listIOValues: (cell: string, controller: string, ios?: Array, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Set the values of outputs. All available output identifiers and possible value ranges can be requested via [listIODescriptions](#/operations/listIODescriptions). The call will return once the values have been set on and accepted by the robot. This can take up to 200 milliseconds. > **NOTE** > > Do not call this endpoint while another request is still in progress. The second call will fail. * @summary Set Output Values * @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 {Array} iOValue * @param {*} [options] Override http request option. * @throws {RequiredError} */ setOutputValues: (cell: string, controller: string, iOValue: Array, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ > Websocket endpoint Continuously receive updates of input/output values via websocket. Updates are sent in the update rate of the controller. > **NOTE** > > If you request many values simultaneously, the request is likely to fail. The amount of values that can be streamed simultaneously depends on the specific robot controller. > **NOTE** > > The inputs and outputs are sent in the update rate of the controller to prevent losing any values. This can lead to a high amount of data transmitted. * @summary Stream Input/Output Values * @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 {Array} [ios] * @param {*} [options] Override http request option. * @throws {RequiredError} */ streamIOValues: (cell: string, controller: string, ios?: Array, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Wait until an input/output reaches a certain value. This call returns as soon as the condition is met or the request fails. The `comparison_type` value is used to define how the current value of the input/output is compared with given value. Only set the value that corresponds to the `value_type` of the input/output. See [listIODescriptions](#/operations/listIODescriptions) for more information. **Examples** 1. Wait until analog input `AI_1` < 10: ``` io: \"AI_1\" comparison_type: \"COMPARISON_LESS\" value: 10 ``` 2. Wait until analog input `AI_2` > 5.0: ``` io: \"AI_2\" comparison_type: \"COMPARISON_GREATER\" value: 5.0 ``` 3. Wait until digital input `DI_3` is true: ``` io: \"DI_3\" comparison_type: \"COMPARISON_EQUAL\" value: true ``` * @summary Wait For * @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 {WaitForIOEventRequest} waitForIOEventRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ waitForIOEvent: (cell: string, controller: string, waitForIOEventRequest: WaitForIOEventRequest, options?: RawAxiosRequestConfig) => Promise; }; /** * ControllerInputsOutputsApi - functional programming interface */ declare const ControllerInputsOutputsApiFp: (configuration?: Configuration) => { /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Lists the input/output descriptions of the robot controller. The input/output descriptions contain information like name, type and unit.\\ Available inputs/outputs are defined by the robot controller\\ Each input/output has a unique identifier. - If no identifiers and no filters are specified in the request, all available inputs/outputs are retrieved by this endpoint. - If a filter, e.g., `direction`, `value_type`, `group` is applied, only matching inputs/outputs are returned. * @summary List Descriptions * @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 {Array} [ios] * @param {IODirection} [direction] Return only inputs/outputs with the specified direction. * @param {IOValueType} [valueType] Return only inputs/outputs with the specified value type. * @param {string} [group] Return only inputs/outputs from the specified group. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listIODescriptions(cell: string, controller: string, ios?: Array, direction?: IODirection, valueType?: IOValueType, group?: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>>; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Retrieves the current values of inputs/outputs. The identifiers of the inputs/outputs must be provided in the request. Request all available input/output identifiers via [listIODescriptions](#/operations/listIODescriptions). * @summary Get Input/Output Values * @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 {Array} [ios] * @param {*} [options] Override http request option. * @throws {RequiredError} */ listIOValues(cell: string, controller: string, ios?: Array, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>>; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Set the values of outputs. All available output identifiers and possible value ranges can be requested via [listIODescriptions](#/operations/listIODescriptions). The call will return once the values have been set on and accepted by the robot. This can take up to 200 milliseconds. > **NOTE** > > Do not call this endpoint while another request is still in progress. The second call will fail. * @summary Set Output Values * @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 {Array} iOValue * @param {*} [options] Override http request option. * @throws {RequiredError} */ setOutputValues(cell: string, controller: string, iOValue: Array, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ > Websocket endpoint Continuously receive updates of input/output values via websocket. Updates are sent in the update rate of the controller. > **NOTE** > > If you request many values simultaneously, the request is likely to fail. The amount of values that can be streamed simultaneously depends on the specific robot controller. > **NOTE** > > The inputs and outputs are sent in the update rate of the controller to prevent losing any values. This can lead to a high amount of data transmitted. * @summary Stream Input/Output Values * @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 {Array} [ios] * @param {*} [options] Override http request option. * @throws {RequiredError} */ streamIOValues(cell: string, controller: string, ios?: Array, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Wait until an input/output reaches a certain value. This call returns as soon as the condition is met or the request fails. The `comparison_type` value is used to define how the current value of the input/output is compared with given value. Only set the value that corresponds to the `value_type` of the input/output. See [listIODescriptions](#/operations/listIODescriptions) for more information. **Examples** 1. Wait until analog input `AI_1` < 10: ``` io: \"AI_1\" comparison_type: \"COMPARISON_LESS\" value: 10 ``` 2. Wait until analog input `AI_2` > 5.0: ``` io: \"AI_2\" comparison_type: \"COMPARISON_GREATER\" value: 5.0 ``` 3. Wait until digital input `DI_3` is true: ``` io: \"DI_3\" comparison_type: \"COMPARISON_EQUAL\" value: true ``` * @summary Wait For * @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 {WaitForIOEventRequest} waitForIOEventRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ waitForIOEvent(cell: string, controller: string, waitForIOEventRequest: WaitForIOEventRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; }; /** * ControllerInputsOutputsApi - factory interface */ declare const ControllerInputsOutputsApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => { /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Lists the input/output descriptions of the robot controller. The input/output descriptions contain information like name, type and unit.\\ Available inputs/outputs are defined by the robot controller\\ Each input/output has a unique identifier. - If no identifiers and no filters are specified in the request, all available inputs/outputs are retrieved by this endpoint. - If a filter, e.g., `direction`, `value_type`, `group` is applied, only matching inputs/outputs are returned. * @summary List Descriptions * @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 {Array} [ios] * @param {IODirection} [direction] Return only inputs/outputs with the specified direction. * @param {IOValueType} [valueType] Return only inputs/outputs with the specified value type. * @param {string} [group] Return only inputs/outputs from the specified group. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listIODescriptions(cell: string, controller: string, ios?: Array, direction?: IODirection, valueType?: IOValueType, group?: string, options?: RawAxiosRequestConfig): AxiosPromise>; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Retrieves the current values of inputs/outputs. The identifiers of the inputs/outputs must be provided in the request. Request all available input/output identifiers via [listIODescriptions](#/operations/listIODescriptions). * @summary Get Input/Output Values * @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 {Array} [ios] * @param {*} [options] Override http request option. * @throws {RequiredError} */ listIOValues(cell: string, controller: string, ios?: Array, options?: RawAxiosRequestConfig): AxiosPromise>; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Set the values of outputs. All available output identifiers and possible value ranges can be requested via [listIODescriptions](#/operations/listIODescriptions). The call will return once the values have been set on and accepted by the robot. This can take up to 200 milliseconds. > **NOTE** > > Do not call this endpoint while another request is still in progress. The second call will fail. * @summary Set Output Values * @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 {Array} iOValue * @param {*} [options] Override http request option. * @throws {RequiredError} */ setOutputValues(cell: string, controller: string, iOValue: Array, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ > Websocket endpoint Continuously receive updates of input/output values via websocket. Updates are sent in the update rate of the controller. > **NOTE** > > If you request many values simultaneously, the request is likely to fail. The amount of values that can be streamed simultaneously depends on the specific robot controller. > **NOTE** > > The inputs and outputs are sent in the update rate of the controller to prevent losing any values. This can lead to a high amount of data transmitted. * @summary Stream Input/Output Values * @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 {Array} [ios] * @param {*} [options] Override http request option. * @throws {RequiredError} */ streamIOValues(cell: string, controller: string, ios?: Array, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Wait until an input/output reaches a certain value. This call returns as soon as the condition is met or the request fails. The `comparison_type` value is used to define how the current value of the input/output is compared with given value. Only set the value that corresponds to the `value_type` of the input/output. See [listIODescriptions](#/operations/listIODescriptions) for more information. **Examples** 1. Wait until analog input `AI_1` < 10: ``` io: \"AI_1\" comparison_type: \"COMPARISON_LESS\" value: 10 ``` 2. Wait until analog input `AI_2` > 5.0: ``` io: \"AI_2\" comparison_type: \"COMPARISON_GREATER\" value: 5.0 ``` 3. Wait until digital input `DI_3` is true: ``` io: \"DI_3\" comparison_type: \"COMPARISON_EQUAL\" value: true ``` * @summary Wait For * @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 {WaitForIOEventRequest} waitForIOEventRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ waitForIOEvent(cell: string, controller: string, waitForIOEventRequest: WaitForIOEventRequest, options?: RawAxiosRequestConfig): AxiosPromise; }; /** * ControllerInputsOutputsApi - object-oriented interface */ declare class ControllerInputsOutputsApi extends BaseAPI { /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Lists the input/output descriptions of the robot controller. The input/output descriptions contain information like name, type and unit.\\ Available inputs/outputs are defined by the robot controller\\ Each input/output has a unique identifier. - If no identifiers and no filters are specified in the request, all available inputs/outputs are retrieved by this endpoint. - If a filter, e.g., `direction`, `value_type`, `group` is applied, only matching inputs/outputs are returned. * @summary List Descriptions * @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 {Array} [ios] * @param {IODirection} [direction] Return only inputs/outputs with the specified direction. * @param {IOValueType} [valueType] Return only inputs/outputs with the specified value type. * @param {string} [group] Return only inputs/outputs from the specified group. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listIODescriptions(cell: string, controller: string, ios?: Array, direction?: IODirection, valueType?: IOValueType, group?: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Retrieves the current values of inputs/outputs. The identifiers of the inputs/outputs must be provided in the request. Request all available input/output identifiers via [listIODescriptions](#/operations/listIODescriptions). * @summary Get Input/Output Values * @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 {Array} [ios] * @param {*} [options] Override http request option. * @throws {RequiredError} */ listIOValues(cell: string, controller: string, ios?: Array, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Set the values of outputs. All available output identifiers and possible value ranges can be requested via [listIODescriptions](#/operations/listIODescriptions). The call will return once the values have been set on and accepted by the robot. This can take up to 200 milliseconds. > **NOTE** > > Do not call this endpoint while another request is still in progress. The second call will fail. * @summary Set Output Values * @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 {Array} iOValue * @param {*} [options] Override http request option. * @throws {RequiredError} */ setOutputValues(cell: string, controller: string, iOValue: Array, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ > Websocket endpoint Continuously receive updates of input/output values via websocket. Updates are sent in the update rate of the controller. > **NOTE** > > If you request many values simultaneously, the request is likely to fail. The amount of values that can be streamed simultaneously depends on the specific robot controller. > **NOTE** > > The inputs and outputs are sent in the update rate of the controller to prevent losing any values. This can lead to a high amount of data transmitted. * @summary Stream Input/Output Values * @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 {Array} [ios] * @param {*} [options] Override http request option. * @throws {RequiredError} */ streamIOValues(cell: string, controller: string, ios?: Array, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Wait until an input/output reaches a certain value. This call returns as soon as the condition is met or the request fails. The `comparison_type` value is used to define how the current value of the input/output is compared with given value. Only set the value that corresponds to the `value_type` of the input/output. See [listIODescriptions](#/operations/listIODescriptions) for more information. **Examples** 1. Wait until analog input `AI_1` < 10: ``` io: \"AI_1\" comparison_type: \"COMPARISON_LESS\" value: 10 ``` 2. Wait until analog input `AI_2` > 5.0: ``` io: \"AI_2\" comparison_type: \"COMPARISON_GREATER\" value: 5.0 ``` 3. Wait until digital input `DI_3` is true: ``` io: \"DI_3\" comparison_type: \"COMPARISON_EQUAL\" value: true ``` * @summary Wait For * @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 {WaitForIOEventRequest} waitForIOEventRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ waitForIOEvent(cell: string, controller: string, waitForIOEventRequest: WaitForIOEventRequest, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; } /** * JoggingApi - axios parameter creator */ declare const JoggingApiAxiosParamCreator: (configuration?: Configuration) => { /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ > Websocket endpoint Provides execution control over a dynamically adaptable jogging motion for a motion group. Jogging describes controlling a motion group by sending real-time commands to move either its joints or the TCP. The commands contain target velocities that may change at any time during execution, so the resulting motion cannot be computed upfront. ### Preconditions The motion group is not moved by any other endpoint. ### Requests #### 1. Send `InitializeJoggingRequest` to configure the jogging. - Sets the robot controller mode to control mode. - Claims the motion group for jogging. For robotic arms, TCP is required to ensure that limits, including TCP limits, are respected. #### 2. Send `JointVelocityRequest` or `TcpVelocityRequest` to start the jogging motion. - Commands can only be processed in the cycle rate of the controller - Sending commands faster will not increase the responsiveness of the jogging motion, it will lead to dropped commands - It is recommended to couple sending commands with the [state stream](#/operations/streamMotionGroupState), which can be subscribed to via nats as well. #### 3. Change or stop the jogging motion - Change the jogging direction and/or velocity during the jogging motion with `JointVelocityRequest` or `TcpVelocityRequest`. - To stop the jogging motion, send zero velocities via either request or `PauseJoggingRequest`. ### Responses - Each request is acknowledged with a corresponding response: - `InitializeJoggingResponse` after `InitializeJoggingRequest` - `JointVelocityResponse` after `JointVelocityRequest` - `TcpVelocityResponse` after `TcpVelocityRequest` - `PauseJoggingResponse` after `PauseJoggingRequest` The responses confirm that the requests were received. They do not signal that the operation was successful; check the [motion group state](#/operations/streamMotionGroupState) for that. - `MovementErrorResponse` with error details is sent in case of an unexpected error, e.g., controller disconnects during jogging. ### Tips and Tricks - Ensure that the websocket connection remains open until the jogging motion is stopped to avoid unexpected stops. * @summary Execute Jogging * @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 {ExecuteJoggingRequest} executeJoggingRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ executeJogging: (cell: string, controller: string, executeJoggingRequest: ExecuteJoggingRequest, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ > **Experimental** > > This endpoint is experimental and its behavior may change in future releases. > Websocket endpoint Provides waypoint-based jogging control for a motion group. Instead of commanding target velocities (see [executeJogging](#/operations/executeJogging)), waypoint jogging streams a queue of timed waypoints that the robot moves through by best effort. This can be used for realtime action chunk streaming, e.g., from a Vision-Language-Action (VLA) model. ### Preconditions The motion group is not moved by any other endpoint. ### Requests #### 1. Send `InitializeJoggingRequest` to configure the jogging. - Sets the robot controller mode to control mode. - Claims the motion group for jogging. For robotic arms, TCP is required to ensure that limits, including TCP limits, are respected. #### 2. Send `JointWaypointsRequest` or `PoseWaypointsRequest` to stream waypoints. - The first waypoints message starts an internal clock. - Each waypoint carries a timestamp relative to that clock for when it should be reached. - Existing waypoints in the queue that are older than the first new timestamp are removed. - The current session timestamp is reported in `execute.details.jogger_session_timestamp_ms` of the [streamRobotControllerState](#/operations/streamRobotControllerState) endpoint. #### 3. Stop the jogging motion - Send `PauseJoggingRequest` to stop the motion. ### Responses - Each request is acknowledged with a corresponding response: - `InitializeJoggingResponse` after `InitializeJoggingRequest` - `JointWaypointsResponse` after `JointWaypointsRequest` - `PoseWaypointsResponse` after `PoseWaypointsRequest` - `PauseJoggingResponse` after `PauseJoggingRequest` The responses confirm that the requests were received. They do not signal that the operation was successful; check the [motion group state](#/operations/streamMotionGroupState) for that. - `MovementErrorResponse` with error details is sent in case of an unexpected error, e.g., controller disconnects during jogging. ### Tips and Tricks - Ensure that the websocket connection remains open until the jogging motion is stopped to avoid unexpected stops. * @summary Execute Waypoint Jogging * @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 {ExecuteWaypointJoggingRequest} executeWaypointJoggingRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ executeWaypointJogging: (cell: string, controller: string, executeWaypointJoggingRequest: ExecuteWaypointJoggingRequest, options?: RawAxiosRequestConfig) => Promise; }; /** * JoggingApi - functional programming interface */ declare const JoggingApiFp: (configuration?: Configuration) => { /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ > Websocket endpoint Provides execution control over a dynamically adaptable jogging motion for a motion group. Jogging describes controlling a motion group by sending real-time commands to move either its joints or the TCP. The commands contain target velocities that may change at any time during execution, so the resulting motion cannot be computed upfront. ### Preconditions The motion group is not moved by any other endpoint. ### Requests #### 1. Send `InitializeJoggingRequest` to configure the jogging. - Sets the robot controller mode to control mode. - Claims the motion group for jogging. For robotic arms, TCP is required to ensure that limits, including TCP limits, are respected. #### 2. Send `JointVelocityRequest` or `TcpVelocityRequest` to start the jogging motion. - Commands can only be processed in the cycle rate of the controller - Sending commands faster will not increase the responsiveness of the jogging motion, it will lead to dropped commands - It is recommended to couple sending commands with the [state stream](#/operations/streamMotionGroupState), which can be subscribed to via nats as well. #### 3. Change or stop the jogging motion - Change the jogging direction and/or velocity during the jogging motion with `JointVelocityRequest` or `TcpVelocityRequest`. - To stop the jogging motion, send zero velocities via either request or `PauseJoggingRequest`. ### Responses - Each request is acknowledged with a corresponding response: - `InitializeJoggingResponse` after `InitializeJoggingRequest` - `JointVelocityResponse` after `JointVelocityRequest` - `TcpVelocityResponse` after `TcpVelocityRequest` - `PauseJoggingResponse` after `PauseJoggingRequest` The responses confirm that the requests were received. They do not signal that the operation was successful; check the [motion group state](#/operations/streamMotionGroupState) for that. - `MovementErrorResponse` with error details is sent in case of an unexpected error, e.g., controller disconnects during jogging. ### Tips and Tricks - Ensure that the websocket connection remains open until the jogging motion is stopped to avoid unexpected stops. * @summary Execute Jogging * @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 {ExecuteJoggingRequest} executeJoggingRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ executeJogging(cell: string, controller: string, executeJoggingRequest: ExecuteJoggingRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ > **Experimental** > > This endpoint is experimental and its behavior may change in future releases. > Websocket endpoint Provides waypoint-based jogging control for a motion group. Instead of commanding target velocities (see [executeJogging](#/operations/executeJogging)), waypoint jogging streams a queue of timed waypoints that the robot moves through by best effort. This can be used for realtime action chunk streaming, e.g., from a Vision-Language-Action (VLA) model. ### Preconditions The motion group is not moved by any other endpoint. ### Requests #### 1. Send `InitializeJoggingRequest` to configure the jogging. - Sets the robot controller mode to control mode. - Claims the motion group for jogging. For robotic arms, TCP is required to ensure that limits, including TCP limits, are respected. #### 2. Send `JointWaypointsRequest` or `PoseWaypointsRequest` to stream waypoints. - The first waypoints message starts an internal clock. - Each waypoint carries a timestamp relative to that clock for when it should be reached. - Existing waypoints in the queue that are older than the first new timestamp are removed. - The current session timestamp is reported in `execute.details.jogger_session_timestamp_ms` of the [streamRobotControllerState](#/operations/streamRobotControllerState) endpoint. #### 3. Stop the jogging motion - Send `PauseJoggingRequest` to stop the motion. ### Responses - Each request is acknowledged with a corresponding response: - `InitializeJoggingResponse` after `InitializeJoggingRequest` - `JointWaypointsResponse` after `JointWaypointsRequest` - `PoseWaypointsResponse` after `PoseWaypointsRequest` - `PauseJoggingResponse` after `PauseJoggingRequest` The responses confirm that the requests were received. They do not signal that the operation was successful; check the [motion group state](#/operations/streamMotionGroupState) for that. - `MovementErrorResponse` with error details is sent in case of an unexpected error, e.g., controller disconnects during jogging. ### Tips and Tricks - Ensure that the websocket connection remains open until the jogging motion is stopped to avoid unexpected stops. * @summary Execute Waypoint Jogging * @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 {ExecuteWaypointJoggingRequest} executeWaypointJoggingRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ executeWaypointJogging(cell: string, controller: string, executeWaypointJoggingRequest: ExecuteWaypointJoggingRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; }; /** * JoggingApi - factory interface */ declare const JoggingApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => { /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ > Websocket endpoint Provides execution control over a dynamically adaptable jogging motion for a motion group. Jogging describes controlling a motion group by sending real-time commands to move either its joints or the TCP. The commands contain target velocities that may change at any time during execution, so the resulting motion cannot be computed upfront. ### Preconditions The motion group is not moved by any other endpoint. ### Requests #### 1. Send `InitializeJoggingRequest` to configure the jogging. - Sets the robot controller mode to control mode. - Claims the motion group for jogging. For robotic arms, TCP is required to ensure that limits, including TCP limits, are respected. #### 2. Send `JointVelocityRequest` or `TcpVelocityRequest` to start the jogging motion. - Commands can only be processed in the cycle rate of the controller - Sending commands faster will not increase the responsiveness of the jogging motion, it will lead to dropped commands - It is recommended to couple sending commands with the [state stream](#/operations/streamMotionGroupState), which can be subscribed to via nats as well. #### 3. Change or stop the jogging motion - Change the jogging direction and/or velocity during the jogging motion with `JointVelocityRequest` or `TcpVelocityRequest`. - To stop the jogging motion, send zero velocities via either request or `PauseJoggingRequest`. ### Responses - Each request is acknowledged with a corresponding response: - `InitializeJoggingResponse` after `InitializeJoggingRequest` - `JointVelocityResponse` after `JointVelocityRequest` - `TcpVelocityResponse` after `TcpVelocityRequest` - `PauseJoggingResponse` after `PauseJoggingRequest` The responses confirm that the requests were received. They do not signal that the operation was successful; check the [motion group state](#/operations/streamMotionGroupState) for that. - `MovementErrorResponse` with error details is sent in case of an unexpected error, e.g., controller disconnects during jogging. ### Tips and Tricks - Ensure that the websocket connection remains open until the jogging motion is stopped to avoid unexpected stops. * @summary Execute Jogging * @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 {ExecuteJoggingRequest} executeJoggingRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ executeJogging(cell: string, controller: string, executeJoggingRequest: ExecuteJoggingRequest, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ > **Experimental** > > This endpoint is experimental and its behavior may change in future releases. > Websocket endpoint Provides waypoint-based jogging control for a motion group. Instead of commanding target velocities (see [executeJogging](#/operations/executeJogging)), waypoint jogging streams a queue of timed waypoints that the robot moves through by best effort. This can be used for realtime action chunk streaming, e.g., from a Vision-Language-Action (VLA) model. ### Preconditions The motion group is not moved by any other endpoint. ### Requests #### 1. Send `InitializeJoggingRequest` to configure the jogging. - Sets the robot controller mode to control mode. - Claims the motion group for jogging. For robotic arms, TCP is required to ensure that limits, including TCP limits, are respected. #### 2. Send `JointWaypointsRequest` or `PoseWaypointsRequest` to stream waypoints. - The first waypoints message starts an internal clock. - Each waypoint carries a timestamp relative to that clock for when it should be reached. - Existing waypoints in the queue that are older than the first new timestamp are removed. - The current session timestamp is reported in `execute.details.jogger_session_timestamp_ms` of the [streamRobotControllerState](#/operations/streamRobotControllerState) endpoint. #### 3. Stop the jogging motion - Send `PauseJoggingRequest` to stop the motion. ### Responses - Each request is acknowledged with a corresponding response: - `InitializeJoggingResponse` after `InitializeJoggingRequest` - `JointWaypointsResponse` after `JointWaypointsRequest` - `PoseWaypointsResponse` after `PoseWaypointsRequest` - `PauseJoggingResponse` after `PauseJoggingRequest` The responses confirm that the requests were received. They do not signal that the operation was successful; check the [motion group state](#/operations/streamMotionGroupState) for that. - `MovementErrorResponse` with error details is sent in case of an unexpected error, e.g., controller disconnects during jogging. ### Tips and Tricks - Ensure that the websocket connection remains open until the jogging motion is stopped to avoid unexpected stops. * @summary Execute Waypoint Jogging * @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 {ExecuteWaypointJoggingRequest} executeWaypointJoggingRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ executeWaypointJogging(cell: string, controller: string, executeWaypointJoggingRequest: ExecuteWaypointJoggingRequest, options?: RawAxiosRequestConfig): AxiosPromise; }; /** * JoggingApi - object-oriented interface */ declare class JoggingApi extends BaseAPI { /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ > Websocket endpoint Provides execution control over a dynamically adaptable jogging motion for a motion group. Jogging describes controlling a motion group by sending real-time commands to move either its joints or the TCP. The commands contain target velocities that may change at any time during execution, so the resulting motion cannot be computed upfront. ### Preconditions The motion group is not moved by any other endpoint. ### Requests #### 1. Send `InitializeJoggingRequest` to configure the jogging. - Sets the robot controller mode to control mode. - Claims the motion group for jogging. For robotic arms, TCP is required to ensure that limits, including TCP limits, are respected. #### 2. Send `JointVelocityRequest` or `TcpVelocityRequest` to start the jogging motion. - Commands can only be processed in the cycle rate of the controller - Sending commands faster will not increase the responsiveness of the jogging motion, it will lead to dropped commands - It is recommended to couple sending commands with the [state stream](#/operations/streamMotionGroupState), which can be subscribed to via nats as well. #### 3. Change or stop the jogging motion - Change the jogging direction and/or velocity during the jogging motion with `JointVelocityRequest` or `TcpVelocityRequest`. - To stop the jogging motion, send zero velocities via either request or `PauseJoggingRequest`. ### Responses - Each request is acknowledged with a corresponding response: - `InitializeJoggingResponse` after `InitializeJoggingRequest` - `JointVelocityResponse` after `JointVelocityRequest` - `TcpVelocityResponse` after `TcpVelocityRequest` - `PauseJoggingResponse` after `PauseJoggingRequest` The responses confirm that the requests were received. They do not signal that the operation was successful; check the [motion group state](#/operations/streamMotionGroupState) for that. - `MovementErrorResponse` with error details is sent in case of an unexpected error, e.g., controller disconnects during jogging. ### Tips and Tricks - Ensure that the websocket connection remains open until the jogging motion is stopped to avoid unexpected stops. * @summary Execute Jogging * @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 {ExecuteJoggingRequest} executeJoggingRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ executeJogging(cell: string, controller: string, executeJoggingRequest: ExecuteJoggingRequest, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ > **Experimental** > > This endpoint is experimental and its behavior may change in future releases. > Websocket endpoint Provides waypoint-based jogging control for a motion group. Instead of commanding target velocities (see [executeJogging](#/operations/executeJogging)), waypoint jogging streams a queue of timed waypoints that the robot moves through by best effort. This can be used for realtime action chunk streaming, e.g., from a Vision-Language-Action (VLA) model. ### Preconditions The motion group is not moved by any other endpoint. ### Requests #### 1. Send `InitializeJoggingRequest` to configure the jogging. - Sets the robot controller mode to control mode. - Claims the motion group for jogging. For robotic arms, TCP is required to ensure that limits, including TCP limits, are respected. #### 2. Send `JointWaypointsRequest` or `PoseWaypointsRequest` to stream waypoints. - The first waypoints message starts an internal clock. - Each waypoint carries a timestamp relative to that clock for when it should be reached. - Existing waypoints in the queue that are older than the first new timestamp are removed. - The current session timestamp is reported in `execute.details.jogger_session_timestamp_ms` of the [streamRobotControllerState](#/operations/streamRobotControllerState) endpoint. #### 3. Stop the jogging motion - Send `PauseJoggingRequest` to stop the motion. ### Responses - Each request is acknowledged with a corresponding response: - `InitializeJoggingResponse` after `InitializeJoggingRequest` - `JointWaypointsResponse` after `JointWaypointsRequest` - `PoseWaypointsResponse` after `PoseWaypointsRequest` - `PauseJoggingResponse` after `PauseJoggingRequest` The responses confirm that the requests were received. They do not signal that the operation was successful; check the [motion group state](#/operations/streamMotionGroupState) for that. - `MovementErrorResponse` with error details is sent in case of an unexpected error, e.g., controller disconnects during jogging. ### Tips and Tricks - Ensure that the websocket connection remains open until the jogging motion is stopped to avoid unexpected stops. * @summary Execute Waypoint Jogging * @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 {ExecuteWaypointJoggingRequest} executeWaypointJoggingRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ executeWaypointJogging(cell: string, controller: string, executeWaypointJoggingRequest: ExecuteWaypointJoggingRequest, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; } /** * KinematicsApi - axios parameter creator */ declare const KinematicsApiAxiosParamCreator: (configuration?: Configuration) => { /** * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___ Returns the reachable joint positions for a list of given poses. * @summary Inverse kinematics configured pose * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {ConfiguredPoseInverseRequest} configuredPoseInverseRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ configuredPoseInverse: (cell: string, configuredPoseInverseRequest: ConfiguredPoseInverseRequest, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___ Converts a vendor-specific pose with configuration data to a vendor-independent pose with kinematic configuration. * @summary Convert vendor-configured pose * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {ConvertVendorConfiguredPoseRequest} convertVendorConfiguredPoseRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ convertVendorConfiguredPose: (cell: string, convertVendorConfiguredPoseRequest: ConvertVendorConfiguredPoseRequest, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___ Returns the TCP poses for a list of given joint positions. * @summary Forward kinematics * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {ForwardKinematicsRequest} forwardKinematicsRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ forwardKinematics: (cell: string, forwardKinematicsRequest: ForwardKinematicsRequest, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___ Returns the reachable joint positions for a list of given poses. * @summary Inverse kinematics * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {InverseKinematicsRequest} inverseKinematicsRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ inverseKinematics: (cell: string, inverseKinematicsRequest: InverseKinematicsRequest, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___ > **Experimental** Returns the projected joint position that satisfies the direction constraint for a given target joint position. This may alter the TCP pose. To project the cartesian pose instead, use the following code snippet: ```python import numpy as np from scipy.spatial.transform import Rotation as R def project_cartesian_pose_direction_constraint(T_world_tcp: models.Pose, constraint: models.DirectionConstraint) -> models.Pose: constraint_tcp = np.array(constraint.tcp) target_constraint_world = np.array(constraint.world) R_world_tcp = R.from_rotvec(T_world_tcp.orientation.root) current_constraint_world = R_world_tcp.apply(constraint_tcp) R_corr, _ = R.align_vectors([target_constraint_world], [current_constraint_world]) R_world_tcp_new = R_corr * R_world_tcp return models.Pose(position=T_world_tcp.position, orientation=R_world_tcp_new.as_rotvec()) ``` * @summary Project joint position to direction constraint * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {ProjectJointPositionDirectionConstraintRequest} projectJointPositionDirectionConstraintRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ projectJointPositionDirectionConstraint: (cell: string, projectJointPositionDirectionConstraintRequest: ProjectJointPositionDirectionConstraintRequest, options?: RawAxiosRequestConfig) => Promise; }; /** * KinematicsApi - functional programming interface */ declare const KinematicsApiFp: (configuration?: Configuration) => { /** * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___ Returns the reachable joint positions for a list of given poses. * @summary Inverse kinematics configured pose * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {ConfiguredPoseInverseRequest} configuredPoseInverseRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ configuredPoseInverse(cell: string, configuredPoseInverseRequest: ConfiguredPoseInverseRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___ Converts a vendor-specific pose with configuration data to a vendor-independent pose with kinematic configuration. * @summary Convert vendor-configured pose * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {ConvertVendorConfiguredPoseRequest} convertVendorConfiguredPoseRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ convertVendorConfiguredPose(cell: string, convertVendorConfiguredPoseRequest: ConvertVendorConfiguredPoseRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>>; /** * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___ Returns the TCP poses for a list of given joint positions. * @summary Forward kinematics * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {ForwardKinematicsRequest} forwardKinematicsRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ forwardKinematics(cell: string, forwardKinematicsRequest: ForwardKinematicsRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___ Returns the reachable joint positions for a list of given poses. * @summary Inverse kinematics * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {InverseKinematicsRequest} inverseKinematicsRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ inverseKinematics(cell: string, inverseKinematicsRequest: InverseKinematicsRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___ > **Experimental** Returns the projected joint position that satisfies the direction constraint for a given target joint position. This may alter the TCP pose. To project the cartesian pose instead, use the following code snippet: ```python import numpy as np from scipy.spatial.transform import Rotation as R def project_cartesian_pose_direction_constraint(T_world_tcp: models.Pose, constraint: models.DirectionConstraint) -> models.Pose: constraint_tcp = np.array(constraint.tcp) target_constraint_world = np.array(constraint.world) R_world_tcp = R.from_rotvec(T_world_tcp.orientation.root) current_constraint_world = R_world_tcp.apply(constraint_tcp) R_corr, _ = R.align_vectors([target_constraint_world], [current_constraint_world]) R_world_tcp_new = R_corr * R_world_tcp return models.Pose(position=T_world_tcp.position, orientation=R_world_tcp_new.as_rotvec()) ``` * @summary Project joint position to direction constraint * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {ProjectJointPositionDirectionConstraintRequest} projectJointPositionDirectionConstraintRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ projectJointPositionDirectionConstraint(cell: string, projectJointPositionDirectionConstraintRequest: ProjectJointPositionDirectionConstraintRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; }; /** * KinematicsApi - factory interface */ declare const KinematicsApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => { /** * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___ Returns the reachable joint positions for a list of given poses. * @summary Inverse kinematics configured pose * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {ConfiguredPoseInverseRequest} configuredPoseInverseRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ configuredPoseInverse(cell: string, configuredPoseInverseRequest: ConfiguredPoseInverseRequest, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___ Converts a vendor-specific pose with configuration data to a vendor-independent pose with kinematic configuration. * @summary Convert vendor-configured pose * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {ConvertVendorConfiguredPoseRequest} convertVendorConfiguredPoseRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ convertVendorConfiguredPose(cell: string, convertVendorConfiguredPoseRequest: ConvertVendorConfiguredPoseRequest, options?: RawAxiosRequestConfig): AxiosPromise>; /** * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___ Returns the TCP poses for a list of given joint positions. * @summary Forward kinematics * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {ForwardKinematicsRequest} forwardKinematicsRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ forwardKinematics(cell: string, forwardKinematicsRequest: ForwardKinematicsRequest, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___ Returns the reachable joint positions for a list of given poses. * @summary Inverse kinematics * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {InverseKinematicsRequest} inverseKinematicsRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ inverseKinematics(cell: string, inverseKinematicsRequest: InverseKinematicsRequest, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___ > **Experimental** Returns the projected joint position that satisfies the direction constraint for a given target joint position. This may alter the TCP pose. To project the cartesian pose instead, use the following code snippet: ```python import numpy as np from scipy.spatial.transform import Rotation as R def project_cartesian_pose_direction_constraint(T_world_tcp: models.Pose, constraint: models.DirectionConstraint) -> models.Pose: constraint_tcp = np.array(constraint.tcp) target_constraint_world = np.array(constraint.world) R_world_tcp = R.from_rotvec(T_world_tcp.orientation.root) current_constraint_world = R_world_tcp.apply(constraint_tcp) R_corr, _ = R.align_vectors([target_constraint_world], [current_constraint_world]) R_world_tcp_new = R_corr * R_world_tcp return models.Pose(position=T_world_tcp.position, orientation=R_world_tcp_new.as_rotvec()) ``` * @summary Project joint position to direction constraint * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {ProjectJointPositionDirectionConstraintRequest} projectJointPositionDirectionConstraintRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ projectJointPositionDirectionConstraint(cell: string, projectJointPositionDirectionConstraintRequest: ProjectJointPositionDirectionConstraintRequest, options?: RawAxiosRequestConfig): AxiosPromise; }; /** * KinematicsApi - object-oriented interface */ declare class KinematicsApi extends BaseAPI { /** * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___ Returns the reachable joint positions for a list of given poses. * @summary Inverse kinematics configured pose * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {ConfiguredPoseInverseRequest} configuredPoseInverseRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ configuredPoseInverse(cell: string, configuredPoseInverseRequest: ConfiguredPoseInverseRequest, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___ Converts a vendor-specific pose with configuration data to a vendor-independent pose with kinematic configuration. * @summary Convert vendor-configured pose * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {ConvertVendorConfiguredPoseRequest} convertVendorConfiguredPoseRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ convertVendorConfiguredPose(cell: string, convertVendorConfiguredPoseRequest: ConvertVendorConfiguredPoseRequest, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___ Returns the TCP poses for a list of given joint positions. * @summary Forward kinematics * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {ForwardKinematicsRequest} forwardKinematicsRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ forwardKinematics(cell: string, forwardKinematicsRequest: ForwardKinematicsRequest, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___ Returns the reachable joint positions for a list of given poses. * @summary Inverse kinematics * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {InverseKinematicsRequest} inverseKinematicsRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ inverseKinematics(cell: string, inverseKinematicsRequest: InverseKinematicsRequest, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___ > **Experimental** Returns the projected joint position that satisfies the direction constraint for a given target joint position. This may alter the TCP pose. To project the cartesian pose instead, use the following code snippet: ```python import numpy as np from scipy.spatial.transform import Rotation as R def project_cartesian_pose_direction_constraint(T_world_tcp: models.Pose, constraint: models.DirectionConstraint) -> models.Pose: constraint_tcp = np.array(constraint.tcp) target_constraint_world = np.array(constraint.world) R_world_tcp = R.from_rotvec(T_world_tcp.orientation.root) current_constraint_world = R_world_tcp.apply(constraint_tcp) R_corr, _ = R.align_vectors([target_constraint_world], [current_constraint_world]) R_world_tcp_new = R_corr * R_world_tcp return models.Pose(position=T_world_tcp.position, orientation=R_world_tcp_new.as_rotvec()) ``` * @summary Project joint position to direction constraint * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {ProjectJointPositionDirectionConstraintRequest} projectJointPositionDirectionConstraintRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ projectJointPositionDirectionConstraint(cell: string, projectJointPositionDirectionConstraintRequest: ProjectJointPositionDirectionConstraintRequest, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; } /** * LicenseApi - axios parameter creator */ declare const LicenseApiAxiosParamCreator: (configuration?: Configuration) => { /** * **Required permissions:** `can_manage_license` - Manage license configuration ___ Activates a license using the provided license owner authentication token. The refresh token is used to enable communication with the license provider without requiring user interaction. * @summary Activate license * @param {ActivateLicenseRequest} activateLicenseRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ activateLicense: (activateLicenseRequest: ActivateLicenseRequest, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_manage_license` - Manage license configuration ___ Deactivates active license. * @summary Deactivate license * @param {*} [options] Override http request option. * @throws {RequiredError} */ deactivateLicense: (options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_access_license` - View license status ___ Get information on the license used with the Wandelbots NOVA instance, e.g., licensed product, expiration date, license status. * @summary Get license * @param {*} [options] Override http request option. * @throws {RequiredError} */ getLicense: (options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Get the license status. - If `valid`, Wandelbots NOVA can be used. - If `expired`, the license has to be renewed in order to use Wandelbots NOVA. * @summary Get license status * @param {*} [options] Override http request option. * @throws {RequiredError} */ getLicenseStatus: (options?: RawAxiosRequestConfig) => Promise; }; /** * LicenseApi - functional programming interface */ declare const LicenseApiFp: (configuration?: Configuration) => { /** * **Required permissions:** `can_manage_license` - Manage license configuration ___ Activates a license using the provided license owner authentication token. The refresh token is used to enable communication with the license provider without requiring user interaction. * @summary Activate license * @param {ActivateLicenseRequest} activateLicenseRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ activateLicense(activateLicenseRequest: ActivateLicenseRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_manage_license` - Manage license configuration ___ Deactivates active license. * @summary Deactivate license * @param {*} [options] Override http request option. * @throws {RequiredError} */ deactivateLicense(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_access_license` - View license status ___ Get information on the license used with the Wandelbots NOVA instance, e.g., licensed product, expiration date, license status. * @summary Get license * @param {*} [options] Override http request option. * @throws {RequiredError} */ getLicense(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Get the license status. - If `valid`, Wandelbots NOVA can be used. - If `expired`, the license has to be renewed in order to use Wandelbots NOVA. * @summary Get license status * @param {*} [options] Override http request option. * @throws {RequiredError} */ getLicenseStatus(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; }; /** * LicenseApi - factory interface */ declare const LicenseApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => { /** * **Required permissions:** `can_manage_license` - Manage license configuration ___ Activates a license using the provided license owner authentication token. The refresh token is used to enable communication with the license provider without requiring user interaction. * @summary Activate license * @param {ActivateLicenseRequest} activateLicenseRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ activateLicense(activateLicenseRequest: ActivateLicenseRequest, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_manage_license` - Manage license configuration ___ Deactivates active license. * @summary Deactivate license * @param {*} [options] Override http request option. * @throws {RequiredError} */ deactivateLicense(options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_access_license` - View license status ___ Get information on the license used with the Wandelbots NOVA instance, e.g., licensed product, expiration date, license status. * @summary Get license * @param {*} [options] Override http request option. * @throws {RequiredError} */ getLicense(options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Get the license status. - If `valid`, Wandelbots NOVA can be used. - If `expired`, the license has to be renewed in order to use Wandelbots NOVA. * @summary Get license status * @param {*} [options] Override http request option. * @throws {RequiredError} */ getLicenseStatus(options?: RawAxiosRequestConfig): AxiosPromise; }; /** * LicenseApi - object-oriented interface */ declare class LicenseApi extends BaseAPI { /** * **Required permissions:** `can_manage_license` - Manage license configuration ___ Activates a license using the provided license owner authentication token. The refresh token is used to enable communication with the license provider without requiring user interaction. * @summary Activate license * @param {ActivateLicenseRequest} activateLicenseRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ activateLicense(activateLicenseRequest: ActivateLicenseRequest, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_manage_license` - Manage license configuration ___ Deactivates active license. * @summary Deactivate license * @param {*} [options] Override http request option. * @throws {RequiredError} */ deactivateLicense(options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_access_license` - View license status ___ Get information on the license used with the Wandelbots NOVA instance, e.g., licensed product, expiration date, license status. * @summary Get license * @param {*} [options] Override http request option. * @throws {RequiredError} */ getLicense(options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Get the license status. - If `valid`, Wandelbots NOVA can be used. - If `expired`, the license has to be renewed in order to use Wandelbots NOVA. * @summary Get license status * @param {*} [options] Override http request option. * @throws {RequiredError} */ getLicenseStatus(options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; } /** * MotionGroupApi - axios parameter creator */ declare const MotionGroupApiAxiosParamCreator: (configuration?: Configuration) => { /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Returns the current state of the selected motion group including the current joint position, velocity, pose, and more. * @summary 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 {string} motionGroup The motion-group identifier. * @param {string} [responseCoordinateSystem] Unique identifier addressing a coordinate system to which the responses should be converted. If not set, world coordinate system is used. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getCurrentMotionGroupState: (cell: string, controller: string, motionGroup: string, responseCoordinateSystem?: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Get the set of parameters that describe the motion group and its configuration including safety zones, limits, etc. This data can change upon connection to the robot. * @summary Description * @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 {string} motionGroup The motion-group identifier. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getMotionGroupDescription: (cell: string, controller: string, motionGroup: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ > Websocket endpoint Receive updates of the motion group state. The stream will be closed from the server if the controller is disconnected. * @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 {string} motionGroup The motion-group identifier. * @param {number} [responseRate] Update rate for the response message in milliseconds (ms). Default is 200 ms. We recommend to use the step rate of the controller or a multiple of the step rate as NOVA updates the state in the controller\'s step rate as well. Minimal response rate is the step rate of controller. * @param {string} [responseCoordinateSystem] Unique identifier addressing a coordinate system to which the cartesian data of the responses should be converted. Default is the world coordinate system. * @param {*} [options] Override http request option. * @throws {RequiredError} */ streamMotionGroupState: (cell: string, controller: string, motionGroup: string, responseRate?: number, responseCoordinateSystem?: string, options?: RawAxiosRequestConfig) => Promise; }; /** * MotionGroupApi - functional programming interface */ declare const MotionGroupApiFp: (configuration?: Configuration) => { /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Returns the current state of the selected motion group including the current joint position, velocity, pose, and more. * @summary 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 {string} motionGroup The motion-group identifier. * @param {string} [responseCoordinateSystem] Unique identifier addressing a coordinate system to which the responses should be converted. If not set, world coordinate system is used. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getCurrentMotionGroupState(cell: string, controller: string, motionGroup: string, responseCoordinateSystem?: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Get the set of parameters that describe the motion group and its configuration including safety zones, limits, etc. This data can change upon connection to the robot. * @summary Description * @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 {string} motionGroup The motion-group identifier. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getMotionGroupDescription(cell: string, controller: string, motionGroup: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ > Websocket endpoint Receive updates of the motion group state. The stream will be closed from the server if the controller is disconnected. * @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 {string} motionGroup The motion-group identifier. * @param {number} [responseRate] Update rate for the response message in milliseconds (ms). Default is 200 ms. We recommend to use the step rate of the controller or a multiple of the step rate as NOVA updates the state in the controller\'s step rate as well. Minimal response rate is the step rate of controller. * @param {string} [responseCoordinateSystem] Unique identifier addressing a coordinate system to which the cartesian data of the responses should be converted. Default is the world coordinate system. * @param {*} [options] Override http request option. * @throws {RequiredError} */ streamMotionGroupState(cell: string, controller: string, motionGroup: string, responseRate?: number, responseCoordinateSystem?: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; }; /** * MotionGroupApi - factory interface */ declare const MotionGroupApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => { /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Returns the current state of the selected motion group including the current joint position, velocity, pose, and more. * @summary 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 {string} motionGroup The motion-group identifier. * @param {string} [responseCoordinateSystem] Unique identifier addressing a coordinate system to which the responses should be converted. If not set, world coordinate system is used. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getCurrentMotionGroupState(cell: string, controller: string, motionGroup: string, responseCoordinateSystem?: string, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Get the set of parameters that describe the motion group and its configuration including safety zones, limits, etc. This data can change upon connection to the robot. * @summary Description * @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 {string} motionGroup The motion-group identifier. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getMotionGroupDescription(cell: string, controller: string, motionGroup: string, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ > Websocket endpoint Receive updates of the motion group state. The stream will be closed from the server if the controller is disconnected. * @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 {string} motionGroup The motion-group identifier. * @param {number} [responseRate] Update rate for the response message in milliseconds (ms). Default is 200 ms. We recommend to use the step rate of the controller or a multiple of the step rate as NOVA updates the state in the controller\'s step rate as well. Minimal response rate is the step rate of controller. * @param {string} [responseCoordinateSystem] Unique identifier addressing a coordinate system to which the cartesian data of the responses should be converted. Default is the world coordinate system. * @param {*} [options] Override http request option. * @throws {RequiredError} */ streamMotionGroupState(cell: string, controller: string, motionGroup: string, responseRate?: number, responseCoordinateSystem?: string, options?: RawAxiosRequestConfig): AxiosPromise; }; /** * MotionGroupApi - object-oriented interface */ declare class MotionGroupApi extends BaseAPI { /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Returns the current state of the selected motion group including the current joint position, velocity, pose, and more. * @summary 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 {string} motionGroup The motion-group identifier. * @param {string} [responseCoordinateSystem] Unique identifier addressing a coordinate system to which the responses should be converted. If not set, world coordinate system is used. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getCurrentMotionGroupState(cell: string, controller: string, motionGroup: string, responseCoordinateSystem?: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Get the set of parameters that describe the motion group and its configuration including safety zones, limits, etc. This data can change upon connection to the robot. * @summary Description * @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 {string} motionGroup The motion-group identifier. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getMotionGroupDescription(cell: string, controller: string, motionGroup: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ > Websocket endpoint Receive updates of the motion group state. The stream will be closed from the server if the controller is disconnected. * @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 {string} motionGroup The motion-group identifier. * @param {number} [responseRate] Update rate for the response message in milliseconds (ms). Default is 200 ms. We recommend to use the step rate of the controller or a multiple of the step rate as NOVA updates the state in the controller\'s step rate as well. Minimal response rate is the step rate of controller. * @param {string} [responseCoordinateSystem] Unique identifier addressing a coordinate system to which the cartesian data of the responses should be converted. Default is the world coordinate system. * @param {*} [options] Override http request option. * @throws {RequiredError} */ streamMotionGroupState(cell: string, controller: string, motionGroup: string, responseRate?: number, responseCoordinateSystem?: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; } /** * MotionGroupModelsApi - axios parameter creator */ declare const MotionGroupModelsApiAxiosParamCreator: (configuration?: Configuration) => { /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Creates a copy of the specified motion group model and registers the copy under a new name as a custom model. Both built-in base models and existing custom models can be copied. * @summary Copy Motion Group Model * @param {string} motionGroupModel Unique identifier for the model of a motion group, e.g., `UniversalRobots_UR10e`. Get the `model` of a configured motion group with [getOptimizerConfiguration](#/operations/getOptimizerConfiguration). * @param {CopyMotionGroupModelRequest} copyMotionGroupModelRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ copyMotionGroupModel: (motionGroupModel: string, copyMotionGroupModelRequest: CopyMotionGroupModelRequest, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Deletes a custom motion group model. Only custom models (where `is_custom` is `true`) can be deleted. Built-in base models cannot be removed. * @summary Delete Motion Group Model * @param {string} motionGroupModel Unique identifier for the model of a motion group, e.g., `UniversalRobots_UR10e`. Get the `model` of a configured motion group with [getOptimizerConfiguration](#/operations/getOptimizerConfiguration). * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteExperimentalMotionGroupModel: (motionGroupModel: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Exports the specified motion group model as a tar.gz archive. The resulting tar.gz file can be imported on another system using the import endpoint. * @summary Export Motion Group Model * @param {string} motionGroupModel Unique identifier for the model of a motion group, e.g., `UniversalRobots_UR10e`. Get the `model` of a configured motion group with [getOptimizerConfiguration](#/operations/getOptimizerConfiguration). * @param {*} [options] Override http request option. * @throws {RequiredError} */ exportMotionGroupModel: (motionGroupModel: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Returns the default collision link chain for a given motion group model. See [getMotionGroupModels](#/operations/getMotionGroupModels) for supported motion group models. The default link chain is derived from 3D models and optimized for collision detection within NOVA. The default link chain includes link shapes only. It does not include any attached components like wire feeders or sensors. Attach additional shapes to the link reference frames by extending the link dictionaries before further use. Additional shapes may overlap each other per link and may also overlap the respective link\'s default shape. * @summary Get Collision Model * @param {string} motionGroupModel Unique identifier for the model of a motion group, e.g., `UniversalRobots_UR10e`. Get the `model` of a configured motion group with [getOptimizerConfiguration](#/operations/getOptimizerConfiguration). * @param {*} [options] Override http request option. * @throws {RequiredError} */ getMotionGroupCollisionModel: (motionGroupModel: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Returns the dynamics model (mass, center of mass, inertia, friction parameters) for the given motion group model. See [getMotionGroupModels](#/operations/getMotionGroupModels) for supported motion group models. * @summary Get Dynamics * @param {string} motionGroupModel Unique identifier for the model of a motion group, e.g., `UniversalRobots_UR10e`. Get the `model` of a configured motion group with [getOptimizerConfiguration](#/operations/getOptimizerConfiguration). * @param {*} [options] Override http request option. * @throws {RequiredError} */ getMotionGroupDynamicModel: (motionGroupModel: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Returns the GLB asset for the specified motion group model. See [getMotionGroupModels](#/operations/getMotionGroupModels) for supported identifiers. * @summary Download GLB Model * @param {string} motionGroupModel Unique identifier for the model of a motion group, e.g., `UniversalRobots_UR10e`. Get the `model` of a configured motion group with [getOptimizerConfiguration](#/operations/getOptimizerConfiguration). * @param {*} [options] Override http request option. * @throws {RequiredError} */ getMotionGroupGlbModel: (motionGroupModel: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Returns the default joint positions from which a virtual robot is started. See [getMotionGroupModels](#/operations/getMotionGroupModels) for supported motion group models. * @summary Get Homejoints * @param {string} motionGroupModel Unique identifier for the model of a motion group, e.g., `UniversalRobots_UR10e`. Get the `model` of a configured motion group with [getOptimizerConfiguration](#/operations/getOptimizerConfiguration). * @param {*} [options] Override http request option. * @throws {RequiredError} */ getMotionGroupHomejoints: (motionGroupModel: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Returns the kinematics model (DH parameters) for the given motion group model. See [getMotionGroupModels](#/operations/getMotionGroupModels) for supported motion group models. * @summary Get Kinematics * @param {string} motionGroupModel Unique identifier for the model of a motion group, e.g., `UniversalRobots_UR10e`. Get the `model` of a configured motion group with [getOptimizerConfiguration](#/operations/getOptimizerConfiguration). * @param {*} [options] Override http request option. * @throws {RequiredError} */ getMotionGroupKinematicModel: (motionGroupModel: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Returns the operation limits for the given motion group model. See [getMotionGroupModels](#/operations/getMotionGroupModels) for supported motion group models. * @summary Get Limits * @param {string} motionGroupModel Unique identifier for the model of a motion group, e.g., `UniversalRobots_UR10e`. Get the `model` of a configured motion group with [getOptimizerConfiguration](#/operations/getOptimizerConfiguration). * @param {*} [options] Override http request option. * @throws {RequiredError} */ getMotionGroupLimitModel: (motionGroupModel: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Returns the list of supported motion group models. * @summary Motion Group Models * @param {*} [options] Override http request option. * @throws {RequiredError} */ getMotionGroupModels: (options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Returns the USD scene model for the specified motion group model. See [getMotionGroupModels](#/operations/getMotionGroupModels) for supported identifiers. * @summary Download USD Model * @param {string} motionGroupModel Unique identifier for the model of a motion group, e.g., `UniversalRobots_UR10e`. Get the `model` of a configured motion group with [getOptimizerConfiguration](#/operations/getOptimizerConfiguration). * @param {*} [options] Override http request option. * @throws {RequiredError} */ getMotionGroupUsdModel: (motionGroupModel: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Imports a motion group model from a tar.gz archive and registers it as a new custom model. The tar.gz archive must have been produced by the export endpoint. * @summary Import Motion Group Model * @param {File} body * @param {*} [options] Override http request option. * @throws {RequiredError} */ importMotionGroupModel: (body: File, options?: RawAxiosRequestConfig) => Promise; }; /** * MotionGroupModelsApi - functional programming interface */ declare const MotionGroupModelsApiFp: (configuration?: Configuration) => { /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Creates a copy of the specified motion group model and registers the copy under a new name as a custom model. Both built-in base models and existing custom models can be copied. * @summary Copy Motion Group Model * @param {string} motionGroupModel Unique identifier for the model of a motion group, e.g., `UniversalRobots_UR10e`. Get the `model` of a configured motion group with [getOptimizerConfiguration](#/operations/getOptimizerConfiguration). * @param {CopyMotionGroupModelRequest} copyMotionGroupModelRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ copyMotionGroupModel(motionGroupModel: string, copyMotionGroupModelRequest: CopyMotionGroupModelRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Deletes a custom motion group model. Only custom models (where `is_custom` is `true`) can be deleted. Built-in base models cannot be removed. * @summary Delete Motion Group Model * @param {string} motionGroupModel Unique identifier for the model of a motion group, e.g., `UniversalRobots_UR10e`. Get the `model` of a configured motion group with [getOptimizerConfiguration](#/operations/getOptimizerConfiguration). * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteExperimentalMotionGroupModel(motionGroupModel: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Exports the specified motion group model as a tar.gz archive. The resulting tar.gz file can be imported on another system using the import endpoint. * @summary Export Motion Group Model * @param {string} motionGroupModel Unique identifier for the model of a motion group, e.g., `UniversalRobots_UR10e`. Get the `model` of a configured motion group with [getOptimizerConfiguration](#/operations/getOptimizerConfiguration). * @param {*} [options] Override http request option. * @throws {RequiredError} */ exportMotionGroupModel(motionGroupModel: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Returns the default collision link chain for a given motion group model. See [getMotionGroupModels](#/operations/getMotionGroupModels) for supported motion group models. The default link chain is derived from 3D models and optimized for collision detection within NOVA. The default link chain includes link shapes only. It does not include any attached components like wire feeders or sensors. Attach additional shapes to the link reference frames by extending the link dictionaries before further use. Additional shapes may overlap each other per link and may also overlap the respective link\'s default shape. * @summary Get Collision Model * @param {string} motionGroupModel Unique identifier for the model of a motion group, e.g., `UniversalRobots_UR10e`. Get the `model` of a configured motion group with [getOptimizerConfiguration](#/operations/getOptimizerConfiguration). * @param {*} [options] Override http request option. * @throws {RequiredError} */ getMotionGroupCollisionModel(motionGroupModel: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Returns the dynamics model (mass, center of mass, inertia, friction parameters) for the given motion group model. See [getMotionGroupModels](#/operations/getMotionGroupModels) for supported motion group models. * @summary Get Dynamics * @param {string} motionGroupModel Unique identifier for the model of a motion group, e.g., `UniversalRobots_UR10e`. Get the `model` of a configured motion group with [getOptimizerConfiguration](#/operations/getOptimizerConfiguration). * @param {*} [options] Override http request option. * @throws {RequiredError} */ getMotionGroupDynamicModel(motionGroupModel: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Returns the GLB asset for the specified motion group model. See [getMotionGroupModels](#/operations/getMotionGroupModels) for supported identifiers. * @summary Download GLB Model * @param {string} motionGroupModel Unique identifier for the model of a motion group, e.g., `UniversalRobots_UR10e`. Get the `model` of a configured motion group with [getOptimizerConfiguration](#/operations/getOptimizerConfiguration). * @param {*} [options] Override http request option. * @throws {RequiredError} */ getMotionGroupGlbModel(motionGroupModel: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Returns the default joint positions from which a virtual robot is started. See [getMotionGroupModels](#/operations/getMotionGroupModels) for supported motion group models. * @summary Get Homejoints * @param {string} motionGroupModel Unique identifier for the model of a motion group, e.g., `UniversalRobots_UR10e`. Get the `model` of a configured motion group with [getOptimizerConfiguration](#/operations/getOptimizerConfiguration). * @param {*} [options] Override http request option. * @throws {RequiredError} */ getMotionGroupHomejoints(motionGroupModel: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Returns the kinematics model (DH parameters) for the given motion group model. See [getMotionGroupModels](#/operations/getMotionGroupModels) for supported motion group models. * @summary Get Kinematics * @param {string} motionGroupModel Unique identifier for the model of a motion group, e.g., `UniversalRobots_UR10e`. Get the `model` of a configured motion group with [getOptimizerConfiguration](#/operations/getOptimizerConfiguration). * @param {*} [options] Override http request option. * @throws {RequiredError} */ getMotionGroupKinematicModel(motionGroupModel: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Returns the operation limits for the given motion group model. See [getMotionGroupModels](#/operations/getMotionGroupModels) for supported motion group models. * @summary Get Limits * @param {string} motionGroupModel Unique identifier for the model of a motion group, e.g., `UniversalRobots_UR10e`. Get the `model` of a configured motion group with [getOptimizerConfiguration](#/operations/getOptimizerConfiguration). * @param {*} [options] Override http request option. * @throws {RequiredError} */ getMotionGroupLimitModel(motionGroupModel: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Returns the list of supported motion group models. * @summary Motion Group Models * @param {*} [options] Override http request option. * @throws {RequiredError} */ getMotionGroupModels(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Returns the USD scene model for the specified motion group model. See [getMotionGroupModels](#/operations/getMotionGroupModels) for supported identifiers. * @summary Download USD Model * @param {string} motionGroupModel Unique identifier for the model of a motion group, e.g., `UniversalRobots_UR10e`. Get the `model` of a configured motion group with [getOptimizerConfiguration](#/operations/getOptimizerConfiguration). * @param {*} [options] Override http request option. * @throws {RequiredError} */ getMotionGroupUsdModel(motionGroupModel: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Imports a motion group model from a tar.gz archive and registers it as a new custom model. The tar.gz archive must have been produced by the export endpoint. * @summary Import Motion Group Model * @param {File} body * @param {*} [options] Override http request option. * @throws {RequiredError} */ importMotionGroupModel(body: File, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; }; /** * MotionGroupModelsApi - factory interface */ declare const MotionGroupModelsApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => { /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Creates a copy of the specified motion group model and registers the copy under a new name as a custom model. Both built-in base models and existing custom models can be copied. * @summary Copy Motion Group Model * @param {string} motionGroupModel Unique identifier for the model of a motion group, e.g., `UniversalRobots_UR10e`. Get the `model` of a configured motion group with [getOptimizerConfiguration](#/operations/getOptimizerConfiguration). * @param {CopyMotionGroupModelRequest} copyMotionGroupModelRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ copyMotionGroupModel(motionGroupModel: string, copyMotionGroupModelRequest: CopyMotionGroupModelRequest, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Deletes a custom motion group model. Only custom models (where `is_custom` is `true`) can be deleted. Built-in base models cannot be removed. * @summary Delete Motion Group Model * @param {string} motionGroupModel Unique identifier for the model of a motion group, e.g., `UniversalRobots_UR10e`. Get the `model` of a configured motion group with [getOptimizerConfiguration](#/operations/getOptimizerConfiguration). * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteExperimentalMotionGroupModel(motionGroupModel: string, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Exports the specified motion group model as a tar.gz archive. The resulting tar.gz file can be imported on another system using the import endpoint. * @summary Export Motion Group Model * @param {string} motionGroupModel Unique identifier for the model of a motion group, e.g., `UniversalRobots_UR10e`. Get the `model` of a configured motion group with [getOptimizerConfiguration](#/operations/getOptimizerConfiguration). * @param {*} [options] Override http request option. * @throws {RequiredError} */ exportMotionGroupModel(motionGroupModel: string, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Returns the default collision link chain for a given motion group model. See [getMotionGroupModels](#/operations/getMotionGroupModels) for supported motion group models. The default link chain is derived from 3D models and optimized for collision detection within NOVA. The default link chain includes link shapes only. It does not include any attached components like wire feeders or sensors. Attach additional shapes to the link reference frames by extending the link dictionaries before further use. Additional shapes may overlap each other per link and may also overlap the respective link\'s default shape. * @summary Get Collision Model * @param {string} motionGroupModel Unique identifier for the model of a motion group, e.g., `UniversalRobots_UR10e`. Get the `model` of a configured motion group with [getOptimizerConfiguration](#/operations/getOptimizerConfiguration). * @param {*} [options] Override http request option. * @throws {RequiredError} */ getMotionGroupCollisionModel(motionGroupModel: string, options?: RawAxiosRequestConfig): AxiosPromise>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Returns the dynamics model (mass, center of mass, inertia, friction parameters) for the given motion group model. See [getMotionGroupModels](#/operations/getMotionGroupModels) for supported motion group models. * @summary Get Dynamics * @param {string} motionGroupModel Unique identifier for the model of a motion group, e.g., `UniversalRobots_UR10e`. Get the `model` of a configured motion group with [getOptimizerConfiguration](#/operations/getOptimizerConfiguration). * @param {*} [options] Override http request option. * @throws {RequiredError} */ getMotionGroupDynamicModel(motionGroupModel: string, options?: RawAxiosRequestConfig): AxiosPromise>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Returns the GLB asset for the specified motion group model. See [getMotionGroupModels](#/operations/getMotionGroupModels) for supported identifiers. * @summary Download GLB Model * @param {string} motionGroupModel Unique identifier for the model of a motion group, e.g., `UniversalRobots_UR10e`. Get the `model` of a configured motion group with [getOptimizerConfiguration](#/operations/getOptimizerConfiguration). * @param {*} [options] Override http request option. * @throws {RequiredError} */ getMotionGroupGlbModel(motionGroupModel: string, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Returns the default joint positions from which a virtual robot is started. See [getMotionGroupModels](#/operations/getMotionGroupModels) for supported motion group models. * @summary Get Homejoints * @param {string} motionGroupModel Unique identifier for the model of a motion group, e.g., `UniversalRobots_UR10e`. Get the `model` of a configured motion group with [getOptimizerConfiguration](#/operations/getOptimizerConfiguration). * @param {*} [options] Override http request option. * @throws {RequiredError} */ getMotionGroupHomejoints(motionGroupModel: string, options?: RawAxiosRequestConfig): AxiosPromise>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Returns the kinematics model (DH parameters) for the given motion group model. See [getMotionGroupModels](#/operations/getMotionGroupModels) for supported motion group models. * @summary Get Kinematics * @param {string} motionGroupModel Unique identifier for the model of a motion group, e.g., `UniversalRobots_UR10e`. Get the `model` of a configured motion group with [getOptimizerConfiguration](#/operations/getOptimizerConfiguration). * @param {*} [options] Override http request option. * @throws {RequiredError} */ getMotionGroupKinematicModel(motionGroupModel: string, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Returns the operation limits for the given motion group model. See [getMotionGroupModels](#/operations/getMotionGroupModels) for supported motion group models. * @summary Get Limits * @param {string} motionGroupModel Unique identifier for the model of a motion group, e.g., `UniversalRobots_UR10e`. Get the `model` of a configured motion group with [getOptimizerConfiguration](#/operations/getOptimizerConfiguration). * @param {*} [options] Override http request option. * @throws {RequiredError} */ getMotionGroupLimitModel(motionGroupModel: string, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Returns the list of supported motion group models. * @summary Motion Group Models * @param {*} [options] Override http request option. * @throws {RequiredError} */ getMotionGroupModels(options?: RawAxiosRequestConfig): AxiosPromise>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Returns the USD scene model for the specified motion group model. See [getMotionGroupModels](#/operations/getMotionGroupModels) for supported identifiers. * @summary Download USD Model * @param {string} motionGroupModel Unique identifier for the model of a motion group, e.g., `UniversalRobots_UR10e`. Get the `model` of a configured motion group with [getOptimizerConfiguration](#/operations/getOptimizerConfiguration). * @param {*} [options] Override http request option. * @throws {RequiredError} */ getMotionGroupUsdModel(motionGroupModel: string, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Imports a motion group model from a tar.gz archive and registers it as a new custom model. The tar.gz archive must have been produced by the export endpoint. * @summary Import Motion Group Model * @param {File} body * @param {*} [options] Override http request option. * @throws {RequiredError} */ importMotionGroupModel(body: File, options?: RawAxiosRequestConfig): AxiosPromise; }; /** * MotionGroupModelsApi - object-oriented interface */ declare class MotionGroupModelsApi extends BaseAPI { /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Creates a copy of the specified motion group model and registers the copy under a new name as a custom model. Both built-in base models and existing custom models can be copied. * @summary Copy Motion Group Model * @param {string} motionGroupModel Unique identifier for the model of a motion group, e.g., `UniversalRobots_UR10e`. Get the `model` of a configured motion group with [getOptimizerConfiguration](#/operations/getOptimizerConfiguration). * @param {CopyMotionGroupModelRequest} copyMotionGroupModelRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ copyMotionGroupModel(motionGroupModel: string, copyMotionGroupModelRequest: CopyMotionGroupModelRequest, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Deletes a custom motion group model. Only custom models (where `is_custom` is `true`) can be deleted. Built-in base models cannot be removed. * @summary Delete Motion Group Model * @param {string} motionGroupModel Unique identifier for the model of a motion group, e.g., `UniversalRobots_UR10e`. Get the `model` of a configured motion group with [getOptimizerConfiguration](#/operations/getOptimizerConfiguration). * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteExperimentalMotionGroupModel(motionGroupModel: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Exports the specified motion group model as a tar.gz archive. The resulting tar.gz file can be imported on another system using the import endpoint. * @summary Export Motion Group Model * @param {string} motionGroupModel Unique identifier for the model of a motion group, e.g., `UniversalRobots_UR10e`. Get the `model` of a configured motion group with [getOptimizerConfiguration](#/operations/getOptimizerConfiguration). * @param {*} [options] Override http request option. * @throws {RequiredError} */ exportMotionGroupModel(motionGroupModel: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Returns the default collision link chain for a given motion group model. See [getMotionGroupModels](#/operations/getMotionGroupModels) for supported motion group models. The default link chain is derived from 3D models and optimized for collision detection within NOVA. The default link chain includes link shapes only. It does not include any attached components like wire feeders or sensors. Attach additional shapes to the link reference frames by extending the link dictionaries before further use. Additional shapes may overlap each other per link and may also overlap the respective link\'s default shape. * @summary Get Collision Model * @param {string} motionGroupModel Unique identifier for the model of a motion group, e.g., `UniversalRobots_UR10e`. Get the `model` of a configured motion group with [getOptimizerConfiguration](#/operations/getOptimizerConfiguration). * @param {*} [options] Override http request option. * @throws {RequiredError} */ getMotionGroupCollisionModel(motionGroupModel: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<{ [key: string]: Collider; }[], any, {}>>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Returns the dynamics model (mass, center of mass, inertia, friction parameters) for the given motion group model. See [getMotionGroupModels](#/operations/getMotionGroupModels) for supported motion group models. * @summary Get Dynamics * @param {string} motionGroupModel Unique identifier for the model of a motion group, e.g., `UniversalRobots_UR10e`. Get the `model` of a configured motion group with [getOptimizerConfiguration](#/operations/getOptimizerConfiguration). * @param {*} [options] Override http request option. * @throws {RequiredError} */ getMotionGroupDynamicModel(motionGroupModel: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Returns the GLB asset for the specified motion group model. See [getMotionGroupModels](#/operations/getMotionGroupModels) for supported identifiers. * @summary Download GLB Model * @param {string} motionGroupModel Unique identifier for the model of a motion group, e.g., `UniversalRobots_UR10e`. Get the `model` of a configured motion group with [getOptimizerConfiguration](#/operations/getOptimizerConfiguration). * @param {*} [options] Override http request option. * @throws {RequiredError} */ getMotionGroupGlbModel(motionGroupModel: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Returns the default joint positions from which a virtual robot is started. See [getMotionGroupModels](#/operations/getMotionGroupModels) for supported motion group models. * @summary Get Homejoints * @param {string} motionGroupModel Unique identifier for the model of a motion group, e.g., `UniversalRobots_UR10e`. Get the `model` of a configured motion group with [getOptimizerConfiguration](#/operations/getOptimizerConfiguration). * @param {*} [options] Override http request option. * @throws {RequiredError} */ getMotionGroupHomejoints(motionGroupModel: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Returns the kinematics model (DH parameters) for the given motion group model. See [getMotionGroupModels](#/operations/getMotionGroupModels) for supported motion group models. * @summary Get Kinematics * @param {string} motionGroupModel Unique identifier for the model of a motion group, e.g., `UniversalRobots_UR10e`. Get the `model` of a configured motion group with [getOptimizerConfiguration](#/operations/getOptimizerConfiguration). * @param {*} [options] Override http request option. * @throws {RequiredError} */ getMotionGroupKinematicModel(motionGroupModel: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Returns the operation limits for the given motion group model. See [getMotionGroupModels](#/operations/getMotionGroupModels) for supported motion group models. * @summary Get Limits * @param {string} motionGroupModel Unique identifier for the model of a motion group, e.g., `UniversalRobots_UR10e`. Get the `model` of a configured motion group with [getOptimizerConfiguration](#/operations/getOptimizerConfiguration). * @param {*} [options] Override http request option. * @throws {RequiredError} */ getMotionGroupLimitModel(motionGroupModel: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Returns the list of supported motion group models. * @summary Motion Group Models * @param {*} [options] Override http request option. * @throws {RequiredError} */ getMotionGroupModels(options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Returns the USD scene model for the specified motion group model. See [getMotionGroupModels](#/operations/getMotionGroupModels) for supported identifiers. * @summary Download USD Model * @param {string} motionGroupModel Unique identifier for the model of a motion group, e.g., `UniversalRobots_UR10e`. Get the `model` of a configured motion group with [getOptimizerConfiguration](#/operations/getOptimizerConfiguration). * @param {*} [options] Override http request option. * @throws {RequiredError} */ getMotionGroupUsdModel(motionGroupModel: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Imports a motion group model from a tar.gz archive and registers it as a new custom model. The tar.gz archive must have been produced by the export endpoint. * @summary Import Motion Group Model * @param {File} body * @param {*} [options] Override http request option. * @throws {RequiredError} */ importMotionGroupModel(body: File, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; } /** * NOVACloudApi - axios parameter creator */ declare const NOVACloudApiAxiosParamCreator: (configuration?: Configuration) => { /** * **Required permissions:** `can_manage_cloud_connection` - Manage NOVA Cloud connection ___ > **Experimental** Register this instance with the NOVA Cloud fleet manager and configure the local NATS server to establish a leafnode connection. The fleet manager will then be able to receive event data from this instance, allowing it to monitor the connected robots. Establishing the connection can take some time (~30-60 seconds), as the NATS server pod in the cluster needs to restart to apply the new configuration. * @summary Connect to NOVA Cloud * @param {number} [completionTimeout] The maximum time (**in seconds**) spent waiting until the operation is complete. If the parameter is set, the request will wait for completion until the specified time is up. For POST and PUT requests completion means that all resources are running and usable. For DELETE completion means that the deletion process is completed. * @param {CloudConnectionRequest} [cloudConnectionRequest] * @param {*} [options] Override http request option. * @throws {RequiredError} */ connectToNovaCloud: (completionTimeout?: number, cloudConnectionRequest?: CloudConnectionRequest, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_manage_cloud_connection` - Manage NOVA Cloud connection ___ > **Experimental** Disconnects this instance from NOVA Cloud and removes the local NATS leafnode configuration. * @summary Disconnect from NOVA Cloud * @param {number} [completionTimeout] The maximum time (**in seconds**) spent waiting until the operation is complete. If the parameter is set, the request will wait for completion until the specified time is up. For POST and PUT requests completion means that all resources are running and usable. For DELETE completion means that the deletion process is completed. * @param {*} [options] Override http request option. * @throws {RequiredError} */ disconnectFromNovaCloud: (completionTimeout?: number, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ > **Experimental** Get the current NOVA Cloud connection config for this instance. * @summary Get Connection Config * @param {*} [options] Override http request option. * @throws {RequiredError} */ getNovaCloudConfig: (options?: RawAxiosRequestConfig) => Promise; }; /** * NOVACloudApi - functional programming interface */ declare const NOVACloudApiFp: (configuration?: Configuration) => { /** * **Required permissions:** `can_manage_cloud_connection` - Manage NOVA Cloud connection ___ > **Experimental** Register this instance with the NOVA Cloud fleet manager and configure the local NATS server to establish a leafnode connection. The fleet manager will then be able to receive event data from this instance, allowing it to monitor the connected robots. Establishing the connection can take some time (~30-60 seconds), as the NATS server pod in the cluster needs to restart to apply the new configuration. * @summary Connect to NOVA Cloud * @param {number} [completionTimeout] The maximum time (**in seconds**) spent waiting until the operation is complete. If the parameter is set, the request will wait for completion until the specified time is up. For POST and PUT requests completion means that all resources are running and usable. For DELETE completion means that the deletion process is completed. * @param {CloudConnectionRequest} [cloudConnectionRequest] * @param {*} [options] Override http request option. * @throws {RequiredError} */ connectToNovaCloud(completionTimeout?: number, cloudConnectionRequest?: CloudConnectionRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_manage_cloud_connection` - Manage NOVA Cloud connection ___ > **Experimental** Disconnects this instance from NOVA Cloud and removes the local NATS leafnode configuration. * @summary Disconnect from NOVA Cloud * @param {number} [completionTimeout] The maximum time (**in seconds**) spent waiting until the operation is complete. If the parameter is set, the request will wait for completion until the specified time is up. For POST and PUT requests completion means that all resources are running and usable. For DELETE completion means that the deletion process is completed. * @param {*} [options] Override http request option. * @throws {RequiredError} */ disconnectFromNovaCloud(completionTimeout?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ > **Experimental** Get the current NOVA Cloud connection config for this instance. * @summary Get Connection Config * @param {*} [options] Override http request option. * @throws {RequiredError} */ getNovaCloudConfig(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; }; /** * NOVACloudApi - factory interface */ declare const NOVACloudApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => { /** * **Required permissions:** `can_manage_cloud_connection` - Manage NOVA Cloud connection ___ > **Experimental** Register this instance with the NOVA Cloud fleet manager and configure the local NATS server to establish a leafnode connection. The fleet manager will then be able to receive event data from this instance, allowing it to monitor the connected robots. Establishing the connection can take some time (~30-60 seconds), as the NATS server pod in the cluster needs to restart to apply the new configuration. * @summary Connect to NOVA Cloud * @param {number} [completionTimeout] The maximum time (**in seconds**) spent waiting until the operation is complete. If the parameter is set, the request will wait for completion until the specified time is up. For POST and PUT requests completion means that all resources are running and usable. For DELETE completion means that the deletion process is completed. * @param {CloudConnectionRequest} [cloudConnectionRequest] * @param {*} [options] Override http request option. * @throws {RequiredError} */ connectToNovaCloud(completionTimeout?: number, cloudConnectionRequest?: CloudConnectionRequest, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_manage_cloud_connection` - Manage NOVA Cloud connection ___ > **Experimental** Disconnects this instance from NOVA Cloud and removes the local NATS leafnode configuration. * @summary Disconnect from NOVA Cloud * @param {number} [completionTimeout] The maximum time (**in seconds**) spent waiting until the operation is complete. If the parameter is set, the request will wait for completion until the specified time is up. For POST and PUT requests completion means that all resources are running and usable. For DELETE completion means that the deletion process is completed. * @param {*} [options] Override http request option. * @throws {RequiredError} */ disconnectFromNovaCloud(completionTimeout?: number, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ > **Experimental** Get the current NOVA Cloud connection config for this instance. * @summary Get Connection Config * @param {*} [options] Override http request option. * @throws {RequiredError} */ getNovaCloudConfig(options?: RawAxiosRequestConfig): AxiosPromise; }; /** * NOVACloudApi - object-oriented interface */ declare class NOVACloudApi extends BaseAPI { /** * **Required permissions:** `can_manage_cloud_connection` - Manage NOVA Cloud connection ___ > **Experimental** Register this instance with the NOVA Cloud fleet manager and configure the local NATS server to establish a leafnode connection. The fleet manager will then be able to receive event data from this instance, allowing it to monitor the connected robots. Establishing the connection can take some time (~30-60 seconds), as the NATS server pod in the cluster needs to restart to apply the new configuration. * @summary Connect to NOVA Cloud * @param {number} [completionTimeout] The maximum time (**in seconds**) spent waiting until the operation is complete. If the parameter is set, the request will wait for completion until the specified time is up. For POST and PUT requests completion means that all resources are running and usable. For DELETE completion means that the deletion process is completed. * @param {CloudConnectionRequest} [cloudConnectionRequest] * @param {*} [options] Override http request option. * @throws {RequiredError} */ connectToNovaCloud(completionTimeout?: number, cloudConnectionRequest?: CloudConnectionRequest, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_manage_cloud_connection` - Manage NOVA Cloud connection ___ > **Experimental** Disconnects this instance from NOVA Cloud and removes the local NATS leafnode configuration. * @summary Disconnect from NOVA Cloud * @param {number} [completionTimeout] The maximum time (**in seconds**) spent waiting until the operation is complete. If the parameter is set, the request will wait for completion until the specified time is up. For POST and PUT requests completion means that all resources are running and usable. For DELETE completion means that the deletion process is completed. * @param {*} [options] Override http request option. * @throws {RequiredError} */ disconnectFromNovaCloud(completionTimeout?: number, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ > **Experimental** Get the current NOVA Cloud connection config for this instance. * @summary Get Connection Config * @param {*} [options] Override http request option. * @throws {RequiredError} */ getNovaCloudConfig(options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; } /** * ProgramApi - axios parameter creator */ declare const ProgramApiAxiosParamCreator: (configuration?: Configuration) => { /** * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___ > **Experimental** Get details of a program. * @summary Get program * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} program * @param {*} [options] Override http request option. * @throws {RequiredError} */ getProgram: (cell: string, program: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___ > **Experimental** List details of all existing programs. * @summary List programs * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listPrograms: (cell: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___ > **Experimental** This endpoint starts a new program execution. The program will be executed asynchronously. * @summary Start the program * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} program * @param {ProgramStartRequest} programStartRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ startProgram: (cell: string, program: string, programStartRequest: ProgramStartRequest, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___ > **Experimental** Stop a specific program run. * @summary Stop program run * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} program * @param {*} [options] Override http request option. * @throws {RequiredError} */ stopProgram: (cell: string, program: string, options?: RawAxiosRequestConfig) => Promise; }; /** * ProgramApi - functional programming interface */ declare const ProgramApiFp: (configuration?: Configuration) => { /** * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___ > **Experimental** Get details of a program. * @summary Get program * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} program * @param {*} [options] Override http request option. * @throws {RequiredError} */ getProgram(cell: string, program: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___ > **Experimental** List details of all existing programs. * @summary List programs * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listPrograms(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>>; /** * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___ > **Experimental** This endpoint starts a new program execution. The program will be executed asynchronously. * @summary Start the program * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} program * @param {ProgramStartRequest} programStartRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ startProgram(cell: string, program: string, programStartRequest: ProgramStartRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___ > **Experimental** Stop a specific program run. * @summary Stop program run * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} program * @param {*} [options] Override http request option. * @throws {RequiredError} */ stopProgram(cell: string, program: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; }; /** * ProgramApi - factory interface */ declare const ProgramApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => { /** * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___ > **Experimental** Get details of a program. * @summary Get program * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} program * @param {*} [options] Override http request option. * @throws {RequiredError} */ getProgram(cell: string, program: string, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___ > **Experimental** List details of all existing programs. * @summary List programs * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listPrograms(cell: string, options?: RawAxiosRequestConfig): AxiosPromise>; /** * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___ > **Experimental** This endpoint starts a new program execution. The program will be executed asynchronously. * @summary Start the program * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} program * @param {ProgramStartRequest} programStartRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ startProgram(cell: string, program: string, programStartRequest: ProgramStartRequest, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___ > **Experimental** Stop a specific program run. * @summary Stop program run * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} program * @param {*} [options] Override http request option. * @throws {RequiredError} */ stopProgram(cell: string, program: string, options?: RawAxiosRequestConfig): AxiosPromise; }; /** * ProgramApi - object-oriented interface */ declare class ProgramApi extends BaseAPI { /** * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___ > **Experimental** Get details of a program. * @summary Get program * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} program * @param {*} [options] Override http request option. * @throws {RequiredError} */ getProgram(cell: string, program: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___ > **Experimental** List details of all existing programs. * @summary List programs * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listPrograms(cell: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___ > **Experimental** This endpoint starts a new program execution. The program will be executed asynchronously. * @summary Start the program * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} program * @param {ProgramStartRequest} programStartRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ startProgram(cell: string, program: string, programStartRequest: ProgramStartRequest, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___ > **Experimental** Stop a specific program run. * @summary Stop program run * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} program * @param {*} [options] Override http request option. * @throws {RequiredError} */ stopProgram(cell: string, program: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; } /** * RobotConfigurationsApi - axios parameter creator */ declare const RobotConfigurationsApiAxiosParamCreator: (configuration?: Configuration) => { /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Returns all robot controller configurations that match the provided [ARP scan result](#/operations/getArpScan). * @summary Robot Controller Configurations * @param {RobotControllerConfigurationRequest} robotControllerConfigurationRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ getControllerConfigFromArpScan: (robotControllerConfigurationRequest: RobotControllerConfigurationRequest, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Returns the identifiers of available robot configurations. A robot configuration represents a robot controller with one or more attached motion groups. * @summary List Robot Configurations * @param {*} [options] Override http request option. * @throws {RequiredError} */ getRobotConfigurations: (options?: RawAxiosRequestConfig) => Promise; }; /** * RobotConfigurationsApi - functional programming interface */ declare const RobotConfigurationsApiFp: (configuration?: Configuration) => { /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Returns all robot controller configurations that match the provided [ARP scan result](#/operations/getArpScan). * @summary Robot Controller Configurations * @param {RobotControllerConfigurationRequest} robotControllerConfigurationRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ getControllerConfigFromArpScan(robotControllerConfigurationRequest: RobotControllerConfigurationRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Returns the identifiers of available robot configurations. A robot configuration represents a robot controller with one or more attached motion groups. * @summary List Robot Configurations * @param {*} [options] Override http request option. * @throws {RequiredError} */ getRobotConfigurations(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>>; }; /** * RobotConfigurationsApi - factory interface */ declare const RobotConfigurationsApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => { /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Returns all robot controller configurations that match the provided [ARP scan result](#/operations/getArpScan). * @summary Robot Controller Configurations * @param {RobotControllerConfigurationRequest} robotControllerConfigurationRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ getControllerConfigFromArpScan(robotControllerConfigurationRequest: RobotControllerConfigurationRequest, options?: RawAxiosRequestConfig): AxiosPromise>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Returns the identifiers of available robot configurations. A robot configuration represents a robot controller with one or more attached motion groups. * @summary List Robot Configurations * @param {*} [options] Override http request option. * @throws {RequiredError} */ getRobotConfigurations(options?: RawAxiosRequestConfig): AxiosPromise>; }; /** * RobotConfigurationsApi - object-oriented interface */ declare class RobotConfigurationsApi extends BaseAPI { /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Returns all robot controller configurations that match the provided [ARP scan result](#/operations/getArpScan). * @summary Robot Controller Configurations * @param {RobotControllerConfigurationRequest} robotControllerConfigurationRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ getControllerConfigFromArpScan(robotControllerConfigurationRequest: RobotControllerConfigurationRequest, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Returns the identifiers of available robot configurations. A robot configuration represents a robot controller with one or more attached motion groups. * @summary List Robot Configurations * @param {*} [options] Override http request option. * @throws {RequiredError} */ getRobotConfigurations(options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; } /** * SessionApi - axios parameter creator */ declare const SessionApiAxiosParamCreator: (configuration?: Configuration) => { /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Returns - session metadata, - user identity, - capabilities, and - token lifetime. When authentication and authorization are configured, the response reflects the currently authenticated user. On unmanaged instances (no authentication and authorization is configured), a default anonymous session is returned with empty user fields, no capabilities, and zero-value timestamps. * @summary Get current user session information * @param {*} [options] Override http request option. * @throws {RequiredError} */ getSession: (options?: RawAxiosRequestConfig) => Promise; }; /** * SessionApi - functional programming interface */ declare const SessionApiFp: (configuration?: Configuration) => { /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Returns - session metadata, - user identity, - capabilities, and - token lifetime. When authentication and authorization are configured, the response reflects the currently authenticated user. On unmanaged instances (no authentication and authorization is configured), a default anonymous session is returned with empty user fields, no capabilities, and zero-value timestamps. * @summary Get current user session information * @param {*} [options] Override http request option. * @throws {RequiredError} */ getSession(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; }; /** * SessionApi - factory interface */ declare const SessionApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => { /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Returns - session metadata, - user identity, - capabilities, and - token lifetime. When authentication and authorization are configured, the response reflects the currently authenticated user. On unmanaged instances (no authentication and authorization is configured), a default anonymous session is returned with empty user fields, no capabilities, and zero-value timestamps. * @summary Get current user session information * @param {*} [options] Override http request option. * @throws {RequiredError} */ getSession(options?: RawAxiosRequestConfig): AxiosPromise; }; /** * SessionApi - object-oriented interface */ declare class SessionApi extends BaseAPI { /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Returns - session metadata, - user identity, - capabilities, and - token lifetime. When authentication and authorization are configured, the response reflects the currently authenticated user. On unmanaged instances (no authentication and authorization is configured), a default anonymous session is returned with empty user fields, no capabilities, and zero-value timestamps. * @summary Get current user session information * @param {*} [options] Override http request option. * @throws {RequiredError} */ getSession(options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; } /** * StoreCollisionComponentsApi - axios parameter creator */ declare const StoreCollisionComponentsApiAxiosParamCreator: (configuration?: Configuration) => { /** * **Required permissions:** `can_write_collision_world` - Write collision models and scenes ___ Deletes the stored collider. > This will delete persistently stored data. * @summary Delete Collider * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} collider Unique identifier addressing a collider. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteStoredCollider: (cell: string, collider: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_write_collision_world` - Write collision models and scenes ___ Deletes the stored link chain. > This will delete persistently stored data. * @summary Delete Link Chain * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} linkChain Unique identifier addressing a collision link chain. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteStoredCollisionLinkChain: (cell: string, linkChain: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_write_collision_world` - Write collision models and scenes ___ Deletes the stored tool. > This will delete persistently stored data. * @summary Delete Tool * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} tool Unique identifier addressing a collision tool. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteStoredCollisionTool: (cell: string, tool: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___ Returns the collider. * @summary Get Collider * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} collider Unique identifier addressing a collider. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getStoredCollider: (cell: string, collider: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___ Returns the collision link chain. * @summary Get Link Chain * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} linkChain Unique identifier addressing a collision link chain. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getStoredCollisionLinkChain: (cell: string, linkChain: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___ Returns the stored tool. * @summary Get Tool * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} tool Unique identifier addressing a collision tool. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getStoredCollisionTool: (cell: string, tool: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___ Returns the stored link chains. * @summary List Link Chains * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listCollisionLinkChains: (cell: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___ Returns a list of keys for stored link chains. * @summary List Link Chain Keys * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listCollisionLinkChainsKeys: (cell: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___ Returns all stored colliders. * @summary List Colliders * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listStoredColliders: (cell: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___ Returns a list of keys for stored colliders. * @summary List Collider Keys * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listStoredCollidersKeys: (cell: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___ Returns the list of stored tools. * @summary List Tools * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listStoredCollisionTools: (cell: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___ Returns a list of keys for stored tools. * @summary List Tool Keys * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listStoredCollisionToolsKeys: (cell: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_write_collision_world` - Write collision models and scenes ___ Stores collider. - If the collider does not exist, it will be created. - If the collider exists, it will be updated. * @summary Store Collider * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} collider Unique identifier addressing a collider. * @param {Collider} collider2 * @param {*} [options] Override http request option. * @throws {RequiredError} */ storeCollider: (cell: string, collider: string, collider2: Collider, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_write_collision_world` - Write collision models and scenes ___ Stores link chain. - If the link chain does not exist, it will be created. - If the link chain exists, it will be updated. * @summary Store Link Chain * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} linkChain Unique identifier addressing a collision link chain. * @param {Array<{ [key: string]: Collider; }>} collider * @param {*} [options] Override http request option. * @throws {RequiredError} */ storeCollisionLinkChain: (cell: string, linkChain: string, collider: Array<{ [key: string]: Collider; }>, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_write_collision_world` - Write collision models and scenes ___ Stores the tool. - If the tool does not exist, it will be created. - If the tool exists, it will be updated. * @summary Store Tool * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} tool Unique identifier addressing a collision tool. * @param {{ [key: string]: Collider; }} requestBody * @param {*} [options] Override http request option. * @throws {RequiredError} */ storeCollisionTool: (cell: string, tool: string, requestBody: { [key: string]: Collider; }, options?: RawAxiosRequestConfig) => Promise; }; /** * StoreCollisionComponentsApi - functional programming interface */ declare const StoreCollisionComponentsApiFp: (configuration?: Configuration) => { /** * **Required permissions:** `can_write_collision_world` - Write collision models and scenes ___ Deletes the stored collider. > This will delete persistently stored data. * @summary Delete Collider * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} collider Unique identifier addressing a collider. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteStoredCollider(cell: string, collider: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_write_collision_world` - Write collision models and scenes ___ Deletes the stored link chain. > This will delete persistently stored data. * @summary Delete Link Chain * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} linkChain Unique identifier addressing a collision link chain. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteStoredCollisionLinkChain(cell: string, linkChain: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_write_collision_world` - Write collision models and scenes ___ Deletes the stored tool. > This will delete persistently stored data. * @summary Delete Tool * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} tool Unique identifier addressing a collision tool. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteStoredCollisionTool(cell: string, tool: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___ Returns the collider. * @summary Get Collider * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} collider Unique identifier addressing a collider. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getStoredCollider(cell: string, collider: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___ Returns the collision link chain. * @summary Get Link Chain * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} linkChain Unique identifier addressing a collision link chain. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getStoredCollisionLinkChain(cell: string, linkChain: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>>; /** * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___ Returns the stored tool. * @summary Get Tool * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} tool Unique identifier addressing a collision tool. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getStoredCollisionTool(cell: string, tool: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<{ [key: string]: Collider; }>>; /** * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___ Returns the stored link chains. * @summary List Link Chains * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listCollisionLinkChains(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<{ [key: string]: Array<{ [key: string]: Collider; }>; }>>; /** * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___ Returns a list of keys for stored link chains. * @summary List Link Chain Keys * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listCollisionLinkChainsKeys(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>>; /** * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___ Returns all stored colliders. * @summary List Colliders * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listStoredColliders(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<{ [key: string]: Collider; }>>; /** * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___ Returns a list of keys for stored colliders. * @summary List Collider Keys * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listStoredCollidersKeys(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>>; /** * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___ Returns the list of stored tools. * @summary List Tools * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listStoredCollisionTools(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<{ [key: string]: { [key: string]: Collider; }; }>>; /** * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___ Returns a list of keys for stored tools. * @summary List Tool Keys * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listStoredCollisionToolsKeys(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>>; /** * **Required permissions:** `can_write_collision_world` - Write collision models and scenes ___ Stores collider. - If the collider does not exist, it will be created. - If the collider exists, it will be updated. * @summary Store Collider * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} collider Unique identifier addressing a collider. * @param {Collider} collider2 * @param {*} [options] Override http request option. * @throws {RequiredError} */ storeCollider(cell: string, collider: string, collider2: Collider, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_write_collision_world` - Write collision models and scenes ___ Stores link chain. - If the link chain does not exist, it will be created. - If the link chain exists, it will be updated. * @summary Store Link Chain * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} linkChain Unique identifier addressing a collision link chain. * @param {Array<{ [key: string]: Collider; }>} collider * @param {*} [options] Override http request option. * @throws {RequiredError} */ storeCollisionLinkChain(cell: string, linkChain: string, collider: Array<{ [key: string]: Collider; }>, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>>; /** * **Required permissions:** `can_write_collision_world` - Write collision models and scenes ___ Stores the tool. - If the tool does not exist, it will be created. - If the tool exists, it will be updated. * @summary Store Tool * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} tool Unique identifier addressing a collision tool. * @param {{ [key: string]: Collider; }} requestBody * @param {*} [options] Override http request option. * @throws {RequiredError} */ storeCollisionTool(cell: string, tool: string, requestBody: { [key: string]: Collider; }, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<{ [key: string]: Collider; }>>; }; /** * StoreCollisionComponentsApi - factory interface */ declare const StoreCollisionComponentsApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => { /** * **Required permissions:** `can_write_collision_world` - Write collision models and scenes ___ Deletes the stored collider. > This will delete persistently stored data. * @summary Delete Collider * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} collider Unique identifier addressing a collider. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteStoredCollider(cell: string, collider: string, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_write_collision_world` - Write collision models and scenes ___ Deletes the stored link chain. > This will delete persistently stored data. * @summary Delete Link Chain * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} linkChain Unique identifier addressing a collision link chain. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteStoredCollisionLinkChain(cell: string, linkChain: string, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_write_collision_world` - Write collision models and scenes ___ Deletes the stored tool. > This will delete persistently stored data. * @summary Delete Tool * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} tool Unique identifier addressing a collision tool. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteStoredCollisionTool(cell: string, tool: string, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___ Returns the collider. * @summary Get Collider * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} collider Unique identifier addressing a collider. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getStoredCollider(cell: string, collider: string, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___ Returns the collision link chain. * @summary Get Link Chain * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} linkChain Unique identifier addressing a collision link chain. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getStoredCollisionLinkChain(cell: string, linkChain: string, options?: RawAxiosRequestConfig): AxiosPromise>; /** * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___ Returns the stored tool. * @summary Get Tool * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} tool Unique identifier addressing a collision tool. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getStoredCollisionTool(cell: string, tool: string, options?: RawAxiosRequestConfig): AxiosPromise<{ [key: string]: Collider; }>; /** * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___ Returns the stored link chains. * @summary List Link Chains * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listCollisionLinkChains(cell: string, options?: RawAxiosRequestConfig): AxiosPromise<{ [key: string]: Array<{ [key: string]: Collider; }>; }>; /** * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___ Returns a list of keys for stored link chains. * @summary List Link Chain Keys * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listCollisionLinkChainsKeys(cell: string, options?: RawAxiosRequestConfig): AxiosPromise>; /** * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___ Returns all stored colliders. * @summary List Colliders * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listStoredColliders(cell: string, options?: RawAxiosRequestConfig): AxiosPromise<{ [key: string]: Collider; }>; /** * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___ Returns a list of keys for stored colliders. * @summary List Collider Keys * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listStoredCollidersKeys(cell: string, options?: RawAxiosRequestConfig): AxiosPromise>; /** * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___ Returns the list of stored tools. * @summary List Tools * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listStoredCollisionTools(cell: string, options?: RawAxiosRequestConfig): AxiosPromise<{ [key: string]: { [key: string]: Collider; }; }>; /** * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___ Returns a list of keys for stored tools. * @summary List Tool Keys * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listStoredCollisionToolsKeys(cell: string, options?: RawAxiosRequestConfig): AxiosPromise>; /** * **Required permissions:** `can_write_collision_world` - Write collision models and scenes ___ Stores collider. - If the collider does not exist, it will be created. - If the collider exists, it will be updated. * @summary Store Collider * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} collider Unique identifier addressing a collider. * @param {Collider} collider2 * @param {*} [options] Override http request option. * @throws {RequiredError} */ storeCollider(cell: string, collider: string, collider2: Collider, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_write_collision_world` - Write collision models and scenes ___ Stores link chain. - If the link chain does not exist, it will be created. - If the link chain exists, it will be updated. * @summary Store Link Chain * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} linkChain Unique identifier addressing a collision link chain. * @param {Array<{ [key: string]: Collider; }>} collider * @param {*} [options] Override http request option. * @throws {RequiredError} */ storeCollisionLinkChain(cell: string, linkChain: string, collider: Array<{ [key: string]: Collider; }>, options?: RawAxiosRequestConfig): AxiosPromise>; /** * **Required permissions:** `can_write_collision_world` - Write collision models and scenes ___ Stores the tool. - If the tool does not exist, it will be created. - If the tool exists, it will be updated. * @summary Store Tool * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} tool Unique identifier addressing a collision tool. * @param {{ [key: string]: Collider; }} requestBody * @param {*} [options] Override http request option. * @throws {RequiredError} */ storeCollisionTool(cell: string, tool: string, requestBody: { [key: string]: Collider; }, options?: RawAxiosRequestConfig): AxiosPromise<{ [key: string]: Collider; }>; }; /** * StoreCollisionComponentsApi - object-oriented interface */ declare class StoreCollisionComponentsApi extends BaseAPI { /** * **Required permissions:** `can_write_collision_world` - Write collision models and scenes ___ Deletes the stored collider. > This will delete persistently stored data. * @summary Delete Collider * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} collider Unique identifier addressing a collider. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteStoredCollider(cell: string, collider: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_write_collision_world` - Write collision models and scenes ___ Deletes the stored link chain. > This will delete persistently stored data. * @summary Delete Link Chain * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} linkChain Unique identifier addressing a collision link chain. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteStoredCollisionLinkChain(cell: string, linkChain: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_write_collision_world` - Write collision models and scenes ___ Deletes the stored tool. > This will delete persistently stored data. * @summary Delete Tool * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} tool Unique identifier addressing a collision tool. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteStoredCollisionTool(cell: string, tool: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___ Returns the collider. * @summary Get Collider * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} collider Unique identifier addressing a collider. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getStoredCollider(cell: string, collider: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___ Returns the collision link chain. * @summary Get Link Chain * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} linkChain Unique identifier addressing a collision link chain. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getStoredCollisionLinkChain(cell: string, linkChain: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<{ [key: string]: Collider; }[], any, {}>>; /** * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___ Returns the stored tool. * @summary Get Tool * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} tool Unique identifier addressing a collision tool. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getStoredCollisionTool(cell: string, tool: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<{ [key: string]: Collider; }, any, {}>>; /** * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___ Returns the stored link chains. * @summary List Link Chains * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listCollisionLinkChains(cell: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<{ [key: string]: { [key: string]: Collider; }[]; }, any, {}>>; /** * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___ Returns a list of keys for stored link chains. * @summary List Link Chain Keys * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listCollisionLinkChainsKeys(cell: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___ Returns all stored colliders. * @summary List Colliders * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listStoredColliders(cell: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<{ [key: string]: Collider; }, any, {}>>; /** * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___ Returns a list of keys for stored colliders. * @summary List Collider Keys * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listStoredCollidersKeys(cell: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___ Returns the list of stored tools. * @summary List Tools * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listStoredCollisionTools(cell: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<{ [key: string]: { [key: string]: Collider; }; }, any, {}>>; /** * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___ Returns a list of keys for stored tools. * @summary List Tool Keys * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listStoredCollisionToolsKeys(cell: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_write_collision_world` - Write collision models and scenes ___ Stores collider. - If the collider does not exist, it will be created. - If the collider exists, it will be updated. * @summary Store Collider * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} collider Unique identifier addressing a collider. * @param {Collider} collider2 * @param {*} [options] Override http request option. * @throws {RequiredError} */ storeCollider(cell: string, collider: string, collider2: Collider, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_write_collision_world` - Write collision models and scenes ___ Stores link chain. - If the link chain does not exist, it will be created. - If the link chain exists, it will be updated. * @summary Store Link Chain * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} linkChain Unique identifier addressing a collision link chain. * @param {Array<{ [key: string]: Collider; }>} collider * @param {*} [options] Override http request option. * @throws {RequiredError} */ storeCollisionLinkChain(cell: string, linkChain: string, collider: Array<{ [key: string]: Collider; }>, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<{ [key: string]: Collider; }[], any, {}>>; /** * **Required permissions:** `can_write_collision_world` - Write collision models and scenes ___ Stores the tool. - If the tool does not exist, it will be created. - If the tool exists, it will be updated. * @summary Store Tool * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} tool Unique identifier addressing a collision tool. * @param {{ [key: string]: Collider; }} requestBody * @param {*} [options] Override http request option. * @throws {RequiredError} */ storeCollisionTool(cell: string, tool: string, requestBody: { [key: string]: Collider; }, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<{ [key: string]: Collider; }, any, {}>>; } /** * StoreCollisionSetupsApi - axios parameter creator */ declare const StoreCollisionSetupsApiAxiosParamCreator: (configuration?: Configuration) => { /** * **Required permissions:** `can_write_collision_world` - Write collision models and scenes ___ Deletes the stored collision setup. > This will delete persistently stored data. * @summary Delete Collision Setup * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} setup Identifier of the collision setup * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteStoredCollisionSetup: (cell: string, setup: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___ Returns the stored collision setup. * @summary Get Collision Setup * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} setup Identifier of the collision setup * @param {*} [options] Override http request option. * @throws {RequiredError} */ getStoredCollisionSetup: (cell: string, setup: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___ Returns a list of stored collision setups. * @summary List Collision Setups * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listStoredCollisionSetups: (cell: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___ Returns a list of keys for stored collision setups. * @summary List Collision Setup Keys * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listStoredCollisionSetupsKeys: (cell: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_write_collision_world` - Write collision models and scenes ___ Stores collision setup. - If the collision setup does not exist, it will be created. - If the collision setup exists, it will be updated. * @summary Store Collision Setup * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} setup Identifier of the collision setup * @param {CollisionSetup} collisionSetup * @param {*} [options] Override http request option. * @throws {RequiredError} */ storeCollisionSetup: (cell: string, setup: string, collisionSetup: CollisionSetup, options?: RawAxiosRequestConfig) => Promise; }; /** * StoreCollisionSetupsApi - functional programming interface */ declare const StoreCollisionSetupsApiFp: (configuration?: Configuration) => { /** * **Required permissions:** `can_write_collision_world` - Write collision models and scenes ___ Deletes the stored collision setup. > This will delete persistently stored data. * @summary Delete Collision Setup * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} setup Identifier of the collision setup * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteStoredCollisionSetup(cell: string, setup: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___ Returns the stored collision setup. * @summary Get Collision Setup * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} setup Identifier of the collision setup * @param {*} [options] Override http request option. * @throws {RequiredError} */ getStoredCollisionSetup(cell: string, setup: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___ Returns a list of stored collision setups. * @summary List Collision Setups * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listStoredCollisionSetups(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<{ [key: string]: CollisionSetup; }>>; /** * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___ Returns a list of keys for stored collision setups. * @summary List Collision Setup Keys * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listStoredCollisionSetupsKeys(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>>; /** * **Required permissions:** `can_write_collision_world` - Write collision models and scenes ___ Stores collision setup. - If the collision setup does not exist, it will be created. - If the collision setup exists, it will be updated. * @summary Store Collision Setup * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} setup Identifier of the collision setup * @param {CollisionSetup} collisionSetup * @param {*} [options] Override http request option. * @throws {RequiredError} */ storeCollisionSetup(cell: string, setup: string, collisionSetup: CollisionSetup, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; }; /** * StoreCollisionSetupsApi - factory interface */ declare const StoreCollisionSetupsApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => { /** * **Required permissions:** `can_write_collision_world` - Write collision models and scenes ___ Deletes the stored collision setup. > This will delete persistently stored data. * @summary Delete Collision Setup * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} setup Identifier of the collision setup * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteStoredCollisionSetup(cell: string, setup: string, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___ Returns the stored collision setup. * @summary Get Collision Setup * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} setup Identifier of the collision setup * @param {*} [options] Override http request option. * @throws {RequiredError} */ getStoredCollisionSetup(cell: string, setup: string, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___ Returns a list of stored collision setups. * @summary List Collision Setups * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listStoredCollisionSetups(cell: string, options?: RawAxiosRequestConfig): AxiosPromise<{ [key: string]: CollisionSetup; }>; /** * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___ Returns a list of keys for stored collision setups. * @summary List Collision Setup Keys * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listStoredCollisionSetupsKeys(cell: string, options?: RawAxiosRequestConfig): AxiosPromise>; /** * **Required permissions:** `can_write_collision_world` - Write collision models and scenes ___ Stores collision setup. - If the collision setup does not exist, it will be created. - If the collision setup exists, it will be updated. * @summary Store Collision Setup * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} setup Identifier of the collision setup * @param {CollisionSetup} collisionSetup * @param {*} [options] Override http request option. * @throws {RequiredError} */ storeCollisionSetup(cell: string, setup: string, collisionSetup: CollisionSetup, options?: RawAxiosRequestConfig): AxiosPromise; }; /** * StoreCollisionSetupsApi - object-oriented interface */ declare class StoreCollisionSetupsApi extends BaseAPI { /** * **Required permissions:** `can_write_collision_world` - Write collision models and scenes ___ Deletes the stored collision setup. > This will delete persistently stored data. * @summary Delete Collision Setup * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} setup Identifier of the collision setup * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteStoredCollisionSetup(cell: string, setup: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___ Returns the stored collision setup. * @summary Get Collision Setup * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} setup Identifier of the collision setup * @param {*} [options] Override http request option. * @throws {RequiredError} */ getStoredCollisionSetup(cell: string, setup: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___ Returns a list of stored collision setups. * @summary List Collision Setups * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listStoredCollisionSetups(cell: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<{ [key: string]: CollisionSetup; }, any, {}>>; /** * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___ Returns a list of keys for stored collision setups. * @summary List Collision Setup Keys * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listStoredCollisionSetupsKeys(cell: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_write_collision_world` - Write collision models and scenes ___ Stores collision setup. - If the collision setup does not exist, it will be created. - If the collision setup exists, it will be updated. * @summary Store Collision Setup * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} setup Identifier of the collision setup * @param {CollisionSetup} collisionSetup * @param {*} [options] Override http request option. * @throws {RequiredError} */ storeCollisionSetup(cell: string, setup: string, collisionSetup: CollisionSetup, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; } /** * StoreObjectApi - axios parameter creator */ declare const StoreObjectApiAxiosParamCreator: (configuration?: Configuration) => { /** * **Required permissions:** `can_write_objects` - Write stored objects ___ Delete all objects. > This will delete ALL your persistently stored data. * @summary Clear all Objects * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ clearAllObjects: (cell: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_write_objects` - Write stored objects ___ Delete an object > This will delete persistently stored data. * @summary Delete Object * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} key * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteObject: (cell: string, key: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_read_objects` - Read stored objects ___ Returns content and metadata of a stored object. * @summary Get Object * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} key * @param {*} [options] Override http request option. * @throws {RequiredError} */ getObject: (cell: string, key: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_read_objects` - Read stored objects ___ Returns metadata. Object content is not returned. * @summary Get Object Metadata * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} key * @param {*} [options] Override http request option. * @throws {RequiredError} */ getObjectMetadata: (cell: string, key: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_read_objects` - Read stored objects ___ List the keys for all objects. * @summary List all Object Keys * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listAllObjectKeys: (cell: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_write_objects` - Write stored objects ___ Store any data as an object. Using a key which already contains an object will override the previously stored object. Use [getObjectMetadata](#/operations/getObjectMetadata) to verify that the key does not contain objects. #### Optional Specify metadata as a dictionary with names and values. * @summary Store Object * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} key * @param {{ [key: string]: string; }} [xMetadata] * @param {any} [anyValue] * @param {*} [options] Override http request option. * @throws {RequiredError} */ storeObject: (cell: string, key: string, xMetadata?: { [key: string]: string; }, anyValue?: any, options?: RawAxiosRequestConfig) => Promise; }; /** * StoreObjectApi - functional programming interface */ declare const StoreObjectApiFp: (configuration?: Configuration) => { /** * **Required permissions:** `can_write_objects` - Write stored objects ___ Delete all objects. > This will delete ALL your persistently stored data. * @summary Clear all Objects * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ clearAllObjects(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_write_objects` - Write stored objects ___ Delete an object > This will delete persistently stored data. * @summary Delete Object * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} key * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteObject(cell: string, key: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_read_objects` - Read stored objects ___ Returns content and metadata of a stored object. * @summary Get Object * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} key * @param {*} [options] Override http request option. * @throws {RequiredError} */ getObject(cell: string, key: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_read_objects` - Read stored objects ___ Returns metadata. Object content is not returned. * @summary Get Object Metadata * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} key * @param {*} [options] Override http request option. * @throws {RequiredError} */ getObjectMetadata(cell: string, key: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_read_objects` - Read stored objects ___ List the keys for all objects. * @summary List all Object Keys * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listAllObjectKeys(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>>; /** * **Required permissions:** `can_write_objects` - Write stored objects ___ Store any data as an object. Using a key which already contains an object will override the previously stored object. Use [getObjectMetadata](#/operations/getObjectMetadata) to verify that the key does not contain objects. #### Optional Specify metadata as a dictionary with names and values. * @summary Store Object * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} key * @param {{ [key: string]: string; }} [xMetadata] * @param {any} [anyValue] * @param {*} [options] Override http request option. * @throws {RequiredError} */ storeObject(cell: string, key: string, xMetadata?: { [key: string]: string; }, anyValue?: any, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; }; /** * StoreObjectApi - factory interface */ declare const StoreObjectApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => { /** * **Required permissions:** `can_write_objects` - Write stored objects ___ Delete all objects. > This will delete ALL your persistently stored data. * @summary Clear all Objects * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ clearAllObjects(cell: string, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_write_objects` - Write stored objects ___ Delete an object > This will delete persistently stored data. * @summary Delete Object * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} key * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteObject(cell: string, key: string, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_read_objects` - Read stored objects ___ Returns content and metadata of a stored object. * @summary Get Object * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} key * @param {*} [options] Override http request option. * @throws {RequiredError} */ getObject(cell: string, key: string, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_read_objects` - Read stored objects ___ Returns metadata. Object content is not returned. * @summary Get Object Metadata * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} key * @param {*} [options] Override http request option. * @throws {RequiredError} */ getObjectMetadata(cell: string, key: string, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_read_objects` - Read stored objects ___ List the keys for all objects. * @summary List all Object Keys * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listAllObjectKeys(cell: string, options?: RawAxiosRequestConfig): AxiosPromise>; /** * **Required permissions:** `can_write_objects` - Write stored objects ___ Store any data as an object. Using a key which already contains an object will override the previously stored object. Use [getObjectMetadata](#/operations/getObjectMetadata) to verify that the key does not contain objects. #### Optional Specify metadata as a dictionary with names and values. * @summary Store Object * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} key * @param {{ [key: string]: string; }} [xMetadata] * @param {any} [anyValue] * @param {*} [options] Override http request option. * @throws {RequiredError} */ storeObject(cell: string, key: string, xMetadata?: { [key: string]: string; }, anyValue?: any, options?: RawAxiosRequestConfig): AxiosPromise; }; /** * StoreObjectApi - object-oriented interface */ declare class StoreObjectApi extends BaseAPI { /** * **Required permissions:** `can_write_objects` - Write stored objects ___ Delete all objects. > This will delete ALL your persistently stored data. * @summary Clear all Objects * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ clearAllObjects(cell: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_write_objects` - Write stored objects ___ Delete an object > This will delete persistently stored data. * @summary Delete Object * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} key * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteObject(cell: string, key: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_read_objects` - Read stored objects ___ Returns content and metadata of a stored object. * @summary Get Object * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} key * @param {*} [options] Override http request option. * @throws {RequiredError} */ getObject(cell: string, key: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_read_objects` - Read stored objects ___ Returns metadata. Object content is not returned. * @summary Get Object Metadata * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} key * @param {*} [options] Override http request option. * @throws {RequiredError} */ getObjectMetadata(cell: string, key: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_read_objects` - Read stored objects ___ List the keys for all objects. * @summary List all Object Keys * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listAllObjectKeys(cell: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_write_objects` - Write stored objects ___ Store any data as an object. Using a key which already contains an object will override the previously stored object. Use [getObjectMetadata](#/operations/getObjectMetadata) to verify that the key does not contain objects. #### Optional Specify metadata as a dictionary with names and values. * @summary Store Object * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {string} key * @param {{ [key: string]: string; }} [xMetadata] * @param {any} [anyValue] * @param {*} [options] Override http request option. * @throws {RequiredError} */ storeObject(cell: string, key: string, xMetadata?: { [key: string]: string; }, anyValue?: any, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; } /** * SystemApi - axios parameter creator */ declare const SystemApiAxiosParamCreator: (configuration?: Configuration) => { /** * **Required permissions:** `can_backup_system` - Create system backups ___ Retrieves a configuration backup based on provided resource identifiers. If an empty array of resources is provided, a backup for all resources will be retrieved. * @summary Retrieve Configuration Backup * @param {Array} [resources] List of resource identifiers to include in the retrieval. * @param {{ [key: string]: string; }} [metadata] Additional metadata to add to the backup * @param {*} [options] Override http request option. * @throws {RequiredError} */ backupConfiguration: (resources?: Array, metadata?: { [key: string]: string; }, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Check if a more recent Wandelbots NOVA Version is available. * @summary Check update * @param {ReleaseChannel} channel * @param {*} [options] Override http request option. * @throws {RequiredError} */ checkNovaVersionUpdate: (channel: ReleaseChannel, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ > **Experimental** Performs an address resolution protocol (ARP) scan on the specified interface/classless inter-domain routing (CIDR) and returns all discovered devices on the network by CIDR notation. * @summary Get ARP-Scan * @param {string} [_interface] * @param {string} [cidr] * @param {number} [timeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ getArpScan: (_interface?: string, cidr?: string, timeout?: number, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_backup_system` - Create system backups ___ Retrieves the status of a configuration backup. The status can only be requested for 5 minutes after backup creation. After 5 minutes, 404 is returned. * @summary Retrieve Backup Status * @param {string} operationId * @param {*} [options] Override http request option. * @throws {RequiredError} */ getConfigurationBackupStatus: (operationId: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Collects information on the current status of all NOVA services and exports them as a .zip file. Includes information on all cells on the instance such as the service logs and virtual robot controllers. From each cell the logs of all services are included, as well as the configuration of each connected controller to start virtual robots. * @summary Download Diagnosis Package * @param {*} [options] Override http request option. * @throws {RequiredError} */ getDiagnosePackage: (options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ > **Experimental** Get the network interfaces of the system. * @summary Network Interfaces * @param {*} [options] Override http request option. * @throws {RequiredError} */ getNetworkInterfaces: (options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ > **Experimental** Get the current state of the network. * @summary Network State * @param {*} [options] Override http request option. * @throws {RequiredError} */ getNetworkState: (options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Get the status of all system services. * @summary Wandelbots NOVA status * @param {*} [options] Override http request option. * @throws {RequiredError} */ getSystemStatus: (options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Get the current Wandelbots NOVA version. * @summary Wandelbots NOVA Version * @param {*} [options] Override http request option. * @throws {RequiredError} */ getSystemVersion: (options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_backup_system` - Create system backups ___ Retrieves a list of all available configuration resources for backup purposes. * @summary List Configuration Resources * @param {*} [options] Override http request option. * @throws {RequiredError} */ listConfigurationResources: (options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_restore_system` - Restore system backups ___ Restores a previously backed up configuration. If an empty array of resources is provided, all resources from the backup will be restored. * @summary Restore Configuration Backup * @param {File} body Backup file stream containing the configuration to restore. * @param {Array} [resources] List of resource identifiers to restore. If empty, all resources from the backup will be restored. * @param {*} [options] Override http request option. * @throws {RequiredError} */ restoreConfiguration: (body: File, resources?: Array, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_update_system` - Update system versions and services ___ Update the Wandelbots NOVA version and all attached services. Sending this API Request will trigger an update of all NOVA services that are part of a cell. Previous cells and cell configurations will remain on the instance. If the update fails, the previous Wandelbots NOVA version is restored. System updates only apply to cells without an explicit chart version. Pinned versions are always preserved; setting `update_cells=false` pins unversioned cells to the current system version before updating. * @summary Update Wandelbots NOVA version * @param {UpdateNovaVersionRequest} updateNovaVersionRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ updateNovaVersion: (updateNovaVersionRequest: UpdateNovaVersionRequest, options?: RawAxiosRequestConfig) => Promise; }; /** * SystemApi - functional programming interface */ declare const SystemApiFp: (configuration?: Configuration) => { /** * **Required permissions:** `can_backup_system` - Create system backups ___ Retrieves a configuration backup based on provided resource identifiers. If an empty array of resources is provided, a backup for all resources will be retrieved. * @summary Retrieve Configuration Backup * @param {Array} [resources] List of resource identifiers to include in the retrieval. * @param {{ [key: string]: string; }} [metadata] Additional metadata to add to the backup * @param {*} [options] Override http request option. * @throws {RequiredError} */ backupConfiguration(resources?: Array, metadata?: { [key: string]: string; }, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Check if a more recent Wandelbots NOVA Version is available. * @summary Check update * @param {ReleaseChannel} channel * @param {*} [options] Override http request option. * @throws {RequiredError} */ checkNovaVersionUpdate(channel: ReleaseChannel, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ > **Experimental** Performs an address resolution protocol (ARP) scan on the specified interface/classless inter-domain routing (CIDR) and returns all discovered devices on the network by CIDR notation. * @summary Get ARP-Scan * @param {string} [_interface] * @param {string} [cidr] * @param {number} [timeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ getArpScan(_interface?: string, cidr?: string, timeout?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>>; /** * **Required permissions:** `can_backup_system` - Create system backups ___ Retrieves the status of a configuration backup. The status can only be requested for 5 minutes after backup creation. After 5 minutes, 404 is returned. * @summary Retrieve Backup Status * @param {string} operationId * @param {*} [options] Override http request option. * @throws {RequiredError} */ getConfigurationBackupStatus(operationId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Collects information on the current status of all NOVA services and exports them as a .zip file. Includes information on all cells on the instance such as the service logs and virtual robot controllers. From each cell the logs of all services are included, as well as the configuration of each connected controller to start virtual robots. * @summary Download Diagnosis Package * @param {*} [options] Override http request option. * @throws {RequiredError} */ getDiagnosePackage(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ > **Experimental** Get the network interfaces of the system. * @summary Network Interfaces * @param {*} [options] Override http request option. * @throws {RequiredError} */ getNetworkInterfaces(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ > **Experimental** Get the current state of the network. * @summary Network State * @param {*} [options] Override http request option. * @throws {RequiredError} */ getNetworkState(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Get the status of all system services. * @summary Wandelbots NOVA status * @param {*} [options] Override http request option. * @throws {RequiredError} */ getSystemStatus(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Get the current Wandelbots NOVA version. * @summary Wandelbots NOVA Version * @param {*} [options] Override http request option. * @throws {RequiredError} */ getSystemVersion(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_backup_system` - Create system backups ___ Retrieves a list of all available configuration resources for backup purposes. * @summary List Configuration Resources * @param {*} [options] Override http request option. * @throws {RequiredError} */ listConfigurationResources(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>>; /** * **Required permissions:** `can_restore_system` - Restore system backups ___ Restores a previously backed up configuration. If an empty array of resources is provided, all resources from the backup will be restored. * @summary Restore Configuration Backup * @param {File} body Backup file stream containing the configuration to restore. * @param {Array} [resources] List of resource identifiers to restore. If empty, all resources from the backup will be restored. * @param {*} [options] Override http request option. * @throws {RequiredError} */ restoreConfiguration(body: File, resources?: Array, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_update_system` - Update system versions and services ___ Update the Wandelbots NOVA version and all attached services. Sending this API Request will trigger an update of all NOVA services that are part of a cell. Previous cells and cell configurations will remain on the instance. If the update fails, the previous Wandelbots NOVA version is restored. System updates only apply to cells without an explicit chart version. Pinned versions are always preserved; setting `update_cells=false` pins unversioned cells to the current system version before updating. * @summary Update Wandelbots NOVA version * @param {UpdateNovaVersionRequest} updateNovaVersionRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ updateNovaVersion(updateNovaVersionRequest: UpdateNovaVersionRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; }; /** * SystemApi - factory interface */ declare const SystemApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => { /** * **Required permissions:** `can_backup_system` - Create system backups ___ Retrieves a configuration backup based on provided resource identifiers. If an empty array of resources is provided, a backup for all resources will be retrieved. * @summary Retrieve Configuration Backup * @param {Array} [resources] List of resource identifiers to include in the retrieval. * @param {{ [key: string]: string; }} [metadata] Additional metadata to add to the backup * @param {*} [options] Override http request option. * @throws {RequiredError} */ backupConfiguration(resources?: Array, metadata?: { [key: string]: string; }, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Check if a more recent Wandelbots NOVA Version is available. * @summary Check update * @param {ReleaseChannel} channel * @param {*} [options] Override http request option. * @throws {RequiredError} */ checkNovaVersionUpdate(channel: ReleaseChannel, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ > **Experimental** Performs an address resolution protocol (ARP) scan on the specified interface/classless inter-domain routing (CIDR) and returns all discovered devices on the network by CIDR notation. * @summary Get ARP-Scan * @param {string} [_interface] * @param {string} [cidr] * @param {number} [timeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ getArpScan(_interface?: string, cidr?: string, timeout?: number, options?: RawAxiosRequestConfig): AxiosPromise>; /** * **Required permissions:** `can_backup_system` - Create system backups ___ Retrieves the status of a configuration backup. The status can only be requested for 5 minutes after backup creation. After 5 minutes, 404 is returned. * @summary Retrieve Backup Status * @param {string} operationId * @param {*} [options] Override http request option. * @throws {RequiredError} */ getConfigurationBackupStatus(operationId: string, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Collects information on the current status of all NOVA services and exports them as a .zip file. Includes information on all cells on the instance such as the service logs and virtual robot controllers. From each cell the logs of all services are included, as well as the configuration of each connected controller to start virtual robots. * @summary Download Diagnosis Package * @param {*} [options] Override http request option. * @throws {RequiredError} */ getDiagnosePackage(options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ > **Experimental** Get the network interfaces of the system. * @summary Network Interfaces * @param {*} [options] Override http request option. * @throws {RequiredError} */ getNetworkInterfaces(options?: RawAxiosRequestConfig): AxiosPromise>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ > **Experimental** Get the current state of the network. * @summary Network State * @param {*} [options] Override http request option. * @throws {RequiredError} */ getNetworkState(options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Get the status of all system services. * @summary Wandelbots NOVA status * @param {*} [options] Override http request option. * @throws {RequiredError} */ getSystemStatus(options?: RawAxiosRequestConfig): AxiosPromise>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Get the current Wandelbots NOVA version. * @summary Wandelbots NOVA Version * @param {*} [options] Override http request option. * @throws {RequiredError} */ getSystemVersion(options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_backup_system` - Create system backups ___ Retrieves a list of all available configuration resources for backup purposes. * @summary List Configuration Resources * @param {*} [options] Override http request option. * @throws {RequiredError} */ listConfigurationResources(options?: RawAxiosRequestConfig): AxiosPromise>; /** * **Required permissions:** `can_restore_system` - Restore system backups ___ Restores a previously backed up configuration. If an empty array of resources is provided, all resources from the backup will be restored. * @summary Restore Configuration Backup * @param {File} body Backup file stream containing the configuration to restore. * @param {Array} [resources] List of resource identifiers to restore. If empty, all resources from the backup will be restored. * @param {*} [options] Override http request option. * @throws {RequiredError} */ restoreConfiguration(body: File, resources?: Array, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_update_system` - Update system versions and services ___ Update the Wandelbots NOVA version and all attached services. Sending this API Request will trigger an update of all NOVA services that are part of a cell. Previous cells and cell configurations will remain on the instance. If the update fails, the previous Wandelbots NOVA version is restored. System updates only apply to cells without an explicit chart version. Pinned versions are always preserved; setting `update_cells=false` pins unversioned cells to the current system version before updating. * @summary Update Wandelbots NOVA version * @param {UpdateNovaVersionRequest} updateNovaVersionRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ updateNovaVersion(updateNovaVersionRequest: UpdateNovaVersionRequest, options?: RawAxiosRequestConfig): AxiosPromise; }; /** * SystemApi - object-oriented interface */ declare class SystemApi extends BaseAPI { /** * **Required permissions:** `can_backup_system` - Create system backups ___ Retrieves a configuration backup based on provided resource identifiers. If an empty array of resources is provided, a backup for all resources will be retrieved. * @summary Retrieve Configuration Backup * @param {Array} [resources] List of resource identifiers to include in the retrieval. * @param {{ [key: string]: string; }} [metadata] Additional metadata to add to the backup * @param {*} [options] Override http request option. * @throws {RequiredError} */ backupConfiguration(resources?: Array, metadata?: { [key: string]: string; }, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Check if a more recent Wandelbots NOVA Version is available. * @summary Check update * @param {ReleaseChannel} channel * @param {*} [options] Override http request option. * @throws {RequiredError} */ checkNovaVersionUpdate(channel: ReleaseChannel, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ > **Experimental** Performs an address resolution protocol (ARP) scan on the specified interface/classless inter-domain routing (CIDR) and returns all discovered devices on the network by CIDR notation. * @summary Get ARP-Scan * @param {string} [_interface] * @param {string} [cidr] * @param {number} [timeout] * @param {*} [options] Override http request option. * @throws {RequiredError} */ getArpScan(_interface?: string, cidr?: string, timeout?: number, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_backup_system` - Create system backups ___ Retrieves the status of a configuration backup. The status can only be requested for 5 minutes after backup creation. After 5 minutes, 404 is returned. * @summary Retrieve Backup Status * @param {string} operationId * @param {*} [options] Override http request option. * @throws {RequiredError} */ getConfigurationBackupStatus(operationId: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Collects information on the current status of all NOVA services and exports them as a .zip file. Includes information on all cells on the instance such as the service logs and virtual robot controllers. From each cell the logs of all services are included, as well as the configuration of each connected controller to start virtual robots. * @summary Download Diagnosis Package * @param {*} [options] Override http request option. * @throws {RequiredError} */ getDiagnosePackage(options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ > **Experimental** Get the network interfaces of the system. * @summary Network Interfaces * @param {*} [options] Override http request option. * @throws {RequiredError} */ getNetworkInterfaces(options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ > **Experimental** Get the current state of the network. * @summary Network State * @param {*} [options] Override http request option. * @throws {RequiredError} */ getNetworkState(options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Get the status of all system services. * @summary Wandelbots NOVA status * @param {*} [options] Override http request option. * @throws {RequiredError} */ getSystemStatus(options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Get the current Wandelbots NOVA version. * @summary Wandelbots NOVA Version * @param {*} [options] Override http request option. * @throws {RequiredError} */ getSystemVersion(options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_backup_system` - Create system backups ___ Retrieves a list of all available configuration resources for backup purposes. * @summary List Configuration Resources * @param {*} [options] Override http request option. * @throws {RequiredError} */ listConfigurationResources(options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_restore_system` - Restore system backups ___ Restores a previously backed up configuration. If an empty array of resources is provided, all resources from the backup will be restored. * @summary Restore Configuration Backup * @param {File} body Backup file stream containing the configuration to restore. * @param {Array} [resources] List of resource identifiers to restore. If empty, all resources from the backup will be restored. * @param {*} [options] Override http request option. * @throws {RequiredError} */ restoreConfiguration(body: File, resources?: Array, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_update_system` - Update system versions and services ___ Update the Wandelbots NOVA version and all attached services. Sending this API Request will trigger an update of all NOVA services that are part of a cell. Previous cells and cell configurations will remain on the instance. If the update fails, the previous Wandelbots NOVA version is restored. System updates only apply to cells without an explicit chart version. Pinned versions are always preserved; setting `update_cells=false` pins unversioned cells to the current system version before updating. * @summary Update Wandelbots NOVA version * @param {UpdateNovaVersionRequest} updateNovaVersionRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ updateNovaVersion(updateNovaVersionRequest: UpdateNovaVersionRequest, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; } /** * TrajectoryCachingApi - axios parameter creator */ declare const TrajectoryCachingApiAxiosParamCreator: (configuration?: Configuration) => { /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Loads and validates the data of a trajectory into the execution cache, rendering the trajectory executable. > #### NOTE > > Using the trajectory cache is an optional performance optimization. It is not necessary to use the cache to execute trajectories. The response contains the result of the validation of the trajectory. Validation can lead to three different results: - Fully valid: The whole trajectory can be executed from start to end. The response will contain an unique identifier which is used to move the robot. - Partially valid: Only parts of the trajectory can be executed. The response will contain an unique identifier to move the robot and information about the failure for the part that is not executable. - Invalid: The trajectory can not be executed. The response will tell you the reason of failure. If the trajectory is at least partially valid, the parts of the trajectory that are valid can be executed using the [executeTrajectory](#/operations/executeTrajectory) endpoint. The workflow is as follows: - Generate a trajectory with [planTrajectory](#/operations/planTrajectory) or your own motion planner, - Send the trajectory to this endpoint to validate it and get a unique identifier for it, - The unique identifier will appear in the list of available trajectories, see [listTrajectories](#/operations/listTrajectories) endpoint, if it is at least partially executable. - Execute your trajectory using the [executeTrajectory](#/operations/executeTrajectory) endpoint. * @summary Add Trajectory * @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 {AddTrajectoryRequest} addTrajectoryRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ addTrajectory: (cell: string, controller: string, addTrajectoryRequest: AddTrajectoryRequest, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Clear the trajectory cache. * @summary Clear Trajectories * @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} */ clearTrajectories: (cell: string, controller: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Delete a previously created trajectory from cache. Use [listTrajectories](#/operations/listTrajectories) to list all cached trajectories. Trajectories are removed automatically if the motion group or the corresponding controller is disconnected. * @summary Delete Trajectory * @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 {string} trajectory This represents the unique identifier of a trajectory. Every executable or partially executable trajectory is cached and an unique identifier is returned. Indicate the unique identifier to execute the trajectory or retrieve information on the trajectory. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteTrajectory: (cell: string, controller: string, trajectory: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Get a previously created trajectory from cache. Use [listTrajectories](#/operations/listTrajectories) to list all cached trajectories. * @summary Get Trajectory * @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 {string} trajectory This represents the unique identifier of a trajectory. Every executable or partially executable trajectory is cached and an unique identifier is returned. Indicate the unique identifier to execute the trajectory or retrieve information on the trajectory. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getTrajectory: (cell: string, controller: string, trajectory: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ List currently cached trajectories. Use [addTrajectory](#/operations/addTrajectory) to add a new trajectory. Adding trajectories is necessary to execute them. Trajectories are removed if the corresponding motion group or controller disconnects. * @summary List Trajectories * @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} */ listTrajectories: (cell: string, controller: string, options?: RawAxiosRequestConfig) => Promise; }; /** * TrajectoryCachingApi - functional programming interface */ declare const TrajectoryCachingApiFp: (configuration?: Configuration) => { /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Loads and validates the data of a trajectory into the execution cache, rendering the trajectory executable. > #### NOTE > > Using the trajectory cache is an optional performance optimization. It is not necessary to use the cache to execute trajectories. The response contains the result of the validation of the trajectory. Validation can lead to three different results: - Fully valid: The whole trajectory can be executed from start to end. The response will contain an unique identifier which is used to move the robot. - Partially valid: Only parts of the trajectory can be executed. The response will contain an unique identifier to move the robot and information about the failure for the part that is not executable. - Invalid: The trajectory can not be executed. The response will tell you the reason of failure. If the trajectory is at least partially valid, the parts of the trajectory that are valid can be executed using the [executeTrajectory](#/operations/executeTrajectory) endpoint. The workflow is as follows: - Generate a trajectory with [planTrajectory](#/operations/planTrajectory) or your own motion planner, - Send the trajectory to this endpoint to validate it and get a unique identifier for it, - The unique identifier will appear in the list of available trajectories, see [listTrajectories](#/operations/listTrajectories) endpoint, if it is at least partially executable. - Execute your trajectory using the [executeTrajectory](#/operations/executeTrajectory) endpoint. * @summary Add Trajectory * @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 {AddTrajectoryRequest} addTrajectoryRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ addTrajectory(cell: string, controller: string, addTrajectoryRequest: AddTrajectoryRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Clear the trajectory cache. * @summary Clear Trajectories * @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} */ clearTrajectories(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Delete a previously created trajectory from cache. Use [listTrajectories](#/operations/listTrajectories) to list all cached trajectories. Trajectories are removed automatically if the motion group or the corresponding controller is disconnected. * @summary Delete Trajectory * @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 {string} trajectory This represents the unique identifier of a trajectory. Every executable or partially executable trajectory is cached and an unique identifier is returned. Indicate the unique identifier to execute the trajectory or retrieve information on the trajectory. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteTrajectory(cell: string, controller: string, trajectory: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Get a previously created trajectory from cache. Use [listTrajectories](#/operations/listTrajectories) to list all cached trajectories. * @summary Get Trajectory * @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 {string} trajectory This represents the unique identifier of a trajectory. Every executable or partially executable trajectory is cached and an unique identifier is returned. Indicate the unique identifier to execute the trajectory or retrieve information on the trajectory. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getTrajectory(cell: string, controller: string, trajectory: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ List currently cached trajectories. Use [addTrajectory](#/operations/addTrajectory) to add a new trajectory. Adding trajectories is necessary to execute them. Trajectories are removed if the corresponding motion group or controller disconnects. * @summary List Trajectories * @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} */ listTrajectories(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; }; /** * TrajectoryCachingApi - factory interface */ declare const TrajectoryCachingApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => { /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Loads and validates the data of a trajectory into the execution cache, rendering the trajectory executable. > #### NOTE > > Using the trajectory cache is an optional performance optimization. It is not necessary to use the cache to execute trajectories. The response contains the result of the validation of the trajectory. Validation can lead to three different results: - Fully valid: The whole trajectory can be executed from start to end. The response will contain an unique identifier which is used to move the robot. - Partially valid: Only parts of the trajectory can be executed. The response will contain an unique identifier to move the robot and information about the failure for the part that is not executable. - Invalid: The trajectory can not be executed. The response will tell you the reason of failure. If the trajectory is at least partially valid, the parts of the trajectory that are valid can be executed using the [executeTrajectory](#/operations/executeTrajectory) endpoint. The workflow is as follows: - Generate a trajectory with [planTrajectory](#/operations/planTrajectory) or your own motion planner, - Send the trajectory to this endpoint to validate it and get a unique identifier for it, - The unique identifier will appear in the list of available trajectories, see [listTrajectories](#/operations/listTrajectories) endpoint, if it is at least partially executable. - Execute your trajectory using the [executeTrajectory](#/operations/executeTrajectory) endpoint. * @summary Add Trajectory * @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 {AddTrajectoryRequest} addTrajectoryRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ addTrajectory(cell: string, controller: string, addTrajectoryRequest: AddTrajectoryRequest, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Clear the trajectory cache. * @summary Clear Trajectories * @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} */ clearTrajectories(cell: string, controller: string, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Delete a previously created trajectory from cache. Use [listTrajectories](#/operations/listTrajectories) to list all cached trajectories. Trajectories are removed automatically if the motion group or the corresponding controller is disconnected. * @summary Delete Trajectory * @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 {string} trajectory This represents the unique identifier of a trajectory. Every executable or partially executable trajectory is cached and an unique identifier is returned. Indicate the unique identifier to execute the trajectory or retrieve information on the trajectory. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteTrajectory(cell: string, controller: string, trajectory: string, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Get a previously created trajectory from cache. Use [listTrajectories](#/operations/listTrajectories) to list all cached trajectories. * @summary Get Trajectory * @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 {string} trajectory This represents the unique identifier of a trajectory. Every executable or partially executable trajectory is cached and an unique identifier is returned. Indicate the unique identifier to execute the trajectory or retrieve information on the trajectory. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getTrajectory(cell: string, controller: string, trajectory: string, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ List currently cached trajectories. Use [addTrajectory](#/operations/addTrajectory) to add a new trajectory. Adding trajectories is necessary to execute them. Trajectories are removed if the corresponding motion group or controller disconnects. * @summary List Trajectories * @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} */ listTrajectories(cell: string, controller: string, options?: RawAxiosRequestConfig): AxiosPromise; }; /** * TrajectoryCachingApi - object-oriented interface */ declare class TrajectoryCachingApi extends BaseAPI { /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Loads and validates the data of a trajectory into the execution cache, rendering the trajectory executable. > #### NOTE > > Using the trajectory cache is an optional performance optimization. It is not necessary to use the cache to execute trajectories. The response contains the result of the validation of the trajectory. Validation can lead to three different results: - Fully valid: The whole trajectory can be executed from start to end. The response will contain an unique identifier which is used to move the robot. - Partially valid: Only parts of the trajectory can be executed. The response will contain an unique identifier to move the robot and information about the failure for the part that is not executable. - Invalid: The trajectory can not be executed. The response will tell you the reason of failure. If the trajectory is at least partially valid, the parts of the trajectory that are valid can be executed using the [executeTrajectory](#/operations/executeTrajectory) endpoint. The workflow is as follows: - Generate a trajectory with [planTrajectory](#/operations/planTrajectory) or your own motion planner, - Send the trajectory to this endpoint to validate it and get a unique identifier for it, - The unique identifier will appear in the list of available trajectories, see [listTrajectories](#/operations/listTrajectories) endpoint, if it is at least partially executable. - Execute your trajectory using the [executeTrajectory](#/operations/executeTrajectory) endpoint. * @summary Add Trajectory * @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 {AddTrajectoryRequest} addTrajectoryRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ addTrajectory(cell: string, controller: string, addTrajectoryRequest: AddTrajectoryRequest, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Clear the trajectory cache. * @summary Clear Trajectories * @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} */ clearTrajectories(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Delete a previously created trajectory from cache. Use [listTrajectories](#/operations/listTrajectories) to list all cached trajectories. Trajectories are removed automatically if the motion group or the corresponding controller is disconnected. * @summary Delete Trajectory * @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 {string} trajectory This represents the unique identifier of a trajectory. Every executable or partially executable trajectory is cached and an unique identifier is returned. Indicate the unique identifier to execute the trajectory or retrieve information on the trajectory. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteTrajectory(cell: string, controller: string, trajectory: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ Get a previously created trajectory from cache. Use [listTrajectories](#/operations/listTrajectories) to list all cached trajectories. * @summary Get Trajectory * @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 {string} trajectory This represents the unique identifier of a trajectory. Every executable or partially executable trajectory is cached and an unique identifier is returned. Indicate the unique identifier to execute the trajectory or retrieve information on the trajectory. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getTrajectory(cell: string, controller: string, trajectory: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ List currently cached trajectories. Use [addTrajectory](#/operations/addTrajectory) to add a new trajectory. Adding trajectories is necessary to execute them. Trajectories are removed if the corresponding motion group or controller disconnects. * @summary List Trajectories * @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} */ listTrajectories(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; } /** * TrajectoryExecutionApi - axios parameter creator */ declare const TrajectoryExecutionApiAxiosParamCreator: (configuration?: Configuration) => { /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ > Websocket endpoint Provides execution control over a previously [planned trajectory](#/operations/planTrajectory). Enables the caller to attach input/output actions to the trajectory. ### Movement behavior | Virtual controller | Physical controller | |------------------|-------------------| | Desired joint configurations are commanded to each motion group and **applied immediately** | Move to desired **actual joint configuration**, **if possible** | ### Concept of location - The location or path parameter specifies the exact position along a trajectory. - The location is a scalar value that ranges from 0 to `n`, where `n` denotes the number of motion commands, or trajectory segments, e.g., line, p2p, etc. See [planTrajectory](#/operations/planTrajectory). - Each integer value of the location corresponds to one motion command, e.g., 3.0 to 3.999 could be a line. ### Preconditions - The motion group\'s control mode is not claimed by any other endpoint. - The motion group\'s joint position are at start location specified with `InitializeMovementRequest`. - Use [executeToTrajectory](#/operations/executeToTrajectory) to move the robot to the start location. ### Requests #### 1. Send `InitializeMovementRequest` to lock the trajectory to this connection The following actions are executed: - Sets robot controller mode to control mode, - Sets start location of the execution Keep in mind that only a single trajectory can be locked to a websocket connection at a time. Pausing the current movement enables you to send another `InitializeMovementRequest` to execute another trajectory on the same connection. #### 2. Send `StartMovementRequest` to start the movement Sets direction of movement, default is forward. #### **Optional** - To pause, send `PauseMovementRequest` before the movement has reached its end location. - Change the movement\'s velocity with `PlaybackSpeedRequest` after initializing the movement with `InitializeMovementRequest`. ### Responses To monitor the state of the movement, listen to the [state stream](#/operations/streamMotionGroupState). The state is published via nats as well. Field `execute` in the `MotionGroupState` indicates whether a movement is ongoing and carries execution details. Each request has a corresponding acknowledgment response. They signal success or failure of the request. Especially for `PauseMovementResponse`, it does not signal the end of the movement. Additionally, `MovementError` messages can be sent in case of unexpected errors during the execution, e.g., controller disconnects during movement. ### Tips and Tricks - A movement can be paused and resumed by sending `PauseMovementRequest` and `StartMovementRequest`. - Send `PlaybackSpeedRequest` before `StartMovementRequest` to reduce the velocity of the movement before it starts. - Send `PlaybackSpeedRequest` repeatedly to implement a slider. The velocity of the motion group can be adjusted with each controller step. Therefore, if your app needs a slider-like UI to alter the velocity of a currently running movement, you can send `PlaybackSpeedRequest` with different speed values repeatedly during the movement. - A closed trajectory (end and start joint position are equal) can be repeated by sending `StartMovementRequest` after the movement has finished. * @summary Execute Trajectory * @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 {ExecuteTrajectoryRequest} executeTrajectoryRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ executeTrajectory: (cell: string, controller: string, executeTrajectoryRequest: ExecuteTrajectoryRequest, options?: RawAxiosRequestConfig) => Promise; }; /** * TrajectoryExecutionApi - functional programming interface */ declare const TrajectoryExecutionApiFp: (configuration?: Configuration) => { /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ > Websocket endpoint Provides execution control over a previously [planned trajectory](#/operations/planTrajectory). Enables the caller to attach input/output actions to the trajectory. ### Movement behavior | Virtual controller | Physical controller | |------------------|-------------------| | Desired joint configurations are commanded to each motion group and **applied immediately** | Move to desired **actual joint configuration**, **if possible** | ### Concept of location - The location or path parameter specifies the exact position along a trajectory. - The location is a scalar value that ranges from 0 to `n`, where `n` denotes the number of motion commands, or trajectory segments, e.g., line, p2p, etc. See [planTrajectory](#/operations/planTrajectory). - Each integer value of the location corresponds to one motion command, e.g., 3.0 to 3.999 could be a line. ### Preconditions - The motion group\'s control mode is not claimed by any other endpoint. - The motion group\'s joint position are at start location specified with `InitializeMovementRequest`. - Use [executeToTrajectory](#/operations/executeToTrajectory) to move the robot to the start location. ### Requests #### 1. Send `InitializeMovementRequest` to lock the trajectory to this connection The following actions are executed: - Sets robot controller mode to control mode, - Sets start location of the execution Keep in mind that only a single trajectory can be locked to a websocket connection at a time. Pausing the current movement enables you to send another `InitializeMovementRequest` to execute another trajectory on the same connection. #### 2. Send `StartMovementRequest` to start the movement Sets direction of movement, default is forward. #### **Optional** - To pause, send `PauseMovementRequest` before the movement has reached its end location. - Change the movement\'s velocity with `PlaybackSpeedRequest` after initializing the movement with `InitializeMovementRequest`. ### Responses To monitor the state of the movement, listen to the [state stream](#/operations/streamMotionGroupState). The state is published via nats as well. Field `execute` in the `MotionGroupState` indicates whether a movement is ongoing and carries execution details. Each request has a corresponding acknowledgment response. They signal success or failure of the request. Especially for `PauseMovementResponse`, it does not signal the end of the movement. Additionally, `MovementError` messages can be sent in case of unexpected errors during the execution, e.g., controller disconnects during movement. ### Tips and Tricks - A movement can be paused and resumed by sending `PauseMovementRequest` and `StartMovementRequest`. - Send `PlaybackSpeedRequest` before `StartMovementRequest` to reduce the velocity of the movement before it starts. - Send `PlaybackSpeedRequest` repeatedly to implement a slider. The velocity of the motion group can be adjusted with each controller step. Therefore, if your app needs a slider-like UI to alter the velocity of a currently running movement, you can send `PlaybackSpeedRequest` with different speed values repeatedly during the movement. - A closed trajectory (end and start joint position are equal) can be repeated by sending `StartMovementRequest` after the movement has finished. * @summary Execute Trajectory * @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 {ExecuteTrajectoryRequest} executeTrajectoryRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ executeTrajectory(cell: string, controller: string, executeTrajectoryRequest: ExecuteTrajectoryRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; }; /** * TrajectoryExecutionApi - factory interface */ declare const TrajectoryExecutionApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => { /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ > Websocket endpoint Provides execution control over a previously [planned trajectory](#/operations/planTrajectory). Enables the caller to attach input/output actions to the trajectory. ### Movement behavior | Virtual controller | Physical controller | |------------------|-------------------| | Desired joint configurations are commanded to each motion group and **applied immediately** | Move to desired **actual joint configuration**, **if possible** | ### Concept of location - The location or path parameter specifies the exact position along a trajectory. - The location is a scalar value that ranges from 0 to `n`, where `n` denotes the number of motion commands, or trajectory segments, e.g., line, p2p, etc. See [planTrajectory](#/operations/planTrajectory). - Each integer value of the location corresponds to one motion command, e.g., 3.0 to 3.999 could be a line. ### Preconditions - The motion group\'s control mode is not claimed by any other endpoint. - The motion group\'s joint position are at start location specified with `InitializeMovementRequest`. - Use [executeToTrajectory](#/operations/executeToTrajectory) to move the robot to the start location. ### Requests #### 1. Send `InitializeMovementRequest` to lock the trajectory to this connection The following actions are executed: - Sets robot controller mode to control mode, - Sets start location of the execution Keep in mind that only a single trajectory can be locked to a websocket connection at a time. Pausing the current movement enables you to send another `InitializeMovementRequest` to execute another trajectory on the same connection. #### 2. Send `StartMovementRequest` to start the movement Sets direction of movement, default is forward. #### **Optional** - To pause, send `PauseMovementRequest` before the movement has reached its end location. - Change the movement\'s velocity with `PlaybackSpeedRequest` after initializing the movement with `InitializeMovementRequest`. ### Responses To monitor the state of the movement, listen to the [state stream](#/operations/streamMotionGroupState). The state is published via nats as well. Field `execute` in the `MotionGroupState` indicates whether a movement is ongoing and carries execution details. Each request has a corresponding acknowledgment response. They signal success or failure of the request. Especially for `PauseMovementResponse`, it does not signal the end of the movement. Additionally, `MovementError` messages can be sent in case of unexpected errors during the execution, e.g., controller disconnects during movement. ### Tips and Tricks - A movement can be paused and resumed by sending `PauseMovementRequest` and `StartMovementRequest`. - Send `PlaybackSpeedRequest` before `StartMovementRequest` to reduce the velocity of the movement before it starts. - Send `PlaybackSpeedRequest` repeatedly to implement a slider. The velocity of the motion group can be adjusted with each controller step. Therefore, if your app needs a slider-like UI to alter the velocity of a currently running movement, you can send `PlaybackSpeedRequest` with different speed values repeatedly during the movement. - A closed trajectory (end and start joint position are equal) can be repeated by sending `StartMovementRequest` after the movement has finished. * @summary Execute Trajectory * @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 {ExecuteTrajectoryRequest} executeTrajectoryRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ executeTrajectory(cell: string, controller: string, executeTrajectoryRequest: ExecuteTrajectoryRequest, options?: RawAxiosRequestConfig): AxiosPromise; }; /** * TrajectoryExecutionApi - object-oriented interface */ declare class TrajectoryExecutionApi extends BaseAPI { /** * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___ > Websocket endpoint Provides execution control over a previously [planned trajectory](#/operations/planTrajectory). Enables the caller to attach input/output actions to the trajectory. ### Movement behavior | Virtual controller | Physical controller | |------------------|-------------------| | Desired joint configurations are commanded to each motion group and **applied immediately** | Move to desired **actual joint configuration**, **if possible** | ### Concept of location - The location or path parameter specifies the exact position along a trajectory. - The location is a scalar value that ranges from 0 to `n`, where `n` denotes the number of motion commands, or trajectory segments, e.g., line, p2p, etc. See [planTrajectory](#/operations/planTrajectory). - Each integer value of the location corresponds to one motion command, e.g., 3.0 to 3.999 could be a line. ### Preconditions - The motion group\'s control mode is not claimed by any other endpoint. - The motion group\'s joint position are at start location specified with `InitializeMovementRequest`. - Use [executeToTrajectory](#/operations/executeToTrajectory) to move the robot to the start location. ### Requests #### 1. Send `InitializeMovementRequest` to lock the trajectory to this connection The following actions are executed: - Sets robot controller mode to control mode, - Sets start location of the execution Keep in mind that only a single trajectory can be locked to a websocket connection at a time. Pausing the current movement enables you to send another `InitializeMovementRequest` to execute another trajectory on the same connection. #### 2. Send `StartMovementRequest` to start the movement Sets direction of movement, default is forward. #### **Optional** - To pause, send `PauseMovementRequest` before the movement has reached its end location. - Change the movement\'s velocity with `PlaybackSpeedRequest` after initializing the movement with `InitializeMovementRequest`. ### Responses To monitor the state of the movement, listen to the [state stream](#/operations/streamMotionGroupState). The state is published via nats as well. Field `execute` in the `MotionGroupState` indicates whether a movement is ongoing and carries execution details. Each request has a corresponding acknowledgment response. They signal success or failure of the request. Especially for `PauseMovementResponse`, it does not signal the end of the movement. Additionally, `MovementError` messages can be sent in case of unexpected errors during the execution, e.g., controller disconnects during movement. ### Tips and Tricks - A movement can be paused and resumed by sending `PauseMovementRequest` and `StartMovementRequest`. - Send `PlaybackSpeedRequest` before `StartMovementRequest` to reduce the velocity of the movement before it starts. - Send `PlaybackSpeedRequest` repeatedly to implement a slider. The velocity of the motion group can be adjusted with each controller step. Therefore, if your app needs a slider-like UI to alter the velocity of a currently running movement, you can send `PlaybackSpeedRequest` with different speed values repeatedly during the movement. - A closed trajectory (end and start joint position are equal) can be repeated by sending `StartMovementRequest` after the movement has finished. * @summary Execute Trajectory * @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 {ExecuteTrajectoryRequest} executeTrajectoryRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ executeTrajectory(cell: string, controller: string, executeTrajectoryRequest: ExecuteTrajectoryRequest, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; } /** * TrajectoryPlanningApi - axios parameter creator */ declare const TrajectoryPlanningApiAxiosParamCreator: (configuration?: Configuration) => { /** * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___ > **Experimental** Merges a list of joint trajectories into a single trajectory with collision-aware blending. This endpoint merges a list of separate trajectories by connecting them via blending. The blending is performed with collision checking to ensure the merged trajectory is safe to execute. Timescaling will be applied to the blended area to ensure all limits are respected. * @summary Merge Trajectories * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {MergeTrajectoriesRequest} mergeTrajectoriesRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ mergeTrajectories: (cell: string, mergeTrajectoriesRequest: MergeTrajectoriesRequest, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___ Plans a collision-free trajectory for a single motion group using point-to-point (PTP) motions. This endpoint is specifically designed for collision-free path planning algorithms that find a trajectory from a start joint position to a target position while avoiding obstacles. Use the following workflow to execute a planned collision-free trajectory: 1. Plan a collision-free trajectory. 2. Optional: Load the planned trajectory into the cache using the [addTrajectory](#/operations/addTrajectory) endpoint. 3. Execute the (cached) trajectory using the [executeTrajectory](#/operations/executeTrajectory) endpoint. If the trajectory planning fails due to collision or algorithm constraints, the response will contain error information about the failure. * @summary Plan Collision-Free Trajectory * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {PlanCollisionFreeRequest} planCollisionFreeRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ planCollisionFree: (cell: string, planCollisionFreeRequest: PlanCollisionFreeRequest, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___ Plans a new trajectory for a single motion group. Describe the trajectory as a sequence of motion commands that the robots TCP should follow. Use the following workflow to execute a planned trajectory: 1. Plan a trajectory. 2. Optional: Load the planned trajectory into the cache using the [addTrajectory](#/operations/addTrajectory) endpoint. 3. Execute the (cached) trajectory using the [executeTrajectory](#/operations/executeTrajectory) endpoint. If the trajectory is not executable, the response will contain the joint trajectory up until the error, e.g., all samples until a collision occurs. > #### Exception > > If a CartesianPTP or JointPTP motion command has an invalid target, the response will contain the trajectory up until the start of the invalid PTP motion. * @summary Plan Trajectory * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {PlanTrajectoryRequest} planTrajectoryRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ planTrajectory: (cell: string, planTrajectoryRequest: PlanTrajectoryRequest, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___ > **Experimental** Searches collision-free trajectories for multiple motion groups simultaneously within a cell. This is the multi-robot variant of collision-free path search — it coordinates paths so that several motion groups, e.g., multiple robot arms, can move from start to target positions without colliding with each other or with the environment. The caller provides per-motion-group setups (robot model, cycle time, mounting, TCP offset, limits, payload, collision geometry), per-motion-group point-to-point path definitions (start and target joint positions), optional cross-group collision setups defining which link-chain/tool colliders to consider between groups plus static environment colliders, and optional RRT-Connect algorithm settings (max iterations, step size, smoothing, blending). On success the response contains a time-synchronized trajectory with joint positions per motion group at shared timestamps so their motions are temporally coordinated. On failure it returns feedback indicating why planning failed, e.g., max iterations exceeded. * @summary Search Collision-Free Trajectories for Multiple Motion Groups * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {MultiSearchCollisionFreeRequest} multiSearchCollisionFreeRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ searchCollisionFreeMultiMotionGroup: (cell: string, multiSearchCollisionFreeRequest: MultiSearchCollisionFreeRequest, options?: RawAxiosRequestConfig) => Promise; }; /** * TrajectoryPlanningApi - functional programming interface */ declare const TrajectoryPlanningApiFp: (configuration?: Configuration) => { /** * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___ > **Experimental** Merges a list of joint trajectories into a single trajectory with collision-aware blending. This endpoint merges a list of separate trajectories by connecting them via blending. The blending is performed with collision checking to ensure the merged trajectory is safe to execute. Timescaling will be applied to the blended area to ensure all limits are respected. * @summary Merge Trajectories * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {MergeTrajectoriesRequest} mergeTrajectoriesRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ mergeTrajectories(cell: string, mergeTrajectoriesRequest: MergeTrajectoriesRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___ Plans a collision-free trajectory for a single motion group using point-to-point (PTP) motions. This endpoint is specifically designed for collision-free path planning algorithms that find a trajectory from a start joint position to a target position while avoiding obstacles. Use the following workflow to execute a planned collision-free trajectory: 1. Plan a collision-free trajectory. 2. Optional: Load the planned trajectory into the cache using the [addTrajectory](#/operations/addTrajectory) endpoint. 3. Execute the (cached) trajectory using the [executeTrajectory](#/operations/executeTrajectory) endpoint. If the trajectory planning fails due to collision or algorithm constraints, the response will contain error information about the failure. * @summary Plan Collision-Free Trajectory * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {PlanCollisionFreeRequest} planCollisionFreeRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ planCollisionFree(cell: string, planCollisionFreeRequest: PlanCollisionFreeRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___ Plans a new trajectory for a single motion group. Describe the trajectory as a sequence of motion commands that the robots TCP should follow. Use the following workflow to execute a planned trajectory: 1. Plan a trajectory. 2. Optional: Load the planned trajectory into the cache using the [addTrajectory](#/operations/addTrajectory) endpoint. 3. Execute the (cached) trajectory using the [executeTrajectory](#/operations/executeTrajectory) endpoint. If the trajectory is not executable, the response will contain the joint trajectory up until the error, e.g., all samples until a collision occurs. > #### Exception > > If a CartesianPTP or JointPTP motion command has an invalid target, the response will contain the trajectory up until the start of the invalid PTP motion. * @summary Plan Trajectory * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {PlanTrajectoryRequest} planTrajectoryRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ planTrajectory(cell: string, planTrajectoryRequest: PlanTrajectoryRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___ > **Experimental** Searches collision-free trajectories for multiple motion groups simultaneously within a cell. This is the multi-robot variant of collision-free path search — it coordinates paths so that several motion groups, e.g., multiple robot arms, can move from start to target positions without colliding with each other or with the environment. The caller provides per-motion-group setups (robot model, cycle time, mounting, TCP offset, limits, payload, collision geometry), per-motion-group point-to-point path definitions (start and target joint positions), optional cross-group collision setups defining which link-chain/tool colliders to consider between groups plus static environment colliders, and optional RRT-Connect algorithm settings (max iterations, step size, smoothing, blending). On success the response contains a time-synchronized trajectory with joint positions per motion group at shared timestamps so their motions are temporally coordinated. On failure it returns feedback indicating why planning failed, e.g., max iterations exceeded. * @summary Search Collision-Free Trajectories for Multiple Motion Groups * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {MultiSearchCollisionFreeRequest} multiSearchCollisionFreeRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ searchCollisionFreeMultiMotionGroup(cell: string, multiSearchCollisionFreeRequest: MultiSearchCollisionFreeRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; }; /** * TrajectoryPlanningApi - factory interface */ declare const TrajectoryPlanningApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => { /** * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___ > **Experimental** Merges a list of joint trajectories into a single trajectory with collision-aware blending. This endpoint merges a list of separate trajectories by connecting them via blending. The blending is performed with collision checking to ensure the merged trajectory is safe to execute. Timescaling will be applied to the blended area to ensure all limits are respected. * @summary Merge Trajectories * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {MergeTrajectoriesRequest} mergeTrajectoriesRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ mergeTrajectories(cell: string, mergeTrajectoriesRequest: MergeTrajectoriesRequest, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___ Plans a collision-free trajectory for a single motion group using point-to-point (PTP) motions. This endpoint is specifically designed for collision-free path planning algorithms that find a trajectory from a start joint position to a target position while avoiding obstacles. Use the following workflow to execute a planned collision-free trajectory: 1. Plan a collision-free trajectory. 2. Optional: Load the planned trajectory into the cache using the [addTrajectory](#/operations/addTrajectory) endpoint. 3. Execute the (cached) trajectory using the [executeTrajectory](#/operations/executeTrajectory) endpoint. If the trajectory planning fails due to collision or algorithm constraints, the response will contain error information about the failure. * @summary Plan Collision-Free Trajectory * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {PlanCollisionFreeRequest} planCollisionFreeRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ planCollisionFree(cell: string, planCollisionFreeRequest: PlanCollisionFreeRequest, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___ Plans a new trajectory for a single motion group. Describe the trajectory as a sequence of motion commands that the robots TCP should follow. Use the following workflow to execute a planned trajectory: 1. Plan a trajectory. 2. Optional: Load the planned trajectory into the cache using the [addTrajectory](#/operations/addTrajectory) endpoint. 3. Execute the (cached) trajectory using the [executeTrajectory](#/operations/executeTrajectory) endpoint. If the trajectory is not executable, the response will contain the joint trajectory up until the error, e.g., all samples until a collision occurs. > #### Exception > > If a CartesianPTP or JointPTP motion command has an invalid target, the response will contain the trajectory up until the start of the invalid PTP motion. * @summary Plan Trajectory * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {PlanTrajectoryRequest} planTrajectoryRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ planTrajectory(cell: string, planTrajectoryRequest: PlanTrajectoryRequest, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___ > **Experimental** Searches collision-free trajectories for multiple motion groups simultaneously within a cell. This is the multi-robot variant of collision-free path search — it coordinates paths so that several motion groups, e.g., multiple robot arms, can move from start to target positions without colliding with each other or with the environment. The caller provides per-motion-group setups (robot model, cycle time, mounting, TCP offset, limits, payload, collision geometry), per-motion-group point-to-point path definitions (start and target joint positions), optional cross-group collision setups defining which link-chain/tool colliders to consider between groups plus static environment colliders, and optional RRT-Connect algorithm settings (max iterations, step size, smoothing, blending). On success the response contains a time-synchronized trajectory with joint positions per motion group at shared timestamps so their motions are temporally coordinated. On failure it returns feedback indicating why planning failed, e.g., max iterations exceeded. * @summary Search Collision-Free Trajectories for Multiple Motion Groups * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {MultiSearchCollisionFreeRequest} multiSearchCollisionFreeRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ searchCollisionFreeMultiMotionGroup(cell: string, multiSearchCollisionFreeRequest: MultiSearchCollisionFreeRequest, options?: RawAxiosRequestConfig): AxiosPromise; }; /** * TrajectoryPlanningApi - object-oriented interface */ declare class TrajectoryPlanningApi extends BaseAPI { /** * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___ > **Experimental** Merges a list of joint trajectories into a single trajectory with collision-aware blending. This endpoint merges a list of separate trajectories by connecting them via blending. The blending is performed with collision checking to ensure the merged trajectory is safe to execute. Timescaling will be applied to the blended area to ensure all limits are respected. * @summary Merge Trajectories * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {MergeTrajectoriesRequest} mergeTrajectoriesRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ mergeTrajectories(cell: string, mergeTrajectoriesRequest: MergeTrajectoriesRequest, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___ Plans a collision-free trajectory for a single motion group using point-to-point (PTP) motions. This endpoint is specifically designed for collision-free path planning algorithms that find a trajectory from a start joint position to a target position while avoiding obstacles. Use the following workflow to execute a planned collision-free trajectory: 1. Plan a collision-free trajectory. 2. Optional: Load the planned trajectory into the cache using the [addTrajectory](#/operations/addTrajectory) endpoint. 3. Execute the (cached) trajectory using the [executeTrajectory](#/operations/executeTrajectory) endpoint. If the trajectory planning fails due to collision or algorithm constraints, the response will contain error information about the failure. * @summary Plan Collision-Free Trajectory * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {PlanCollisionFreeRequest} planCollisionFreeRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ planCollisionFree(cell: string, planCollisionFreeRequest: PlanCollisionFreeRequest, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___ Plans a new trajectory for a single motion group. Describe the trajectory as a sequence of motion commands that the robots TCP should follow. Use the following workflow to execute a planned trajectory: 1. Plan a trajectory. 2. Optional: Load the planned trajectory into the cache using the [addTrajectory](#/operations/addTrajectory) endpoint. 3. Execute the (cached) trajectory using the [executeTrajectory](#/operations/executeTrajectory) endpoint. If the trajectory is not executable, the response will contain the joint trajectory up until the error, e.g., all samples until a collision occurs. > #### Exception > > If a CartesianPTP or JointPTP motion command has an invalid target, the response will contain the trajectory up until the start of the invalid PTP motion. * @summary Plan Trajectory * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {PlanTrajectoryRequest} planTrajectoryRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ planTrajectory(cell: string, planTrajectoryRequest: PlanTrajectoryRequest, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___ > **Experimental** Searches collision-free trajectories for multiple motion groups simultaneously within a cell. This is the multi-robot variant of collision-free path search — it coordinates paths so that several motion groups, e.g., multiple robot arms, can move from start to target positions without colliding with each other or with the environment. The caller provides per-motion-group setups (robot model, cycle time, mounting, TCP offset, limits, payload, collision geometry), per-motion-group point-to-point path definitions (start and target joint positions), optional cross-group collision setups defining which link-chain/tool colliders to consider between groups plus static environment colliders, and optional RRT-Connect algorithm settings (max iterations, step size, smoothing, blending). On success the response contains a time-synchronized trajectory with joint positions per motion group at shared timestamps so their motions are temporally coordinated. On failure it returns feedback indicating why planning failed, e.g., max iterations exceeded. * @summary Search Collision-Free Trajectories for Multiple Motion Groups * @param {string} cell Unique identifier addressing a cell in all API calls. * @param {MultiSearchCollisionFreeRequest} multiSearchCollisionFreeRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ searchCollisionFreeMultiMotionGroup(cell: string, multiSearchCollisionFreeRequest: MultiSearchCollisionFreeRequest, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; } /** * VersionApi - axios parameter creator */ declare const VersionApiAxiosParamCreator: (configuration?: Configuration) => { /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Retrieves the version of the NOVA API. * @summary API Version * @param {*} [options] Override http request option. * @throws {RequiredError} */ getApiVersion: (options?: RawAxiosRequestConfig) => Promise; }; /** * VersionApi - functional programming interface */ declare const VersionApiFp: (configuration?: Configuration) => { /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Retrieves the version of the NOVA API. * @summary API Version * @param {*} [options] Override http request option. * @throws {RequiredError} */ getApiVersion(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; }; /** * VersionApi - factory interface */ declare const VersionApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => { /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Retrieves the version of the NOVA API. * @summary API Version * @param {*} [options] Override http request option. * @throws {RequiredError} */ getApiVersion(options?: RawAxiosRequestConfig): AxiosPromise; }; /** * VersionApi - object-oriented interface */ declare class VersionApi extends BaseAPI { /** * **Required permissions:** `can_access_system` - View system status and metadata ___ Retrieves the version of the NOVA API. * @summary API Version * @param {*} [options] Override http request option. * @throws {RequiredError} */ getApiVersion(options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; } /** * VirtualControllerApi - axios parameter creator */ declare const VirtualControllerApiAxiosParamCreator: (configuration?: Configuration) => { /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Adds a coordinate system to the robot controller. > #### NOTE > > When a new coordinate system is added, the **virtual robot is restarted** to apply the new configuration. > > During this restart: > - Robot visualization can temporarily disappear or appear outdated in the UI. > - Coordinate system changes are not immediately visible in visualizations. > - All connections to virtual robot are closed and re-established, which introduces a short delay before the system is fully operational again. > > The API call itself does **not wait until the restart and re-synchronization are complete**. > This means that immediately after a successful response, the new coordinate system may not yet be available for visualization or program execution. * @summary Add Coordinate Systems * @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 {string} coordinateSystem Unique identifier addressing a coordinate system. * @param {CoordinateSystemData} coordinateSystemData * @param {*} [options] Override http request option. * @throws {RequiredError} */ addVirtualControllerCoordinateSystem: (cell: string, controller: string, coordinateSystem: string, coordinateSystemData: CoordinateSystemData, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Adds a motion group configuration for the virtual robot controller. Fields: - Only one of **motion_group_model** or **json_data** should be set. - **motion_group_model**: Identifies a single motion group. See [getMotionGroupModels](#/operations/getMotionGroupModels) for supported types. - **json_data**: Full JSON configuration of the virtual robot controller. This can be obtained from the physical controller\'s configuration via [getVirtualControllerConfiguration](#/operations/getVirtualControllerConfiguration). - **extracted_motion_group_id** (required when using json_data): The motion group identifier to extract from the provided JSON configuration. - **motion_group**: Unique identifier for the motion group to be added. - **initial_joint_position**: Specifies the initial joint position for the added motion group. > #### NOTE > > When a motion group is added, **the virtual robot is restarted** to apply the new configuration. > > During this restart: > - Robot visualization can temporarily disappear or appear outdated in the UI. > - Motion group changes are not immediately visible in visualizations. > - All connections to virtual robot are closed and re-established, which introduces a short delay before the system is fully operational again. > > The API call itself **does not wait until the restart and re-synchronization are complete**. > This means that immediately after a successful response, the new motion group may not yet be available for use. * @summary Add Motion Group * @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 {AddVirtualControllerMotionGroupRequest} addVirtualControllerMotionGroupRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ addVirtualControllerMotionGroup: (cell: string, controller: string, addVirtualControllerMotionGroupRequest: AddVirtualControllerMotionGroupRequest, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Adds a new safety zone to the virtual robot controller. Safety zones define geometric boundaries that restrict or permit robot motion in 3D space. Each zone has a `geometry` that defines its shape, and two flags that control its behavior: - **`restricted: true`** the robot is not allowed to enter this zone. - **`inverted: true`** the zone applies to the **outside** of the shape, meaning the shape defines the *allowed* region; everything outside is the zone. Combined with `restricted: true`, the robot must stay **inside** the shape. Common combinations: | `restricted` | `inverted` | Effect | |---|---|---| | `true` | `false` | Keep-out zone, the robot cannot enter the shape, e.g., obstacle, table, wall | | `true` | `true` | Keep-in zone, the robot must stay inside the shape, e.g., workspace envelope / cell boundary | The `mg_uid` field specifies which motion group the safety zone is enforced for and must match an existing motion group UID on the controller. The `uid_ref_cs` field defines the coordinate system in which the geometry coordinates are expressed. The coordinate system must be defined on the controller beforehand. If empty (`\"\"`), the World coordinate system is used. Using an incorrect coordinate system places the safety zone in a different physical location. --- ## Geometry Shape Reference All coordinates are in **millimetres (mm)**. Choose the shape that best fits the physical boundary. --- ### Box A rectangular cuboid defined by one **corner point** (`center`) and **three adjacent corners** (`neighbour`). Despite the field name, `center` is not the geometric centroid but one corner of the box, and each `neighbour` is the corner directly connected to it by one edge. This format is used directly by robot controllers (FANUC, KUKA, etc.) and supports arbitrary orientations, including left-handed coordinate systems that parametric (size + quaternion) formats cannot represent. **When to use:** Cell workspace envelope, machine enclosure, table, rectangular obstacle, pallet zone. **How to define:** ``` center → one corner of the box [x, y, z] neighbour = [ x1, y1, z1, ← corner connected by the first edge x2, y2, z2, ← corner connected by the second edge x3, y3, z3 ← corner connected by the third edge ] edge_length_i = ||neighbour_i − corner|| ``` The three edge vectors and the geometric centroid are: ``` d0 = neighbour[0] − corner d1 = neighbour[1] − corner d2 = neighbour[2] − corner centroid = corner + (d0 + d1 + d2) / 2 ``` For an **axis-aligned** box with one corner at `[cx, cy, cz]` and edge lengths `[ex, ey, ez]`: ``` corner = [cx, cy, cz] neighbour = [cx+ex, cy, cz, cx, cy+ey, cz, cx, cy, cz+ez] ``` --- ### Prism An extruded polygon is a 2D closed polygon (defined in the XY plane) extruded vertically between `bottom` and `top` Z coordinates. The polygon can be convex or concave. **When to use:** Irregular floor-plan areas (aisles, loading bays, L-shaped zones), conveyor corridors, or any zone with a non-rectangular footprint. **How to define:** ``` point = [x1, y1, x2, y2, x3, y3, ...] ← 2D vertices (XY), flattened, ≥ 3 points top = upper Z bound [mm] bottom = lower Z bound [mm] ``` Points must form a closed polygon; the last point implicitly connects to the first. --- ### Sphere A perfect sphere defined by its **center point** and **radius**. **When to use:** Protection zones around sensors, cameras, workpieces, point-like obstacles, singularity avoidance zones around the robot base. **How to define:** ``` center = [x, y, z] ← center of the sphere [mm] radius ← radius [mm] ``` --- ### Capsule A cylinder with hemispherical caps at each end, defined by two axis endpoints (`top`, `bottom`) and a **radius**. The axis can have any orientation. **When to use:** Pipes, cable trays, vertical columns, horizontal beams, or tube-shaped obstacles. **How to define:** ``` top = [x, y, z] ← center of the top hemisphere [mm] bottom = [x, y, z] ← center of the bottom hemisphere [mm] radius ← cylinder + hemisphere radius [mm] ``` The total length of the capsule is `||top − bottom|| + 2 × radius`. --- ### Lozenge A rounded rectangle (stadium/discorectangle shape) in a plane, defined by a **center pose**, two **dimensions**, and a **corner radius**. The plane orientation is defined by the quaternion in `center`. **When to use:** Conveyor belt surfaces, worktables with rounded edges, or flat rectangular zones in arbitrary orientations. **How to define:** ``` center.x/y/z ← position of the center [mm] center.qx/qy/qz/qw ← orientation as unit quaternion (identity = XY plane) x_dimension ← total length along local X axis [mm] y_dimension ← total width along local Y axis [mm] radius ← corner rounding radius [mm] ``` For a horizontal lozenge, use identity quaternion `(qx=0, qy=0, qz=0, qw=1)`. --- ### Plane A mathematical half-space plane defined by its **3D vertices**. All vertices must be coplanar. The plane is unbounded (infinite extent in all directions parallel to the surface). The points define the plane\'s orientation and position only. **When to use:** Floor boundaries, virtual walls, tilted surfaces, e.g., ramps, inclined conveyors, or flat custom barriers. **How to define:** ``` point = [x1, y1, z1, x2, y2, z2, x3, y3, z3, ...] ← 3D vertices, flattened, ≥ 3 points ``` Points must be coplanar and form a closed polygon. --- > #### NOTE > > When a safety zone is added, **the virtual robot is restarted** to apply the new configuration. > > During this restart: > - All connections to the virtual robot are closed and re-established, introducing a short delay before the system is fully operational again. > - The safety checksum is automatically updated to reflect the configuration change. > > The API call **does not wait until the restart and re-synchronization are complete**. * @summary Add Safety Zone * @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 {SafetyZone} safetyZone * @param {*} [options] Override http request option. * @throws {RequiredError} */ addVirtualControllerSafetyZone: (cell: string, controller: string, safetyZone: SafetyZone, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Adds a new TCP or updates an existing TCP in the motion group. The position and rotation values in the request body are defined within the flange\'s coordinate system. > **NOTE** > > Ensure the TCP\'s position is within the robot\'s reach. Refer to the robot\'s documentation or data sheet for details like joint limits or reach. > #### NOTE > > When adding or updating a TCP, the **virtual robot is restarted** to apply the new configuration. > > During this restart: > - Robot visualization can temporarily disappear. > - The TCP may not be immediately visible or appear outdated in visualizations. > - All connections to virtual robot are closed and re-established, which introduces a short delay before the TCP is available for operation. > > The API call itself does **not wait until the restart and re-synchronization are complete**. > A successful response indicates that the request was accepted, but the TCP may not yet be visible nor usable. * @summary Add TCP * @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 {string} motionGroup The motion-group identifier. * @param {string} tcp The unique identifier of a TCP. * @param {RobotTcpData} robotTcpData * @param {*} [options] Override http request option. * @throws {RequiredError} */ addVirtualControllerTcp: (cell: string, controller: string, motionGroup: string, tcp: string, robotTcpData: RobotTcpData, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Deletes a coordinate system from the virtual controller. This will remove the coordinate system from the list of coordinate systems and also remove all dependent coordinate systems that use the deleted coordinate system as reference. > #### NOTE > > When a new coordinate system is removed, the **virtual robot is restarted** to apply the new configuration. > > During this restart: > - Robot visualization can temporarily disappear or appear outdated in the UI. > - Coordinate system changes are not immediately visible in visualizations. > - All connections to virtual robot are closed and re-established, which introduces a short delay before the system is fully operational again. > > The API call itself does **not wait until the restart and re-synchronization are complete**. > This means that immediately after a successful response, the new coordinate system may not yet be available for visualization or program execution. * @summary Delete Coordinate System * @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 {string} coordinateSystem Unique identifier addressing a coordinate system. * @param {boolean} [deleteDependent] If true, all dependent coordinate systems will be deleted as well. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteVirtualControllerCoordinateSystem: (cell: string, controller: string, coordinateSystem: string, deleteDependent?: boolean, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Removes a motion group configuration from the virtual controller. > #### NOTE > > When a motion group is removed, **the virtual robot is restarted** to apply the new configuration. > > During this restart: > - Robot visualization can temporarily disappear or appear outdated in the UI. > - Motion group changes are not immediately visible in visualizations. > - All connections to virtual robot are closed and re-established, which introduces a short delay before the system is fully operational again. > > The API call itself **does not wait until the restart and re-synchronization are complete**. * @summary Delete Motion Group * @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 {string} motionGroup The motion-group identifier. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteVirtualControllerMotionGroup: (cell: string, controller: string, motionGroup: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Removes a safety zone from the virtual robot controller. > #### NOTE > > When a safety zone is removed, **the virtual robot is restarted** to apply the new configuration. > > During this restart: > - All connections to the virtual robot are closed and re-established, which introduces a short delay before the system is fully operational again. > - The safety checksum is automatically updated to reflect the configuration change. > > The API call itself **does not wait until the restart and re-synchronization are complete**. * @summary Delete Safety Zone * @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} id The unique identifier of the safety zone to delete. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteVirtualControllerSafetyZone: (cell: string, controller: string, id: number, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Removes the TCP (Tool Center Point) from the motion group. An unknown TCP is a valid input and will simply be ignored. > #### NOTE > > When removing a TCP, the **virtual robot is restarted** to apply the new configuration. > > During this restart: > - Robot visualization can temporarily disappear. > - The removal of the TCP may not be immediately visible or appear outdated in visualizations. > - All connections to virtual robot are closed and re-established, which introduces a short delay before the system is fully operational again. > > The API call itself does **not wait until the restart and re-synchronization are complete**. > A successful response indicates that the request was accepted, but the then used TCP may not yet be visible nor usable. * @summary Remove TCP * @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 {string} motionGroup The motion-group identifier. * @param {string} tcp The unique identifier of a TCP. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteVirtualControllerTcp: (cell: string, controller: string, motionGroup: string, tcp: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Requests the Emergency Stop state of the virtual robot controller. Use [getCurrentMotionGroupState](#/operations/getCurrentMotionGroupState) to get the Emergency Stop state with `safety_state` regardless of the controller type. > **NOTE** > > The Emergency Stop state can only be changed when using virtual robot controllers. * @summary Get Emergency Stop 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 {*} [options] Override http request option. * @throws {RequiredError} */ getEmergencyStop: (cell: string, controller: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Get the current motion group state which provides values for the joints\' position, velocity and acceleration. * @summary Get Motion Group 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 {string} motionGroup The motion-group identifier. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getMotionGroupState: (cell: string, controller: string, motionGroup: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Gets information on the motion group. * @summary Motion Group Description * @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} */ getMotionGroups: (cell: string, controller: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Requests the operation mode of the virtual robot controller. To get the operation mode regardless of the controller type, use [getCurrentMotionGroupState](#/operations/getCurrentMotionGroupState). > **NOTE** > > The operation mode can only be changed via API when using virtual robot controllers. * @summary Get Operation 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} */ getOperationMode: (cell: string, controller: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Gets motion group mounting. The motion group is based on the origin of the returned coordinate system. * @summary Get Mounting * @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 {string} motionGroup The motion-group identifier. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getVirtualControllerMounting: (cell: string, controller: string, motionGroup: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Gets all safety zones configured in the virtual robot controller. Safety zones define geometric boundaries that restrict robot motion or define protected areas in the workspace. * @summary List Safety Zones * @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} */ getVirtualControllerSafetyZones: (cell: string, controller: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Lists all coordinate systems on the robot controller. * @summary List Coordinate Systems * @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} */ listVirtualControllerCoordinateSystems: (cell: string, controller: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Lists TCPs of the motion group. An empty TCP list is valid, e.g., for external axes. * @summary List TCPs * @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 {string} motionGroup The motion-group identifier. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listVirtualControllerTcps: (cell: string, controller: string, motionGroup: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Activates or releases the Emergency Stop on the virtual robot controller. Activating the Emergency Stop stops the execution of all motions. The stop is executed on physical controllers immediately not gracefully and not on paths. Due to restricted physical behavior of the virtual robot controller, the Emergency Stop is executed on paths. To return to normal operation the Emergency Stop needs to be released. Use [getCurrentMotionGroupState](#/operations/getCurrentMotionGroupState) to get the Emergency Stop state with `safety_state` regardless of the controller type. > **NOTE** > > The Emergency Stop state can only be changed via API when using virtual robot controllers. * @summary Push or Release Emergency Stop * @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 {boolean} [active] * @param {*} [options] Override http request option. * @throws {RequiredError} */ setEmergencyStop: (cell: string, controller: string, active?: boolean, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Sets the values for joint position, joint velocity or joint acceleration of a motion group state. The values are immediately applied to the joints of the motion group. > #### NOTE > > Only use the endpoint when the motion group is in monitor mode. If the motion group is controlled, currently jogging or planning motions, > the values are overridden by the controller or an error may occur. * @summary Set Motion Group 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 {string} motionGroup The motion-group identifier. * @param {MotionGroupJoints} motionGroupJoints * @param {*} [options] Override http request option. * @throws {RequiredError} */ setMotionGroupState: (cell: string, controller: string, motionGroup: string, motionGroupJoints: MotionGroupJoints, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Changes the operation mode of the virtual robot controller to the specified value. To get the operation mode regardless of the controller type, use [getCurrentMotionGroupState](#/operations/getCurrentMotionGroupState). > **NOTE** > > The operation mode can only be changed via API when using virtual robot controllers. * @summary Set Operation 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 {OperationMode} mode * @param {*} [options] Override http request option. * @throws {RequiredError} */ setOperationMode: (cell: string, controller: string, mode: OperationMode, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Sets the motion group mounting by specifying a coordinate system. The motion group will be based on the coordinate system\'s origin. The coordinate system defines a transformation offset, which consists of: - A unique identifier - A user-facing name - An offset in another coordinate system, referenced by the unique identifier of the reference coordinate system. > #### Changing the mounting configuration is considered a setup change > > When the mounting is set to a new coordinate system, the **virtual robot is restarted** to apply the new configuration. > > During this restart: > - Robot visualization can temporarily disappear or not reflect the new mounting immediately. > - Motion group state and coordinate system alignment may not be immediately visible in visualizations. > - All connections to virtual robot are closed and re-established, which introduces a short delay before the system is fully operational again. > > The API call itself does **not wait until the restart and re-synchronization are complete**. > A successful response indicates that the request was accepted, but the updated mounting may not yet be visible. * @summary Set Mounting * @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 {string} motionGroup The motion-group identifier. * @param {CoordinateSystem} coordinateSystem * @param {*} [options] Override http request option. * @throws {RequiredError} */ setVirtualControllerMounting: (cell: string, controller: string, motionGroup: string, coordinateSystem: CoordinateSystem, options?: RawAxiosRequestConfig) => Promise; }; /** * VirtualControllerApi - functional programming interface */ declare const VirtualControllerApiFp: (configuration?: Configuration) => { /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Adds a coordinate system to the robot controller. > #### NOTE > > When a new coordinate system is added, the **virtual robot is restarted** to apply the new configuration. > > During this restart: > - Robot visualization can temporarily disappear or appear outdated in the UI. > - Coordinate system changes are not immediately visible in visualizations. > - All connections to virtual robot are closed and re-established, which introduces a short delay before the system is fully operational again. > > The API call itself does **not wait until the restart and re-synchronization are complete**. > This means that immediately after a successful response, the new coordinate system may not yet be available for visualization or program execution. * @summary Add Coordinate Systems * @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 {string} coordinateSystem Unique identifier addressing a coordinate system. * @param {CoordinateSystemData} coordinateSystemData * @param {*} [options] Override http request option. * @throws {RequiredError} */ addVirtualControllerCoordinateSystem(cell: string, controller: string, coordinateSystem: string, coordinateSystemData: CoordinateSystemData, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Adds a motion group configuration for the virtual robot controller. Fields: - Only one of **motion_group_model** or **json_data** should be set. - **motion_group_model**: Identifies a single motion group. See [getMotionGroupModels](#/operations/getMotionGroupModels) for supported types. - **json_data**: Full JSON configuration of the virtual robot controller. This can be obtained from the physical controller\'s configuration via [getVirtualControllerConfiguration](#/operations/getVirtualControllerConfiguration). - **extracted_motion_group_id** (required when using json_data): The motion group identifier to extract from the provided JSON configuration. - **motion_group**: Unique identifier for the motion group to be added. - **initial_joint_position**: Specifies the initial joint position for the added motion group. > #### NOTE > > When a motion group is added, **the virtual robot is restarted** to apply the new configuration. > > During this restart: > - Robot visualization can temporarily disappear or appear outdated in the UI. > - Motion group changes are not immediately visible in visualizations. > - All connections to virtual robot are closed and re-established, which introduces a short delay before the system is fully operational again. > > The API call itself **does not wait until the restart and re-synchronization are complete**. > This means that immediately after a successful response, the new motion group may not yet be available for use. * @summary Add Motion Group * @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 {AddVirtualControllerMotionGroupRequest} addVirtualControllerMotionGroupRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ addVirtualControllerMotionGroup(cell: string, controller: string, addVirtualControllerMotionGroupRequest: AddVirtualControllerMotionGroupRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Adds a new safety zone to the virtual robot controller. Safety zones define geometric boundaries that restrict or permit robot motion in 3D space. Each zone has a `geometry` that defines its shape, and two flags that control its behavior: - **`restricted: true`** the robot is not allowed to enter this zone. - **`inverted: true`** the zone applies to the **outside** of the shape, meaning the shape defines the *allowed* region; everything outside is the zone. Combined with `restricted: true`, the robot must stay **inside** the shape. Common combinations: | `restricted` | `inverted` | Effect | |---|---|---| | `true` | `false` | Keep-out zone, the robot cannot enter the shape, e.g., obstacle, table, wall | | `true` | `true` | Keep-in zone, the robot must stay inside the shape, e.g., workspace envelope / cell boundary | The `mg_uid` field specifies which motion group the safety zone is enforced for and must match an existing motion group UID on the controller. The `uid_ref_cs` field defines the coordinate system in which the geometry coordinates are expressed. The coordinate system must be defined on the controller beforehand. If empty (`\"\"`), the World coordinate system is used. Using an incorrect coordinate system places the safety zone in a different physical location. --- ## Geometry Shape Reference All coordinates are in **millimetres (mm)**. Choose the shape that best fits the physical boundary. --- ### Box A rectangular cuboid defined by one **corner point** (`center`) and **three adjacent corners** (`neighbour`). Despite the field name, `center` is not the geometric centroid but one corner of the box, and each `neighbour` is the corner directly connected to it by one edge. This format is used directly by robot controllers (FANUC, KUKA, etc.) and supports arbitrary orientations, including left-handed coordinate systems that parametric (size + quaternion) formats cannot represent. **When to use:** Cell workspace envelope, machine enclosure, table, rectangular obstacle, pallet zone. **How to define:** ``` center → one corner of the box [x, y, z] neighbour = [ x1, y1, z1, ← corner connected by the first edge x2, y2, z2, ← corner connected by the second edge x3, y3, z3 ← corner connected by the third edge ] edge_length_i = ||neighbour_i − corner|| ``` The three edge vectors and the geometric centroid are: ``` d0 = neighbour[0] − corner d1 = neighbour[1] − corner d2 = neighbour[2] − corner centroid = corner + (d0 + d1 + d2) / 2 ``` For an **axis-aligned** box with one corner at `[cx, cy, cz]` and edge lengths `[ex, ey, ez]`: ``` corner = [cx, cy, cz] neighbour = [cx+ex, cy, cz, cx, cy+ey, cz, cx, cy, cz+ez] ``` --- ### Prism An extruded polygon is a 2D closed polygon (defined in the XY plane) extruded vertically between `bottom` and `top` Z coordinates. The polygon can be convex or concave. **When to use:** Irregular floor-plan areas (aisles, loading bays, L-shaped zones), conveyor corridors, or any zone with a non-rectangular footprint. **How to define:** ``` point = [x1, y1, x2, y2, x3, y3, ...] ← 2D vertices (XY), flattened, ≥ 3 points top = upper Z bound [mm] bottom = lower Z bound [mm] ``` Points must form a closed polygon; the last point implicitly connects to the first. --- ### Sphere A perfect sphere defined by its **center point** and **radius**. **When to use:** Protection zones around sensors, cameras, workpieces, point-like obstacles, singularity avoidance zones around the robot base. **How to define:** ``` center = [x, y, z] ← center of the sphere [mm] radius ← radius [mm] ``` --- ### Capsule A cylinder with hemispherical caps at each end, defined by two axis endpoints (`top`, `bottom`) and a **radius**. The axis can have any orientation. **When to use:** Pipes, cable trays, vertical columns, horizontal beams, or tube-shaped obstacles. **How to define:** ``` top = [x, y, z] ← center of the top hemisphere [mm] bottom = [x, y, z] ← center of the bottom hemisphere [mm] radius ← cylinder + hemisphere radius [mm] ``` The total length of the capsule is `||top − bottom|| + 2 × radius`. --- ### Lozenge A rounded rectangle (stadium/discorectangle shape) in a plane, defined by a **center pose**, two **dimensions**, and a **corner radius**. The plane orientation is defined by the quaternion in `center`. **When to use:** Conveyor belt surfaces, worktables with rounded edges, or flat rectangular zones in arbitrary orientations. **How to define:** ``` center.x/y/z ← position of the center [mm] center.qx/qy/qz/qw ← orientation as unit quaternion (identity = XY plane) x_dimension ← total length along local X axis [mm] y_dimension ← total width along local Y axis [mm] radius ← corner rounding radius [mm] ``` For a horizontal lozenge, use identity quaternion `(qx=0, qy=0, qz=0, qw=1)`. --- ### Plane A mathematical half-space plane defined by its **3D vertices**. All vertices must be coplanar. The plane is unbounded (infinite extent in all directions parallel to the surface). The points define the plane\'s orientation and position only. **When to use:** Floor boundaries, virtual walls, tilted surfaces, e.g., ramps, inclined conveyors, or flat custom barriers. **How to define:** ``` point = [x1, y1, z1, x2, y2, z2, x3, y3, z3, ...] ← 3D vertices, flattened, ≥ 3 points ``` Points must be coplanar and form a closed polygon. --- > #### NOTE > > When a safety zone is added, **the virtual robot is restarted** to apply the new configuration. > > During this restart: > - All connections to the virtual robot are closed and re-established, introducing a short delay before the system is fully operational again. > - The safety checksum is automatically updated to reflect the configuration change. > > The API call **does not wait until the restart and re-synchronization are complete**. * @summary Add Safety Zone * @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 {SafetyZone} safetyZone * @param {*} [options] Override http request option. * @throws {RequiredError} */ addVirtualControllerSafetyZone(cell: string, controller: string, safetyZone: SafetyZone, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Adds a new TCP or updates an existing TCP in the motion group. The position and rotation values in the request body are defined within the flange\'s coordinate system. > **NOTE** > > Ensure the TCP\'s position is within the robot\'s reach. Refer to the robot\'s documentation or data sheet for details like joint limits or reach. > #### NOTE > > When adding or updating a TCP, the **virtual robot is restarted** to apply the new configuration. > > During this restart: > - Robot visualization can temporarily disappear. > - The TCP may not be immediately visible or appear outdated in visualizations. > - All connections to virtual robot are closed and re-established, which introduces a short delay before the TCP is available for operation. > > The API call itself does **not wait until the restart and re-synchronization are complete**. > A successful response indicates that the request was accepted, but the TCP may not yet be visible nor usable. * @summary Add TCP * @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 {string} motionGroup The motion-group identifier. * @param {string} tcp The unique identifier of a TCP. * @param {RobotTcpData} robotTcpData * @param {*} [options] Override http request option. * @throws {RequiredError} */ addVirtualControllerTcp(cell: string, controller: string, motionGroup: string, tcp: string, robotTcpData: RobotTcpData, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Deletes a coordinate system from the virtual controller. This will remove the coordinate system from the list of coordinate systems and also remove all dependent coordinate systems that use the deleted coordinate system as reference. > #### NOTE > > When a new coordinate system is removed, the **virtual robot is restarted** to apply the new configuration. > > During this restart: > - Robot visualization can temporarily disappear or appear outdated in the UI. > - Coordinate system changes are not immediately visible in visualizations. > - All connections to virtual robot are closed and re-established, which introduces a short delay before the system is fully operational again. > > The API call itself does **not wait until the restart and re-synchronization are complete**. > This means that immediately after a successful response, the new coordinate system may not yet be available for visualization or program execution. * @summary Delete Coordinate System * @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 {string} coordinateSystem Unique identifier addressing a coordinate system. * @param {boolean} [deleteDependent] If true, all dependent coordinate systems will be deleted as well. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteVirtualControllerCoordinateSystem(cell: string, controller: string, coordinateSystem: string, deleteDependent?: boolean, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Removes a motion group configuration from the virtual controller. > #### NOTE > > When a motion group is removed, **the virtual robot is restarted** to apply the new configuration. > > During this restart: > - Robot visualization can temporarily disappear or appear outdated in the UI. > - Motion group changes are not immediately visible in visualizations. > - All connections to virtual robot are closed and re-established, which introduces a short delay before the system is fully operational again. > > The API call itself **does not wait until the restart and re-synchronization are complete**. * @summary Delete Motion Group * @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 {string} motionGroup The motion-group identifier. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteVirtualControllerMotionGroup(cell: string, controller: string, motionGroup: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Removes a safety zone from the virtual robot controller. > #### NOTE > > When a safety zone is removed, **the virtual robot is restarted** to apply the new configuration. > > During this restart: > - All connections to the virtual robot are closed and re-established, which introduces a short delay before the system is fully operational again. > - The safety checksum is automatically updated to reflect the configuration change. > > The API call itself **does not wait until the restart and re-synchronization are complete**. * @summary Delete Safety Zone * @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} id The unique identifier of the safety zone to delete. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteVirtualControllerSafetyZone(cell: string, controller: string, id: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Removes the TCP (Tool Center Point) from the motion group. An unknown TCP is a valid input and will simply be ignored. > #### NOTE > > When removing a TCP, the **virtual robot is restarted** to apply the new configuration. > > During this restart: > - Robot visualization can temporarily disappear. > - The removal of the TCP may not be immediately visible or appear outdated in visualizations. > - All connections to virtual robot are closed and re-established, which introduces a short delay before the system is fully operational again. > > The API call itself does **not wait until the restart and re-synchronization are complete**. > A successful response indicates that the request was accepted, but the then used TCP may not yet be visible nor usable. * @summary Remove TCP * @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 {string} motionGroup The motion-group identifier. * @param {string} tcp The unique identifier of a TCP. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteVirtualControllerTcp(cell: string, controller: string, motionGroup: string, tcp: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Requests the Emergency Stop state of the virtual robot controller. Use [getCurrentMotionGroupState](#/operations/getCurrentMotionGroupState) to get the Emergency Stop state with `safety_state` regardless of the controller type. > **NOTE** > > The Emergency Stop state can only be changed when using virtual robot controllers. * @summary Get Emergency Stop 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 {*} [options] Override http request option. * @throws {RequiredError} */ getEmergencyStop(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Get the current motion group state which provides values for the joints\' position, velocity and acceleration. * @summary Get Motion Group 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 {string} motionGroup The motion-group identifier. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getMotionGroupState(cell: string, controller: string, motionGroup: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Gets information on the motion group. * @summary Motion Group Description * @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} */ getMotionGroups(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Requests the operation mode of the virtual robot controller. To get the operation mode regardless of the controller type, use [getCurrentMotionGroupState](#/operations/getCurrentMotionGroupState). > **NOTE** > > The operation mode can only be changed via API when using virtual robot controllers. * @summary Get Operation 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} */ getOperationMode(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Gets motion group mounting. The motion group is based on the origin of the returned coordinate system. * @summary Get Mounting * @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 {string} motionGroup The motion-group identifier. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getVirtualControllerMounting(cell: string, controller: string, motionGroup: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Gets all safety zones configured in the virtual robot controller. Safety zones define geometric boundaries that restrict robot motion or define protected areas in the workspace. * @summary List Safety Zones * @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} */ getVirtualControllerSafetyZones(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Lists all coordinate systems on the robot controller. * @summary List Coordinate Systems * @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} */ listVirtualControllerCoordinateSystems(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Lists TCPs of the motion group. An empty TCP list is valid, e.g., for external axes. * @summary List TCPs * @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 {string} motionGroup The motion-group identifier. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listVirtualControllerTcps(cell: string, controller: string, motionGroup: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Activates or releases the Emergency Stop on the virtual robot controller. Activating the Emergency Stop stops the execution of all motions. The stop is executed on physical controllers immediately not gracefully and not on paths. Due to restricted physical behavior of the virtual robot controller, the Emergency Stop is executed on paths. To return to normal operation the Emergency Stop needs to be released. Use [getCurrentMotionGroupState](#/operations/getCurrentMotionGroupState) to get the Emergency Stop state with `safety_state` regardless of the controller type. > **NOTE** > > The Emergency Stop state can only be changed via API when using virtual robot controllers. * @summary Push or Release Emergency Stop * @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 {boolean} [active] * @param {*} [options] Override http request option. * @throws {RequiredError} */ setEmergencyStop(cell: string, controller: string, active?: boolean, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Sets the values for joint position, joint velocity or joint acceleration of a motion group state. The values are immediately applied to the joints of the motion group. > #### NOTE > > Only use the endpoint when the motion group is in monitor mode. If the motion group is controlled, currently jogging or planning motions, > the values are overridden by the controller or an error may occur. * @summary Set Motion Group 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 {string} motionGroup The motion-group identifier. * @param {MotionGroupJoints} motionGroupJoints * @param {*} [options] Override http request option. * @throws {RequiredError} */ setMotionGroupState(cell: string, controller: string, motionGroup: string, motionGroupJoints: MotionGroupJoints, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Changes the operation mode of the virtual robot controller to the specified value. To get the operation mode regardless of the controller type, use [getCurrentMotionGroupState](#/operations/getCurrentMotionGroupState). > **NOTE** > > The operation mode can only be changed via API when using virtual robot controllers. * @summary Set Operation 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 {OperationMode} mode * @param {*} [options] Override http request option. * @throws {RequiredError} */ setOperationMode(cell: string, controller: string, mode: OperationMode, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Sets the motion group mounting by specifying a coordinate system. The motion group will be based on the coordinate system\'s origin. The coordinate system defines a transformation offset, which consists of: - A unique identifier - A user-facing name - An offset in another coordinate system, referenced by the unique identifier of the reference coordinate system. > #### Changing the mounting configuration is considered a setup change > > When the mounting is set to a new coordinate system, the **virtual robot is restarted** to apply the new configuration. > > During this restart: > - Robot visualization can temporarily disappear or not reflect the new mounting immediately. > - Motion group state and coordinate system alignment may not be immediately visible in visualizations. > - All connections to virtual robot are closed and re-established, which introduces a short delay before the system is fully operational again. > > The API call itself does **not wait until the restart and re-synchronization are complete**. > A successful response indicates that the request was accepted, but the updated mounting may not yet be visible. * @summary Set Mounting * @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 {string} motionGroup The motion-group identifier. * @param {CoordinateSystem} coordinateSystem * @param {*} [options] Override http request option. * @throws {RequiredError} */ setVirtualControllerMounting(cell: string, controller: string, motionGroup: string, coordinateSystem: CoordinateSystem, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; }; /** * VirtualControllerApi - factory interface */ declare const VirtualControllerApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => { /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Adds a coordinate system to the robot controller. > #### NOTE > > When a new coordinate system is added, the **virtual robot is restarted** to apply the new configuration. > > During this restart: > - Robot visualization can temporarily disappear or appear outdated in the UI. > - Coordinate system changes are not immediately visible in visualizations. > - All connections to virtual robot are closed and re-established, which introduces a short delay before the system is fully operational again. > > The API call itself does **not wait until the restart and re-synchronization are complete**. > This means that immediately after a successful response, the new coordinate system may not yet be available for visualization or program execution. * @summary Add Coordinate Systems * @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 {string} coordinateSystem Unique identifier addressing a coordinate system. * @param {CoordinateSystemData} coordinateSystemData * @param {*} [options] Override http request option. * @throws {RequiredError} */ addVirtualControllerCoordinateSystem(cell: string, controller: string, coordinateSystem: string, coordinateSystemData: CoordinateSystemData, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Adds a motion group configuration for the virtual robot controller. Fields: - Only one of **motion_group_model** or **json_data** should be set. - **motion_group_model**: Identifies a single motion group. See [getMotionGroupModels](#/operations/getMotionGroupModels) for supported types. - **json_data**: Full JSON configuration of the virtual robot controller. This can be obtained from the physical controller\'s configuration via [getVirtualControllerConfiguration](#/operations/getVirtualControllerConfiguration). - **extracted_motion_group_id** (required when using json_data): The motion group identifier to extract from the provided JSON configuration. - **motion_group**: Unique identifier for the motion group to be added. - **initial_joint_position**: Specifies the initial joint position for the added motion group. > #### NOTE > > When a motion group is added, **the virtual robot is restarted** to apply the new configuration. > > During this restart: > - Robot visualization can temporarily disappear or appear outdated in the UI. > - Motion group changes are not immediately visible in visualizations. > - All connections to virtual robot are closed and re-established, which introduces a short delay before the system is fully operational again. > > The API call itself **does not wait until the restart and re-synchronization are complete**. > This means that immediately after a successful response, the new motion group may not yet be available for use. * @summary Add Motion Group * @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 {AddVirtualControllerMotionGroupRequest} addVirtualControllerMotionGroupRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ addVirtualControllerMotionGroup(cell: string, controller: string, addVirtualControllerMotionGroupRequest: AddVirtualControllerMotionGroupRequest, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Adds a new safety zone to the virtual robot controller. Safety zones define geometric boundaries that restrict or permit robot motion in 3D space. Each zone has a `geometry` that defines its shape, and two flags that control its behavior: - **`restricted: true`** the robot is not allowed to enter this zone. - **`inverted: true`** the zone applies to the **outside** of the shape, meaning the shape defines the *allowed* region; everything outside is the zone. Combined with `restricted: true`, the robot must stay **inside** the shape. Common combinations: | `restricted` | `inverted` | Effect | |---|---|---| | `true` | `false` | Keep-out zone, the robot cannot enter the shape, e.g., obstacle, table, wall | | `true` | `true` | Keep-in zone, the robot must stay inside the shape, e.g., workspace envelope / cell boundary | The `mg_uid` field specifies which motion group the safety zone is enforced for and must match an existing motion group UID on the controller. The `uid_ref_cs` field defines the coordinate system in which the geometry coordinates are expressed. The coordinate system must be defined on the controller beforehand. If empty (`\"\"`), the World coordinate system is used. Using an incorrect coordinate system places the safety zone in a different physical location. --- ## Geometry Shape Reference All coordinates are in **millimetres (mm)**. Choose the shape that best fits the physical boundary. --- ### Box A rectangular cuboid defined by one **corner point** (`center`) and **three adjacent corners** (`neighbour`). Despite the field name, `center` is not the geometric centroid but one corner of the box, and each `neighbour` is the corner directly connected to it by one edge. This format is used directly by robot controllers (FANUC, KUKA, etc.) and supports arbitrary orientations, including left-handed coordinate systems that parametric (size + quaternion) formats cannot represent. **When to use:** Cell workspace envelope, machine enclosure, table, rectangular obstacle, pallet zone. **How to define:** ``` center → one corner of the box [x, y, z] neighbour = [ x1, y1, z1, ← corner connected by the first edge x2, y2, z2, ← corner connected by the second edge x3, y3, z3 ← corner connected by the third edge ] edge_length_i = ||neighbour_i − corner|| ``` The three edge vectors and the geometric centroid are: ``` d0 = neighbour[0] − corner d1 = neighbour[1] − corner d2 = neighbour[2] − corner centroid = corner + (d0 + d1 + d2) / 2 ``` For an **axis-aligned** box with one corner at `[cx, cy, cz]` and edge lengths `[ex, ey, ez]`: ``` corner = [cx, cy, cz] neighbour = [cx+ex, cy, cz, cx, cy+ey, cz, cx, cy, cz+ez] ``` --- ### Prism An extruded polygon is a 2D closed polygon (defined in the XY plane) extruded vertically between `bottom` and `top` Z coordinates. The polygon can be convex or concave. **When to use:** Irregular floor-plan areas (aisles, loading bays, L-shaped zones), conveyor corridors, or any zone with a non-rectangular footprint. **How to define:** ``` point = [x1, y1, x2, y2, x3, y3, ...] ← 2D vertices (XY), flattened, ≥ 3 points top = upper Z bound [mm] bottom = lower Z bound [mm] ``` Points must form a closed polygon; the last point implicitly connects to the first. --- ### Sphere A perfect sphere defined by its **center point** and **radius**. **When to use:** Protection zones around sensors, cameras, workpieces, point-like obstacles, singularity avoidance zones around the robot base. **How to define:** ``` center = [x, y, z] ← center of the sphere [mm] radius ← radius [mm] ``` --- ### Capsule A cylinder with hemispherical caps at each end, defined by two axis endpoints (`top`, `bottom`) and a **radius**. The axis can have any orientation. **When to use:** Pipes, cable trays, vertical columns, horizontal beams, or tube-shaped obstacles. **How to define:** ``` top = [x, y, z] ← center of the top hemisphere [mm] bottom = [x, y, z] ← center of the bottom hemisphere [mm] radius ← cylinder + hemisphere radius [mm] ``` The total length of the capsule is `||top − bottom|| + 2 × radius`. --- ### Lozenge A rounded rectangle (stadium/discorectangle shape) in a plane, defined by a **center pose**, two **dimensions**, and a **corner radius**. The plane orientation is defined by the quaternion in `center`. **When to use:** Conveyor belt surfaces, worktables with rounded edges, or flat rectangular zones in arbitrary orientations. **How to define:** ``` center.x/y/z ← position of the center [mm] center.qx/qy/qz/qw ← orientation as unit quaternion (identity = XY plane) x_dimension ← total length along local X axis [mm] y_dimension ← total width along local Y axis [mm] radius ← corner rounding radius [mm] ``` For a horizontal lozenge, use identity quaternion `(qx=0, qy=0, qz=0, qw=1)`. --- ### Plane A mathematical half-space plane defined by its **3D vertices**. All vertices must be coplanar. The plane is unbounded (infinite extent in all directions parallel to the surface). The points define the plane\'s orientation and position only. **When to use:** Floor boundaries, virtual walls, tilted surfaces, e.g., ramps, inclined conveyors, or flat custom barriers. **How to define:** ``` point = [x1, y1, z1, x2, y2, z2, x3, y3, z3, ...] ← 3D vertices, flattened, ≥ 3 points ``` Points must be coplanar and form a closed polygon. --- > #### NOTE > > When a safety zone is added, **the virtual robot is restarted** to apply the new configuration. > > During this restart: > - All connections to the virtual robot are closed and re-established, introducing a short delay before the system is fully operational again. > - The safety checksum is automatically updated to reflect the configuration change. > > The API call **does not wait until the restart and re-synchronization are complete**. * @summary Add Safety Zone * @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 {SafetyZone} safetyZone * @param {*} [options] Override http request option. * @throws {RequiredError} */ addVirtualControllerSafetyZone(cell: string, controller: string, safetyZone: SafetyZone, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Adds a new TCP or updates an existing TCP in the motion group. The position and rotation values in the request body are defined within the flange\'s coordinate system. > **NOTE** > > Ensure the TCP\'s position is within the robot\'s reach. Refer to the robot\'s documentation or data sheet for details like joint limits or reach. > #### NOTE > > When adding or updating a TCP, the **virtual robot is restarted** to apply the new configuration. > > During this restart: > - Robot visualization can temporarily disappear. > - The TCP may not be immediately visible or appear outdated in visualizations. > - All connections to virtual robot are closed and re-established, which introduces a short delay before the TCP is available for operation. > > The API call itself does **not wait until the restart and re-synchronization are complete**. > A successful response indicates that the request was accepted, but the TCP may not yet be visible nor usable. * @summary Add TCP * @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 {string} motionGroup The motion-group identifier. * @param {string} tcp The unique identifier of a TCP. * @param {RobotTcpData} robotTcpData * @param {*} [options] Override http request option. * @throws {RequiredError} */ addVirtualControllerTcp(cell: string, controller: string, motionGroup: string, tcp: string, robotTcpData: RobotTcpData, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Deletes a coordinate system from the virtual controller. This will remove the coordinate system from the list of coordinate systems and also remove all dependent coordinate systems that use the deleted coordinate system as reference. > #### NOTE > > When a new coordinate system is removed, the **virtual robot is restarted** to apply the new configuration. > > During this restart: > - Robot visualization can temporarily disappear or appear outdated in the UI. > - Coordinate system changes are not immediately visible in visualizations. > - All connections to virtual robot are closed and re-established, which introduces a short delay before the system is fully operational again. > > The API call itself does **not wait until the restart and re-synchronization are complete**. > This means that immediately after a successful response, the new coordinate system may not yet be available for visualization or program execution. * @summary Delete Coordinate System * @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 {string} coordinateSystem Unique identifier addressing a coordinate system. * @param {boolean} [deleteDependent] If true, all dependent coordinate systems will be deleted as well. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteVirtualControllerCoordinateSystem(cell: string, controller: string, coordinateSystem: string, deleteDependent?: boolean, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Removes a motion group configuration from the virtual controller. > #### NOTE > > When a motion group is removed, **the virtual robot is restarted** to apply the new configuration. > > During this restart: > - Robot visualization can temporarily disappear or appear outdated in the UI. > - Motion group changes are not immediately visible in visualizations. > - All connections to virtual robot are closed and re-established, which introduces a short delay before the system is fully operational again. > > The API call itself **does not wait until the restart and re-synchronization are complete**. * @summary Delete Motion Group * @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 {string} motionGroup The motion-group identifier. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteVirtualControllerMotionGroup(cell: string, controller: string, motionGroup: string, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Removes a safety zone from the virtual robot controller. > #### NOTE > > When a safety zone is removed, **the virtual robot is restarted** to apply the new configuration. > > During this restart: > - All connections to the virtual robot are closed and re-established, which introduces a short delay before the system is fully operational again. > - The safety checksum is automatically updated to reflect the configuration change. > > The API call itself **does not wait until the restart and re-synchronization are complete**. * @summary Delete Safety Zone * @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} id The unique identifier of the safety zone to delete. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteVirtualControllerSafetyZone(cell: string, controller: string, id: number, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Removes the TCP (Tool Center Point) from the motion group. An unknown TCP is a valid input and will simply be ignored. > #### NOTE > > When removing a TCP, the **virtual robot is restarted** to apply the new configuration. > > During this restart: > - Robot visualization can temporarily disappear. > - The removal of the TCP may not be immediately visible or appear outdated in visualizations. > - All connections to virtual robot are closed and re-established, which introduces a short delay before the system is fully operational again. > > The API call itself does **not wait until the restart and re-synchronization are complete**. > A successful response indicates that the request was accepted, but the then used TCP may not yet be visible nor usable. * @summary Remove TCP * @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 {string} motionGroup The motion-group identifier. * @param {string} tcp The unique identifier of a TCP. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteVirtualControllerTcp(cell: string, controller: string, motionGroup: string, tcp: string, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Requests the Emergency Stop state of the virtual robot controller. Use [getCurrentMotionGroupState](#/operations/getCurrentMotionGroupState) to get the Emergency Stop state with `safety_state` regardless of the controller type. > **NOTE** > > The Emergency Stop state can only be changed when using virtual robot controllers. * @summary Get Emergency Stop 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 {*} [options] Override http request option. * @throws {RequiredError} */ getEmergencyStop(cell: string, controller: string, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Get the current motion group state which provides values for the joints\' position, velocity and acceleration. * @summary Get Motion Group 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 {string} motionGroup The motion-group identifier. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getMotionGroupState(cell: string, controller: string, motionGroup: string, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Gets information on the motion group. * @summary Motion Group Description * @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} */ getMotionGroups(cell: string, controller: string, options?: RawAxiosRequestConfig): AxiosPromise>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Requests the operation mode of the virtual robot controller. To get the operation mode regardless of the controller type, use [getCurrentMotionGroupState](#/operations/getCurrentMotionGroupState). > **NOTE** > > The operation mode can only be changed via API when using virtual robot controllers. * @summary Get Operation 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} */ getOperationMode(cell: string, controller: string, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Gets motion group mounting. The motion group is based on the origin of the returned coordinate system. * @summary Get Mounting * @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 {string} motionGroup The motion-group identifier. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getVirtualControllerMounting(cell: string, controller: string, motionGroup: string, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Gets all safety zones configured in the virtual robot controller. Safety zones define geometric boundaries that restrict robot motion or define protected areas in the workspace. * @summary List Safety Zones * @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} */ getVirtualControllerSafetyZones(cell: string, controller: string, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Lists all coordinate systems on the robot controller. * @summary List Coordinate Systems * @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} */ listVirtualControllerCoordinateSystems(cell: string, controller: string, options?: RawAxiosRequestConfig): AxiosPromise>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Lists TCPs of the motion group. An empty TCP list is valid, e.g., for external axes. * @summary List TCPs * @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 {string} motionGroup The motion-group identifier. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listVirtualControllerTcps(cell: string, controller: string, motionGroup: string, options?: RawAxiosRequestConfig): AxiosPromise>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Activates or releases the Emergency Stop on the virtual robot controller. Activating the Emergency Stop stops the execution of all motions. The stop is executed on physical controllers immediately not gracefully and not on paths. Due to restricted physical behavior of the virtual robot controller, the Emergency Stop is executed on paths. To return to normal operation the Emergency Stop needs to be released. Use [getCurrentMotionGroupState](#/operations/getCurrentMotionGroupState) to get the Emergency Stop state with `safety_state` regardless of the controller type. > **NOTE** > > The Emergency Stop state can only be changed via API when using virtual robot controllers. * @summary Push or Release Emergency Stop * @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 {boolean} [active] * @param {*} [options] Override http request option. * @throws {RequiredError} */ setEmergencyStop(cell: string, controller: string, active?: boolean, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Sets the values for joint position, joint velocity or joint acceleration of a motion group state. The values are immediately applied to the joints of the motion group. > #### NOTE > > Only use the endpoint when the motion group is in monitor mode. If the motion group is controlled, currently jogging or planning motions, > the values are overridden by the controller or an error may occur. * @summary Set Motion Group 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 {string} motionGroup The motion-group identifier. * @param {MotionGroupJoints} motionGroupJoints * @param {*} [options] Override http request option. * @throws {RequiredError} */ setMotionGroupState(cell: string, controller: string, motionGroup: string, motionGroupJoints: MotionGroupJoints, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Changes the operation mode of the virtual robot controller to the specified value. To get the operation mode regardless of the controller type, use [getCurrentMotionGroupState](#/operations/getCurrentMotionGroupState). > **NOTE** > > The operation mode can only be changed via API when using virtual robot controllers. * @summary Set Operation 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 {OperationMode} mode * @param {*} [options] Override http request option. * @throws {RequiredError} */ setOperationMode(cell: string, controller: string, mode: OperationMode, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Sets the motion group mounting by specifying a coordinate system. The motion group will be based on the coordinate system\'s origin. The coordinate system defines a transformation offset, which consists of: - A unique identifier - A user-facing name - An offset in another coordinate system, referenced by the unique identifier of the reference coordinate system. > #### Changing the mounting configuration is considered a setup change > > When the mounting is set to a new coordinate system, the **virtual robot is restarted** to apply the new configuration. > > During this restart: > - Robot visualization can temporarily disappear or not reflect the new mounting immediately. > - Motion group state and coordinate system alignment may not be immediately visible in visualizations. > - All connections to virtual robot are closed and re-established, which introduces a short delay before the system is fully operational again. > > The API call itself does **not wait until the restart and re-synchronization are complete**. > A successful response indicates that the request was accepted, but the updated mounting may not yet be visible. * @summary Set Mounting * @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 {string} motionGroup The motion-group identifier. * @param {CoordinateSystem} coordinateSystem * @param {*} [options] Override http request option. * @throws {RequiredError} */ setVirtualControllerMounting(cell: string, controller: string, motionGroup: string, coordinateSystem: CoordinateSystem, options?: RawAxiosRequestConfig): AxiosPromise; }; /** * VirtualControllerApi - object-oriented interface */ declare class VirtualControllerApi extends BaseAPI { /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Adds a coordinate system to the robot controller. > #### NOTE > > When a new coordinate system is added, the **virtual robot is restarted** to apply the new configuration. > > During this restart: > - Robot visualization can temporarily disappear or appear outdated in the UI. > - Coordinate system changes are not immediately visible in visualizations. > - All connections to virtual robot are closed and re-established, which introduces a short delay before the system is fully operational again. > > The API call itself does **not wait until the restart and re-synchronization are complete**. > This means that immediately after a successful response, the new coordinate system may not yet be available for visualization or program execution. * @summary Add Coordinate Systems * @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 {string} coordinateSystem Unique identifier addressing a coordinate system. * @param {CoordinateSystemData} coordinateSystemData * @param {*} [options] Override http request option. * @throws {RequiredError} */ addVirtualControllerCoordinateSystem(cell: string, controller: string, coordinateSystem: string, coordinateSystemData: CoordinateSystemData, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Adds a motion group configuration for the virtual robot controller. Fields: - Only one of **motion_group_model** or **json_data** should be set. - **motion_group_model**: Identifies a single motion group. See [getMotionGroupModels](#/operations/getMotionGroupModels) for supported types. - **json_data**: Full JSON configuration of the virtual robot controller. This can be obtained from the physical controller\'s configuration via [getVirtualControllerConfiguration](#/operations/getVirtualControllerConfiguration). - **extracted_motion_group_id** (required when using json_data): The motion group identifier to extract from the provided JSON configuration. - **motion_group**: Unique identifier for the motion group to be added. - **initial_joint_position**: Specifies the initial joint position for the added motion group. > #### NOTE > > When a motion group is added, **the virtual robot is restarted** to apply the new configuration. > > During this restart: > - Robot visualization can temporarily disappear or appear outdated in the UI. > - Motion group changes are not immediately visible in visualizations. > - All connections to virtual robot are closed and re-established, which introduces a short delay before the system is fully operational again. > > The API call itself **does not wait until the restart and re-synchronization are complete**. > This means that immediately after a successful response, the new motion group may not yet be available for use. * @summary Add Motion Group * @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 {AddVirtualControllerMotionGroupRequest} addVirtualControllerMotionGroupRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ addVirtualControllerMotionGroup(cell: string, controller: string, addVirtualControllerMotionGroupRequest: AddVirtualControllerMotionGroupRequest, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Adds a new safety zone to the virtual robot controller. Safety zones define geometric boundaries that restrict or permit robot motion in 3D space. Each zone has a `geometry` that defines its shape, and two flags that control its behavior: - **`restricted: true`** the robot is not allowed to enter this zone. - **`inverted: true`** the zone applies to the **outside** of the shape, meaning the shape defines the *allowed* region; everything outside is the zone. Combined with `restricted: true`, the robot must stay **inside** the shape. Common combinations: | `restricted` | `inverted` | Effect | |---|---|---| | `true` | `false` | Keep-out zone, the robot cannot enter the shape, e.g., obstacle, table, wall | | `true` | `true` | Keep-in zone, the robot must stay inside the shape, e.g., workspace envelope / cell boundary | The `mg_uid` field specifies which motion group the safety zone is enforced for and must match an existing motion group UID on the controller. The `uid_ref_cs` field defines the coordinate system in which the geometry coordinates are expressed. The coordinate system must be defined on the controller beforehand. If empty (`\"\"`), the World coordinate system is used. Using an incorrect coordinate system places the safety zone in a different physical location. --- ## Geometry Shape Reference All coordinates are in **millimetres (mm)**. Choose the shape that best fits the physical boundary. --- ### Box A rectangular cuboid defined by one **corner point** (`center`) and **three adjacent corners** (`neighbour`). Despite the field name, `center` is not the geometric centroid but one corner of the box, and each `neighbour` is the corner directly connected to it by one edge. This format is used directly by robot controllers (FANUC, KUKA, etc.) and supports arbitrary orientations, including left-handed coordinate systems that parametric (size + quaternion) formats cannot represent. **When to use:** Cell workspace envelope, machine enclosure, table, rectangular obstacle, pallet zone. **How to define:** ``` center → one corner of the box [x, y, z] neighbour = [ x1, y1, z1, ← corner connected by the first edge x2, y2, z2, ← corner connected by the second edge x3, y3, z3 ← corner connected by the third edge ] edge_length_i = ||neighbour_i − corner|| ``` The three edge vectors and the geometric centroid are: ``` d0 = neighbour[0] − corner d1 = neighbour[1] − corner d2 = neighbour[2] − corner centroid = corner + (d0 + d1 + d2) / 2 ``` For an **axis-aligned** box with one corner at `[cx, cy, cz]` and edge lengths `[ex, ey, ez]`: ``` corner = [cx, cy, cz] neighbour = [cx+ex, cy, cz, cx, cy+ey, cz, cx, cy, cz+ez] ``` --- ### Prism An extruded polygon is a 2D closed polygon (defined in the XY plane) extruded vertically between `bottom` and `top` Z coordinates. The polygon can be convex or concave. **When to use:** Irregular floor-plan areas (aisles, loading bays, L-shaped zones), conveyor corridors, or any zone with a non-rectangular footprint. **How to define:** ``` point = [x1, y1, x2, y2, x3, y3, ...] ← 2D vertices (XY), flattened, ≥ 3 points top = upper Z bound [mm] bottom = lower Z bound [mm] ``` Points must form a closed polygon; the last point implicitly connects to the first. --- ### Sphere A perfect sphere defined by its **center point** and **radius**. **When to use:** Protection zones around sensors, cameras, workpieces, point-like obstacles, singularity avoidance zones around the robot base. **How to define:** ``` center = [x, y, z] ← center of the sphere [mm] radius ← radius [mm] ``` --- ### Capsule A cylinder with hemispherical caps at each end, defined by two axis endpoints (`top`, `bottom`) and a **radius**. The axis can have any orientation. **When to use:** Pipes, cable trays, vertical columns, horizontal beams, or tube-shaped obstacles. **How to define:** ``` top = [x, y, z] ← center of the top hemisphere [mm] bottom = [x, y, z] ← center of the bottom hemisphere [mm] radius ← cylinder + hemisphere radius [mm] ``` The total length of the capsule is `||top − bottom|| + 2 × radius`. --- ### Lozenge A rounded rectangle (stadium/discorectangle shape) in a plane, defined by a **center pose**, two **dimensions**, and a **corner radius**. The plane orientation is defined by the quaternion in `center`. **When to use:** Conveyor belt surfaces, worktables with rounded edges, or flat rectangular zones in arbitrary orientations. **How to define:** ``` center.x/y/z ← position of the center [mm] center.qx/qy/qz/qw ← orientation as unit quaternion (identity = XY plane) x_dimension ← total length along local X axis [mm] y_dimension ← total width along local Y axis [mm] radius ← corner rounding radius [mm] ``` For a horizontal lozenge, use identity quaternion `(qx=0, qy=0, qz=0, qw=1)`. --- ### Plane A mathematical half-space plane defined by its **3D vertices**. All vertices must be coplanar. The plane is unbounded (infinite extent in all directions parallel to the surface). The points define the plane\'s orientation and position only. **When to use:** Floor boundaries, virtual walls, tilted surfaces, e.g., ramps, inclined conveyors, or flat custom barriers. **How to define:** ``` point = [x1, y1, z1, x2, y2, z2, x3, y3, z3, ...] ← 3D vertices, flattened, ≥ 3 points ``` Points must be coplanar and form a closed polygon. --- > #### NOTE > > When a safety zone is added, **the virtual robot is restarted** to apply the new configuration. > > During this restart: > - All connections to the virtual robot are closed and re-established, introducing a short delay before the system is fully operational again. > - The safety checksum is automatically updated to reflect the configuration change. > > The API call **does not wait until the restart and re-synchronization are complete**. * @summary Add Safety Zone * @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 {SafetyZone} safetyZone * @param {*} [options] Override http request option. * @throws {RequiredError} */ addVirtualControllerSafetyZone(cell: string, controller: string, safetyZone: SafetyZone, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Adds a new TCP or updates an existing TCP in the motion group. The position and rotation values in the request body are defined within the flange\'s coordinate system. > **NOTE** > > Ensure the TCP\'s position is within the robot\'s reach. Refer to the robot\'s documentation or data sheet for details like joint limits or reach. > #### NOTE > > When adding or updating a TCP, the **virtual robot is restarted** to apply the new configuration. > > During this restart: > - Robot visualization can temporarily disappear. > - The TCP may not be immediately visible or appear outdated in visualizations. > - All connections to virtual robot are closed and re-established, which introduces a short delay before the TCP is available for operation. > > The API call itself does **not wait until the restart and re-synchronization are complete**. > A successful response indicates that the request was accepted, but the TCP may not yet be visible nor usable. * @summary Add TCP * @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 {string} motionGroup The motion-group identifier. * @param {string} tcp The unique identifier of a TCP. * @param {RobotTcpData} robotTcpData * @param {*} [options] Override http request option. * @throws {RequiredError} */ addVirtualControllerTcp(cell: string, controller: string, motionGroup: string, tcp: string, robotTcpData: RobotTcpData, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Deletes a coordinate system from the virtual controller. This will remove the coordinate system from the list of coordinate systems and also remove all dependent coordinate systems that use the deleted coordinate system as reference. > #### NOTE > > When a new coordinate system is removed, the **virtual robot is restarted** to apply the new configuration. > > During this restart: > - Robot visualization can temporarily disappear or appear outdated in the UI. > - Coordinate system changes are not immediately visible in visualizations. > - All connections to virtual robot are closed and re-established, which introduces a short delay before the system is fully operational again. > > The API call itself does **not wait until the restart and re-synchronization are complete**. > This means that immediately after a successful response, the new coordinate system may not yet be available for visualization or program execution. * @summary Delete Coordinate System * @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 {string} coordinateSystem Unique identifier addressing a coordinate system. * @param {boolean} [deleteDependent] If true, all dependent coordinate systems will be deleted as well. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteVirtualControllerCoordinateSystem(cell: string, controller: string, coordinateSystem: string, deleteDependent?: boolean, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Removes a motion group configuration from the virtual controller. > #### NOTE > > When a motion group is removed, **the virtual robot is restarted** to apply the new configuration. > > During this restart: > - Robot visualization can temporarily disappear or appear outdated in the UI. > - Motion group changes are not immediately visible in visualizations. > - All connections to virtual robot are closed and re-established, which introduces a short delay before the system is fully operational again. > > The API call itself **does not wait until the restart and re-synchronization are complete**. * @summary Delete Motion Group * @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 {string} motionGroup The motion-group identifier. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteVirtualControllerMotionGroup(cell: string, controller: string, motionGroup: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Removes a safety zone from the virtual robot controller. > #### NOTE > > When a safety zone is removed, **the virtual robot is restarted** to apply the new configuration. > > During this restart: > - All connections to the virtual robot are closed and re-established, which introduces a short delay before the system is fully operational again. > - The safety checksum is automatically updated to reflect the configuration change. > > The API call itself **does not wait until the restart and re-synchronization are complete**. * @summary Delete Safety Zone * @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} id The unique identifier of the safety zone to delete. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteVirtualControllerSafetyZone(cell: string, controller: string, id: number, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Removes the TCP (Tool Center Point) from the motion group. An unknown TCP is a valid input and will simply be ignored. > #### NOTE > > When removing a TCP, the **virtual robot is restarted** to apply the new configuration. > > During this restart: > - Robot visualization can temporarily disappear. > - The removal of the TCP may not be immediately visible or appear outdated in visualizations. > - All connections to virtual robot are closed and re-established, which introduces a short delay before the system is fully operational again. > > The API call itself does **not wait until the restart and re-synchronization are complete**. > A successful response indicates that the request was accepted, but the then used TCP may not yet be visible nor usable. * @summary Remove TCP * @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 {string} motionGroup The motion-group identifier. * @param {string} tcp The unique identifier of a TCP. * @param {*} [options] Override http request option. * @throws {RequiredError} */ deleteVirtualControllerTcp(cell: string, controller: string, motionGroup: string, tcp: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Requests the Emergency Stop state of the virtual robot controller. Use [getCurrentMotionGroupState](#/operations/getCurrentMotionGroupState) to get the Emergency Stop state with `safety_state` regardless of the controller type. > **NOTE** > > The Emergency Stop state can only be changed when using virtual robot controllers. * @summary Get Emergency Stop 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 {*} [options] Override http request option. * @throws {RequiredError} */ getEmergencyStop(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Get the current motion group state which provides values for the joints\' position, velocity and acceleration. * @summary Get Motion Group 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 {string} motionGroup The motion-group identifier. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getMotionGroupState(cell: string, controller: string, motionGroup: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Gets information on the motion group. * @summary Motion Group Description * @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} */ getMotionGroups(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Requests the operation mode of the virtual robot controller. To get the operation mode regardless of the controller type, use [getCurrentMotionGroupState](#/operations/getCurrentMotionGroupState). > **NOTE** > > The operation mode can only be changed via API when using virtual robot controllers. * @summary Get Operation 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} */ getOperationMode(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Gets motion group mounting. The motion group is based on the origin of the returned coordinate system. * @summary Get Mounting * @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 {string} motionGroup The motion-group identifier. * @param {*} [options] Override http request option. * @throws {RequiredError} */ getVirtualControllerMounting(cell: string, controller: string, motionGroup: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Gets all safety zones configured in the virtual robot controller. Safety zones define geometric boundaries that restrict robot motion or define protected areas in the workspace. * @summary List Safety Zones * @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} */ getVirtualControllerSafetyZones(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Lists all coordinate systems on the robot controller. * @summary List Coordinate Systems * @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} */ listVirtualControllerCoordinateSystems(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Lists TCPs of the motion group. An empty TCP list is valid, e.g., for external axes. * @summary List TCPs * @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 {string} motionGroup The motion-group identifier. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listVirtualControllerTcps(cell: string, controller: string, motionGroup: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Activates or releases the Emergency Stop on the virtual robot controller. Activating the Emergency Stop stops the execution of all motions. The stop is executed on physical controllers immediately not gracefully and not on paths. Due to restricted physical behavior of the virtual robot controller, the Emergency Stop is executed on paths. To return to normal operation the Emergency Stop needs to be released. Use [getCurrentMotionGroupState](#/operations/getCurrentMotionGroupState) to get the Emergency Stop state with `safety_state` regardless of the controller type. > **NOTE** > > The Emergency Stop state can only be changed via API when using virtual robot controllers. * @summary Push or Release Emergency Stop * @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 {boolean} [active] * @param {*} [options] Override http request option. * @throws {RequiredError} */ setEmergencyStop(cell: string, controller: string, active?: boolean, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Sets the values for joint position, joint velocity or joint acceleration of a motion group state. The values are immediately applied to the joints of the motion group. > #### NOTE > > Only use the endpoint when the motion group is in monitor mode. If the motion group is controlled, currently jogging or planning motions, > the values are overridden by the controller or an error may occur. * @summary Set Motion Group 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 {string} motionGroup The motion-group identifier. * @param {MotionGroupJoints} motionGroupJoints * @param {*} [options] Override http request option. * @throws {RequiredError} */ setMotionGroupState(cell: string, controller: string, motionGroup: string, motionGroupJoints: MotionGroupJoints, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Changes the operation mode of the virtual robot controller to the specified value. To get the operation mode regardless of the controller type, use [getCurrentMotionGroupState](#/operations/getCurrentMotionGroupState). > **NOTE** > > The operation mode can only be changed via API when using virtual robot controllers. * @summary Set Operation 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 {OperationMode} mode * @param {*} [options] Override http request option. * @throws {RequiredError} */ setOperationMode(cell: string, controller: string, mode: OperationMode, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Sets the motion group mounting by specifying a coordinate system. The motion group will be based on the coordinate system\'s origin. The coordinate system defines a transformation offset, which consists of: - A unique identifier - A user-facing name - An offset in another coordinate system, referenced by the unique identifier of the reference coordinate system. > #### Changing the mounting configuration is considered a setup change > > When the mounting is set to a new coordinate system, the **virtual robot is restarted** to apply the new configuration. > > During this restart: > - Robot visualization can temporarily disappear or not reflect the new mounting immediately. > - Motion group state and coordinate system alignment may not be immediately visible in visualizations. > - All connections to virtual robot are closed and re-established, which introduces a short delay before the system is fully operational again. > > The API call itself does **not wait until the restart and re-synchronization are complete**. > A successful response indicates that the request was accepted, but the updated mounting may not yet be visible. * @summary Set Mounting * @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 {string} motionGroup The motion-group identifier. * @param {CoordinateSystem} coordinateSystem * @param {*} [options] Override http request option. * @throws {RequiredError} */ setVirtualControllerMounting(cell: string, controller: string, motionGroup: string, coordinateSystem: CoordinateSystem, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; } /** * VirtualControllerBehaviorApi - axios parameter creator */ declare const VirtualControllerBehaviorApiAxiosParamCreator: (configuration?: Configuration) => { /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ > Websocket endpoint Sends the **commanded** state, e.g., joint positions, velocities, accelerations, torques, for each motion group of the virtual controller and sets the joint configuration. Use [planTrajectory](#/operations/planTrajectory) and [executeTrajectory](#/operations/executeTrajectory) to move motion groups on virtual controllers. Learn more about the [movement behavior of virtual controllers in comparison to physical controllers](#/operations/executeTrajectory#movement-behavior). > **NOTE** > > Incoming joint configurations are not visualized and their velocity limits are not checked. #### Use cases 1. Creating a robotic application that dynamically adapts to the configured joints on the robot controller, using this stream to feed new joint configurations back to the motion groups.\\ The stream only sends data to the robot controller if a motion is executed.\\ If the robot controller\'s joint configuration differs too much from the incoming joint configuration, a following error occurs. Joint configurations that result in following errors are executed only for motions with a low velocity. 2. Mimic freedrive motions. > **DANGER** > > If the incoming joint configuration is set to maximum velocity, the movement to reach this incoming joint configuration > will be executed with maximum speed regardless of safety zones and mechanical limits. * @summary Stream Joint Configuration * @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 {ExternalJointStreamRequest} externalJointStreamRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ externalJointsStream: (cell: string, controller: string, externalJointStreamRequest: ExternalJointStreamRequest, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Get the cycle time of controller communication in [ms]. * @summary Get Cycle Time * @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} */ getCycleTime: (cell: string, controller: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Get the current virtual controller behavior. See [setVirtualControllerBehavior](#/operations/setVirtualControllerBehavior) and the body for details. * @summary Get Behavior * @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} */ getVirtualControllerBehavior: (cell: string, controller: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Set virtual controller behavior. See query parameters for details. * @summary Set Behavior * @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 {Behavior} [behavior] * @param {*} [options] Override http request option. * @throws {RequiredError} */ setVirtualControllerBehavior: (cell: string, controller: string, behavior?: Behavior, options?: RawAxiosRequestConfig) => Promise; }; /** * VirtualControllerBehaviorApi - functional programming interface */ declare const VirtualControllerBehaviorApiFp: (configuration?: Configuration) => { /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ > Websocket endpoint Sends the **commanded** state, e.g., joint positions, velocities, accelerations, torques, for each motion group of the virtual controller and sets the joint configuration. Use [planTrajectory](#/operations/planTrajectory) and [executeTrajectory](#/operations/executeTrajectory) to move motion groups on virtual controllers. Learn more about the [movement behavior of virtual controllers in comparison to physical controllers](#/operations/executeTrajectory#movement-behavior). > **NOTE** > > Incoming joint configurations are not visualized and their velocity limits are not checked. #### Use cases 1. Creating a robotic application that dynamically adapts to the configured joints on the robot controller, using this stream to feed new joint configurations back to the motion groups.\\ The stream only sends data to the robot controller if a motion is executed.\\ If the robot controller\'s joint configuration differs too much from the incoming joint configuration, a following error occurs. Joint configurations that result in following errors are executed only for motions with a low velocity. 2. Mimic freedrive motions. > **DANGER** > > If the incoming joint configuration is set to maximum velocity, the movement to reach this incoming joint configuration > will be executed with maximum speed regardless of safety zones and mechanical limits. * @summary Stream Joint Configuration * @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 {ExternalJointStreamRequest} externalJointStreamRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ externalJointsStream(cell: string, controller: string, externalJointStreamRequest: ExternalJointStreamRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Get the cycle time of controller communication in [ms]. * @summary Get Cycle Time * @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} */ getCycleTime(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Get the current virtual controller behavior. See [setVirtualControllerBehavior](#/operations/setVirtualControllerBehavior) and the body for details. * @summary Get Behavior * @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} */ getVirtualControllerBehavior(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Set virtual controller behavior. See query parameters for details. * @summary Set Behavior * @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 {Behavior} [behavior] * @param {*} [options] Override http request option. * @throws {RequiredError} */ setVirtualControllerBehavior(cell: string, controller: string, behavior?: Behavior, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; }; /** * VirtualControllerBehaviorApi - factory interface */ declare const VirtualControllerBehaviorApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => { /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ > Websocket endpoint Sends the **commanded** state, e.g., joint positions, velocities, accelerations, torques, for each motion group of the virtual controller and sets the joint configuration. Use [planTrajectory](#/operations/planTrajectory) and [executeTrajectory](#/operations/executeTrajectory) to move motion groups on virtual controllers. Learn more about the [movement behavior of virtual controllers in comparison to physical controllers](#/operations/executeTrajectory#movement-behavior). > **NOTE** > > Incoming joint configurations are not visualized and their velocity limits are not checked. #### Use cases 1. Creating a robotic application that dynamically adapts to the configured joints on the robot controller, using this stream to feed new joint configurations back to the motion groups.\\ The stream only sends data to the robot controller if a motion is executed.\\ If the robot controller\'s joint configuration differs too much from the incoming joint configuration, a following error occurs. Joint configurations that result in following errors are executed only for motions with a low velocity. 2. Mimic freedrive motions. > **DANGER** > > If the incoming joint configuration is set to maximum velocity, the movement to reach this incoming joint configuration > will be executed with maximum speed regardless of safety zones and mechanical limits. * @summary Stream Joint Configuration * @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 {ExternalJointStreamRequest} externalJointStreamRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ externalJointsStream(cell: string, controller: string, externalJointStreamRequest: ExternalJointStreamRequest, options?: RawAxiosRequestConfig): AxiosPromise>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Get the cycle time of controller communication in [ms]. * @summary Get Cycle Time * @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} */ getCycleTime(cell: string, controller: string, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Get the current virtual controller behavior. See [setVirtualControllerBehavior](#/operations/setVirtualControllerBehavior) and the body for details. * @summary Get Behavior * @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} */ getVirtualControllerBehavior(cell: string, controller: string, options?: RawAxiosRequestConfig): AxiosPromise; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Set virtual controller behavior. See query parameters for details. * @summary Set Behavior * @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 {Behavior} [behavior] * @param {*} [options] Override http request option. * @throws {RequiredError} */ setVirtualControllerBehavior(cell: string, controller: string, behavior?: Behavior, options?: RawAxiosRequestConfig): AxiosPromise; }; /** * VirtualControllerBehaviorApi - object-oriented interface */ declare class VirtualControllerBehaviorApi extends BaseAPI { /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ > Websocket endpoint Sends the **commanded** state, e.g., joint positions, velocities, accelerations, torques, for each motion group of the virtual controller and sets the joint configuration. Use [planTrajectory](#/operations/planTrajectory) and [executeTrajectory](#/operations/executeTrajectory) to move motion groups on virtual controllers. Learn more about the [movement behavior of virtual controllers in comparison to physical controllers](#/operations/executeTrajectory#movement-behavior). > **NOTE** > > Incoming joint configurations are not visualized and their velocity limits are not checked. #### Use cases 1. Creating a robotic application that dynamically adapts to the configured joints on the robot controller, using this stream to feed new joint configurations back to the motion groups.\\ The stream only sends data to the robot controller if a motion is executed.\\ If the robot controller\'s joint configuration differs too much from the incoming joint configuration, a following error occurs. Joint configurations that result in following errors are executed only for motions with a low velocity. 2. Mimic freedrive motions. > **DANGER** > > If the incoming joint configuration is set to maximum velocity, the movement to reach this incoming joint configuration > will be executed with maximum speed regardless of safety zones and mechanical limits. * @summary Stream Joint Configuration * @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 {ExternalJointStreamRequest} externalJointStreamRequest * @param {*} [options] Override http request option. * @throws {RequiredError} */ externalJointsStream(cell: string, controller: string, externalJointStreamRequest: ExternalJointStreamRequest, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Get the cycle time of controller communication in [ms]. * @summary Get Cycle Time * @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} */ getCycleTime(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Get the current virtual controller behavior. See [setVirtualControllerBehavior](#/operations/setVirtualControllerBehavior) and the body for details. * @summary Get Behavior * @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} */ getVirtualControllerBehavior(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Set virtual controller behavior. See query parameters for details. * @summary Set Behavior * @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 {Behavior} [behavior] * @param {*} [options] Override http request option. * @throws {RequiredError} */ setVirtualControllerBehavior(cell: string, controller: string, behavior?: Behavior, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; } /** * VirtualControllerInputsOutputsApi - axios parameter creator */ declare const VirtualControllerInputsOutputsApiAxiosParamCreator: (configuration?: Configuration) => { /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Retrieves the current values of inputs/outputs of the virtual controller. The identifiers of inputs/outputs must be provided in the request. Request all available input/output identifiers via [listVirtualControllerIODescriptions](#/operations/listVirtualControllerIODescriptions). * @summary Get Input/Output Values * @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 {Array} ios * @param {*} [options] Override http request option. * @throws {RequiredError} */ listIOs: (cell: string, controller: string, ios: Array, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Lists the input/output descriptions of the virtual robot controller. The input/output descriptions contain information like name, type and unit.\\ Available inputs/outputs are defined by the virtual robot controller.\\ Each input/output has a unique identifier. - If no identifiers and no filters are specified in the request, all available inputs/outputs are retrieved by this endpoint. - If a filter, e.g., `direction`, `value_type`, `group` is applied, only matching inputs/outputs are returned. * @summary List Descriptions * @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 {Array} [ios] * @param {IODirection} [direction] Return only inputs/outputs with the specified direction. * @param {IOValueType} [valueType] Return only inputs/outputs with the specified value type. * @param {string} [group] Return only inputs/outputs from the specified group. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listVirtualControllerIODescriptions: (cell: string, controller: string, ios?: Array, direction?: IODirection, valueType?: IOValueType, group?: string, options?: RawAxiosRequestConfig) => Promise; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Sets a list of values of a virtual controller inputs/outputs. * @summary Set Input/Ouput Values * @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 {Array} iOValue * @param {*} [options] Override http request option. * @throws {RequiredError} */ setIOValues: (cell: string, controller: string, iOValue: Array, options?: RawAxiosRequestConfig) => Promise; }; /** * VirtualControllerInputsOutputsApi - functional programming interface */ declare const VirtualControllerInputsOutputsApiFp: (configuration?: Configuration) => { /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Retrieves the current values of inputs/outputs of the virtual controller. The identifiers of inputs/outputs must be provided in the request. Request all available input/output identifiers via [listVirtualControllerIODescriptions](#/operations/listVirtualControllerIODescriptions). * @summary Get Input/Output Values * @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 {Array} ios * @param {*} [options] Override http request option. * @throws {RequiredError} */ listIOs(cell: string, controller: string, ios: Array, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Lists the input/output descriptions of the virtual robot controller. The input/output descriptions contain information like name, type and unit.\\ Available inputs/outputs are defined by the virtual robot controller.\\ Each input/output has a unique identifier. - If no identifiers and no filters are specified in the request, all available inputs/outputs are retrieved by this endpoint. - If a filter, e.g., `direction`, `value_type`, `group` is applied, only matching inputs/outputs are returned. * @summary List Descriptions * @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 {Array} [ios] * @param {IODirection} [direction] Return only inputs/outputs with the specified direction. * @param {IOValueType} [valueType] Return only inputs/outputs with the specified value type. * @param {string} [group] Return only inputs/outputs from the specified group. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listVirtualControllerIODescriptions(cell: string, controller: string, ios?: Array, direction?: IODirection, valueType?: IOValueType, group?: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Sets a list of values of a virtual controller inputs/outputs. * @summary Set Input/Ouput Values * @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 {Array} iOValue * @param {*} [options] Override http request option. * @throws {RequiredError} */ setIOValues(cell: string, controller: string, iOValue: Array, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise>; }; /** * VirtualControllerInputsOutputsApi - factory interface */ declare const VirtualControllerInputsOutputsApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => { /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Retrieves the current values of inputs/outputs of the virtual controller. The identifiers of inputs/outputs must be provided in the request. Request all available input/output identifiers via [listVirtualControllerIODescriptions](#/operations/listVirtualControllerIODescriptions). * @summary Get Input/Output Values * @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 {Array} ios * @param {*} [options] Override http request option. * @throws {RequiredError} */ listIOs(cell: string, controller: string, ios: Array, options?: RawAxiosRequestConfig): AxiosPromise>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Lists the input/output descriptions of the virtual robot controller. The input/output descriptions contain information like name, type and unit.\\ Available inputs/outputs are defined by the virtual robot controller.\\ Each input/output has a unique identifier. - If no identifiers and no filters are specified in the request, all available inputs/outputs are retrieved by this endpoint. - If a filter, e.g., `direction`, `value_type`, `group` is applied, only matching inputs/outputs are returned. * @summary List Descriptions * @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 {Array} [ios] * @param {IODirection} [direction] Return only inputs/outputs with the specified direction. * @param {IOValueType} [valueType] Return only inputs/outputs with the specified value type. * @param {string} [group] Return only inputs/outputs from the specified group. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listVirtualControllerIODescriptions(cell: string, controller: string, ios?: Array, direction?: IODirection, valueType?: IOValueType, group?: string, options?: RawAxiosRequestConfig): AxiosPromise>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Sets a list of values of a virtual controller inputs/outputs. * @summary Set Input/Ouput Values * @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 {Array} iOValue * @param {*} [options] Override http request option. * @throws {RequiredError} */ setIOValues(cell: string, controller: string, iOValue: Array, options?: RawAxiosRequestConfig): AxiosPromise; }; /** * VirtualControllerInputsOutputsApi - object-oriented interface */ declare class VirtualControllerInputsOutputsApi extends BaseAPI { /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Retrieves the current values of inputs/outputs of the virtual controller. The identifiers of inputs/outputs must be provided in the request. Request all available input/output identifiers via [listVirtualControllerIODescriptions](#/operations/listVirtualControllerIODescriptions). * @summary Get Input/Output Values * @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 {Array} ios * @param {*} [options] Override http request option. * @throws {RequiredError} */ listIOs(cell: string, controller: string, ios: Array, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Lists the input/output descriptions of the virtual robot controller. The input/output descriptions contain information like name, type and unit.\\ Available inputs/outputs are defined by the virtual robot controller.\\ Each input/output has a unique identifier. - If no identifiers and no filters are specified in the request, all available inputs/outputs are retrieved by this endpoint. - If a filter, e.g., `direction`, `value_type`, `group` is applied, only matching inputs/outputs are returned. * @summary List Descriptions * @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 {Array} [ios] * @param {IODirection} [direction] Return only inputs/outputs with the specified direction. * @param {IOValueType} [valueType] Return only inputs/outputs with the specified value type. * @param {string} [group] Return only inputs/outputs from the specified group. * @param {*} [options] Override http request option. * @throws {RequiredError} */ listVirtualControllerIODescriptions(cell: string, controller: string, ios?: Array, direction?: IODirection, valueType?: IOValueType, group?: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; /** * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___ Sets a list of values of a virtual controller inputs/outputs. * @summary Set Input/Ouput Values * @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 {Array} iOValue * @param {*} [options] Override http request option. * @throws {RequiredError} */ setIOValues(cell: string, controller: string, iOValue: Array, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse>; } //#endregion export { AbbConfdata, AbbConfiguredPose, AbbController, AbbControllerEgmServer, AbbControllerKindEnum, AbbPose, ActivateLicenseRequest, AddTrajectoryError, AddTrajectoryErrorData, AddTrajectoryRequest, AddTrajectoryResponse, AddVirtualControllerMotionGroupRequest, ApiVersion, App, ApplicationApi, ApplicationApiAxiosParamCreator, ApplicationApiFactory, ApplicationApiFp, AxisRange, BASE_PATH, BUSInputsOutputsApi, BUSInputsOutputsApiAxiosParamCreator, BUSInputsOutputsApiFactory, BUSInputsOutputsApiFp, BaseAPI, Behavior, BlendingAuto, BlendingAutoBlendingNameEnum, BlendingPosition, BlendingPositionBlendingNameEnum, BlendingSpace, BooleanValue, BooleanValueValueTypeEnum, Box, BoxBoxTypeEnum, BoxShapeTypeEnum, BusIODescription, BusIOModbusClient, BusIOModbusClientBusTypeEnum, BusIOModbusServer, BusIOModbusServerBusTypeEnum, BusIOModbusTCPClient, BusIOModbusTCPClientNetworkTypeEnum, BusIOModbusTCPServer, BusIOModbusTCPServerNetworkTypeEnum, BusIOModbusVirtual, BusIOModbusVirtualBusTypeEnum, BusIOProfinet, BusIOProfinetBusTypeEnum, BusIOProfinetDefaultRoute, BusIOProfinetIpConfig, BusIOProfinetNetwork, BusIOProfinetSlot, BusIOProfinetVirtual, BusIOProfinetVirtualBusTypeEnum, BusIOSnap7, BusIOSnap7BusTypeEnum, BusIOType, BusIOsState, BusIOsStateEnum, COLLECTION_FORMATS, CapabilityEntry, Capsule, CapsuleShapeTypeEnum, CartesianLimits, Cell, CellApi, CellApiAxiosParamCreator, CellApiFactory, CellApiFp, CloudConfigStatus, CloudConfigStatusConfigured, CloudConfigStatusConfiguredStatusEnum, CloudConfigStatusNotConfigured, CloudConfigStatusNotConfiguredStatusEnum, CloudConfiguration, CloudConnectionError, CloudConnectionErrorError, CloudConnectionErrorInvalidToken, CloudConnectionErrorInvalidTokenCodeEnum, CloudConnectionErrorInvalidTokenDetails, CloudConnectionErrorInvalidTokenDetailsCloudResponse, CloudConnectionErrorLeafnodeConnectionError, CloudConnectionErrorLeafnodeConnectionErrorCodeEnum, CloudConnectionErrorLeafnodeConnectionErrorDetails, CloudConnectionErrorLeafnodeConnectionTimeout, CloudConnectionErrorLeafnodeConnectionTimeoutCodeEnum, CloudConnectionErrorLeafnodeRestartTimeout, CloudConnectionErrorLeafnodeRestartTimeoutCodeEnum, CloudConnectionErrorNatsFailed, CloudConnectionErrorNatsFailedCodeEnum, CloudConnectionErrorNatsFailedDetails, CloudConnectionErrorUnexpectedResponse, CloudConnectionErrorUnexpectedResponseCodeEnum, CloudConnectionErrorUnexpectedResponseDetails, CloudConnectionErrorUnexpectedResponseDetailsCloudResponse, CloudConnectionRequest, CloudDisconnectionError, CloudDisconnectionStatusDisconnected, CloudDisconnectionStatusDisconnectedStatusEnum, CloudDisconnectionStatusDisconnecting, CloudDisconnectionStatusDisconnectingStatusEnum, CloudRegistrationSuccessResponse, Collider, ColliderShape, ColliderValue, ColliderValueOrKey, ColliderValueSourceEnum, Collision, CollisionContact, CollisionError, CollisionErrorKindEnum, CollisionFreeAlgorithm, CollisionMotionGroup, CollisionSetup, CollisionSetupValue, CollisionSetupValueOrKey, CollisionSetupValueSourceEnum, Comparator, Configuration, ConfigurationArchiveStatus, ConfigurationArchiveStatusCreating, ConfigurationArchiveStatusCreatingStatusEnum, ConfigurationArchiveStatusError, ConfigurationArchiveStatusErrorStatusEnum, ConfigurationArchiveStatusSuccess, ConfigurationArchiveStatusSuccessStatusEnum, ConfigurationParameters, ConfigurationResource, ConfiguredPose, ConfiguredPoseInverse422Response, ConfiguredPoseInverseFailedResponse, ConfiguredPoseInverseRequest, ConfiguredPoseInverseResponse, ConfiguredPoseInverseResponseResponse, ConstrainedPose, ContainerEnvironmentInner, ContainerImage, ContainerImageSecretsInner, ContainerResources, ContainerStorage, ControllerApi, ControllerApiAxiosParamCreator, ControllerApiFactory, ControllerApiFp, ControllerDescription, ControllerInputsOutputsApi, ControllerInputsOutputsApiAxiosParamCreator, ControllerInputsOutputsApiFactory, ControllerInputsOutputsApiFp, ConvertVendorConfiguredPose422Response, ConvertVendorConfiguredPoseRequest, ConvertVendorConfiguredPoseRequestVendorConfiguredPoses, ConvexHull, ConvexHullShapeTypeEnum, CoordinateSystem, CoordinateSystemData, CopyMotionGroupModelRequest, CubicSplineParameter, CycleTime, Cylinder, CylinderShapeTypeEnum, DHParameter, Direction, DirectionConstraint, DirectionConstraintConstraintNameEnum, DynamicModel, ErrorDirectionConstraintNotMet, ErrorDirectionConstraintNotMetErrorFeedbackNameEnum, ErrorDirectionConstraintNotNormalized, ErrorDirectionConstraintNotNormalizedErrorFeedbackNameEnum, ErrorInvalidJointCount, ErrorInvalidJointCountErrorFeedbackNameEnum, ErrorJointLimitExceeded, ErrorJointLimitExceededErrorFeedbackNameEnum, ErrorJointPositionCollision, ErrorJointPositionCollisionErrorFeedbackNameEnum, ErrorMaxIterationsExceeded, ErrorMaxIterationsExceededErrorFeedbackNameEnum, ErrorMotionGroupKeyMismatch, ErrorUnsupportedOperation, ErrorUnsupportedOperationErrorFeedbackNameEnum, Execute, ExecuteDetails, ExecuteJoggingRequest, ExecuteJoggingResponse, ExecuteTrajectoryRequest, ExecuteTrajectoryResponse, ExecuteWaypointJoggingRequest, ExecuteWaypointJoggingResponse, ExternalJointStreamDatapoint, ExternalJointStreamRequest, FanucController, FanucControllerKindEnum, FeedbackAxisRangeExceeded, FeedbackAxisRangeExceededErrorFeedbackNameEnum, FeedbackCollision, FeedbackCollisionErrorFeedbackNameEnum, FeedbackCommandsMissing, FeedbackCommandsMissingErrorFeedbackNameEnum, FeedbackCubicSplineIsNotIncreasing, FeedbackCubicSplineIsNotIncreasingErrorFeedbackNameEnum, FeedbackCubicSplineNotAtStartPose, FeedbackCubicSplineNotAtStartPoseErrorFeedbackNameEnum, FeedbackDirectionConstraintNoSolutionExists, FeedbackDirectionConstraintNoSolutionExistsErrorFeedbackNameEnum, FeedbackDirectionConstraintNotMet, FeedbackDirectionConstraintNotMetErrorFeedbackNameEnum, FeedbackDirectionConstraintNotNormalized, FeedbackDirectionConstraintNotNormalizedErrorFeedbackNameEnum, FeedbackInvalidDof, FeedbackInvalidDofErrorFeedbackNameEnum, FeedbackInvalidNanValue, FeedbackInvalidNanValueErrorFeedbackNameEnum, FeedbackInvalidSamplingTime, FeedbackInvalidSamplingTimeErrorFeedbackNameEnum, FeedbackJointLimitExceeded, FeedbackJointLimitExceededErrorFeedbackNameEnum, FeedbackNoSolutionInCurrentConfiguration, FeedbackNoSolutionInCurrentConfigurationErrorFeedbackNameEnum, FeedbackOutOfWorkspace, FeedbackOutOfWorkspaceErrorFeedbackNameEnum, FeedbackSingularity, FeedbackSingularityErrorFeedbackNameEnum, FeedbackStartJointsMissing, FeedbackStartJointsMissingErrorFeedbackNameEnum, FeedbackTorqueExceeded, FeedbackTorqueExceededErrorFeedbackNameEnum, Flag, FlangePayload, FloatValue, FloatValueValueTypeEnum, ForwardKinematics422Response, ForwardKinematicsRequest, ForwardKinematicsResponse, ForwardKinematicsValidationError, GetTrajectoryResponse, HTTPValidationError, IOBooleanValue, IOBooleanValueValueTypeEnum, IOBoundary, IODescription, IODirection, IOFloatValue, IOFloatValueValueTypeEnum, IOIntegerValue, IOIntegerValueValueTypeEnum, IOOrigin, IOValue, IOValueType, ImageCredentials, InconsistentTrajectorySizeError, InconsistentTrajectorySizeErrorInconsistentTrajectorySize, InconsistentTrajectorySizeErrorKindEnum, InertiaTensor, InitializeJoggingRequest, InitializeJoggingRequestMessageTypeEnum, InitializeJoggingResponse, InitializeJoggingResponseKindEnum, InitializeMovementRequest, InitializeMovementRequestMessageTypeEnum, InitializeMovementRequestTrajectory, InitializeMovementResponse, InitializeMovementResponseKindEnum, IntegerValue, IntegerValueValueTypeEnum, InvalidDofError, InvalidDofErrorInvalidDof, InvalidDofErrorKindEnum, InverseFeedbackAtIndex, InverseFeedbackAtIndexErrorFeedback, InverseKinematics422Response, InverseKinematicsRequest, InverseKinematicsResponse, InverseKinematicsValidationError, InverseKinematicsValidationErrorAllOfData, JoggingApi, JoggingApiAxiosParamCreator, JoggingApiFactory, JoggingApiFp, JoggingDetails, JoggingDetailsKindEnum, JoggingDetailsState, JoggingPausedByUser, JoggingPausedByUserKindEnum, JoggingPausedNearCollision, JoggingPausedNearCollisionKindEnum, JoggingPausedNearJointLimit, JoggingPausedNearJointLimitKindEnum, JoggingPausedNearSingularity, JoggingPausedNearSingularityKindEnum, JoggingPausedOnIO, JoggingPausedOnIOKindEnum, JoggingRunning, JoggingRunningKindEnum, JointLimitExceededError, JointLimitExceededErrorKindEnum, JointLimits, JointPTPMotion, JointTrajectory, JointTypeEnum, JointVelocityRequest, JointVelocityRequestMessageTypeEnum, JointVelocityResponse, JointVelocityResponseKindEnum, JointWaypoint, JointWaypointsRequest, JointWaypointsRequestMessageTypeEnum, JointWaypointsResponse, JointWaypointsResponseKindEnum, KinematicBranch, KinematicBranchElbow, KinematicBranchShoulder, KinematicBranchWrist, KinematicConfiguration, KinematicModel, KinematicsApi, KinematicsApiAxiosParamCreator, KinematicsApiFactory, KinematicsApiFp, KukaConfiguredPose, KukaController, KukaControllerKindEnum, KukaControllerRsiServer, KukaPose, KukaStatusAndTurnBits, License, LicenseApi, LicenseApiAxiosParamCreator, LicenseApiFactory, LicenseApiFp, LicenseStatus, LicenseStatusEnum, LimitRange, LimitSet, LimitsOverride, LinkChainValue, LinkChainValueOrKey, LinkChainValueSourceEnum, ListTrajectoriesResponse, Manufacturer, MergeTrajectories422Response, MergeTrajectoriesError, MergeTrajectoriesErrorErrorFeedback, MergeTrajectoriesRequest, MergeTrajectoriesResponse, MergeTrajectoriesResponseFeedbackInner, MergeTrajectoriesSegment, MergeTrajectoriesValidationError, MidpointInsertionAlgorithm, MidpointInsertionAlgorithmAlgorithmNameEnum, ModbusIO, ModbusIOArea, ModbusIOByteOrder, ModbusIOData, ModbusIOTypeEnum, ModelError, MotionCommand, MotionCommandBlending, MotionCommandPath, MotionGroupApi, MotionGroupApiAxiosParamCreator, MotionGroupApiFactory, MotionGroupApiFp, MotionGroupDescription, MotionGroupFromJson, MotionGroupFromType, MotionGroupInfo, MotionGroupJoints, MotionGroupModelDescription, MotionGroupModelsApi, MotionGroupModelsApiAxiosParamCreator, MotionGroupModelsApiFactory, MotionGroupModelsApiFp, MotionGroupSetup, MotionGroupState, MotionGroupStateJointLimitReached, MovementErrorResponse, MovementErrorResponseKindEnum, MultiCollisionSetup, MultiErrorInvalidJointCount, MultiErrorJointLimitExceeded, MultiErrorJointPositionCollision, MultiJointTrajectory, MultiSearchCollisionFree422Response, MultiSearchCollisionFreeRequest, MultiSearchCollisionFreeResponse, MultiSearchCollisionFreeResponseResponse, MultiSearchCollisionFreeValidationError, MultiSearchCollisionFreeValidationErrorAllOfData, NOVACloudApi, NOVACloudApiAxiosParamCreator, NOVACloudApiFactory, NOVACloudApiFp, NanValueError, NanValueErrorKindEnum, NanValueErrorNanValue, NetworkDevice, NetworkInterface, NetworkState, NetworkStateConnectionTypeEnum, OpMode, OperatingState, OperationLimits, OperationMode, OrientationType, PathCartesianPTP, PathCartesianPTPPathDefinitionNameEnum, PathCircle, PathCirclePathDefinitionNameEnum, PathCubicSpline, PathCubicSplinePathDefinitionNameEnum, PathDirectionConstrainedCartesianPTP, PathDirectionConstrainedCartesianPTPPathDefinitionNameEnum, PathDirectionConstrainedJointPTP, PathDirectionConstrainedJointPTPPathDefinitionNameEnum, PathJointPTP, PathJointPTPPathDefinitionNameEnum, PathLine, PathLinePathDefinitionNameEnum, PauseJoggingRequest, PauseJoggingRequestMessageTypeEnum, PauseJoggingResponse, PauseJoggingResponseKindEnum, PauseMovementRequest, PauseMovementRequestMessageTypeEnum, PauseMovementResponse, PauseMovementResponseKindEnum, PauseOnIO, Payload, Plan422Response, PlanCollisionFreeFailedResponse, PlanCollisionFreeRequest, PlanCollisionFreeResponse, PlanCollisionFreeResponseResponse, PlanTrajectoryFailedResponse, PlanTrajectoryFailedResponseErrorFeedback, PlanTrajectoryRequest, PlanTrajectoryResponse, PlanTrajectoryResponseResponse, PlanValidationError, PlanValidationErrorAllOfData, Plane, PlaneShapeTypeEnum, PlaybackSpeedRequest, PlaybackSpeedRequestMessageTypeEnum, PlaybackSpeedResponse, PlaybackSpeedResponseKindEnum, Pose, PoseWaypoint, PoseWaypointsRequest, PoseWaypointsRequestMessageTypeEnum, PoseWaypointsResponse, PoseWaypointsResponseKindEnum, ProfinetDescription, ProfinetIO, ProfinetIOData, ProfinetIODirection, ProfinetIOTypeEnum, ProfinetInputOutputConfig, ProfinetSlotDescription, ProfinetSubSlotDescription, Program, ProgramApi, ProgramApiAxiosParamCreator, ProgramApiFactory, ProgramApiFp, ProgramRun, ProgramRunState, ProgramStartRequest, ProjectJointPositionDirectionConstraint422Response, ProjectJointPositionDirectionConstraintRequest, ProjectJointPositionDirectionConstraintResponse, ProjectJointPositionDirectionConstraintValidationError, ProjectJointPositionDirectionConstraintValidationErrorAllOfData, RRTConnectAlgorithm, RRTConnectAlgorithmAlgorithmNameEnum, RRTConnectAlgorithmStepSize, Range, Rectangle, RectangleShapeTypeEnum, RectangularCapsule, RectangularCapsuleShapeTypeEnum, ReleaseChannel, RequestArgs, RequiredError, RobotConfigurationsApi, RobotConfigurationsApiAxiosParamCreator, RobotConfigurationsApiFactory, RobotConfigurationsApiFp, RobotController, RobotControllerConfiguration, RobotControllerConfigurationRequest, RobotControllerState, RobotSystemMode, RobotTcp, RobotTcpData, SafetyGeometry, SafetyGeometryBox, SafetyGeometryCapsule, SafetyGeometryLozenge, SafetyGeometryPlane, SafetyGeometryPrism, SafetyGeometrySphere, SafetyStateType, SafetyZone, SafetyZonePose, SafetyZones, ServiceGroup, ServiceStatus, ServiceStatusPhase, ServiceStatusResponse, ServiceStatusSeverity, ServiceStatusStatus, SessionApi, SessionApiAxiosParamCreator, SessionApiFactory, SessionApiFp, SessionResponse, SetIO, SettableRobotSystemMode, SingularityTypeEnum, Snap7IO, Snap7IOArea, Snap7IOData, Snap7IODirection, Snap7IOTypeEnum, Sphere, SphereShapeTypeEnum, StartMovementRequest, StartMovementRequestMessageTypeEnum, StartMovementResponse, StartMovementResponseKindEnum, StartOnIO, StorageKey, StorageKeySourceEnum, StoreCollisionComponentsApi, StoreCollisionComponentsApiAxiosParamCreator, StoreCollisionComponentsApiFactory, StoreCollisionComponentsApiFp, StoreCollisionSetupsApi, StoreCollisionSetupsApiAxiosParamCreator, StoreCollisionSetupsApiFactory, StoreCollisionSetupsApiFp, StoreObjectApi, StoreObjectApiAxiosParamCreator, StoreObjectApiFactory, StoreObjectApiFp, StreamIOValuesResponse, SystemApi, SystemApiAxiosParamCreator, SystemApiFactory, SystemApiFp, TcpOffset, TcpRequiredError, TcpRequiredErrorKindEnum, TcpVelocityRequest, TcpVelocityRequestMessageTypeEnum, TcpVelocityResponse, TcpVelocityResponseKindEnum, ToolValue, ToolValueOrKey, ToolValueSourceEnum, TorqueExceededError, TorqueExceededErrorKindEnum, TorqueExceededErrorTorqueExceeded, TrajectoryCachingApi, TrajectoryCachingApiAxiosParamCreator, TrajectoryCachingApiFactory, TrajectoryCachingApiFp, TrajectoryData, TrajectoryDataMessageTypeEnum, TrajectoryDetails, TrajectoryDetailsKindEnum, TrajectoryDetailsState, TrajectoryEnded, TrajectoryEndedKindEnum, TrajectoryExecutionApi, TrajectoryExecutionApiAxiosParamCreator, TrajectoryExecutionApiFactory, TrajectoryExecutionApiFp, TrajectoryId, TrajectoryIdMessageTypeEnum, TrajectoryPausedByUser, TrajectoryPausedByUserKindEnum, TrajectoryPausedOnIO, TrajectoryPausedOnIOKindEnum, TrajectoryPlanningApi, TrajectoryPlanningApiAxiosParamCreator, TrajectoryPlanningApiFactory, TrajectoryPlanningApiFp, TrajectoryRunning, TrajectoryRunningKindEnum, TrajectorySection, TrajectoryWaitForIO, TrajectoryWaitForIOKindEnum, UnitType, UniversalrobotsController, UniversalrobotsControllerKindEnum, UpdateCellVersionRequest, UpdateNovaVersionRequest, User, ValidationError, ValidationError2, ValidationErrorLocInner, VersionApi, VersionApiAxiosParamCreator, VersionApiFactory, VersionApiFp, VirtualController, VirtualControllerApi, VirtualControllerApiAxiosParamCreator, VirtualControllerApiFactory, VirtualControllerApiFp, VirtualControllerBehaviorApi, VirtualControllerBehaviorApiAxiosParamCreator, VirtualControllerBehaviorApiFactory, VirtualControllerBehaviorApiFp, VirtualControllerInputsOutputsApi, VirtualControllerInputsOutputsApiAxiosParamCreator, VirtualControllerInputsOutputsApiFactory, VirtualControllerInputsOutputsApiFp, VirtualControllerKindEnum, VirtualRobotConfiguration, WaitForIOEventRequest, YaskawaController, YaskawaControllerKindEnum, ZodValidationError, ZodValidationErrorError, ZodValidationErrorErrorCodeEnum, ZodValidationErrorErrorDetailsInner, ZodValidationErrorErrorDetailsInnerPathInner, operationServerMap };