import * as _$axios from "axios";
import { AxiosInstance, AxiosPromise, RawAxiosRequestConfig } from "axios";

//#region v1/configuration.d.ts
/**
 * Wandelbots NOVA API
 * Interact with robots in an easy and intuitive way.
 *
 * The version of the OpenAPI document: 1.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<string> | ((name: string) => string) | ((name: string) => Promise<string>);
  username?: string;
  password?: string;
  accessToken?: string | Promise<string> | ((name?: string, scopes?: string[]) => string) | ((name?: string, scopes?: string[]) => Promise<string>);
  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<string> | ((name: string) => string) | ((name: string) => Promise<string>);
  /**
   * 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<string> | ((name?: string, scopes?: string[]) => string) | ((name?: string, scopes?: string[]) => Promise<string>);
  /**
   * 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 v1/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 v1/api.d.ts
/**
 * 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;
  'controllerIp': string;
  /**
   * Default values: 80, 443. If custom value is set, field is required.
   */
  'controllerPort': number;
  'egmServer': 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 \'controllerIp\'
 */
interface AbbControllerEgmServer {
  'ip': string;
  'port': number;
}
/**
 * The authentication token to fetch the license from the license server.
 */
interface ActivateLicenseRequest {
  'owner_refresh_token': string;
}
/**
 * This message is used to add a coordinate system with a pose including a position offset in [mm] and a rotational offset in rotation vector notation.
 */
interface AddRequest {
  'offset': Pose;
  /**
   * Human readable name of this coordinate system, e.g. to simplify recognition.
   */
  'name'?: string;
}
/**
 * Request to calculate the joint positions of a motion group in order to move its TCP to a specific pose (Inverse Kinematic Solutions).
 */
interface AllJointPositionsRequest {
  /**
   * Identifier of the motion-group.
   */
  'motion_group': string;
  'tcp_pose': TcpPose;
}
/**
 * A list of Joint Positions. If any of them is applied to the motion-group, its TCP will be at the specified pose.
 */
interface AllJointPositionsResponse {
  /**
   * Joint position in [rad].
   */
  'joint_positions'?: Array<Joints>;
}
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/$appIcon).
   */
  'appIcon': string;
  'containerImage': 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<ContainerEnvironmentInner>;
  'storage'?: ContainerStorage;
  'resources'?: ContainerResources;
}
interface ArrayInput {
  'array': Array<CollectionValue>;
}
interface ArrayOutput {
  'array': Array<ResponseGetValuesProgramsValuesGetValue>;
}
/**
 * ## BEHAVIOR_AUTOMATIC This is the default behavior. The motion group instantly takes any 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. It changes the TCP path around the target point of the motion command. The value represents the percentage of the original velocity.
   */
  '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;
  'blending_name': BlendingPositionBlendingNameEnum;
}
declare const BlendingPositionBlendingNameEnum: {
  readonly BlendingPosition: "BlendingPosition";
};
type BlendingPositionBlendingNameEnum = typeof BlendingPositionBlendingNameEnum[keyof typeof BlendingPositionBlendingNameEnum];
/**
 * Defines a cuboid shape centered around an origin.
 */
interface Box {
  /**
   * 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 type defines if the box is hollow or not.
   */
  'type': BoxTypeEnum;
}
declare const BoxTypeEnum: {
  readonly TypeHollow: "TYPE_HOLLOW";
  readonly TypeFull: "TYPE_FULL";
};
type BoxTypeEnum = typeof BoxTypeEnum[keyof typeof BoxTypeEnum];
/**
 * 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 Box2 {
  'shape_type': Box2ShapeTypeEnum;
  /**
   * 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': Box2BoxTypeEnum;
}
declare const Box2ShapeTypeEnum: {
  readonly Box: "box";
};
type Box2ShapeTypeEnum = typeof Box2ShapeTypeEnum[keyof typeof Box2ShapeTypeEnum];
declare const Box2BoxTypeEnum: {
  readonly Hollow: "HOLLOW";
  readonly Full: "FULL";
};
type Box2BoxTypeEnum = typeof Box2BoxTypeEnum[keyof typeof Box2BoxTypeEnum];
/**
 * Centered around origin.  If margin is applied to full box, it is added to all sizes (shape still has edges). Hollow box is represented by thin boxes that make up its walls. If margin is applied to hollow box, its sizes are reduced by the margin.
 */
interface Box3 {
  'shape_type': Box3ShapeTypeEnum;
  'size_x': number;
  'size_y': number;
  'size_z': number;
  'type': Box3TypeEnum;
}
declare const Box3ShapeTypeEnum: {
  readonly Box: "box";
};
type Box3ShapeTypeEnum = typeof Box3ShapeTypeEnum[keyof typeof Box3ShapeTypeEnum];
declare const Box3TypeEnum: {
  readonly Hollow: "HOLLOW";
  readonly Full: "FULL";
};
type Box3TypeEnum = typeof Box3TypeEnum[keyof typeof Box3TypeEnum];
/**
 * Defines a cylinder like shape with 2 semi-spheres on top and bottom.
 */
interface Capsule {
  /**
   * The radius of the cylinder and semi-spheres in [mm].
   */
  'radius': number;
  /**
   * The height of the inner cylinder in [mm].
   */
  'cylinder_height': number;
}
/**
 * Defines a cylindrical shape with 2 semi-spheres on the top and bottom. Centred around origin, symmetric around z-axis.
 */
interface Capsule2 {
  'shape_type': Capsule2ShapeTypeEnum;
  /**
   * 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 Capsule2ShapeTypeEnum: {
  readonly Capsule: "capsule";
};
type Capsule2ShapeTypeEnum = typeof Capsule2ShapeTypeEnum[keyof typeof Capsule2ShapeTypeEnum];
/**
 * Centered around origin, symmetric around z-axis.
 */
interface Capsule3 {
  'shape_type': Capsule3ShapeTypeEnum;
  'radius': number;
  'cylinder_height': number;
}
declare const Capsule3ShapeTypeEnum: {
  readonly Capsule: "capsule";
};
type Capsule3ShapeTypeEnum = typeof Capsule3ShapeTypeEnum[keyof typeof Capsule3ShapeTypeEnum];
interface Capture {
  'image': string;
}
/**
 * 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 {
  /**
   * 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;
  'controllers'?: Array<RobotController>;
  'apps'?: Array<App>;
}
interface Circle {
  'via_pose': Pose;
  'target_pose': Pose;
}
interface CodeWithArguments {
  /**
   * Wandelscript code string which describes a Wandelscript Program as content/json.
   */
  'code': string;
  'initial_state'?: {
    [key: string]: CollectionValue;
  } | null;
}
interface CollectionValue {
  'pose': Array<any>;
  'position': Array<any>;
  'orientation': Array<any>;
  'image': string;
  'pointcloud': string;
  'array': Array<CollectionValue>;
}
/**
 * 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'?: Pose2;
  /**
   * Increases the shape\'s size in all dimensions. Applied in [mm]. Can be used to keep a safe distance to the shape.
   */
  'margin'?: number;
}
/**
 * Defines a collider with a single shape.  Pose describes where the shape of the collider is positioned.
 */
interface ColliderInput {
  'shape': ColliderOutputShape;
  'pose': PyjectoryDatatypesCorePose;
  /**
   * Increases the shape\'s size in all dimensions. Applied in [mm]. Can be used to keep a safe distance to the shape.
   */
  'margin'?: number;
}
/**
 * Defines a collider with a single shape.  Pose describes where the shape of the collider is positioned.
 */
interface ColliderOutput {
  'shape': ColliderOutputShape;
  'pose': PyjectoryDatatypesCorePose;
  /**
   * 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 ColliderOutputShape
 */
type ColliderOutputShape = Box3 | Capsule3 | ConvexHull3 | Cylinder3 | Plane3 | Rectangle3 | RectangularCapsule3 | Sphere3;
/**
 * @type ColliderShape
 */
type ColliderShape = {
  shape_type: 'box';
} & Box2 | {
  shape_type: 'capsule';
} & Capsule2 | {
  shape_type: 'convex_hull';
} & ConvexHull2 | {
  shape_type: 'cylinder';
} & Cylinder2 | {
  shape_type: 'plane';
} & Plane2 | {
  shape_type: 'rectangle';
} & Rectangle2 | {
  shape_type: 'rectangular_capsule';
} & RectangularCapsule2 | {
  shape_type: 'sphere';
} & Sphere2;
interface Collision {
  'id_of_a'?: string;
  'id_of_b'?: string;
  'id_of_world'?: string;
  /**
   * Describes a position in 3D space. A three-dimensional vector [x, y, z] with double precision.
   */
  'normal_world_on_b'?: Array<number>;
  'position_on_a'?: CollisionContact;
  'position_on_b'?: CollisionContact;
}
interface CollisionContact {
  /**
   * Describes a position in 3D space. A three-dimensional vector [x, y, z] with double precision.
   */
  'local'?: Array<number>;
  /**
   * Describes a position in 3D space. A three-dimensional vector [x, y, z] with double precision.
   */
  'world'?: Array<number>;
}
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;
  };
}
interface CollisionMotionGroupAssembly {
  /**
   * References a stored link chain.
   */
  'stored_link_chain'?: string;
  /**
   * References a stored tool.
   */
  'stored_tool'?: string;
  /**
   * 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;
  };
}
/**
 * Configuration of a robot in the collision scene.  Default link shapes are provided for all supported robots. Apply `use_default_link_shapes` with `true`.  `link_attachements` are additional shapes that are attached to the link reference frames. The reference frame of the `link_attachements` is obtained after applying all sets of DH-parameters from base to (including) the specified index. Adjacent links in the kinematic chain of the robot are not checked for collision.  The tool is treated like another link attached to the end (flange) of the chain. All tool shapes are described in the flange frame.
 */
interface CollisionRobotConfigurationInput {
  /**
   * If `true`, default shapes are used for all links.
   */
  'use_default_link_shapes': boolean;
  /**
   * Shapes to attach to link reference frames, additionally to default shapes. The keys are integers representing the link indices, and the values are objects mapping shape names to their collider definitions.
   */
  'link_attachements'?: {
    [key: string]: {
      [key: string]: ColliderInput;
    };
  };
  /**
   * Shapes that make up the tool, attached to the flange frame.
   */
  'tool'?: {
    [key: string]: ColliderInput;
  };
}
/**
 * Configuration of a robot in the collision scene.  Default link shapes are provided for all supported robots. Apply `use_default_link_shapes` with `true`.  `link_attachements` are additional shapes that are attached to the link reference frames. The reference frame of the `link_attachements` is obtained after applying all sets of DH-parameters from base to (including) the specified index. Adjacent links in the kinematic chain of the robot are not checked for collision.  The tool is treated like another link attached to the end (flange) of the chain. All tool shapes are described in the flange frame.
 */
interface CollisionRobotConfigurationOutput {
  /**
   * If `true`, default shapes are used for all links.
   */
  'use_default_link_shapes': boolean;
  /**
   * Shapes to attach to link reference frames, additionally to default shapes. The keys are integers representing the link indices, and the values are objects mapping shape names to their collider definitions.
   */
  'link_attachements'?: {
    [key: string]: {
      [key: string]: ColliderOutput;
    };
  };
  /**
   * Shapes that make up the tool, attached to the flange frame.
   */
  'tool'?: {
    [key: string]: ColliderOutput;
  };
}
/**
 * Defines the collision scene.  There are two types of objects in the scene: - `colliders`: Each collider is attached directly to the origin of the scene: Origin >> Collider - `motion-groups`: Each motion group is assigned a kinematic chain of links with a special collider, called tool, attached to the last element.   The motion group is attached to the origin of the scene via its mounting: Origin >> Mounting >> Motion Group Base >> […]
 */
interface CollisionScene {
  /**
   * A collection of identifiable colliders.
   */
  'colliders'?: {
    [key: string]: Collider;
  };
  /**
   * Maps a Wandelbots NOVA motion group to its configuration in the collision scene. Key must be a motion group identifier.  Values are collision motion group objects.  A collision motion group defines a motion group in the collision scene.  The motion group is attached to the origin of the scene. To relocate the motion group, configure its mounting offset on the physical controller. This ensures that the definition of motion commands and collision scenes use the same coordinate system. The kinematic chain looks like this: - Origin >> Mounting >> Base >> Joint 0 >> Link 0 >> Joint 1 >> […] >> TCP  A `tool` is treated like another link attached to the end (flange) of the kinematic chain. All tool colliders are described in the flange frame.
   */
  'motion_groups'?: {
    [key: string]: CollisionMotionGroup;
  };
}
/**
 * Defines the collision scene assembly. Merges all referenced and new scene components into a single scene.  Previously added components with identical identifiers are overwritten within the same group.  There is one group for each of the following components: - Colliders attached to the origin of the scene, - Tool per motion group, and - For each link per motion group.  The scene is assembled by adding components in the following order. 1. stored_scenes 2. scene 3. stored_colliders 4. colliders 5. stored_link_chains and stored_tools (per motion group) 6. link_chains and tools (per motion group)
 */
interface CollisionSceneAssembly {
  /**
   * Add stored scenes to the scene via their identifiers. The scenes are merged based on their order in the array. The scene at index zero serves as base. Following scenes overwrite components with identical identifiers, see [Collision Scene Assembly](Collision Scene Assembly).
   */
  'stored_scenes'?: Array<string>;
  'scene'?: CollisionScene;
  /**
   * Add stored colliders to the scene via their identifiers. The colliders are added to the the origin of the scene.
   */
  'stored_colliders'?: Array<string>;
  /**
   * A collection of identifiable colliders.
   */
  'colliders'?: {
    [key: string]: Collider;
  };
  /**
   * Maps a Wandelbots NOVA motion group to its assembly configuration in the collision scene. Key must be a motion group identifier.  A collision motion group defines a motion group in the collision scene.  The motion group is attached to the origin of the scene. To relocate the motion group, configure its mounting offset on the physical controller. This ensures that the definition of motion commands and collision scenes use the same coordinate system. The kinematic chain looks like this: - Origin >> Mounting >> Base >> Joint 0 >> Link 0 >> Joint 1 >> […] >> TCP  A `tool` is treated like another link attached to the end (flange) of the kinematic chain. All tool colliders are described in the flange frame.
   */
  'motion_groups'?: {
    [key: string]: CollisionMotionGroupAssembly;
  };
}
/**
 * A command is a single motion command (line, circle, joint_ptp, cartesian_ptp, cubic_spline) with corresponding settings (limits, blending). The motion commands are a flattened union/oneof type. Only set one of the motion commands per command. A motion command always starts at the end of the previous motion command. Subsequently, a plan request must have start joint configuration to plan a well defined motion.
 */
interface Command {
  /**
   * Command settings for a single motion command. Allow blending between two motion commands or override limits on a motion command level.
   */
  'settings'?: CommandSettings;
  /**
   * A line is representing a straight line from start position to provided target position. The orientation is calculated via a quaternion [slerp](https://en.wikipedia.org/wiki/Slerp) from start orienation to provided target orientation.
   */
  'line'?: Pose;
  /**
   * A circular constructs a circle in translative space from start position, provided via position, and provided target position. The orientation is calculated via a [bezier spline](https://en.wikipedia.org/wiki/B%C3%A9zier_curve) from start orienation to provided target orientation. The via point defines the control point for the bezier spline. Therefore, the control point will not be hit directly.
   */
  'circle'?: Circle;
  /**
   * A joint point-to-point is representing a line in joint space. All joints will be moved synchronously.
   */
  'joint_ptp'?: Joints;
  /**
   * A cartesian point-to-point is representing a joint point-to-point motion from start point to provided target pose. This is a joint point-to-point as well, but the target is 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.
   */
  'cartesian_ptp'?: Pose;
  /**
   * A [cubic spline](https://de.wikipedia.org/wiki/Spline-Interpolation) is representing a cartesian cubic spline in translative and orientational space from start point to provided target pose via control points.
   */
  'cubic_spline'?: CubicSpline;
}
/**
 * Settings which can be used to modify the behavior in a command-wise manner.
 */
interface CommandSettings {
  /**
   * Auto-blending is used to keep a constant velocity when blending between two motion commands. It changes the TCP path around the target point of a motion command. The value represents the percentage of the original velocity.  What is blending? Blending alters the geometry of 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.
   */
  'auto_blending'?: number;
  /**
   * If auto-blending blends too much of the resulting trajectory, position-blending could be used between two motion commands. Specifies the maximum radius in [mm] around the motion command\'s target point where the geometry of the TCP path is allowed to be changed to blend the current motion command into the next one.
   */
  'position_blending'?: number;
  'limits_override'?: LimitsOverride;
}
/**
 * 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 ComparatorUnknown: "COMPARATOR_UNKNOWN";
  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];
/**
 * Describes a collision shape compounded from multiple collision objects. All objects are described in the compounds reference frame.
 */
interface Compound {
  /**
   * A list of geometries sharing the same reference frame.
   */
  'child_geometries': Array<Geometry>;
}
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 `<registry>/<image>:<tag>`.
   */
  'image': string;
  'credentials'?: ImageCredentials;
  /**
   * Known secrets for authentication with the container registry.
   */
  'secrets'?: Array<ContainerImageSecretsInner>;
}
interface ContainerImageSecretsInner {
  'name': string;
}
/**
 * Additional resources that the application requires.
 */
interface ContainerResources {
  /**
   * Number of GPUs the application requires.
   */
  'intel-gpu'?: number;
}
/**
 * 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 {
  'mountPath': string;
  /**
   * The amount of requested storage capacity.
   */
  'capacity': string;
}
interface ControllerCapabilities {
  /**
   * Can this controller be moved through freedrive (true), or not (false).
   */
  'support_freedrive': boolean;
  /**
   * Can this controller be controlled with NOVA (true) or is it only possible to read data (false).
   */
  'support_control': boolean;
}
/**
 * The data type to describe a robot controller.
 */
interface ControllerInstance {
  /**
   * The unique identifier to address the robot controller in the cell.
   */
  'controller': string;
  /**
   * The unique identifier to address a robot controller model when configuring the robot controller. Used for evaluation of the robot controller model and to ensure communication with the expected robot controller type.
   */
  'model_name': string;
  /**
   * Resolvable host name or IP address that connects to the robot controller.
   */
  'host': string;
  /**
   * True if the user has actively confirmed that it is allowed to install required communication software onto the robot controller.  NOTE: Installing third party software on a robot controller can result in liability issues in regard to the actual certified state of the robot system. Please contact your company\'s legal responsible before installing third party software.
   */
  'allow_software_install_on_controller': boolean;
  /**
   * The list of physical connected motion groups as detected by the controller.
   */
  'physical_motion_groups': Array<MotionGroupPhysical>;
  'vendor_software_version'?: VersionNumber;
  /**
   * Set to true if there was an error while inspecting this instance, e.g. The robot controller is not reachable due to missing network connection or turned off.  The instance remains configured but can\'t provide information on the robot controller.
   */
  'has_error': boolean;
  /**
   * If has_error is true, error_details provides detailed background information about the error.
   */
  'error_details'?: string;
}
/**
 * The list of configured robot controllers.
 */
interface ControllerInstanceList {
  'instances': Array<ControllerInstance>;
}
/**
 * Defines a convex hull encapsulating a set of vertices.
 */
interface ConvexHull {
  /**
   * The list of encapsulated points.
   */
  'vertices': Array<Vector3d>;
}
/**
 * Defines a convex hull encapsulating a set of vertices.
 */
interface ConvexHull2 {
  'shape_type': ConvexHull2ShapeTypeEnum;
  /**
   * The list of encapsulated points.
   */
  'vertices': Array<Array<number>>;
}
declare const ConvexHull2ShapeTypeEnum: {
  readonly ConvexHull: "convex_hull";
};
type ConvexHull2ShapeTypeEnum = typeof ConvexHull2ShapeTypeEnum[keyof typeof ConvexHull2ShapeTypeEnum];
/**
 * Convex hull around all vertices.
 */
interface ConvexHull3 {
  'shape_type': ConvexHull3ShapeTypeEnum;
  'vertices': Array<Array<any>>;
}
declare const ConvexHull3ShapeTypeEnum: {
  readonly ConvexHull: "convex_hull";
};
type ConvexHull3ShapeTypeEnum = typeof ConvexHull3ShapeTypeEnum[keyof typeof ConvexHull3ShapeTypeEnum];
interface CoordinateSystem {
  /**
   * Unique identifier of the coordinate system.
   */
  'coordinate_system': string;
  /**
   * Human readable name of this coordinate system.
   */
  'name'?: string;
  /**
   * The identifier of the reference coordinate system. Empty if world is used.
   */
  'reference_uid'?: string;
  'position'?: Vector3d;
  'rotation'?: RotationAngles;
}
interface CoordinateSystems {
  'coordinate_systems': Array<CoordinateSystem>;
}
interface CreateDeviceRequestInner {
  'type'?: any;
  /**
   * A unique identifier for the collision scene.
   */
  'identifier'?: string;
  'host'?: string;
  'port'?: number;
  'prim_paths'?: {
    [key: string]: string;
  };
  'controller_model_name'?: string;
  'motion_group_id'?: string;
  'rae_host'?: string;
  'rae_port'?: number;
  'url'?: string;
  'initial_pose'?: Array<number>;
  /**
   * A collection of static colliders within the scene, identified by their names.
   */
  'static_colliders'?: {
    [key: string]: ColliderInput;
  };
  /**
   * Configurations for robots within the scene. Allow for the specification of collision geometries and other robot-specific settings, identified by robot names.
   */
  'robot_configurations'?: {
    [key: string]: CollisionRobotConfigurationInput;
  };
}
interface CreateProgramRun200Response {
  /**
   * The identifier of the program run for further inspection of the running program.
   */
  'id'?: string;
}
interface CreateProgramRunRequest {
  /**
   * The identifier of the program stored in the program library.
   */
  'program_id': string;
}
interface CreateTrigger200Response {
  /**
   * The identifier of the created trigger.
   */
  'id'?: string;
}
interface CreateTriggerRequest {
  /**
   * The identifier of the program to run when the trigger condition is met.
   */
  'program_id': string;
  /**
   * Indicated whether the trigger is enabled or not.
   */
  'enabled': boolean;
  'type': TriggerType;
  'config'?: OpcuaNodeValueTriggerConfig;
}
interface CubicSpline {
  'parameters': Array<CubicSplineCubicSplineParameter>;
}
interface CubicSplineCubicSplineParameter {
  'pose': Pose;
  'path_parameter': number;
}
interface CubicSplineParameter {
  'pose': Pose2;
  'path_parameter': number;
}
interface CycleTime {
  /**
   * Cycle time of controller communication in [ms].
   */
  'cycle_time_ms': number;
}
/**
 * Defines a cylindrical shape centered around the z-axis.
 */
interface Cylinder {
  /**
   * The radius of the cylinder in [mm].
   */
  'radius': number;
  /**
   * The height of the cylinder in [mm].
   */
  'height': 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 Cylinder2 {
  'shape_type': Cylinder2ShapeTypeEnum;
  /**
   * The radius of the cylinder in [mm].
   */
  'radius': number;
  /**
   * The height of the cylinder in [mm].
   */
  'height': number;
}
declare const Cylinder2ShapeTypeEnum: {
  readonly Cylinder: "cylinder";
};
type Cylinder2ShapeTypeEnum = typeof Cylinder2ShapeTypeEnum[keyof typeof Cylinder2ShapeTypeEnum];
/**
 * Centered around origin, symmetric around z-axis.  If margin is applied, it is added to radius and height (shape still has edges).
 */
interface Cylinder3 {
  'shape_type': Cylinder3ShapeTypeEnum;
  'radius': number;
  'height': number;
}
declare const Cylinder3ShapeTypeEnum: {
  readonly Cylinder: "cylinder";
};
type Cylinder3ShapeTypeEnum = typeof Cylinder3ShapeTypeEnum[keyof typeof Cylinder3ShapeTypeEnum];
/**
 * 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;
}
/**
 * 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 request to move a motion group in a cartesian direction.
 */
interface DirectionJoggingRequest {
  /**
   * Identifier of the motion group.
   */
  'motion_group': string;
  'position_direction': Vector3d;
  'rotation_direction': Vector3d;
  /**
   * Unique identifier addressing the base coordinate system of position_direction and rotation_direction. If not set, world coordinate system is used. Set coordinate_system to \"tool\" to select the current tool coordinate system as base.
   */
  'coordinate_system'?: string;
  /**
   * in (mm/s)
   */
  'position_velocity': number;
  /**
   * in (rad/s)
   */
  'rotation_velocity': number;
  'tcp'?: any;
  /**
   * Update rate for the response message in ms. If not set 200ms are used.
   */
  'response_rate'?: number;
  /**
   * Unique identifier addressing a coordinate system in which the responses should be converted. If not set, world coordinate system is used.
   */
  'response_coordinate_system'?: string;
}
/**
 * @type ExecuteTrajectoryRequest
 */
type ExecuteTrajectoryRequest = InitializeMovementRequest | PauseMovementRequest | PlaybackSpeedRequest | StartMovementRequest;
/**
 * @type ExecuteTrajectoryResponse
 */
type ExecuteTrajectoryResponse = InitializeMovementResponse | Movement | MovementError | PauseMovementResponse | PlaybackSpeedResponse | Standstill;
/**
 * The ExecutionResult object contains the execution results of a robot.  Arguments:     motion_group_id: The unique identifier of the motion group     motion_duration: The total execution duration of the motion group     paths: The paths of the motion group as list of Path objects
 */
interface ExecutionResult {
  'motion_group_id': string;
  'motion_duration': number;
  'paths': Array<Path>;
}
/**
 * A datapoint inside external joint stream.
 */
interface ExternalJointStreamDatapoint {
  /**
   * Unique identifier addressing a controller in the cell.
   */
  'id': number;
  'value': ExternalJointStreamDatapointValue;
}
/**
 * The joint-values of the external joint stream datapoint.
 */
interface ExternalJointStreamDatapointValue {
  /**
   * The joint positions of the robot.
   */
  'positions': Array<number>;
  /**
   * The joint velocities of the robot.
   */
  'velocities': Array<number>;
  /**
   * The joint accelerations of the robot.
   */
  'accelerations': Array<number>;
  /**
   * The joint torques of the robot.
   */
  'torques': Array<number>;
}
/**
 * The configuration of a physical FANUC robot controller has to contain IP address of the controller.
 */
interface FanucController {
  'kind'?: FanucControllerKindEnum;
  'controllerIp': string;
}
declare const FanucControllerKindEnum: {
  readonly FanucController: "FanucController";
};
type FanucControllerKindEnum = typeof FanucControllerKindEnum[keyof typeof FanucControllerKindEnum];
interface FeedbackCollision {
  'collisions'?: Array<Collision>;
  'joint_position'?: Array<number>;
  'tcp_pose'?: Pose2;
  'error_feedback_name': FeedbackCollisionErrorFeedbackNameEnum;
}
declare const FeedbackCollisionErrorFeedbackNameEnum: {
  readonly FeedbackCollision: "FeedbackCollision";
};
type FeedbackCollisionErrorFeedbackNameEnum = typeof FeedbackCollisionErrorFeedbackNameEnum[keyof typeof FeedbackCollisionErrorFeedbackNameEnum];
/**
 * This error is returned when a joint position limit is exceeded. The joint index denotes which joint is out of its limits, starting with 1 and followed by the full joint position.
 */
interface FeedbackJointLimitExceeded {
  'joint_index'?: number;
  'joint_position'?: Array<number>;
  'error_feedback_name': FeedbackJointLimitExceededErrorFeedbackNameEnum;
}
declare const FeedbackJointLimitExceededErrorFeedbackNameEnum: {
  readonly FeedbackJointLimitExceeded: "FeedbackJointLimitExceeded";
};
type FeedbackJointLimitExceededErrorFeedbackNameEnum = typeof FeedbackJointLimitExceededErrorFeedbackNameEnum[keyof typeof FeedbackJointLimitExceededErrorFeedbackNameEnum];
/**
 * Requested TCP pose is outside of motion group\'s workspace.
 */
interface FeedbackOutOfWorkspace {
  'invalid_tcp_pose'?: Pose2;
  '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<number>;
  'error_feedback_name': FeedbackSingularityErrorFeedbackNameEnum;
}
declare const FeedbackSingularityErrorFeedbackNameEnum: {
  readonly FeedbackSingularity: "FeedbackSingularity";
};
type FeedbackSingularityErrorFeedbackNameEnum = typeof FeedbackSingularityErrorFeedbackNameEnum[keyof typeof FeedbackSingularityErrorFeedbackNameEnum];
interface Flag {
  'active': boolean;
}
/**
 * Representing a force on a specific point in operational space (e.g. on robot flange).
 */
interface ForceVector {
  'force'?: Vector3d;
  'moment'?: Vector3d;
  /**
   * optional, unique name of base coordinate system, if empty world is used
   */
  'coordinate_system'?: string;
}
/**
 * A Geometry is defined by a shape and a pose.
 */
interface Geometry {
  'sphere'?: Sphere;
  'box'?: Box;
  'rectangle'?: Rectangle;
  /**
   * Defines an x-y plane with infinite size.
   */
  'plane'?: object;
  'cylinder'?: Cylinder;
  'convex_hull'?: ConvexHull;
  'capsule'?: Capsule;
  'rectangular_capsule'?: RectangularCapsule;
  'compound'?: Compound;
  'init_pose': PlannerPose;
  /**
   * An identifier may be used to refer to this geometry, e.g. when giving feedback.
   */
  'id'?: string;
}
interface GetAllProgramRuns200Response {
  'program_runs'?: Array<ProgramRunObject>;
}
interface GetAllTriggers200Response {
  'triggers'?: Array<TriggerObject>;
}
interface GetModeResponse {
  'robot_system_mode': RobotSystemMode;
}
interface GetTrajectoryResponse {
  /**
   * A list of points representing the trajectory of a planned motion with defined `sample_time` in milliseconds (ms).
   */
  'trajectory'?: Array<TrajectorySample>;
}
interface GetTrajectorySampleResponse {
  'sample'?: TrajectorySample;
}
/**
 * Contains an arbitrary serialized message along with a @type that describes the type of the serialized message.
 */
interface GoogleProtobufAny {
  [key: string]: any;
  /**
   * The type of the serialized message.
   */
  '@type'?: string;
}
interface HTTPExceptionResponse {
  /**
   * A message describing the error.
   */
  'detail': string;
}
interface HTTPValidationError {
  'detail'?: Array<ValidationError>;
}
interface HTTPValidationError2 {
  'detail'?: Array<ValidationError2>;
}
interface IO {
  'name': string;
  'direction': IODirectionEnum;
  'bool'?: boolean;
  'integer'?: string;
  'double'?: number;
}
declare const IODirectionEnum: {
  readonly ControllerIn: "ControllerIn";
  readonly ControllerOut: "ControllerOut";
};
type IODirectionEnum = typeof IODirectionEnum[keyof typeof IODirectionEnum];
interface IODescription {
  /**
   * Unique identifier defined by the controller. Identifiers are only defined uniquely per controller, e.g. I/Os for two different robots on the same controller can have the same identifier.
   */
  'id': string;
  /**
   * Name of the I/O. Customize it on the physical controller or in the virtual robot specification.
   */
  'name': string;
  /**
   * Name of the I/O group. Customize it on the physical controller or in the virtual robot specification.
   */
  'group'?: string;
  /**
   * Identifies the I/O type. Possible responses \"input\" or \"output\".
   */
  'type': IODescriptionTypeEnum;
  /**
   * Data type of the I/O.
   */
  'value_type': IODescriptionValueTypeEnum;
  /**
   * OBSOLETE! Replaced by min/max. Amount of bits the value is encoded in.
   */
  'bit_size': number;
  /**
   * The unit of I/O value.
   */
  'unit'?: IODescriptionUnitEnum;
  'min'?: IOValue;
  'max'?: IOValue;
}
declare const IODescriptionTypeEnum: {
  readonly IoTypeInput: "IO_TYPE_INPUT";
  readonly IoTypeOutput: "IO_TYPE_OUTPUT";
};
type IODescriptionTypeEnum = typeof IODescriptionTypeEnum[keyof typeof IODescriptionTypeEnum];
declare const IODescriptionValueTypeEnum: {
  readonly IoValueDigital: "IO_VALUE_DIGITAL";
  readonly IoValueAnalogFloating: "IO_VALUE_ANALOG_FLOATING";
  readonly IoValueAnalogInteger: "IO_VALUE_ANALOG_INTEGER";
};
type IODescriptionValueTypeEnum = typeof IODescriptionValueTypeEnum[keyof typeof IODescriptionValueTypeEnum];
declare const IODescriptionUnitEnum: {
  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 IODescriptionUnitEnum = typeof IODescriptionUnitEnum[keyof typeof IODescriptionUnitEnum];
/**
 * I/O value representation. Depending on the I/O type, only one of the value fields will be set.
 */
interface IOValue {
  /**
   * Unique identifier of the I/O.
   */
  'io': string;
  /**
   * Value of a digital I/O. This field is only set if the I/O is of type IO_VALUE_DIGITAL.
   */
  'boolean_value'?: boolean;
  /**
   * Value of an analog I/O with integer representation. This field is only set if the I/O is of type IO_VALUE_ANALOG_INTEGER.  > The integral value is transmitted as a string to avoid precision loss in conversion to JSON. > We recommend to use int64 for implementation. If you want to interact with int64 in numbers, > there are some JS bigint libraries availible to parse the string into an integral value.
   */
  'integer_value'?: string;
  /**
   * Value of an analog I/O with floating number representation. This field is only set if the I/O is of type IO_VALUE_ANALOG_FLOATING.
   */
  'floating_value'?: number;
}
interface IOs {
  'IOs': Array<IO>;
}
/**
 * User provided credentials for creating a secret to pull an image from a registry.
 */
interface ImageCredentials {
  'registry': string;
  'user': string;
  'password': string;
}
interface InfoServiceCapabilities {
  /**
   * Is this motion group able to provide a list of all available TCPs.
   */
  'list_tcps': boolean;
  /**
   * Is this motion group able to provide the currently active TCP.
   */
  'get_active_tcp': boolean;
  /**
   * Is this motion group able to get the safety setup.
   */
  'get_safety_setup': boolean;
  /**
   * Is this motion group able to provide a motion group specification.
   */
  'get_motion_group_specification': boolean;
  /**
   * Is this motion group able to provide a list of all available payloads.
   */
  'list_payloads': boolean;
  /**
   * Is this motion group able to provide the currently active payload.
   */
  'get_active_payload': boolean;
  /**
   * Is this motion group able to provide the mounting information.
   */
  'get_mounting': boolean;
}
/**
 * Sets up connection by locking a trajectory for execution. The trajectory is identified by the UUID. 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 the server, set automatically.
   */
  'message_type'?: string;
  /**
   * The UUID of the trajectory which should be executed and locked to the connection. Get information about the trajectory via [getMotionTrajectorySample](#/operations/getMotionTrajectorySample) or [getMotionTrajectory](#/operations/getMotionTrajectory).
   */
  'trajectory': string;
  /**
   * Location on trajectory where the execution will start. The default value is the start (forward movement) or end (backward movement) of the trajectory. If you want to start your movement from an arbitrary location, e.g. in combination with [streamMoveToTrajectoryViaJointPTP](#/operations/streamMoveToTrajectoryViaJointPTP), set the location by respecting the following format: - 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;
  /**
   * Update rate for the response message in milliseconds (ms). Default is 200 ms. Recommendation: As Wandelbots NOVA updates states in the controller\'s step rate, use either the controller\'s step rate, or multiply the step rate and use the product.                 Wandelbots NOVA will not interpolate the state but rather round it to the nearest step rate below the configured response rate. Minimal response rate is the step rate of controller.
   */
  'response_rate'?: 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;
}
/**
 * Response for InitializeMovementRequest message.
 */
interface InitializeMovementResponse {
  'init_response': InitializeMovementResponseInitResponse;
}
interface InitializeMovementResponseInitResponse {
  /**
   * Indicates if the motion was successfully locked and is ready for execution by sending a StartMovementRequest. Send PlaybackSpeedRequest to override the planned velocity.
   */
  'succeeded': boolean;
  /**
   * Error message in case of invalid InitializeMovementRequest.
   */
  'error_message'?: string;
}
/**
 * A response for a Jogging Request, is streamed during an active Jogging Movement.
 */
interface JoggingResponse {
  /**
   * Identifier of the motion group.
   */
  'motion_group': string;
  'state': RobotControllerState;
  /**
   * State of the current movement, e.g. ongoing or stopped due to a particular reason.
   */
  'movement_state': JoggingResponseMovementStateEnum;
}
declare const JoggingResponseMovementStateEnum: {
  readonly MovementStateUnknown: "MOVEMENT_STATE_UNKNOWN";
  readonly MovementStateError: "MOVEMENT_STATE_ERROR";
  readonly MovementStateMoving: "MOVEMENT_STATE_MOVING";
  readonly MovementStateStopByRequest: "MOVEMENT_STATE_STOP_BY_REQUEST";
  readonly MovementStateJointLimitReached: "MOVEMENT_STATE_JOINT_LIMIT_REACHED";
  readonly MovementStateStopForIo: "MOVEMENT_STATE_STOP_FOR_IO";
  readonly MovementStateStopForForceLimit: "MOVEMENT_STATE_STOP_FOR_FORCE_LIMIT";
};
type JoggingResponseMovementStateEnum = typeof JoggingResponseMovementStateEnum[keyof typeof JoggingResponseMovementStateEnum];
interface JoggingServiceCapabilities {
  /**
   * Can this motion group be moved via joint jogging.
   */
  'joint_jogging': boolean;
  /**
   * Can this motion group be moved via cartesian jogging.
   */
  'cartesian_jogging': boolean;
}
/**
 * A request to move the joints of a motion group.
 */
interface JointJoggingRequest {
  /**
   * Identifier of the motion group.
   */
  'motion_group': string;
  /**
   * in [rad/s]
   */
  'joint_velocities': Array<number>;
  'tcp'?: any;
  /**
   * Update rate for the response message in ms. If not set 200ms are used.
   */
  'response_rate'?: number;
  /**
   * Unique identifier addressing a coordinate system in which the responses should be converted. If not set, world coordinate system is used.
   */
  'response_coordinate_system'?: string;
}
/**
 * A joint limit can contain a position (rad or mm), a velocity (rad/s or mm/s), an acceleration (rad/s² or mm/s²) or a jerk (rad/s³ or mm/s³).
 */
interface JointLimit {
  /**
   * Definition of the joint where the limits are applied.
   */
  'joint': JointLimitJointEnum;
  /**
   * Lower joint limit which is smaller than the upper joint limit.
   */
  'lower_limit': number;
  /**
   * Upper joint boundary which is bigger than the lower joint limit.
   */
  'upper_limit': number;
  /**
   * True, if joint limit is unlimited. Lower and upper limits are ignored.
   */
  'unlimited'?: boolean;
}
declare const JointLimitJointEnum: {
  readonly JointnameAxisInvalid: "JOINTNAME_AXIS_INVALID";
  readonly JointnameAxis1: "JOINTNAME_AXIS_1";
  readonly JointnameAxis2: "JOINTNAME_AXIS_2";
  readonly JointnameAxis3: "JOINTNAME_AXIS_3";
  readonly JointnameAxis4: "JOINTNAME_AXIS_4";
  readonly JointnameAxis5: "JOINTNAME_AXIS_5";
  readonly JointnameAxis6: "JOINTNAME_AXIS_6";
  readonly JointnameAxis7: "JOINTNAME_AXIS_7";
  readonly JointnameAxis8: "JOINTNAME_AXIS_8";
  readonly JointnameAxis9: "JOINTNAME_AXIS_9";
  readonly JointnameAxis10: "JOINTNAME_AXIS_10";
  readonly JointnameAxis11: "JOINTNAME_AXIS_11";
  readonly JointnameAxis12: "JOINTNAME_AXIS_12";
};
type JointLimitJointEnum = typeof JointLimitJointEnum[keyof typeof JointLimitJointEnum];
/**
 * This error is returned when a joint position limit is exceeded. The joint index denotes which joint is out of its limits, starting with 1 and the full joint position is returned.
 */
interface JointLimitExceeded {
  'joint_index'?: number;
  'joint_position'?: Joints;
}
/**
 * Request to find the joint positions the motion-group needs to apply for its TCP to be in a specified pose (Inverse Kinematic Solution).
 */
interface JointPositionRequest {
  /**
   * Identifier of the motion group.
   */
  'motion_group': string;
  'tcp_pose': TcpPose;
  'reference_joint_position': Joints;
}
interface JointTrajectory {
  /**
   * List of joint positions [rad] for each sample. The number of samples must match the number of timestamps provided in the times field.
   */
  'joint_positions': Array<Joints>;
  /**
   * Timestamp for each sample [s].
   */
  'times': Array<number>;
  /**
   * Location for each sample, scalar value defining a position along a path. Typical range: 0 to `n`, `n` denoting the number of motion commands. Each integer value of the location corresponds to a specific motion command. If provided, the number of samples must match the number of timestamps provided in the times field.
   */
  'locations': Array<number>;
}
/**
 * This structure describes a set of joint values of a motion group. We call a set of joint values describing the current position in joint space of a motion group a \"joint position\". Joint position was chosen as the term to be consistent with the terms \"joint velocity\" and \"joint acceleration\". `joints` must have as many entries as the motion group\'s degrees of freedom to be valid. Float precision is the default.
 */
interface Joints {
  'joints': Array<number>;
}
interface KinematicServiceCapabilities {
  /**
   * Can this motion-group compute its nearest joint position from a TCP pose.
   */
  'calculate_joint_position': boolean;
  /**
   * Can this motion-group compute all its possible joint positions from a TCP pose.
   */
  'calculate_all_joint_positions': boolean;
  /**
   * Can this motion-group compute its TCP pose from joint positions.
   */
  'calculate_tcp_pose': boolean;
}
/**
 * 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;
  'controllerIp': string;
  'controllerPort': number;
  'rsiServer': 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;
}
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<string>;
  '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];
/**
 * NOTE: if a joint or Cartesian limit is not set or present for the corresponding device, then the value is not present (in the list or the optional value is null). The unit depends on the kind of axis (rotational or linear).
 */
interface LimitSettings {
  /**
   * Joint position limits in [rad or mm], configured in the safety setup, starting at base.
   */
  'joint_position_limits'?: Array<JointLimit>;
  /**
   * Max allowed velocity for joints in [rad/s or mm/s] of the safety setup, starting at base.
   */
  'joint_velocity_limits'?: Array<SingleJointLimit>;
  /**
   * Max allowed acceleration for joints in [rad/s^2 or mm/s^2] of the safety setup, starting at base.
   */
  'joint_acceleration_limits'?: Array<SingleJointLimit>;
  /**
   * Max allowed torque for joints in [Nm or N] of the safety setup, starting at base.
   */
  'joint_torque_limits'?: Array<SingleJointLimit>;
  /**
   * [mm/s] max. allowed velocity at the TCP, 1-dimensional.
   */
  'tcp_velocity_limit'?: number;
  /**
   * [mm/s^2] max. allowed acceleration at the TCP, 1-dimensional.
   */
  'tcp_acceleration_limit'?: number;
  /**
   * [rad/s] max. allowed orientation velocity at the TCP, 1-dimensional.
   */
  'tcp_orientation_velocity_limit'?: number;
  /**
   * [rad/s^2] max. allowed orientation acceleration at the TCP, 1-dimensional.
   */
  'tcp_orientation_acceleration_limit'?: number;
  /**
   * [N] max. allowed force at the TCP, 1-dimensional.
   */
  'tcp_force_limit'?: number;
  /**
   * [mm/s] max. allowed velocity at the elbow, 1-dimensional.
   */
  'elbow_velocity_limit'?: number;
  /**
   * [mm/s^2] max. allowed acceleration at the elbow, 1-dimensional.
   */
  'elbow_acceleration_limit'?: number;
  /**
   * [N] max. allowed force at the elbow, 1-dimensional.
   */
  'elbow_force_limit'?: number;
}
/**
 * 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'?: Joints;
  /**
   * 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'?: Joints;
  /**
   * 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 rotation velocity in [rad/s].
   */
  'tcp_orientation_velocity_limit'?: number;
  /**
   * Maximum allowed TCP rotation acceleration in [rad/s^2].
   */
  'tcp_orientation_acceleration_limit'?: number;
}
interface ListDevices200ResponseInner {
  'type'?: any;
  /**
   * A unique identifier for the collision scene.
   */
  'identifier'?: string;
  'host'?: string;
  'port'?: number;
  'prim_paths'?: {
    [key: string]: string;
  };
  'controller_model_name'?: string;
  'motion_group_id'?: string;
  'rae_host'?: string;
  'rae_port'?: number;
  'url'?: string;
  'initial_pose'?: Array<number>;
  /**
   * A collection of static colliders within the scene, identified by their names.
   */
  'static_colliders'?: {
    [key: string]: ColliderOutput;
  };
  /**
   * Configurations for robots within the scene. Allow for the specification of collision geometries and other robot-specific settings, identified by robot names.
   */
  'robot_configurations'?: {
    [key: string]: CollisionRobotConfigurationOutput;
  };
}
/**
 * Array of I/O description values.
 */
interface ListIODescriptionsResponse {
  'io_descriptions': Array<IODescription>;
}
/**
 * Array of I/O values.
 */
interface ListIOValuesResponse {
  'io_values': Array<IOValue>;
}
interface ListPayloadsResponse {
  'payloads'?: Array<Payload>;
}
/**
 * List of all the stored programs, represented by their metadata.
 */
interface ListProgramMetadataResponse {
  'programs': Array<ProgramMetadata>;
}
/**
 * List of all the stored recipes, represented by their metadata.
 */
interface ListRecipeMetadataResponse {
  'recipes': Array<RecipeMetadata>;
}
interface ListResponse {
  'coordinatesystems'?: Array<CoordinateSystem>;
}
interface ListTcpsResponse {
  /**
   * Represents the tcp offset from the device flange (in other words the absolute transformation from flange to the tcp).
   */
  'tcps'?: Array<RobotTcp>;
}
declare const Manufacturer: {
  readonly Abb: "abb";
  readonly Fanuc: "fanuc";
  readonly Kuka: "kuka";
  readonly Universalrobots: "universalrobots";
  readonly Yaskawa: "yaskawa";
};
type Manufacturer = typeof Manufacturer[keyof typeof Manufacturer];
/**
 * Mode change example: * Client sends [jointJogging](#/operations/jointJogging)](cell=\"..\",...) * Server responds with *current_robot_mode: ROBOT_SYSTEM_MODE_UNDEFINED, by_client_request: true* at the beginning of the transition. * Server responds with *current_robot_mode: ROBOT_SYSTEM_MODE_CONTROL, by_client_request: true* when the transition is done.  In case an error happens during execution, e.g. a path would lead to a joint limit violation: * Server responds with *current_robot_mode: ROBOT_SYSTEM_MODE_UNDEFINED, by_client_request: false* * Server responds with *current_robot_mode: ROBOT_SYSTEM_MODE_MONITOR, by_client_request: false*  In case an error happens during connection, e.g. the robot is not reachable: * Client sends [setDefaultMode](#/operations/setDefaultMode)(mode: MODE_CONTROL) * Server responds with *current_robot_mode:ROBOT_SYSTEM_MODE_UNDEFINED, by_client_request: true* * Server responds with *current_robot_mode:ROBOT_SYSTEM_MODE_DISCONNECT, by_client_request: false*
 */
interface ModeChangeResponse {
  'current_robot_mode': RobotSystemMode;
  /**
   * True if mode change was requested by client.
   */
  'by_client_request': boolean;
  'previous_robot_mode': RobotSystemMode;
  /**
   * Details about cause of mode change.
   */
  'cause_of_change': string;
}
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 | PathJointPTP | PathLine;
interface MotionGroupBehaviorGetter {
  'behavior': Behavior;
}
interface MotionGroupInfo {
  /**
   * The unique identifier of the motion group. Use it to refer to the motion group in other calls.
   */
  'id': number;
  /**
   * 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;
}
interface MotionGroupInfos {
  'motiongroups': Array<MotionGroupInfo>;
}
/**
 * The data type describes the physically connected motion groups on a robot controller, e.g. a robot arm.
 */
interface MotionGroupInstance {
  /**
   * Identifier of the motion group.
   */
  'motion_group': string;
  /**
   * Identifier of the robot controller the motion group is attached to.
   */
  'controller': string;
  /**
   * The name of the motion group has on the robot controller.
   */
  'name_from_controller': string;
  /**
   * The robot controller model if available. Usable for frontend 3D visualization.
   */
  'model_from_controller': string;
  /**
   * The serial number of the motion group if available. If not available, the serial number of the robot controller. if available. If not available, then empty.
   */
  'serial_number'?: string;
}
/**
 * A list of motion groups.
 */
interface MotionGroupInstanceList {
  'instances': Array<MotionGroupInstance>;
}
/**
 * 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<number>;
  /**
   * The joint velocities of the motion group.
   */
  'velocities'?: Array<number>;
  /**
   * The joint accelerations of the motion group.
   */
  'accelerations'?: Array<number>;
  /**
   * The joint torques of the motion group.
   */
  'torques'?: Array<number>;
}
/**
 * The data type describes the physically connected motion groups on a robot controller.
 */
interface MotionGroupPhysical {
  /**
   * The unique identifier to address a motion group.
   */
  'motion_group': string;
  /**
   * The name the motion group has on the robot controller.
   */
  'name_from_controller': string;
  /**
   * True if this motion group is active. When a request for a motion group is made, the motion group will be activated and remain activated. The robot controller provides the current state and data for all active motion groups. See [getCurrentMotionGroupState](#/operations/getCurrentMotionGroupState). To deactivate a motion group, use [deactivateMotionGroup](#/operations/deactivateMotionGroup).
   */
  'active': boolean;
  /**
   * The robot controller model if available. Usable for frontend 3D visualization.
   */
  'model_from_controller'?: string;
  /**
   * The serial number of the motion group if available. If not available, the serial number of the robot controller. if available. If not available, then empty.
   */
  'serial_number'?: string;
}
/**
 * Holding static properties of the motion group.
 */
interface MotionGroupSpecification {
  /**
   * A list of DH (Denavit-Hartenberg) parameters. An element in this list contains a set of DH parameters that describe the relation of two cartesian reference frames. Every joint of a serial motion group has an associated cartesian reference frame located in the rotation axis of the joint. A set of DH parameters is applied in the following order: theta, d, a, alpha.
   */
  'dh_parameters'?: Array<DHParameter>;
  /**
   * Mechanical joint limits in [rad/mm], starting with the first joint in the motion group base. For every joint there is a minimum and maximum value. Those are defined by the motion group manufacturer and can be found in its data sheet. If a mechanical joint limit is exceeded, the motion group stops immediately. The stop is triggered by the physical robot controller. This should be prevented by using proper soft joint limits.
   */
  'mechanical_joint_limits'?: Array<JointLimit>;
}
/**
 * Presents the current state of the motion group.
 */
interface MotionGroupState {
  /**
   * Identifier of the motion group.
   */
  'motion_group': string;
  /**
   * Convenience: Identifier of the robot controller the motion group is attached to.
   */
  'controller': string;
  /**
   * Current joint position of each joint in [rad]
   */
  'joint_position': Joints;
  /**
   * Current joint velocity of each joint in [rad/s]
   */
  'joint_velocity': Joints;
  /**
   * Current joint torque of each joint in [Nm]. Is only available if the robot controller supports it (e.g. available for UR Controllers).
   */
  'joint_torque'?: Joints;
  /**
   * Current position of the Flange (last point of the motion group before the endeffector starts) in [mm]. The position is relative to the response_coordinate_system that is 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;
  /**
   * Current position of the TCP currently selected on the robot control panel. Attention: This TCP is not necessarily the same as specified as `tcp` in the request. If you need the information for the specified TCP, use the tcp_pose in the outer response. Position is in [mm]. The position is relative to the response_coordinate_system that is specified in the request.
   */
  'tcp_pose': TcpPose;
  /**
   * Current velocity at TCP in [mm/s]. If `tcp` is not specified, the velocity at the flange is returned. The velocity is relative to the response_coordinate_system specified in the request.
   */
  'velocity': MotionVector;
  /**
   * Current Force at TCP in [N]. Is only available if the robot controller supports it, e.g. available for UR Controllers. The velocity is relative to the response_coordinate_system specified in the request.
   */
  'force'?: ForceVector;
  /**
   * Indicates whether the joint is in a limit for all joints of the motion group.
   */
  'joint_limit_reached': MotionGroupStateJointLimitReached;
  /**
   * Current Current at TCP in [A]. Is only available if the robot controller supports it, e.g. available for UR Controllers.
   */
  'joint_current'?: Joints;
  /**
   * 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. It is of type string to represent uint64 values, which is not supported by OpenAPI.
   */
  'sequence_number': string;
}
/**
 * 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<boolean>;
}
interface MotionGroupStateResponse {
  /**
   * Current state of the motion group.
   */
  'state': MotionGroupState;
  /**
   * Current position of the TCP specified as `tcp` in the request. Attention: This TCP is not necessarily the same the one currently selected on the robot control panel. If you need the information for the currently selected TCP, use the state.tcp_pose in the response. If `tcp` is not specified in the request, this field will be omitted in the response. Position is in [mm]. The position is relative to the response_coordinate_system specified in the request.
   */
  'tcp_pose'?: TcpPose;
}
interface MotionId {
  /**
   * This represents the UUID of a motion. Every executable or partially executable motion is cached and an UUID is returned. Indicate the UUID to execute the motion or retrieve information on the motion.
   */
  'motion': string;
}
interface MotionIdsListResponse {
  /**
   * -| Identifiers of all motions which are currently cached. Use [planMotion](#/operations/planMotion) to add a new motion. Motions are deleted if corresponding motion group or controller is disconnected.
   */
  'motions'?: Array<string>;
}
interface MotionVector {
  'linear'?: Vector3d;
  'angular'?: Vector3d;
  /**
   * optional, unique name of base coordinate system, if empty world is used
   */
  'coordinate_system'?: string;
}
/**
 * Mounting of a motion group.
 */
interface Mounting {
  /**
   * Identifier of mounting coordinate system. The motion group is based on the origin of this coordinate system.
   */
  'coordinate_system': string;
  /**
   * The pose offset based on world coordinate system of the mounting.
   */
  'pose': Pose;
}
/**
 * Moves the motion group forward or backward along a previously planned motion.  Once started, you can stop a motion using the [stop](#/operations/stopExecution) endpoint.  Prerequisite, before starting the motion execution:   - The motion group is currently at the endpoint of the planned motion.
 */
interface MoveRequest {
  /**
   * This represents the UUID of a motion. Every executable or partially executable motion is cached and an UUID is returned. Indicate the UUID to execute the motion or retrieve information on the motion.
   */
  'motion': string;
  /**
   * Set the velocity for executed movements of the motion in percent. A percentage of 100% means that the robot moves as fast as possible without violating the limits. Setting this value does not affect the overall shape of the velocity profile. Everything is slowed down by the same factor. Therefore, this should only be used for teaching and trajectory evaluation purposes. If the process requires a certain velocity, the respective limits should be set when planning the motion. This will not change the velocity override of the controller. The controller velocity override value shall be 100% to ensure controllability of the motion group.
   */
  'playback_speed_in_percent': number;
  /**
   * 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.
   */
  'response_rate'?: number;
  /**
   * Unique identifier addressing a coordinate system in which the responses should be converted. If not set, world coordinate system is used.
   */
  'response_coordinate_system'?: string;
  /**
   * Location the motion is requested to start at. The default value is the begin of the trajectory. 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.
   */
  'start_location_on_trajectory'?: number;
  /**
   * Define an arb I/O that is listened to during the motion. If the defined comparator evaluates to true the execution is started.
   */
  'set_ios'?: Array<SetIO>;
  /**
   * Defines an I/O that is listened to during the motion. If the defined comparator evaluates to true the execution is started.
   */
  'start_on_io'?: StartOnIO;
  /**
   * Defines an I/O that is listened to during the motion. If the defined comparator evaluates to true the execution is paused.
   */
  'pause_on_io'?: PauseOnIO;
}
interface MoveResponse {
  /**
   * Remaining time in milliseconds (ms) to reach the end of the motion.
   */
  'time_to_end': number;
  /**
   * Refers to the current location of motion group on the trajectory.
   */
  'current_location_on_trajectory': number;
}
/**
 * Request to move the motion group via joint point-to-point to a given location on a planned motion. You must use this endpoint in order to start moving from an arbritrary location of the trajectory. Afterwards, you are able to call [streamMoveForward](#/operations/streamMoveForward) or [streamMoveBackward](#/operations/streamMoveBackward) to move along the planned motion. Use the [stopExecution](#/operations/stopExecution) endpoint to stop the motion gracefully.
 */
interface MoveToTrajectoryViaJointPTPRequest {
  /**
   * This represents the UUID of a motion. Every executable or partially executable motion is cached and an UUID is returned. Indicate the UUID to execute the motion or retrieve information on the motion.
   */
  'motion': string;
  /**
   * Gets the target location the robot should move to via joint point-to-point (moveJ). 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_on_trajectory': number;
  'limit_override'?: LimitsOverride;
  /**
   * Unique identifier addressing a coordinate system in which the responses should be converted. If not set, world coordinate system is used.
   */
  'response_coordinate_system'?: string;
}
/**
 * Sent during movement, response-rate closest to the nearest multiple of controller step-rate but not exceeding the configured rate.
 */
interface Movement {
  'movement': MovementMovement;
}
/**
 * Response signalling an error during trajectory execution. This response is sent in case of an unexpected error , e.g. controller disconnects. The error details are described in the error_message field.
 */
interface MovementError {
  'error': MovementErrorError;
}
interface MovementErrorError {
  /**
   * Human-readable error details that describes the error.
   */
  'error_message': string;
}
interface MovementMovement {
  /**
   * Remaining time in milliseconds (ms) to reach the end of the motion.
   */
  'time_to_end': number;
  /**
   * Current location of motion group on the trajectory.
   */
  'current_location': number;
  /**
   * Current state of the robot controller and moving motion group.
   */
  'state': RobotControllerState;
}
/**
 * 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': OpModeModeEnum;
}
declare const OpModeModeEnum: {
  readonly OperationModeManual: "OPERATION_MODE_MANUAL";
  readonly OperationModeAuto: "OPERATION_MODE_AUTO";
};
type OpModeModeEnum = typeof OpModeModeEnum[keyof typeof OpModeModeEnum];
/**
 * Configuration for an OPC UA node value trigger. When the specified node has the specified value the trigger condition is met and the program is executed.
 */
interface OpcuaNodeValueTriggerConfig {
  /**
   * Url of the OPC UA server.
   */
  'host': string;
  /**
   * Identifier of the OPC UA node to monitor.
   */
  'node_id': string;
  'node_value': OpcuaNodeValueTriggerConfigNodeValue;
}
/**
 * Value to trigger the program when matched.
 */
interface OpcuaNodeValueTriggerConfigNodeValue {}
/**
 * The configuration of a motion-group used for motion planning.
 */
interface OptimizerSetup {
  /**
   * String identifiying the exact motion group model (robot model).
   */
  'motion_group_type': string;
  /**
   * The offset from the world frame to the motion group base.
   */
  'mounting': PlannerPose;
  /**
   * The offset from the motion group flange to the TCP.
   */
  'tcp': PlannerPose;
  /**
   * The limits, safety zones and safety zone collision models of the motion group and tool.
   */
  'safety_setup': SafetyConfiguration;
  /**
   * The dynamic parameters (mass, inertias, center of gravity) of the payload attached at the flange.
   */
  'payload'?: 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 DH parameters describing the motion group geometry, starting from base.
   */
  'dh_parameters'?: Array<DHParameter>;
}
/**
 * Requested TCP pose is outside of motion group\'s workspace.
 */
interface OutOfWorkspace {
  'invalid_tcp_pose'?: Pose;
}
interface Path {
  'poses'?: Array<RobotState>;
}
/**
 * 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.
 */
interface PathCartesianPTP {
  'target_pose': Pose2;
  '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': Pose2;
  'target_pose': Pose2;
  '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<CubicSplineParameter>;
  'path_definition_name': PathCubicSplinePathDefinitionNameEnum;
}
declare const PathCubicSplinePathDefinitionNameEnum: {
  readonly PathCubicSpline: "PathCubicSpline";
};
type PathCubicSplinePathDefinitionNameEnum = typeof PathCubicSplinePathDefinitionNameEnum[keyof typeof PathCubicSplinePathDefinitionNameEnum];
/**
 * A joint point-to-point represents a line in joint space. All joints will be moved synchronously.
 */
interface PathJointPTP {
  'target_joint_position': Array<number>;
  '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': Pose2;
  'path_definition_name': PathLinePathDefinitionNameEnum;
}
declare const PathLinePathDefinitionNameEnum: {
  readonly PathLine: "PathLine";
};
type PathLinePathDefinitionNameEnum = typeof PathLinePathDefinitionNameEnum[keyof typeof PathLinePathDefinitionNameEnum];
/**
 * 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'?: string;
  /**
   * Defaults to `true`. Set to true to get a response signalling successful initiation to pause the movement.
   */
  'send_response'?: boolean;
}
/**
 * Response 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 Standstill response.
 */
interface PauseMovementResponse {
  'pause_response': PauseMovementResponsePauseResponse;
}
interface PauseMovementResponsePauseResponse {
  /**
   * Indicates if PauseMovementRequest can be executed.
   */
  'succeeded': boolean;
  /**
   * Error message in case of invalid PauseMovementRequest or failure while claiming motion.
   */
  'error_message'?: string;
}
/**
 * Defines an I/O 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;
}
interface Payload {
  /**
   * Unique identifier of the payload.
   */
  'name': string;
  /**
   * Mass of payload in [kg].
   */
  'payload': number;
  'center_of_mass'?: Vector3d;
  'moment_of_inertia'?: Vector3d;
}
interface PlanCollisionFreePTPRequest {
  /**
   * The robot setup as returned from the [getOptimizerConfiguration](#/operations/getOptimizerConfiguration) endpoint.
   */
  'robot_setup': OptimizerSetup;
  'start_joint_position': Array<number>;
  'target': PlanCollisionFreePTPRequestTarget;
  /**
   * A collection of identifiable colliders.
   */
  'static_colliders'?: {
    [key: string]: Collider;
  };
  /**
   * Collision motion group considered during the motion planning.
   */
  'collision_motion_group'?: CollisionMotionGroup;
}
/**
 * @type PlanCollisionFreePTPRequestTarget
 * The target position of the motion. The target can be defined in joint space as joint positions, or cartesian space as TCP pose.
 */
type PlanCollisionFreePTPRequestTarget = Array<number> | Pose2;
/**
 * The planning failed. The motion can be executed until the defected command part starts.
 */
interface PlanFailedOnTrajectoryResponse {
  /**
   * Identifier of the motion until the error.
   */
  'motion'?: string;
  'description'?: string;
  'last_valid_joint_position'?: Joints;
  'last_valid_tcp_pose'?: Pose;
  /**
   * Location on the trajectory where the error occurred. The location is defined as a floating point range from 0 to n, where 0 is the start of the trajectory and n is the end of the trajectory. n is the number commands. The decimal places represent the percentage of the defective command.
   */
  'error_location_on_trajectory'?: number;
  'joint_limit_exceeded'?: JointLimitExceeded;
  'singularity'?: Singularity;
  'safety_zone_violation'?: SafetyZoneViolation;
  'out_of_workspace'?: OutOfWorkspace;
}
/**
 * Starting point of motion is invalid. Therefore, planning a motion is not possible.
 */
interface PlanFailedResponse {
  'description'?: string;
  /**
   * Error in case no start joint position was provided. Every motion needs to start with a joint position as reference to uniquely define the kinematic configuration of the motion-group at the start the motion.
   */
  'start_joints_missing'?: object;
  /**
   * Error in case no motion commands were provided. Every planning needs to have at least one motion command to describe the path to be followed.
   */
  'commands_missing'?: object;
  'joint_limit_exceeded'?: JointLimitExceeded;
  'singularity'?: Singularity;
  'safety_zone_violation'?: SafetyZoneViolation;
  'out_of_workspace'?: OutOfWorkspace;
}
interface PlanRequest {
  /**
   * Identifier of the motion group.
   */
  'motion_group': string;
  /**
   * -| To define a motion the start joints have to be indicated. Cartesian movements will be in the same kinematic configuration as the start joint position until the first joint point-to-point motion. Motions can only be executed if the start joint position is the current joint position of the motion group. To retrieve the current joint position, use the endpoint [getCurrentMotionGroupState](#/operations/getCurrentMotionGroupState). To move the robot to the start joint position, use the endpoint [streamMoveToTrajectoryViaJointP2P](#/operations/streamMoveToTrajectoryViaJointP2P).
   */
  'start_joint_position': Joints;
  /**
   * List of motion commands. A command consists of a motion command (line, circle, joint_ptp, cartesian_ptp, cubic_spline) and corresponding settings (blending, limits override).
   */
  'commands': Array<Command>;
  /**
   * Tool identifier. If not set, the current tool is used.
   */
  'tcp'?: string;
  /**
   * Payload identifier. If unset, the currently set payload is used.
   */
  'payload'?: string;
}
/**
 * -| The plan response signals if the planned motion is executable, partially executable, or not executable. If the motion is executable or partially executable, the response contains an unique identifier for the motion and the end joint position. To execute the motion, use this unique identifier in the move endpoints [streamMoveForward](#/operations/streamMoveForward) or [streamMoveBackward](#/operations/streamMoveBackward). To retrieve information about this motion use the identifier [getMotionTrajectory](#/operations/getMotionTrajectory) and [getMotionTrajectorySample](#/operations/getMotionTrajectorySample). Use the end joint position to plan and concatenate the next motion. If an error occurred, the response contains feedback including the reason for failure and the location where the failure occurred.
 */
interface PlanResponse {
  'plan_successful_response'?: PlanSuccessfulResponse;
  'plan_failed_on_trajectory_response'?: PlanFailedOnTrajectoryResponse;
  'plan_failed_response'?: PlanFailedResponse;
}
/**
 * The motion can be executed entirely.
 */
interface PlanSuccessfulResponse {
  /**
   * Unique identifier of the motion. Use as reference to execute the motion or to retrieve information on the motion.
   */
  'motion': string;
  /**
   * The final joint position. Use this position as a start joint position to concatenate motions.
   */
  'end_joint_position': Joints;
}
interface PlanTrajectoryFailedResponse {
  'error_feedback': PlanTrajectoryFailedResponseErrorFeedback;
  'error_location_on_trajectory'?: number;
  /**
   * The joint trajectory from the start joint position to the error.
   */
  'joint_trajectory'?: JointTrajectory;
}
/**
 * @type PlanTrajectoryFailedResponseErrorFeedback
 */
type PlanTrajectoryFailedResponseErrorFeedback = FeedbackCollision | FeedbackJointLimitExceeded | FeedbackOutOfWorkspace | FeedbackSingularity;
interface PlanTrajectoryRequest {
  /**
   * The robot setup as returned from the [getOptimizerConfiguration](#/operations/getOptimizerConfiguration) endpoint.
   */
  'robot_setup': OptimizerSetup;
  'start_joint_position': Array<number>;
  /**
   * 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<MotionCommand>;
  /**
   * A collection of identifiable colliders.
   */
  'static_colliders'?: {
    [key: string]: Collider;
  };
  /**
   * Collision motion group considered during the motion planning.
   */
  'collision_motion_group'?: CollisionMotionGroup;
}
interface PlanTrajectoryResponse {
  'response': PlanTrajectoryResponseResponse;
}
/**
 * @type PlanTrajectoryResponseResponse
 */
type PlanTrajectoryResponseResponse = JointTrajectory | PlanTrajectoryFailedResponse;
/**
 * Defines an x/y-plane with infinite size.
 */
interface Plane2 {
  'shape_type': Plane2ShapeTypeEnum;
}
declare const Plane2ShapeTypeEnum: {
  readonly Plane: "plane";
};
type Plane2ShapeTypeEnum = typeof Plane2ShapeTypeEnum[keyof typeof Plane2ShapeTypeEnum];
/**
 * XY-plane.
 */
interface Plane3 {
  'shape_type': Plane3ShapeTypeEnum;
}
declare const Plane3ShapeTypeEnum: {
  readonly Plane: "plane";
};
type Plane3ShapeTypeEnum = typeof Plane3ShapeTypeEnum[keyof typeof Plane3ShapeTypeEnum];
interface PlannedMotion {
  /**
   * Identifier of the motion group.
   */
  'motion_group': string;
  /**
   * Timestamp for each sample [s].
   */
  'times': Array<number>;
  /**
   * List of Joint Positions [rad] for eache sample. The number of samples must match the number of timestamps provided in the times field.
   */
  'joint_positions': Array<Joints>;
  /**
   * Location for each sample, scalar value defining a position along a path. Typical range: 0 to `n`, `n` denoting the number of motion commands. Each integer value of the location corresponds to a specific motion command. If provided, the number of samples must match the number of timestamps provided in the times field.
   */
  'locations'?: Array<number>;
  /**
   * Tool identifier for which this sequence was calculated. Relevant for validation of the tcp-velocities. If not set, the current tool is assumed.
   */
  'tcp'?: string;
}
interface PlannerPose {
  'position'?: Vector3d;
  'orientation'?: Quaternion;
}
/**
 * All known joint and cartesian limits of a motion-group. Used for motion planning.
 */
interface PlanningLimits {
  /**
   * Joint position limits in [rad], configured in the safety setup, starting at base.
   */
  'joint_position_limits'?: Array<PlanningLimitsLimitRange>;
  /**
   * Maximum allowed velocity for joints in [rad/s or mm/s] of the safety setup, starting at base.
   */
  'joint_velocity_limits'?: Array<number>;
  /**
   * Maximum allowed acceleration for joints in [rad/s^2 or mm/s^2] of the safety setup, starting at base.
   */
  'joint_acceleration_limits'?: Array<number>;
  /**
   * Maximum allowed torque for joints in [Nm or N] of the safety setup, starting at base.
   */
  'joint_torque_limits'?: Array<number>;
  /**
   * At maximum one dimensional velocity in [mm/s] at TCP allowed.
   */
  'tcp_velocity_limit'?: number;
  /**
   * At maximum one dimensional acceleration in [mm/s^2] at TCP allowed.
   */
  'tcp_acceleration_limit'?: number;
  /**
   * At maximum one dimensional orientation velocity in [rad/s] at TCP allowed.
   */
  'tcp_orientation_velocity_limit'?: number;
  /**
   * At maximum one dimensional orientation acceleration in [rad/s^2] at TCP allowed.
   */
  'tcp_orientation_acceleration_limit'?: number;
  /**
   * At maximum one dimensional force in [N] at TCP allowed.
   */
  'tcp_force_limit'?: number;
  /**
   * At maximum one dimensional velocity in [mm/s] at the elbow allowed.
   */
  'elbow_velocity_limit'?: number;
  /**
   * At maximum one dimensional acceleration in [mm/s^2] at the elbow allowed.
   */
  'elbow_acceleration_limit'?: number;
  /**
   * At maximum one dimensional force in [N] at the elbow allowed.
   */
  'elbow_force_limit'?: number;
}
/**
 * The upper_limit must be greater then the lower_limit.
 */
interface PlanningLimitsLimitRange {
  'lower_limit': number;
  'upper_limit': number;
}
/**
 * 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'?: string;
  /**
   * 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;
}
interface PlaybackSpeedResponse {
  'playback_speed_response': PlaybackSpeedResponsePlaybackSpeedResponse;
}
interface PlaybackSpeedResponsePlaybackSpeedResponse {
  /**
   * Value of the requested playback speed in percent [%].
   */
  'requested_value': number;
}
interface PointCloud {
  'pointcloud': string;
}
/**
 * Representing a pose in space with its origin in `coordinate_system`. A pose consists of positional coordinates [x, y, z] in millimeters (mm) and orientational coordinates in axis-angle representation [rx, ry, rz] in radian (rad).
 */
interface Pose {
  /**
   * Position vector, defined in [x, y, z] with floating numbers in millimeters (ms).
   */
  'position': Vector3d;
  /**
   * Rotation vector, defined in [rx, ry, rz] with floating numbers. The rotation is represented in vector3 using an axis-angle representation: axis.normalized * angle (angle in radians).
   */
  'orientation'?: Vector3d;
  /**
   * Unique identifier addressing the reference coordinate system of the pose. Default is the world coordinate system.
   */
  'coordinate_system'?: string;
}
/**
 * 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 Pose2 {
  /**
   * Describes a position in 3D space. A three-dimensional vector [x, y, z] with double precision.
   */
  'position'?: Array<number>;
  /**
   * 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<number>;
}
/**
 * The metadata of a program.
 */
interface ProgramMetadata {
  /**
   * The unique identifier of the program.
   */
  'id': string;
  /**
   * The name of the program presented to the enduser.
   */
  'name': string;
  /**
   * The date when the program was created.
   */
  'created_date': string;
  /**
   * The date when the program was last updated.
   */
  'last_updated_date': string;
  /**
   * Whether the program is accessible for the enduser or only for the developer.
   */
  'is_hidden': boolean;
  /**
   * The path to the image of the program
   */
  'image'?: string;
}
interface ProgramRun {
  'id': string;
  'state': ProgramRunState;
  'logs'?: string;
  'stdout'?: string;
  'store'?: {
    [key: string]: StoreValue;
  };
  'error'?: string | null;
  'traceback'?: string | null;
  'start_time'?: number | null;
  'end_time'?: number | null;
  'execution_results'?: Array<ExecutionResult>;
}
interface ProgramRunObject {
  /**
   * The identifier of the program run.
   */
  'id': string;
  /**
   * The identifier of the program stored in the program library.
   */
  'program_id': string;
  /**
   * The status of the program run which shows which state the program run is currently is in.
   */
  'status': string;
  /**
   * The output of the program run, which provides the output generate while running the program.
   */
  'program_output'?: string;
  /**
   * ISO 8601 date-time format when the program run was created.
   */
  'created_at': string;
  /**
   * ISO 8601 date-time format when the program run was last updated.
   */
  'last_updated_at': string;
}
declare const ProgramRunState: {
  readonly NotStarted: "not started";
  readonly Running: "running";
  readonly Completed: "completed";
  readonly Failed: "failed";
  readonly Stopped: "stopped";
};
type ProgramRunState = typeof ProgramRunState[keyof typeof ProgramRunState];
interface ProgramRunnerReference {
  'id': string;
  'state': ProgramRunState;
}
/**
 * A pose (position and orientation)
 */
interface PyjectoryDatatypesCorePose {
  'position': Array<any>;
  'orientation': Array<any>;
}
/**
 * Rotation vector, defined in [rx, ry, rz] with floating numbers. The rotation is represented in vector3 using an axis-angle representation: axis.normalized * angle (angle in radians). Must be defined for the first pose of a path. If not defined for the rest of the path, the previous orientation will be used.
 */
interface PyjectoryDatatypesSerializerOrientation {
  'orientation': Array<any>;
}
/**
 * Object\'s position and orientaton, defined in [x, y, z, rx, ry, rz]. x,y,z are defined in millimeters. rx,ry,rz are defined in radians.
 */
interface PyjectoryDatatypesSerializerPose {
  'pose': Array<any>;
}
/**
 * Single point, defined in [x, y, z] with floating numbers. Must be defined.
 */
interface PyjectoryDatatypesSerializerPosition {
  'position': Array<any>;
}
/**
 * Configuration of the etcd client  This configuration is necessary to add an etcd server as device to the cell. The etcd server itself is running in the cell by default.  [etcd](https://etcd.io/) is a distributed, reliable key-value store that can be used to store values which can be addressed by Wandelscript in advanced Wandelscript programs.  Args:     identifier: the identifier name for etcd     host: The host name.  Default is \'etcd\'.     port : The port defined in the etcd manifest file. The default is 2379.
 */
interface PyripheryEtcdETCDConfiguration {
  'type'?: any;
  'identifier'?: string;
  'host'?: string;
  'port'?: number;
}
/**
 * The configuration of the Omniservice
 */
interface PyripheryHardwareIsaacIsaacConfiguration {
  'type'?: any;
  'identifier'?: string;
  'host'?: string;
  'prim_paths'?: {
    [key: string]: string;
  };
}
/**
 * Configuration of the OPCUAConnector  Args:     url: The URL of the OPC UA service
 */
interface PyripheryOpcuaOPCUAConfiguration {
  'type'?: any;
  'identifier'?: string;
  'url'?: string;
}
/**
 * Configuration of a Robot Controller.  This will configure the robot controller such that it is controllable through Wandelscript.  This is for advanced users only: it should not be necessary to change this configuration in most use cases.
 */
interface PyripheryPyraeControllerControllerConfiguration {
  'type'?: any;
  'identifier'?: string;
  'host'?: string;
  'controller_model_name'?: string;
  'rae_host'?: string;
  'rae_port'?: number;
}
/**
 * Configuration of a RAE Robot  Args:     model_name: Type of the robot that is initialized on the RAE     host: Host of the real robot. A virtual robot is used when \"localhost\" is given     motion_group_id: Motion group id of the robot     rae_host: Host of the RAEe     rae_port: Port of the RAE
 */
interface PyripheryPyraeRobotRobotConfiguration {
  'type'?: PyripheryPyraeRobotRobotConfigurationTypeEnum;
  'identifier'?: string;
  'host'?: string;
  'controller_model_name'?: string;
  'motion_group_id'?: string | null;
  'rae_host'?: string;
  'rae_port'?: number;
}
declare const PyripheryPyraeRobotRobotConfigurationTypeEnum: {
  readonly Robot: "robot";
  readonly RobotPlanner: "robot_planner";
};
type PyripheryPyraeRobotRobotConfigurationTypeEnum = typeof PyripheryPyraeRobotRobotConfigurationTypeEnum[keyof typeof PyripheryPyraeRobotRobotConfigurationTypeEnum];
interface PyripheryRoboticsConfigurableCollisionSceneConfigurableCollisionSceneConfigurationInput {
  'type'?: any;
  /**
   * A unique identifier for the collision scene.
   */
  'identifier'?: string;
  /**
   * A collection of static colliders within the scene, identified by their names.
   */
  'static_colliders'?: {
    [key: string]: ColliderInput;
  };
  /**
   * Configurations for robots within the scene. Allow for the specification of collision geometries and other robot-specific settings, identified by robot names.
   */
  'robot_configurations'?: {
    [key: string]: CollisionRobotConfigurationInput;
  };
}
interface PyripheryRoboticsConfigurableCollisionSceneConfigurableCollisionSceneConfigurationOutput {
  'type'?: any;
  /**
   * A unique identifier for the collision scene.
   */
  'identifier'?: string;
  /**
   * A collection of static colliders within the scene, identified by their names.
   */
  'static_colliders'?: {
    [key: string]: ColliderOutput;
  };
  /**
   * Configurations for robots within the scene. Allow for the specification of collision geometries and other robot-specific settings, identified by robot names.
   */
  'robot_configurations'?: {
    [key: string]: CollisionRobotConfigurationOutput;
  };
}
interface PyripheryRoboticsRobotcellTimerConfiguration {
  'type'?: PyripheryRoboticsRobotcellTimerConfigurationTypeEnum;
  'identifier'?: string;
}
declare const PyripheryRoboticsRobotcellTimerConfigurationTypeEnum: {
  readonly Timer: "timer";
  readonly SimulatedTimer: "simulated_timer";
};
type PyripheryRoboticsRobotcellTimerConfigurationTypeEnum = typeof PyripheryRoboticsRobotcellTimerConfigurationTypeEnum[keyof typeof PyripheryRoboticsRobotcellTimerConfigurationTypeEnum];
/**
 * The configuration of a simulated robot  Args:     initial_pose: The start pose of the robot, None means it is unknown
 */
interface PyripheryRoboticsSimulationRobotWithViewOpen3dConfiguration {
  'type'?: any;
  'identifier'?: string;
  'initial_pose'?: Array<number>;
}
interface PyripheryRoboticsSimulationSimulatedIOConfiguration {
  'type'?: any;
  'identifier'?: string;
}
interface PyripheryRoboticsSimulationSimulatedOPCUAConfiguration {
  'type'?: any;
  'identifier'?: string;
}
/**
 * A unit quaternion with double precision. The quaternion should be normalized: If interpreted as vector, its length has to be 1.
 */
interface Quaternion {
  'x': number;
  'y': number;
  'z': number;
  'w': number;
}
/**
 * The metadata of a recipe.
 */
interface RecipeMetadata {
  /**
   * The unique identifier of the recipe.
   */
  'id'?: string;
  'name': string;
  'created_date': string;
  'last_updated_date': string;
  'is_production': boolean;
  'program_id': string;
  'image'?: string;
}
/**
 * Defines an x-y plane with finite size.
 */
interface Rectangle {
  /**
   * The dimension in x direction in [mm].
   */
  'size_x': number;
  /**
   * The dimension in y direction in [mm].
   */
  'size_y': number;
}
/**
 * Defines an x/y-plane with finite size. Centred around the z-axis.
 */
interface Rectangle2 {
  'shape_type': Rectangle2ShapeTypeEnum;
  /**
   * The dimension in x-direction in [mm].
   */
  'size_x': number;
  /**
   * The dimension in y-direction in [mm].
   */
  'size_y': number;
}
declare const Rectangle2ShapeTypeEnum: {
  readonly Rectangle: "rectangle";
};
type Rectangle2ShapeTypeEnum = typeof Rectangle2ShapeTypeEnum[keyof typeof Rectangle2ShapeTypeEnum];
/**
 * Centered in XY-plane.
 */
interface Rectangle3 {
  'shape_type': Rectangle3ShapeTypeEnum;
  'size_x': number;
  'size_y': number;
}
declare const Rectangle3ShapeTypeEnum: {
  readonly Rectangle: "rectangle";
};
type Rectangle3ShapeTypeEnum = typeof Rectangle3ShapeTypeEnum[keyof typeof Rectangle3ShapeTypeEnum];
/**
 * A convex hull around four spheres. Sphere center points in x-y-plane, offset by either combination +-sizeX/+-sizeY. Alternative description: Rectangle in x-y-plane with a 3D padding.
 */
interface RectangularCapsule {
  /**
   * 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;
}
/**
 * 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 RectangularCapsule2 {
  'shape_type': RectangularCapsule2ShapeTypeEnum;
  /**
   * 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 RectangularCapsule2ShapeTypeEnum: {
  readonly RectangularCapsule: "rectangular_capsule";
};
type RectangularCapsule2ShapeTypeEnum = typeof RectangularCapsule2ShapeTypeEnum[keyof typeof RectangularCapsule2ShapeTypeEnum];
/**
 * Convex hull around four spheres. Sphere center points in XY-plane, offset by either combination \"+/- sizeX\" or \"+/- sizeY\".  Alternative description: Rectangle in x-y-plane with a 3D padding.
 */
interface RectangularCapsule3 {
  'shape_type': RectangularCapsule3ShapeTypeEnum;
  'radius': number;
  'sphere_center_distance_x': number;
  'sphere_center_distance_y': number;
}
declare const RectangularCapsule3ShapeTypeEnum: {
  readonly RectangularCapsule: "rectangular_capsule";
};
type RectangularCapsule3ShapeTypeEnum = typeof RectangularCapsule3ShapeTypeEnum[keyof typeof RectangularCapsule3ShapeTypeEnum];
/**
 * The channel that defines what a new Wandelbots NOVA version is.    * `next` the over all latest version   * `stable` newes patch of the current version
 */
declare const ReleaseChannel: {
  readonly Stable: "stable";
  readonly Next: "next";
};
type ReleaseChannel = typeof ReleaseChannel[keyof typeof ReleaseChannel];
/**
 * Wandelscript code string which describes a Program as text/plain
 */
interface Request {
  /**
   * Wandelscript code string which describes a Wandelscript Program as content/json.
   */
  'code': string;
  'initial_state'?: {
    [key: string]: CollectionValue;
  };
}
/**
 * Wandelscript code string which describes a program
 */
interface Request1 {
  /**
   * Wandelscript code string which describes a Wandelscript Program as content/json.
   */
  'code': string;
  'initial_state'?: {
    [key: string]: CollectionValue;
  };
}
interface ResponseGetValueProgramsValuesKeyGet {
  'pose': Array<any>;
  'position': Array<any>;
  'orientation': Array<any>;
  'image': string;
  'pointcloud': string;
  'array': Array<ResponseGetValuesProgramsValuesGetValue>;
}
interface ResponseGetValuesProgramsValuesGetValue {
  'pose': Array<any>;
  'position': Array<any>;
  'orientation': Array<any>;
  'image': string;
  'pointcloud': string;
  'array': Array<ResponseGetValuesProgramsValuesGetValue>;
}
/**
 * The configuration of a physical or virtual robot controller.
 */
interface RobotController {
  /**
   * A unique name of the Controller inside 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;
/**
 * Returns the whole current state of robot controller.
 */
interface RobotControllerState {
  /**
   * Identifier of the configured robot controller.
   */
  'controller': string;
  /**
   * 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.
   */
  'operation_mode': RobotControllerStateOperationModeEnum;
  /**
   * 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.
   */
  'safety_state': RobotControllerStateSafetyStateEnum;
  /**
   * Timestamp indicating when the represented information was received from the robot controller.
   */
  'timestamp': string;
  /**
   * 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<MotionGroupState>;
  /**
   * 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. It is of type string to represent uint64 values, which is not supported by OpenAPI.
   */
  'sequence_number': string;
}
declare const RobotControllerStateOperationModeEnum: {
  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 RobotControllerStateOperationModeEnum = typeof RobotControllerStateOperationModeEnum[keyof typeof RobotControllerStateOperationModeEnum];
declare const RobotControllerStateSafetyStateEnum: {
  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 RobotControllerStateSafetyStateEnum = typeof RobotControllerStateSafetyStateEnum[keyof typeof RobotControllerStateSafetyStateEnum];
/**
 * Describes a geometry encapsulating a given link from a robot.
 */
interface RobotLinkGeometry {
  /**
   * Determines how many sets of DH-parameter are applied to get from robot base coordinate system to the link coordinate system in which the geometry is defined.
   */
  'link_index': number;
  'geometry': Geometry;
}
/**
 * Collection of information on the current state of the robot
 */
interface RobotState {
  'pose': PyjectoryDatatypesCorePose;
  'joints'?: Array<number> | null;
}
/**
 * The system mode of the robot system.  ### ROBOT_SYSTEM_MODE_UNDEFINED  Indicates that the robot controller is currently performing a mode transition.  ### ROBOT_SYSTEM_MODE_DISCONNECT  There is no communication with the robot controller at all. All connections are closed. No command is sent to the robot controller while in this mode. No IO interaction is possible in this mode! All move requests will be rejected in this mode!  ### ROBOT_SYSTEM_MODE_MONITOR  A connection to the robot controller is established to only read the robot controller state. No command is sent to the robot controller while in this mode. It is possible to receive IO information. All move requests will be rejected in this mode!  ### ROBOT_SYSTEM_MODE_CONTROL  An active connection is established with the robot controller and the robot system is cyclic commanded to stay in its actual position. The robot controller state is received in the cycle time of the robot controller. Requests via the MotionService and JoggingService will be processed and executed in this mode. IO interaction is possible in this mode! **In this mode the robot system can be commanded to move.**  ### ROBOT_SYSTEM_MODE_FREE_DRIVE  Like ROBOT_SYSTEM_MODE_MONITOR, a connection to the robot controller is established to only read the robot controller state. The difference is that the motion groups can be moved by the user (Free Drive). Thus, the servo motors are turned on. All move requests will be rejected in this mode! **This mode is not supported by every robot!** Use [getSupportedModes](#/operations/getSupportedModes) to evaluate if the device supports free drive.
 */
declare const RobotSystemMode: {
  readonly RobotSystemModeUndefined: "ROBOT_SYSTEM_MODE_UNDEFINED";
  readonly RobotSystemModeDisconnect: "ROBOT_SYSTEM_MODE_DISCONNECT";
  readonly RobotSystemModeMonitor: "ROBOT_SYSTEM_MODE_MONITOR";
  readonly RobotSystemModeControl: "ROBOT_SYSTEM_MODE_CONTROL";
  readonly RobotSystemModeFreeDrive: "ROBOT_SYSTEM_MODE_FREE_DRIVE";
};
type RobotSystemMode = typeof RobotSystemMode[keyof typeof RobotSystemMode];
interface RobotTcp {
  /**
   * Identifier of this tcp.
   */
  'id': string;
  /**
   * A readable and changeable name for frontend visualization.
   */
  'readable_name'?: string;
  'position': Vector3d;
  'rotation'?: RotationAngles;
}
interface RobotTcps {
  'tcps': Array<RobotTcp>;
}
/**
 * The type of rotation description that is used to specify the rotation.  **Quaternion notation**  * The rotation is represented using a 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.  **Rotation Vector notation**  * The rotation is represented using an axis-angle representation: > axis = Vector[0:2] > angle = |axis| in [rad] > axis.normalized * angle  **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 RotationAngleTypes: {
  readonly Quaternion: "QUATERNION";
  readonly RotationVector: "ROTATION_VECTOR";
  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 RotationAngleTypes = typeof RotationAngleTypes[keyof typeof RotationAngleTypes];
/**
 * Defines rotation angles and their interpretation. Except of QUATERNION the angles are in [rad]. Rotation Vector order: X = Vector[0], Y = Vector[1], Z = Vector[2], W = Vector[3].
 */
interface RotationAngles {
  /**
   * The values for the rotation notation.
   */
  'angles': Array<number>;
  'type': RotationAngleTypes;
}
/**
 * The safety configuration of a motion-group. Used for motion planning.
 */
interface SafetyConfiguration {
  'global_limits': PlanningLimits;
  /**
   * All limits applied in certain SafetyZones.
   */
  'safety_zone_limits'?: Array<SafetyZoneLimits>;
  /**
   * SafetyZones are areas which cannot be entered or impose certain limits.
   */
  'safety_zones'?: Array<SafetyZone>;
  /**
   * The shape of the motion-group to validate against SafetyZones.
   */
  'robot_model_geometries'?: Array<RobotLinkGeometry>;
  /**
   * The shape of the TCP to validate against SafetyZones.
   */
  'tcp_geometries'?: Array<Geometry>;
}
interface SafetySetup {
  'safety_settings'?: Array<SafetySetupSafetySettings>;
  'safety_zones'?: Array<SafetySetupSafetyZone>;
  'robot_model_geometries'?: Array<RobotLinkGeometry>;
  'tool_geometries'?: Array<ToolGeometry>;
}
/**
 * Restricts the robot movements due to the safety configuration.
 */
interface SafetySetupSafetySettings {
  /**
   * The safety state that the settings are valid for.
   */
  'safety_state'?: SafetySetupSafetySettingsSafetyStateEnum;
  'settings'?: LimitSettings;
}
declare const SafetySetupSafetySettingsSafetyStateEnum: {
  readonly SafetyInvalid: "SAFETY_INVALID";
  readonly SafetyNormal: "SAFETY_NORMAL";
  readonly SafetyReduced: "SAFETY_REDUCED";
};
type SafetySetupSafetySettingsSafetyStateEnum = typeof SafetySetupSafetySettingsSafetyStateEnum[keyof typeof SafetySetupSafetySettingsSafetyStateEnum];
/**
 * Describes the physical space in which the safety limitations will be applied.
 */
interface SafetySetupSafetyZone {
  /**
   * A unique identifier.
   */
  'id'?: number;
  /**
   * The precedence if two zones overlap.
   */
  'priority'?: number;
  'geometry'?: Geometry;
  /**
   * Unique identifier of an specific motion-group if the safety zone only applies to it. If it is not set, then the safety zone applies to all motion-groups.
   */
  'motion_group_uid'?: number;
}
/**
 * A zone where the MotionGroup cannot enter or certain limits apply.
 */
interface SafetyZone {
  /**
   * A unique identifier.
   */
  'id': number;
  /**
   * The precedence if multiple zones overlap.
   */
  'priority': number;
  'geometry': Geometry;
}
/**
 * All limits which apply within a single safety zone.
 */
interface SafetyZoneLimits {
  'safety_zone': number;
  'limits': PlanningLimits;
}
/**
 * Safety zone violations occur when a motion is planned within a safety zone set on the controller. The message description indicates which part of the motion group collides with which safety zone.
 */
interface SafetyZoneViolation {
  'description'?: string;
}
interface ServiceStatus {
  'service': string;
  '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];
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;
}
/**
 * Defines an I/O that should be set upon reaching a certain location on the trajectory.
 */
interface SetIO {
  'io': IOValue;
  /**
   * The location on the trajectory where the I/O should be set.
   */
  'location': number;
}
/**
 * Set the velocity for executed movements of the motion in percent.
 */
interface SetPlaybackSpeed {
  /**
   * This represents the UUID of a motion. Every executable or partially executable motion is cached and an UUID is returned. Indicate the UUID to execute the motion or retrieve information on the motion.
   */
  'motion': string;
  /**
   * Set the velocity for executed movements of the motion in percent. A percentage of 100% means that the robot moves as fast as possible without violating the limits. Setting this value does not affect the overall shape of the velocity profile. Everything is slowed down by the same factor. Therefore, this should only be used for teaching and trajectory evaluation purposes. If the process requires a certain velocity, the respective limits should be set when planning the motion. This will not change the velocity override of the controller. The controller velocity override value shall be 100% to ensure controllability of the motion group.
   */
  'playback_speed_in_percent': number;
}
/**
 * A joint limit can contain a position (rad or mm), a velocity (rad/s or mm/s), an acceleration (rad/s² or mm/s²) or a jerk (rad/s³ or mm/s³).
 */
interface SingleJointLimit {
  /**
   * Definition of the joint where the limits are applied.
   */
  'joint': SingleJointLimitJointEnum;
  /**
   * Limit, unit depends on usage of this message structure.
   */
  'limit': number;
}
declare const SingleJointLimitJointEnum: {
  readonly JointnameAxisInvalid: "JOINTNAME_AXIS_INVALID";
  readonly JointnameAxis1: "JOINTNAME_AXIS_1";
  readonly JointnameAxis2: "JOINTNAME_AXIS_2";
  readonly JointnameAxis3: "JOINTNAME_AXIS_3";
  readonly JointnameAxis4: "JOINTNAME_AXIS_4";
  readonly JointnameAxis5: "JOINTNAME_AXIS_5";
  readonly JointnameAxis6: "JOINTNAME_AXIS_6";
  readonly JointnameAxis7: "JOINTNAME_AXIS_7";
  readonly JointnameAxis8: "JOINTNAME_AXIS_8";
  readonly JointnameAxis9: "JOINTNAME_AXIS_9";
  readonly JointnameAxis10: "JOINTNAME_AXIS_10";
  readonly JointnameAxis11: "JOINTNAME_AXIS_11";
  readonly JointnameAxis12: "JOINTNAME_AXIS_12";
};
type SingleJointLimitJointEnum = typeof SingleJointLimitJointEnum[keyof typeof SingleJointLimitJointEnum];
/**
 * 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.  The singularity type is the type of singularity that the robot is in. The singular joint position is the joint position of the robot when it is in a singularity.
 */
interface Singularity {
  'singularity_type'?: SingularitySingularityTypeEnum;
  'singular_joint_position'?: Joints;
}
declare const SingularitySingularityTypeEnum: {
  readonly SingularityTypeUnknown: "SINGULARITY_TYPE_UNKNOWN";
  readonly SingularityTypeWrist: "SINGULARITY_TYPE_WRIST";
  readonly SingularityTypeElbow: "SINGULARITY_TYPE_ELBOW";
  readonly SingularityTypeShoulder: "SINGULARITY_TYPE_SHOULDER";
};
type SingularitySingularityTypeEnum = typeof SingularitySingularityTypeEnum[keyof typeof SingularitySingularityTypeEnum];
declare const SingularityTypeEnum: {
  readonly Wrist: "WRIST";
  readonly Elbow: "ELBOW";
  readonly Shoulder: "SHOULDER";
};
type SingularityTypeEnum = typeof SingularityTypeEnum[keyof typeof SingularityTypeEnum];
/**
 * Defines a spherical shape centered around an origin.
 */
interface Sphere {
  /**
   * The radius of the sphere in [mm].
   */
  'radius': number;
}
/**
 * Defines a spherical shape centred around the origin.
 */
interface Sphere2 {
  'shape_type': Sphere2ShapeTypeEnum;
  /**
   * The radius of the sphere in [mm].
   */
  'radius': number;
}
declare const Sphere2ShapeTypeEnum: {
  readonly Sphere: "sphere";
};
type Sphere2ShapeTypeEnum = typeof Sphere2ShapeTypeEnum[keyof typeof Sphere2ShapeTypeEnum];
/**
 * Centered around origin.
 */
interface Sphere3 {
  'shape_type': Sphere3ShapeTypeEnum;
  'radius': number;
}
declare const Sphere3ShapeTypeEnum: {
  readonly Sphere: "sphere";
};
type Sphere3ShapeTypeEnum = typeof Sphere3ShapeTypeEnum[keyof typeof Sphere3ShapeTypeEnum];
/**
 * The response will be sent one time at the end of every execution signalling that the motion group has stopped moving.
 */
interface Standstill {
  'standstill': StandstillStandstill;
}
/**
 * The reason why the movement is paused.
 */
declare const StandstillReason: {
  readonly ReasonMotionEnded: "REASON_MOTION_ENDED";
  readonly ReasonUserPausedMotion: "REASON_USER_PAUSED_MOTION";
  readonly ReasonWaitingForIo: "REASON_WAITING_FOR_IO";
  readonly ReasonPausedOnIo: "REASON_PAUSED_ON_IO";
};
type StandstillReason = typeof StandstillReason[keyof typeof StandstillReason];
interface StandstillStandstill {
  'reason': StandstillReason;
  'location': number;
  /**
   * Current state of the controller and motion group which came to a standstill.
   */
  'state': RobotControllerState;
}
/**
 * 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'?: string;
  'direction'?: Direction;
  /**
   * Attaches a list of I/O commands to the trajectory. The I/Os 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 I/O is not set.
   */
  'set_ios'?: Array<SetIO>;
  /**
   * Defines an I/O that is listened to before the movement. Execution starts if the defined comparator evaluates to `true`.
   */
  'start_on_io'?: StartOnIO;
  /**
   * Defines an I/O that is listened to during the movement. Execution pauses if the defined comparator evaluates to `true`.
   */
  'pause_on_io'?: PauseOnIO;
}
/**
 * Defines an I/O 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;
}
/**
 * The `Status` type defines a logical error model that is suitable for different programming environments including REST APIs and RPC APIs. It is used by [gRPC](https://github.com/grpc). Each `status` message contains three pieces of data: error code, error message, and error details. You can find out more about this error model and how to work with it in the [API Design Guide](https://cloud.google.com/apis/design/errors).
 */
interface Status {
  /**
   * The status code, which should be an enum value of [google.rpc.Code](https://github.com/googleapis/googleapis/blob/master/google/rpc/code.proto).
   */
  'code'?: number;
  /**
   * An error message in English.
   */
  'message'?: string;
  /**
   * A list of messages that carry the error details. There is a common set of message types for APIs to use. > Currently, this is unused.
   */
  'details'?: Array<GoogleProtobufAny>;
}
/**
 * The response will be sent once at the end of every motion signalling that the motion group has stopped moving.
 */
interface StopResponse {
  'stop_code': StopResponseStopCodeEnum;
  /**
   * Will provide detailed information about the reason for stopping.
   */
  'message'?: string;
  'location_on_trajectory': number;
}
declare const StopResponseStopCodeEnum: {
  readonly StopCodeUnknown: "STOP_CODE_UNKNOWN";
  readonly StopCodeUserRequest: "STOP_CODE_USER_REQUEST";
  readonly StopCodePathEnd: "STOP_CODE_PATH_END";
  readonly StopCodeJointLimitReached: "STOP_CODE_JOINT_LIMIT_REACHED";
  readonly StopCodeIo: "STOP_CODE_IO";
  readonly StopCodeForceLimit: "STOP_CODE_FORCE_LIMIT";
  readonly StopCodeError: "STOP_CODE_ERROR";
};
type StopResponseStopCodeEnum = typeof StopResponseStopCodeEnum[keyof typeof StopResponseStopCodeEnum];
interface StoreValue {
  'pose': Array<any>;
  'position': Array<any>;
  'orientation': Array<any>;
  'image': string;
  'pointcloud': string;
  'array': Array<ResponseGetValuesProgramsValuesGetValue>;
}
interface StreamMoveBackward {
  'backward': MoveRequest;
}
interface StreamMoveForward {
  'forward': MoveRequest;
}
interface StreamMovePlaybackSpeed {
  'playback_speed': SetPlaybackSpeed;
}
/**
 * @type StreamMoveRequest
 */
type StreamMoveRequest = StreamMoveBackward | StreamMoveForward | StreamMovePlaybackSpeed | StreamMoveToTrajectory | StreamStop;
/**
 * The stream will return MoveResponse repeatedly as long as defined in `response_rate` until the movement is completed. Finally, a single StopResponse is returned and the stream is closed.
 */
interface StreamMoveResponse {
  /**
   * This field is filled during the movement.
   */
  'move_response'?: MoveResponse;
  /**
   * This field is filled when the movement is finished. It is the final response
   */
  'stop_response'?: StopResponse;
  /**
   * The current state of the robot controller and motion group in motion.
   */
  'state'?: RobotControllerState;
}
interface StreamMoveToTrajectory {
  'to_trajectory': MoveToTrajectoryViaJointPTPRequest;
}
interface StreamStop {
  'stop': MotionId;
}
/**
 * Representing a robot pose in operational space aware of a configured TCP.
 */
interface TcpPose {
  'position': Vector3d;
  'orientation': Vector3d;
  /**
   * Unique name of base coordinate system, if empty world is used.
   */
  'coordinate_system'?: string;
  /**
   * Identifier of tcp on controller.
   */
  'tcp': string;
}
/**
 * Request to compute the TCP pose for a single joint position sample.
 */
interface TcpPoseRequest {
  /**
   * Unique identifier of the motion-group.
   */
  'motion_group': string;
  'joint_position': Joints;
  /**
   * Specifies the TCP at which the pose is calculated via its unique identifier. Optional. If not provided, the currently active TCP is used.
   */
  'tcp'?: string;
  /**
   * Unique identifier of the base coordinate system of the calculated pose. Optional. If empty, world is used.
   */
  'coordinate_system'?: string;
}
/**
 * Describes a geometry encapsulating a given tool from a robot.
 */
interface ToolGeometry {
  /**
   * Identifier of this tcp.
   */
  'tcp': string;
  /**
   * The shape of the tool to validate against SafetyZones.
   */
  'geometries'?: Array<Geometry>;
}
/**
 * A sample of a trajectory is a single point of the trajectory at a specific location.
 */
interface TrajectorySample {
  'tcp_pose'?: Pose;
  /**
   * [mm/s]
   */
  'tcp_velocity'?: number;
  /**
   * [mm/s^2]
   */
  'tcp_acceleration'?: number;
  /**
   * [rad/s]
   */
  'tcp_orientation_velocity'?: number;
  /**
   * [rad/s^2]
   */
  'tcp_orientation_acceleration'?: number;
  'joint_position'?: Joints;
  'joint_velocity'?: Joints;
  'joint_acceleration'?: Joints;
  'joint_torques'?: Joints;
  /**
   * [s]
   */
  'time'?: number;
  /**
   * location on trajectory
   */
  'location_on_trajectory'?: number;
}
interface TriggerObject {
  /**
   * The identifier of the trigger.
   */
  'id'?: string;
  /**
   * The identifier of the program to run when the trigger condition is met.
   */
  'program_id': string;
  /**
   * Indicates whether the trigger is enabled or not.
   */
  'enabled': boolean;
  'type': TriggerType;
  'config': OpcuaNodeValueTriggerConfig;
  /**
   * ISO 8601 date-time format when the trigger was created.
   */
  'created_at': string;
  /**
   * ISO 8601 date-time format when the trigger was last updated.
   */
  'last_updated_at': string;
  /**
   * The program runs that were triggered by this trigger.
   */
  'program_runs'?: Array<string>;
}
/**
 * The type of the trigger.
 */
declare const TriggerType: {
  readonly OpcuaNodeValue: "opcua_node_value";
};
type TriggerType = typeof TriggerType[keyof typeof TriggerType];
/**
 * The configuration of a physical Universal Robots controller has to contain IP address of the controller.
 */
interface UniversalrobotsController {
  'kind'?: UniversalrobotsControllerKindEnum;
  'controllerIp': string;
}
declare const UniversalrobotsControllerKindEnum: {
  readonly UniversalrobotsController: "UniversalrobotsController";
};
type UniversalrobotsControllerKindEnum = typeof UniversalrobotsControllerKindEnum[keyof typeof UniversalrobotsControllerKindEnum];
/**
 * An update is defined by the indicated Wandelbots NOVA release channel.
 */
interface UpdateNovaVersionRequest {
  'channel': ReleaseChannel;
}
/**
 * This message is used to update the metadata of a program. Only the set fields get updated.
 */
interface UpdateProgramMetadataRequest {
  'name'?: string;
  'is_hidden'?: boolean;
  'image'?: string;
}
/**
 * This message is used to update the metadata of a recipe. Only the set fields get updated.
 */
interface UpdateRecipeMetadataRequest {
  'name'?: string;
  'is_production'?: boolean;
  'program_id'?: string;
}
interface UpdateTriggerRequest {
  /**
   * The identifier of the program to run when the trigger condition is met.
   */
  'program_id'?: string;
  /**
   * Whether the trigger is enabled or not.
   */
  'enabled'?: boolean;
  'config'?: OpcuaNodeValueTriggerConfig;
}
interface ValidationError {
  'loc': Array<ValidationErrorLocInner>;
  'msg': string;
  'type': string;
}
interface ValidationError2 {
  'loc': Array<ValidationError2LocInner>;
  'msg': string;
  'type': string;
}
interface ValidationError2LocInner {}
/**
 * @type ValidationErrorLocInner
 */
type ValidationErrorLocInner = number | string;
interface Value {
  'pose': Array<any>;
  'position': Array<any>;
  'orientation': Array<any>;
  'image': string;
  'pointcloud': string;
  'array': Array<CollectionValue>;
}
/**
 * A 3 dimensional Vector with double precision.
 */
interface Vector3d {
  'x': number;
  'y': number;
  'z': number;
}
/**
 * A generic representation of a version number.
 */
interface VersionNumber {
  'major_version': number;
  'minor_version'?: number;
  'build_version'?: number;
  'bugfix_version'?: number;
  /**
   * If minor version is a wildcard set to true.
   */
  'minor_version_wildcard'?: boolean;
  /**
   * If build version is a wildcard set to true.
   */
  'build_version_wildcard'?: boolean;
  /**
   * If bugfix version is a wildcard set to true.
   */
  'bugfix_version_wildcard'?: boolean;
  /**
   * A string representation of the version e.g. 1.1.x.x.
   */
  'string_version'?: 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;
  'type'?: VirtualControllerTypes;
  /**
   * Complete JSON configuration of the virtual robot controller. Can be obtained from the physical controller\'s configuration via [getVirtualRobotConfiguration](#/operations/getVirtualRobotConfiguration). If this field is provided, the `type` field should not be used.
   */
  'json'?: string;
  /**
   * Initial joint position of the first motion group from the virtual robot controller. Provide the joint position as a JSON array containing 7 float values, each representing a joint position in radians, e.g. \"[0, 0, 0, 0, 0, 0, 0]\". If the robot has fewer than 7 joints, use \"0\" for each remaining position to ensure the array has exactly 7 values.
   */
  'position'?: string;
}
declare const VirtualControllerKindEnum: {
  readonly VirtualController: "VirtualController";
};
type VirtualControllerKindEnum = typeof VirtualControllerKindEnum[keyof typeof VirtualControllerKindEnum];
declare const VirtualControllerTypes: {
  readonly AbbIrb101003715: "abb-irb1010_037_15";
  readonly AbbIrb110004754: "abb-irb1100_0475_4";
  readonly AbbIrb11000584: "abb-irb1100_058_4";
  readonly AbbIrb12007: "abb-irb1200_7";
  readonly AbbIrb13000911: "abb-irb1300_09_11";
  readonly AbbIrb130011510: "abb-irb1300_115_10";
  readonly AbbIrb13001412: "abb-irb1300_14_12";
  readonly AbbIrb1300147: "abb-irb1300_14_7";
  readonly AbbIrb16001210: "abb-irb1600_12_10";
  readonly AbbIrb1600126: "abb-irb1600_12_6";
  readonly AbbIrb160014510: "abb-irb1600_145_10";
  readonly AbbIrb16001456: "abb-irb1600_145_6";
  readonly AbbIrb2600Id18515: "abb-irb2600ID_185_15";
  readonly AbbIrb2600Id2008: "abb-irb2600ID_200_8";
  readonly AbbIrb260016512: "abb-irb2600_165_12";
  readonly AbbIrb260016520: "abb-irb2600_165_20";
  readonly AbbIrb260018512: "abb-irb2600_185_12";
  readonly AbbIrb460020545: "abb-irb4600_205_45";
  readonly AbbIrb460020560: "abb-irb4600_205_60";
  readonly AbbIrb460025020: "abb-irb4600_250_20";
  readonly AbbIrb460025540: "abb-irb4600_255_40";
  readonly AbbIrb6730210310: "abb-irb6730_210_310";
  readonly AbbIrb6730240290: "abb-irb6730_240_290";
  readonly FanucArcMate100iD: "fanuc-arc_mate_100iD";
  readonly FanucArcMate100iD16S: "fanuc-arc_mate_100iD16S";
  readonly FanucArcMate120iD: "fanuc-arc_mate_120iD";
  readonly FanucArcMate120iD12L: "fanuc-arc_mate_120iD12L";
  readonly FanucArcMate120iD35: "fanuc-arc_mate_120iD35";
  readonly FanucCr35ib: "fanuc-cr35ib";
  readonly FanucCr7ia: "fanuc-cr7ia";
  readonly FanucCr7ial: "fanuc-cr7ial";
  readonly FanucCrx10ia: "fanuc-crx10ia";
  readonly FanucCrx10ial: "fanuc-crx10ial";
  readonly FanucCrx20ial: "fanuc-crx20ial";
  readonly FanucCrx25ia: "fanuc-crx25ia";
  readonly FanucCrx30ia: "fanuc-crx30ia";
  readonly FanucCrx5ia: "fanuc-crx5ia";
  readonly FanucLrMate200iD: "fanuc-lr_mate_200iD";
  readonly FanucLrMate200iD4S: "fanuc-lr_mate_200iD4S";
  readonly FanucLrMate200iD7L: "fanuc-lr_mate_200iD7L";
  readonly FanucM10iD12: "fanuc-m10iD12";
  readonly FanucM10iD16S: "fanuc-m10iD16S";
  readonly FanucM20iD25: "fanuc-m20iD25";
  readonly FanucM20iD35: "fanuc-m20iD35";
  readonly FanucM710iC20L: "fanuc-m710iC20L";
  readonly FanucM900iB280L: "fanuc-m900iB280L";
  readonly FanucM900iB360E: "fanuc-m900iB360E";
  readonly FanucR2000ic125l: "fanuc-r2000ic125l";
  readonly FanucR2000ic210f: "fanuc-r2000ic210f";
  readonly KukaKr10R1100: "kuka-kr10_r1100";
  readonly KukaKr10R11002: "kuka-kr10_r1100_2";
  readonly KukaKr10R900: "kuka-kr10_r900";
  readonly KukaKr10R9002: "kuka-kr10_r900_2";
  readonly KukaKr120R27002: "kuka-kr120_r2700_2";
  readonly KukaKr120R31002: "kuka-kr120_r3100_2";
  readonly KukaKr120R39002K: "kuka-kr120_r3900_2_k";
  readonly KukaKr12R18102: "kuka-kr12_r1810_2";
  readonly KukaKr150R2: "kuka-kr150_r2";
  readonly KukaKr16R16102: "kuka-kr16_r1610_2";
  readonly KukaKr16R20102: "kuka-kr16_r2010_2";
  readonly KukaKr20R1810: "kuka-kr20_r1810";
  readonly KukaKr20R18102: "kuka-kr20_r1810_2";
  readonly KukaKr210R2700: "kuka-kr210_r2700";
  readonly KukaKr210R2700Extra: "kuka-kr210_r2700_extra";
  readonly KukaKr210R27002: "kuka-kr210_r2700_2";
  readonly KukaKr210R31002: "kuka-kr210_r3100_2";
  readonly KukaKr210R33002: "kuka-kr210_r3300_2";
  readonly KukaKr240R2700: "kuka-kr240_r2700";
  readonly KukaKr240R2900: "kuka-kr240_r2900";
  readonly KukaKr240R37002: "kuka-kr240_r3700_2";
  readonly KukaKr250R27002: "kuka-kr250_r2700_2";
  readonly KukaKr270R2700: "kuka-kr270_r2700";
  readonly KukaKr30R2100: "kuka-kr30_r2100";
  readonly KukaKr30R3: "kuka-kr30_r3";
  readonly KukaKr360L2403: "kuka-kr360_l240_3";
  readonly KukaKr3R540: "kuka-kr3_r540";
  readonly KukaKr4R600: "kuka-kr4_r600";
  readonly KukaKr500L3403: "kuka-kr500_l340_3";
  readonly KukaKr50R2500: "kuka-kr50_r2500";
  readonly KukaKr60R3: "kuka-kr60_r3";
  readonly KukaKr6R1820: "kuka-kr6_r1820";
  readonly KukaKr6R7002: "kuka-kr6_r700_2";
  readonly KukaKr6R700Sixx: "kuka-kr6_r700_sixx";
  readonly KukaKr6R900: "kuka-kr6_r900";
  readonly KukaKr6R9002: "kuka-kr6_r900_2";
  readonly KukaKr70R2100: "kuka-kr70_r2100";
  readonly KukaLbrIisy11R1300: "kuka-lbr_iisy_11_r1300";
  readonly UniversalrobotsUr10cb: "universalrobots-ur10cb";
  readonly UniversalrobotsUr10e: "universalrobots-ur10e";
  readonly UniversalrobotsUr12e: "universalrobots-ur12e";
  readonly UniversalrobotsUr16e: "universalrobots-ur16e";
  readonly UniversalrobotsUr20e: "universalrobots-ur20e";
  readonly UniversalrobotsUr3e: "universalrobots-ur3e";
  readonly UniversalrobotsUr5cb: "universalrobots-ur5cb";
  readonly UniversalrobotsUr5e: "universalrobots-ur5e";
  readonly UniversalrobotsUr7e: "universalrobots-ur7e";
  readonly YaskawaAr1440: "yaskawa-ar1440";
  readonly YaskawaAr1730: "yaskawa-ar1730";
  readonly YaskawaAr2010: "yaskawa-ar2010";
  readonly YaskawaAr3120: "yaskawa-ar3120";
  readonly YaskawaAr700: "yaskawa-ar700";
  readonly YaskawaAr900: "yaskawa-ar900";
  readonly YaskawaGp110: "yaskawa-gp110";
  readonly YaskawaGp12: "yaskawa-gp12";
  readonly YaskawaGp180: "yaskawa-gp180";
  readonly YaskawaGp180120: "yaskawa-gp180-120";
  readonly YaskawaGp20hl: "yaskawa-gp20hl";
  readonly YaskawaGp215: "yaskawa-gp215";
  readonly YaskawaGp225: "yaskawa-gp225";
  readonly YaskawaGp25: "yaskawa-gp25";
  readonly YaskawaGp250: "yaskawa-gp250";
  readonly YaskawaGp2512: "yaskawa-gp25_12";
  readonly YaskawaGp280: "yaskawa-gp280";
  readonly YaskawaGp35L: "yaskawa-gp35L";
  readonly YaskawaGp400: "yaskawa-gp400";
  readonly YaskawaGp50: "yaskawa-gp50";
  readonly YaskawaGp600: "yaskawa-gp600";
  readonly YaskawaGp7: "yaskawa-gp7";
  readonly YaskawaGp8: "yaskawa-gp8";
  readonly YaskawaGp88: "yaskawa-gp88";
  readonly YaskawaHc10dtp: "yaskawa-hc10dtp";
  readonly YaskawaHc20dtp: "yaskawa-hc20dtp";
};
type VirtualControllerTypes = typeof VirtualControllerTypes[keyof typeof VirtualControllerTypes];
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 configuration of a physical Yaskawa robot controller has to contain IP address of the controller.
 */
interface YaskawaController {
  'kind'?: YaskawaControllerKindEnum;
  'controllerIp': string;
}
declare const YaskawaControllerKindEnum: {
  readonly YaskawaController: "YaskawaController";
};
type YaskawaControllerKindEnum = typeof YaskawaControllerKindEnum[keyof typeof YaskawaControllerKindEnum];
/**
 * 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.  After adding the application to the cell, open the application on the Wandelbots NOVA home screen.  Read [build your application](/docs/docs/development/) for more information.  <!-- theme: none --> > #### Predefined Environment Variables > - `NOVA_API`: The endpoint where the API is reachable from the container serving the Application. > - `BASE_PATH`: The root path of the deployed Application. It will be reachable via: http://$host/$BASE_PATH > - `CELL_NAME`: The name of the cell where the application is deployed.
   * @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<RequestArgs>;
  /**
   * **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<RequestArgs>;
  /**
   * **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<RequestArgs>;
  /**
   * **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 the \'Update Configuration\' endpoint.
   * @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<RequestArgs>;
  /**
   * **Required permissions:** `can_access_apps` - View application configurations ___  List all GUI applications that have been added to a cell. with the \'Add Application\' endpoint. 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<RequestArgs>;
  /**
   * **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<RequestArgs>;
};
/**
 * 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.  After adding the application to the cell, open the application on the Wandelbots NOVA home screen.  Read [build your application](/docs/docs/development/) for more information.  <!-- theme: none --> > #### Predefined Environment Variables > - `NOVA_API`: The endpoint where the API is reachable from the container serving the Application. > - `BASE_PATH`: The root path of the deployed Application. It will be reachable via: http://$host/$BASE_PATH > - `CELL_NAME`: The name of the cell where the application is deployed.
   * @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<void>>;
  /**
   * **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<void>>;
  /**
   * **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<void>>;
  /**
   * **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 the \'Update Configuration\' endpoint.
   * @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<App>>;
  /**
   * **Required permissions:** `can_access_apps` - View application configurations ___  List all GUI applications that have been added to a cell. with the \'Add Application\' endpoint. 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<Array<string>>>;
  /**
   * **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<void>>;
};
/**
 * 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.  After adding the application to the cell, open the application on the Wandelbots NOVA home screen.  Read [build your application](/docs/docs/development/) for more information.  <!-- theme: none --> > #### Predefined Environment Variables > - `NOVA_API`: The endpoint where the API is reachable from the container serving the Application. > - `BASE_PATH`: The root path of the deployed Application. It will be reachable via: http://$host/$BASE_PATH > - `CELL_NAME`: The name of the cell where the application is deployed.
   * @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<void>;
  /**
   * **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<void>;
  /**
   * **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<void>;
  /**
   * **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 the \'Update Configuration\' endpoint.
   * @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<App>;
  /**
   * **Required permissions:** `can_access_apps` - View application configurations ___  List all GUI applications that have been added to a cell. with the \'Add Application\' endpoint. 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<Array<string>>;
  /**
   * **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<void>;
};
/**
 * 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.  After adding the application to the cell, open the application on the Wandelbots NOVA home screen.  Read [build your application](/docs/docs/development/) for more information.  <!-- theme: none --> > #### Predefined Environment Variables > - `NOVA_API`: The endpoint where the API is reachable from the container serving the Application. > - `BASE_PATH`: The root path of the deployed Application. It will be reachable via: http://$host/$BASE_PATH > - `CELL_NAME`: The name of the cell where the application is deployed.
   * @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<void, any, {}>>;
  /**
   * **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<void, any, {}>>;
  /**
   * **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<void, any, {}>>;
  /**
   * **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 the \'Update Configuration\' endpoint.
   * @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<App, any, {}>>;
  /**
   * **Required permissions:** `can_access_apps` - View application configurations ___  List all GUI applications that have been added to a cell. with the \'Add Application\' endpoint. 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<string[], any, {}>>;
  /**
   * **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<void, any, {}>>;
}
/**
 * CellApi - axios parameter creator
 */
declare const CellApiAxiosParamCreator: (configuration?: Configuration) => {
  /**
   * **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<RequestArgs>;
  /**
   * **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](docs/wandelbots-nova-api/#create-a-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<RequestArgs>;
  /**
   * **Required permissions:** `can_access_system` - View system status and metadata ___  List all cell resources.  > **NOTE** > > The output generated by this endpoint can be too large for the site to handle, and may produce an error or incorrect output. > Use `curl` in combination with `> output.json` to capture the output, or use an API client like Postman.
   * @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<RequestArgs>;
  /**
   * **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<RequestArgs>;
  /**
   * **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<RequestArgs>;
  /**
   * **Required permissions:** `can_manage_cells` - Create, update, or delete cells ___  Update the definition of the entire Cell.
   * @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<RequestArgs>;
};
/**
 * CellApi - functional programming interface
 */
declare const CellApiFp: (configuration?: Configuration) => {
  /**
   * **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<void>>;
  /**
   * **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](docs/wandelbots-nova-api/#create-a-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<void>>;
  /**
   * **Required permissions:** `can_access_system` - View system status and metadata ___  List all cell resources.  > **NOTE** > > The output generated by this endpoint can be too large for the site to handle, and may produce an error or incorrect output. > Use `curl` in combination with `> output.json` to capture the output, or use an API client like Postman.
   * @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<Cell>>;
  /**
   * **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<Array<ServiceStatus>>>;
  /**
   * **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<Array<string>>>;
  /**
   * **Required permissions:** `can_manage_cells` - Create, update, or delete cells ___  Update the definition of the entire Cell.
   * @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<void>>;
};
/**
 * CellApi - factory interface
 */
declare const CellApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
  /**
   * **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<void>;
  /**
   * **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](docs/wandelbots-nova-api/#create-a-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<void>;
  /**
   * **Required permissions:** `can_access_system` - View system status and metadata ___  List all cell resources.  > **NOTE** > > The output generated by this endpoint can be too large for the site to handle, and may produce an error or incorrect output. > Use `curl` in combination with `> output.json` to capture the output, or use an API client like Postman.
   * @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<Cell>;
  /**
   * **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<Array<ServiceStatus>>;
  /**
   * **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<Array<string>>;
  /**
   * **Required permissions:** `can_manage_cells` - Create, update, or delete cells ___  Update the definition of the entire Cell.
   * @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<void>;
};
/**
 * CellApi - object-oriented interface
 */
declare class CellApi extends BaseAPI {
  /**
   * **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<void, any, {}>>;
  /**
   * **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](docs/wandelbots-nova-api/#create-a-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<void, any, {}>>;
  /**
   * **Required permissions:** `can_access_system` - View system status and metadata ___  List all cell resources.  > **NOTE** > > The output generated by this endpoint can be too large for the site to handle, and may produce an error or incorrect output. > Use `curl` in combination with `> output.json` to capture the output, or use an API client like Postman.
   * @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<Cell, any, {}>>;
  /**
   * **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<ServiceStatus[], any, {}>>;
  /**
   * **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<string[], any, {}>>;
  /**
   * **Required permissions:** `can_manage_cells` - Create, update, or delete cells ___  Update the definition of the entire Cell.
   * @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<void, any, {}>>;
}
/**
 * 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.  <!-- theme: warning --> > **WARNING** > > Using it in conjunction with the settings app may lead to unpredictable behavior.
   * @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<RequestArgs>;
  /**
   * **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 the \'Add Robot Controller\' endpoint.  <!-- theme: warning --> > **WARNING** > > Using it in conjunction with the settings app may lead to unpredictable behavior.
   * @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<RequestArgs>;
  /**
   * **Required permissions:** `can_manage_controllers` - Create, update, or delete robot controllers ___  Delete a robot controller from the cell.  <!-- theme: warning --> > **WARNING** > > Using it in conjunction with the settings app may lead to unpredictable behavior.
   * @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<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Get the current state of a robot controller.
   * @summary State of Device
   * @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<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Get the current robot system mode of a registered robot controller. The robot system mode indicates if a robot controller can be used. See [setDefaultMode](#/operations/setDefaultMode) for more information about the different modes. The mode is influenced by the operating mode of the robot controller. The operating mode can be changed via [setDefaultMode](#/operations/setDefaultMode). Request the current operating mode of the robot controller via [getCurrentRobotControllerState](#/operations/getCurrentRobotControllerState).
   * @summary Current Mode
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} controller Unique identifier to address a controller in the cell.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getMode: (cell: string, controller: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Get the configuration for a robot controller.
   * @summary Robot 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}
   */
  getRobotController: (cell: string, controller: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Lists supported operating modes. Usually cobots support free drive and control, industrial robots only support control.
   * @summary Supported Motion Modes
   * @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}
   */
  getSupportedModes: (cell: string, controller: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **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.  > **NOTE** > > The output generated by this endpoint can be too large for the site to handle and may produce an error or incorrect output. > Use `curl` in combination with `> output.json` to capture the output, or use an API client like Postman.
   * @summary Virtual Robot 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}
   */
  getVirtualRobotConfiguration: (cell: string, controller: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  List all configured 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}
   */
  listControllers: (cell: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **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** > > 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 {SetDefaultModeModeEnum} mode
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  setDefaultMode: (cell: string, controller: string, mode: SetDefaultModeModeEnum, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  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. <!-- theme: danger --> > **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 (e.g by using the (getActivePayload)[getActivePayload] endpoint), > - 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 Collobarative Robots (\"Cobots\"). Use the (getSupportedModes)[getSupportedModes] endpoint to check if the robot controller supports free drive mode.
   * @summary Stream Free Drive 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 {number} [responseRate]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  streamFreeDrive: (cell: string, controller: string, responseRate?: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Receive updates of the current robot system mode of a robot controller via websocket upon robot system mode change. See [setDefaultMode](#/operations/setDefaultMode) for more information about the different modes.
   * @summary Stream Mode Change
   * @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}
   */
  streamModeChange: (cell: string, controller: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Receive updates of the state of a robot controller.
   * @summary Stream State of Device
   * @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}
   */
  streamRobotControllerState: (cell: string, controller: string, responseRate?: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **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.  <!-- theme: warning --> > **WARNING** > > Using it in conjunction with the settings app may lead to unpredictable behavior.   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.  <!-- theme: info --> > **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 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 {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<RequestArgs>;
};
/**
 * 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.  <!-- theme: warning --> > **WARNING** > > Using it in conjunction with the settings app may lead to unpredictable behavior.
   * @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<void>>;
  /**
   * **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 the \'Add Robot Controller\' endpoint.  <!-- theme: warning --> > **WARNING** > > Using it in conjunction with the settings app may lead to unpredictable behavior.
   * @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<void>>;
  /**
   * **Required permissions:** `can_manage_controllers` - Create, update, or delete robot controllers ___  Delete a robot controller from the cell.  <!-- theme: warning --> > **WARNING** > > Using it in conjunction with the settings app may lead to unpredictable behavior.
   * @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<void>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Get the current state of a robot controller.
   * @summary State of Device
   * @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<RobotControllerState>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Get the current robot system mode of a registered robot controller. The robot system mode indicates if a robot controller can be used. See [setDefaultMode](#/operations/setDefaultMode) for more information about the different modes. The mode is influenced by the operating mode of the robot controller. The operating mode can be changed via [setDefaultMode](#/operations/setDefaultMode). Request the current operating mode of the robot controller via [getCurrentRobotControllerState](#/operations/getCurrentRobotControllerState).
   * @summary Current Mode
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} controller Unique identifier to address a controller in the cell.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getMode(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<GetModeResponse>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Get the configuration for a robot controller.
   * @summary Robot 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}
   */
  getRobotController(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<RobotController>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Lists supported operating modes. Usually cobots support free drive and control, industrial robots only support control.
   * @summary Supported Motion Modes
   * @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}
   */
  getSupportedModes(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ControllerCapabilities>>;
  /**
   * **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.  > **NOTE** > > The output generated by this endpoint can be too large for the site to handle and may produce an error or incorrect output. > Use `curl` in combination with `> output.json` to capture the output, or use an API client like Postman.
   * @summary Virtual Robot 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}
   */
  getVirtualRobotConfiguration(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<VirtualRobotConfiguration>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  List all configured 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}
   */
  listControllers(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ControllerInstanceList>>;
  /**
   * **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** > > 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 {SetDefaultModeModeEnum} mode
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  setDefaultMode(cell: string, controller: string, mode: SetDefaultModeModeEnum, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  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. <!-- theme: danger --> > **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 (e.g by using the (getActivePayload)[getActivePayload] endpoint), > - 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 Collobarative Robots (\"Cobots\"). Use the (getSupportedModes)[getSupportedModes] endpoint to check if the robot controller supports free drive mode.
   * @summary Stream Free Drive 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 {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<RobotControllerState>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Receive updates of the current robot system mode of a robot controller via websocket upon robot system mode change. See [setDefaultMode](#/operations/setDefaultMode) for more information about the different modes.
   * @summary Stream Mode Change
   * @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}
   */
  streamModeChange(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ModeChangeResponse>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Receive updates of the state of a robot controller.
   * @summary Stream State of Device
   * @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}
   */
  streamRobotControllerState(cell: string, controller: string, responseRate?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<RobotControllerState>>;
  /**
   * **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.  <!-- theme: warning --> > **WARNING** > > Using it in conjunction with the settings app may lead to unpredictable behavior.   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.  <!-- theme: info --> > **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 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 {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<void>>;
};
/**
 * 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.  <!-- theme: warning --> > **WARNING** > > Using it in conjunction with the settings app may lead to unpredictable behavior.
   * @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<void>;
  /**
   * **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 the \'Add Robot Controller\' endpoint.  <!-- theme: warning --> > **WARNING** > > Using it in conjunction with the settings app may lead to unpredictable behavior.
   * @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<void>;
  /**
   * **Required permissions:** `can_manage_controllers` - Create, update, or delete robot controllers ___  Delete a robot controller from the cell.  <!-- theme: warning --> > **WARNING** > > Using it in conjunction with the settings app may lead to unpredictable behavior.
   * @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<void>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Get the current state of a robot controller.
   * @summary State of Device
   * @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<RobotControllerState>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Get the current robot system mode of a registered robot controller. The robot system mode indicates if a robot controller can be used. See [setDefaultMode](#/operations/setDefaultMode) for more information about the different modes. The mode is influenced by the operating mode of the robot controller. The operating mode can be changed via [setDefaultMode](#/operations/setDefaultMode). Request the current operating mode of the robot controller via [getCurrentRobotControllerState](#/operations/getCurrentRobotControllerState).
   * @summary Current Mode
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} controller Unique identifier to address a controller in the cell.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getMode(cell: string, controller: string, options?: RawAxiosRequestConfig): AxiosPromise<GetModeResponse>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Get the configuration for a robot controller.
   * @summary Robot 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}
   */
  getRobotController(cell: string, controller: string, options?: RawAxiosRequestConfig): AxiosPromise<RobotController>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Lists supported operating modes. Usually cobots support free drive and control, industrial robots only support control.
   * @summary Supported Motion Modes
   * @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}
   */
  getSupportedModes(cell: string, controller: string, options?: RawAxiosRequestConfig): AxiosPromise<ControllerCapabilities>;
  /**
   * **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.  > **NOTE** > > The output generated by this endpoint can be too large for the site to handle and may produce an error or incorrect output. > Use `curl` in combination with `> output.json` to capture the output, or use an API client like Postman.
   * @summary Virtual Robot 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}
   */
  getVirtualRobotConfiguration(cell: string, controller: string, options?: RawAxiosRequestConfig): AxiosPromise<VirtualRobotConfiguration>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  List all configured 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}
   */
  listControllers(cell: string, options?: RawAxiosRequestConfig): AxiosPromise<ControllerInstanceList>;
  /**
   * **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** > > 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 {SetDefaultModeModeEnum} mode
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  setDefaultMode(cell: string, controller: string, mode: SetDefaultModeModeEnum, options?: RawAxiosRequestConfig): AxiosPromise<void>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  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. <!-- theme: danger --> > **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 (e.g by using the (getActivePayload)[getActivePayload] endpoint), > - 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 Collobarative Robots (\"Cobots\"). Use the (getSupportedModes)[getSupportedModes] endpoint to check if the robot controller supports free drive mode.
   * @summary Stream Free Drive 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 {number} [responseRate]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  streamFreeDrive(cell: string, controller: string, responseRate?: number, options?: RawAxiosRequestConfig): AxiosPromise<RobotControllerState>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Receive updates of the current robot system mode of a robot controller via websocket upon robot system mode change. See [setDefaultMode](#/operations/setDefaultMode) for more information about the different modes.
   * @summary Stream Mode Change
   * @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}
   */
  streamModeChange(cell: string, controller: string, options?: RawAxiosRequestConfig): AxiosPromise<ModeChangeResponse>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Receive updates of the state of a robot controller.
   * @summary Stream State of Device
   * @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}
   */
  streamRobotControllerState(cell: string, controller: string, responseRate?: number, options?: RawAxiosRequestConfig): AxiosPromise<RobotControllerState>;
  /**
   * **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.  <!-- theme: warning --> > **WARNING** > > Using it in conjunction with the settings app may lead to unpredictable behavior.   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.  <!-- theme: info --> > **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 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 {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<void>;
};
/**
 * 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.  <!-- theme: warning --> > **WARNING** > > Using it in conjunction with the settings app may lead to unpredictable behavior.
   * @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<void, any, {}>>;
  /**
   * **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 the \'Add Robot Controller\' endpoint.  <!-- theme: warning --> > **WARNING** > > Using it in conjunction with the settings app may lead to unpredictable behavior.
   * @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<void, any, {}>>;
  /**
   * **Required permissions:** `can_manage_controllers` - Create, update, or delete robot controllers ___  Delete a robot controller from the cell.  <!-- theme: warning --> > **WARNING** > > Using it in conjunction with the settings app may lead to unpredictable behavior.
   * @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<void, any, {}>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Get the current state of a robot controller.
   * @summary State of Device
   * @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<RobotControllerState, any, {}>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Get the current robot system mode of a registered robot controller. The robot system mode indicates if a robot controller can be used. See [setDefaultMode](#/operations/setDefaultMode) for more information about the different modes. The mode is influenced by the operating mode of the robot controller. The operating mode can be changed via [setDefaultMode](#/operations/setDefaultMode). Request the current operating mode of the robot controller via [getCurrentRobotControllerState](#/operations/getCurrentRobotControllerState).
   * @summary Current Mode
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} controller Unique identifier to address a controller in the cell.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getMode(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<GetModeResponse, any, {}>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Get the configuration for a robot controller.
   * @summary Robot 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}
   */
  getRobotController(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<RobotController, any, {}>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Lists supported operating modes. Usually cobots support free drive and control, industrial robots only support control.
   * @summary Supported Motion Modes
   * @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}
   */
  getSupportedModes(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<ControllerCapabilities, any, {}>>;
  /**
   * **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.  > **NOTE** > > The output generated by this endpoint can be too large for the site to handle and may produce an error or incorrect output. > Use `curl` in combination with `> output.json` to capture the output, or use an API client like Postman.
   * @summary Virtual Robot 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}
   */
  getVirtualRobotConfiguration(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<VirtualRobotConfiguration, any, {}>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  List all configured 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}
   */
  listControllers(cell: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<ControllerInstanceList, any, {}>>;
  /**
   * **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** > > 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 {SetDefaultModeModeEnum} mode
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  setDefaultMode(cell: string, controller: string, mode: SetDefaultModeModeEnum, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<void, any, {}>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  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. <!-- theme: danger --> > **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 (e.g by using the (getActivePayload)[getActivePayload] endpoint), > - 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 Collobarative Robots (\"Cobots\"). Use the (getSupportedModes)[getSupportedModes] endpoint to check if the robot controller supports free drive mode.
   * @summary Stream Free Drive 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 {number} [responseRate]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  streamFreeDrive(cell: string, controller: string, responseRate?: number, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<RobotControllerState, any, {}>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Receive updates of the current robot system mode of a robot controller via websocket upon robot system mode change. See [setDefaultMode](#/operations/setDefaultMode) for more information about the different modes.
   * @summary Stream Mode Change
   * @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}
   */
  streamModeChange(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<ModeChangeResponse, any, {}>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Receive updates of the state of a robot controller.
   * @summary Stream State of Device
   * @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}
   */
  streamRobotControllerState(cell: string, controller: string, responseRate?: number, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<RobotControllerState, any, {}>>;
  /**
   * **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.  <!-- theme: warning --> > **WARNING** > > Using it in conjunction with the settings app may lead to unpredictable behavior.   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.  <!-- theme: info --> > **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 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 {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<void, any, {}>>;
}
declare const SetDefaultModeModeEnum: {
  readonly ModeMonitor: "MODE_MONITOR";
  readonly ModeControl: "MODE_CONTROL";
};
type SetDefaultModeModeEnum = typeof SetDefaultModeModeEnum[keyof typeof SetDefaultModeModeEnum];
/**
 * ControllerIOsApi - axios parameter creator
 */
declare const ControllerIOsApiAxiosParamCreator: (configuration?: Configuration) => {
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Lists the I/O descriptions of the robot controller. The I/O descriptions contain information such as the name of the I/O, the I/O type and the I/O unit. The set of available I/Os is defined by the robot controller. Each I/O has a unique identifier. If no identifiers are specified in the request, retrieve the full list of available I/Os in this endpoint.
   * @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<string>} [ios]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  listIODescriptions: (cell: string, controller: string, ios?: Array<string>, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Retrieves the current values of I/Os. The identifiers of the I/Os must be provided in the request. Request all available I/O identifiers via [listIODescriptions](#/operations/listIODescriptions).
   * @summary 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<string>} [ios]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  listIOValues: (cell: string, controller: string, ios?: Array<string>, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Set the values of outputs. All available I/O 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 might 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 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>} iOValue
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  setOutputValues: (cell: string, controller: string, iOValue: Array<IOValue>, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Continuously receive updates of I/O values via websocket. Updates are sent in the update rate of the controller.  > **NOTE** > > Do not request too many values simultaneously as the request is then 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. Consider that this might lead to a high amount of data transmitted.
   * @summary Stream 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<string>} [ios]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  streamIOValues: (cell: string, controller: string, ios?: Array<string>, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Wait until an I/O 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 I/O is compared with given value. Only set the value that corresponds to the value_type of the I/O, see (listIODescriptions)[listIODescriptions] for more information. Examples: If you want to wait until an analog input (\"AI_1\") is less than 10, you would set io to \"AI_1\" comparison_type to COMPARISON_LESS and only integer_value to 10. If you want to wait until an analog input (\"AI_2\") is greater than 5.0, you would set io to \"AI_2\" comparison_type to COMPARISON_GREATER and only floating_value to 5.0. If you want to wait until a digital input (\"DI_3\") is true, you would set io to \"DI_3\" comparison_type to COMPARISON_EQUAL and only boolean_value to 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 {string} io
   * @param {WaitForIOEventComparisonTypeEnum} comparisonType
   * @param {boolean} [booleanValue]
   * @param {string} [integerValue]
   * @param {number} [floatingValue]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  waitForIOEvent: (cell: string, controller: string, io: string, comparisonType: WaitForIOEventComparisonTypeEnum, booleanValue?: boolean, integerValue?: string, floatingValue?: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
/**
 * ControllerIOsApi - functional programming interface
 */
declare const ControllerIOsApiFp: (configuration?: Configuration) => {
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Lists the I/O descriptions of the robot controller. The I/O descriptions contain information such as the name of the I/O, the I/O type and the I/O unit. The set of available I/Os is defined by the robot controller. Each I/O has a unique identifier. If no identifiers are specified in the request, retrieve the full list of available I/Os in this endpoint.
   * @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<string>} [ios]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  listIODescriptions(cell: string, controller: string, ios?: Array<string>, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ListIODescriptionsResponse>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Retrieves the current values of I/Os. The identifiers of the I/Os must be provided in the request. Request all available I/O identifiers via [listIODescriptions](#/operations/listIODescriptions).
   * @summary 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<string>} [ios]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  listIOValues(cell: string, controller: string, ios?: Array<string>, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ListIOValuesResponse>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Set the values of outputs. All available I/O 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 might 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 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>} iOValue
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  setOutputValues(cell: string, controller: string, iOValue: Array<IOValue>, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Continuously receive updates of I/O values via websocket. Updates are sent in the update rate of the controller.  > **NOTE** > > Do not request too many values simultaneously as the request is then 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. Consider that this might lead to a high amount of data transmitted.
   * @summary Stream 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<string>} [ios]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  streamIOValues(cell: string, controller: string, ios?: Array<string>, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ListIOValuesResponse>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Wait until an I/O 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 I/O is compared with given value. Only set the value that corresponds to the value_type of the I/O, see (listIODescriptions)[listIODescriptions] for more information. Examples: If you want to wait until an analog input (\"AI_1\") is less than 10, you would set io to \"AI_1\" comparison_type to COMPARISON_LESS and only integer_value to 10. If you want to wait until an analog input (\"AI_2\") is greater than 5.0, you would set io to \"AI_2\" comparison_type to COMPARISON_GREATER and only floating_value to 5.0. If you want to wait until a digital input (\"DI_3\") is true, you would set io to \"DI_3\" comparison_type to COMPARISON_EQUAL and only boolean_value to 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 {string} io
   * @param {WaitForIOEventComparisonTypeEnum} comparisonType
   * @param {boolean} [booleanValue]
   * @param {string} [integerValue]
   * @param {number} [floatingValue]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  waitForIOEvent(cell: string, controller: string, io: string, comparisonType: WaitForIOEventComparisonTypeEnum, booleanValue?: boolean, integerValue?: string, floatingValue?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<boolean>>;
};
/**
 * ControllerIOsApi - factory interface
 */
declare const ControllerIOsApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Lists the I/O descriptions of the robot controller. The I/O descriptions contain information such as the name of the I/O, the I/O type and the I/O unit. The set of available I/Os is defined by the robot controller. Each I/O has a unique identifier. If no identifiers are specified in the request, retrieve the full list of available I/Os in this endpoint.
   * @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<string>} [ios]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  listIODescriptions(cell: string, controller: string, ios?: Array<string>, options?: RawAxiosRequestConfig): AxiosPromise<ListIODescriptionsResponse>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Retrieves the current values of I/Os. The identifiers of the I/Os must be provided in the request. Request all available I/O identifiers via [listIODescriptions](#/operations/listIODescriptions).
   * @summary 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<string>} [ios]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  listIOValues(cell: string, controller: string, ios?: Array<string>, options?: RawAxiosRequestConfig): AxiosPromise<ListIOValuesResponse>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Set the values of outputs. All available I/O 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 might 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 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>} iOValue
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  setOutputValues(cell: string, controller: string, iOValue: Array<IOValue>, options?: RawAxiosRequestConfig): AxiosPromise<void>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Continuously receive updates of I/O values via websocket. Updates are sent in the update rate of the controller.  > **NOTE** > > Do not request too many values simultaneously as the request is then 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. Consider that this might lead to a high amount of data transmitted.
   * @summary Stream 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<string>} [ios]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  streamIOValues(cell: string, controller: string, ios?: Array<string>, options?: RawAxiosRequestConfig): AxiosPromise<ListIOValuesResponse>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Wait until an I/O 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 I/O is compared with given value. Only set the value that corresponds to the value_type of the I/O, see (listIODescriptions)[listIODescriptions] for more information. Examples: If you want to wait until an analog input (\"AI_1\") is less than 10, you would set io to \"AI_1\" comparison_type to COMPARISON_LESS and only integer_value to 10. If you want to wait until an analog input (\"AI_2\") is greater than 5.0, you would set io to \"AI_2\" comparison_type to COMPARISON_GREATER and only floating_value to 5.0. If you want to wait until a digital input (\"DI_3\") is true, you would set io to \"DI_3\" comparison_type to COMPARISON_EQUAL and only boolean_value to 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 {string} io
   * @param {WaitForIOEventComparisonTypeEnum} comparisonType
   * @param {boolean} [booleanValue]
   * @param {string} [integerValue]
   * @param {number} [floatingValue]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  waitForIOEvent(cell: string, controller: string, io: string, comparisonType: WaitForIOEventComparisonTypeEnum, booleanValue?: boolean, integerValue?: string, floatingValue?: number, options?: RawAxiosRequestConfig): AxiosPromise<boolean>;
};
/**
 * ControllerIOsApi - object-oriented interface
 */
declare class ControllerIOsApi extends BaseAPI {
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Lists the I/O descriptions of the robot controller. The I/O descriptions contain information such as the name of the I/O, the I/O type and the I/O unit. The set of available I/Os is defined by the robot controller. Each I/O has a unique identifier. If no identifiers are specified in the request, retrieve the full list of available I/Os in this endpoint.
   * @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<string>} [ios]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  listIODescriptions(cell: string, controller: string, ios?: Array<string>, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<ListIODescriptionsResponse, any, {}>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Retrieves the current values of I/Os. The identifiers of the I/Os must be provided in the request. Request all available I/O identifiers via [listIODescriptions](#/operations/listIODescriptions).
   * @summary 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<string>} [ios]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  listIOValues(cell: string, controller: string, ios?: Array<string>, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<ListIOValuesResponse, any, {}>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Set the values of outputs. All available I/O 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 might 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 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>} iOValue
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  setOutputValues(cell: string, controller: string, iOValue: Array<IOValue>, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<void, any, {}>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Continuously receive updates of I/O values via websocket. Updates are sent in the update rate of the controller.  > **NOTE** > > Do not request too many values simultaneously as the request is then 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. Consider that this might lead to a high amount of data transmitted.
   * @summary Stream 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<string>} [ios]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  streamIOValues(cell: string, controller: string, ios?: Array<string>, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<ListIOValuesResponse, any, {}>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Wait until an I/O 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 I/O is compared with given value. Only set the value that corresponds to the value_type of the I/O, see (listIODescriptions)[listIODescriptions] for more information. Examples: If you want to wait until an analog input (\"AI_1\") is less than 10, you would set io to \"AI_1\" comparison_type to COMPARISON_LESS and only integer_value to 10. If you want to wait until an analog input (\"AI_2\") is greater than 5.0, you would set io to \"AI_2\" comparison_type to COMPARISON_GREATER and only floating_value to 5.0. If you want to wait until a digital input (\"DI_3\") is true, you would set io to \"DI_3\" comparison_type to COMPARISON_EQUAL and only boolean_value to 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 {string} io
   * @param {WaitForIOEventComparisonTypeEnum} comparisonType
   * @param {boolean} [booleanValue]
   * @param {string} [integerValue]
   * @param {number} [floatingValue]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  waitForIOEvent(cell: string, controller: string, io: string, comparisonType: WaitForIOEventComparisonTypeEnum, booleanValue?: boolean, integerValue?: string, floatingValue?: number, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<boolean, any, {}>>;
}
declare const WaitForIOEventComparisonTypeEnum: {
  readonly ComparisonTypeEqual: "COMPARISON_TYPE_EQUAL";
  readonly ComparisonTypeGreater: "COMPARISON_TYPE_GREATER";
  readonly ComparisonTypeLess: "COMPARISON_TYPE_LESS";
};
type WaitForIOEventComparisonTypeEnum = typeof WaitForIOEventComparisonTypeEnum[keyof typeof WaitForIOEventComparisonTypeEnum];
/**
 * CoordinateSystemsApi - axios parameter creator
 */
declare const CoordinateSystemsApiAxiosParamCreator: (configuration?: Configuration) => {
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Add a user coordinate system to the list of coordinate systems but not on a robot controller.  The coordinate system is defined by a name and an offset in another coordinate system referenced by the unique identifier of the reference coordinate system.  Will return the specification of the added coordinate systems which includes the unique identifier of the added coordinate system.  All available coordinate systems can be listed via the [listCoordinateSystems](#/operations/listCoordinateSystems) endpoint.
   * @summary Add
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {AddRequest} addRequest
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  addCoordinateSystem: (cell: string, addRequest: AddRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Removes a user coordinate system specified by the given identifier.  > **NOTE** > > If the coordinate system has originally been configured on the robot controller, it will remain on the controller even after this endpoint has been executed successfully..  This will remove the user coordinate system from the list of user coordinate systems but keep all dependent coordinate systems which use the deleted coordinate system as reference. Coordinate systems on the robot controller are not affected by this operation. They can be removed via the robot control panel only and will be removed in NOVA when the controller is removed. On virtual controllers, use the [deleteVirtualRobotCoordinateSystem](#/operations/deleteVirtualRobotCoordinateSystem) endpoint to remove coordinate systems from NOVA and the virtual controller.  All available coordinate systems can be listed via the [listCoordinateSystems](#/operations/listCoordinateSystems) endpoint.
   * @summary Delete
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} coordinateSystem Unique identifier addressing a coordinate system.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  deleteCoordinateSystem: (cell: string, coordinateSystem: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Request a coordinate system specification for a given identifier.  Use parameter rotation_type to get the orientation part of the transformation offset of the coordinate system returned in the requested rotation angle type. If parameter rotation_type is not set, the orientation part of the transformation offset of the coordinate system is returned in the rotation angle type used on the robot controller. This can be useful for visualization purposes in the client application due to equivalent numbers with robot control panel visualization.  User coordinate systems can be configured on a robot controller during setup or added to the system via the [addCoordinateSystem](#/operations/addCoordinateSystem) endpoint.  Updating the robot controller\'s configuration either requires credentials or is not possible. With the endpoint [addCoordinateSystem](#/operations/addCoordinateSystem) you can create a coordinate system without changing the robot controller\'s configuration.
   * @summary Description
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} coordinateSystem Unique identifier addressing a coordinate system.
   * @param {RotationAngleTypes} [rotationType]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getCoordinateSystem: (cell: string, coordinateSystem: string, rotationType?: RotationAngleTypes, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Lists all specifications of coordinate systems from robot controllers and user coordinate systems added to the system via the [addCoordinateSystem](#/operations/addCoordinateSystem) endpoint. Use parameter rotation_type to get the orientation part of the transformation offset of the coordinate system returned in the requested rotation angle type. If parameter rotation_type is not set, the orientation part of the transformation offset of the coordinate system is returned in the rotation angle type used on the robot controller. This can be useful for visualization purposes in the client application due to equivalent numbers with robot control panel visualization.  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.  Updating the robot controller\'s configuration either requires credentials or is not possible. With the endpoint [addCoordinateSystem](#/operations/addCoordinateSystem) you can create a coordinate system without changing the robot controller\'s configuration.
   * @summary List
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {RotationAngleTypes} [rotationType]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  listCoordinateSystems: (cell: string, rotationType?: RotationAngleTypes, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Transform a pose to another base.
   * @summary Transform
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} coordinateSystem Unique identifier addressing a coordinate system.
   * @param {Pose} pose
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  transformInCoordinateSystem: (cell: string, coordinateSystem: string, pose: Pose, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
/**
 * CoordinateSystemsApi - functional programming interface
 */
declare const CoordinateSystemsApiFp: (configuration?: Configuration) => {
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Add a user coordinate system to the list of coordinate systems but not on a robot controller.  The coordinate system is defined by a name and an offset in another coordinate system referenced by the unique identifier of the reference coordinate system.  Will return the specification of the added coordinate systems which includes the unique identifier of the added coordinate system.  All available coordinate systems can be listed via the [listCoordinateSystems](#/operations/listCoordinateSystems) endpoint.
   * @summary Add
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {AddRequest} addRequest
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  addCoordinateSystem(cell: string, addRequest: AddRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<CoordinateSystem>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Removes a user coordinate system specified by the given identifier.  > **NOTE** > > If the coordinate system has originally been configured on the robot controller, it will remain on the controller even after this endpoint has been executed successfully..  This will remove the user coordinate system from the list of user coordinate systems but keep all dependent coordinate systems which use the deleted coordinate system as reference. Coordinate systems on the robot controller are not affected by this operation. They can be removed via the robot control panel only and will be removed in NOVA when the controller is removed. On virtual controllers, use the [deleteVirtualRobotCoordinateSystem](#/operations/deleteVirtualRobotCoordinateSystem) endpoint to remove coordinate systems from NOVA and the virtual controller.  All available coordinate systems can be listed via the [listCoordinateSystems](#/operations/listCoordinateSystems) endpoint.
   * @summary Delete
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} coordinateSystem Unique identifier addressing a coordinate system.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  deleteCoordinateSystem(cell: string, coordinateSystem: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Request a coordinate system specification for a given identifier.  Use parameter rotation_type to get the orientation part of the transformation offset of the coordinate system returned in the requested rotation angle type. If parameter rotation_type is not set, the orientation part of the transformation offset of the coordinate system is returned in the rotation angle type used on the robot controller. This can be useful for visualization purposes in the client application due to equivalent numbers with robot control panel visualization.  User coordinate systems can be configured on a robot controller during setup or added to the system via the [addCoordinateSystem](#/operations/addCoordinateSystem) endpoint.  Updating the robot controller\'s configuration either requires credentials or is not possible. With the endpoint [addCoordinateSystem](#/operations/addCoordinateSystem) you can create a coordinate system without changing the robot controller\'s configuration.
   * @summary Description
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} coordinateSystem Unique identifier addressing a coordinate system.
   * @param {RotationAngleTypes} [rotationType]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getCoordinateSystem(cell: string, coordinateSystem: string, rotationType?: RotationAngleTypes, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<CoordinateSystem>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Lists all specifications of coordinate systems from robot controllers and user coordinate systems added to the system via the [addCoordinateSystem](#/operations/addCoordinateSystem) endpoint. Use parameter rotation_type to get the orientation part of the transformation offset of the coordinate system returned in the requested rotation angle type. If parameter rotation_type is not set, the orientation part of the transformation offset of the coordinate system is returned in the rotation angle type used on the robot controller. This can be useful for visualization purposes in the client application due to equivalent numbers with robot control panel visualization.  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.  Updating the robot controller\'s configuration either requires credentials or is not possible. With the endpoint [addCoordinateSystem](#/operations/addCoordinateSystem) you can create a coordinate system without changing the robot controller\'s configuration.
   * @summary List
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {RotationAngleTypes} [rotationType]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  listCoordinateSystems(cell: string, rotationType?: RotationAngleTypes, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ListResponse>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Transform a pose to another base.
   * @summary Transform
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} coordinateSystem Unique identifier addressing a coordinate system.
   * @param {Pose} pose
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  transformInCoordinateSystem(cell: string, coordinateSystem: string, pose: Pose, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Pose>>;
};
/**
 * CoordinateSystemsApi - factory interface
 */
declare const CoordinateSystemsApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Add a user coordinate system to the list of coordinate systems but not on a robot controller.  The coordinate system is defined by a name and an offset in another coordinate system referenced by the unique identifier of the reference coordinate system.  Will return the specification of the added coordinate systems which includes the unique identifier of the added coordinate system.  All available coordinate systems can be listed via the [listCoordinateSystems](#/operations/listCoordinateSystems) endpoint.
   * @summary Add
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {AddRequest} addRequest
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  addCoordinateSystem(cell: string, addRequest: AddRequest, options?: RawAxiosRequestConfig): AxiosPromise<CoordinateSystem>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Removes a user coordinate system specified by the given identifier.  > **NOTE** > > If the coordinate system has originally been configured on the robot controller, it will remain on the controller even after this endpoint has been executed successfully..  This will remove the user coordinate system from the list of user coordinate systems but keep all dependent coordinate systems which use the deleted coordinate system as reference. Coordinate systems on the robot controller are not affected by this operation. They can be removed via the robot control panel only and will be removed in NOVA when the controller is removed. On virtual controllers, use the [deleteVirtualRobotCoordinateSystem](#/operations/deleteVirtualRobotCoordinateSystem) endpoint to remove coordinate systems from NOVA and the virtual controller.  All available coordinate systems can be listed via the [listCoordinateSystems](#/operations/listCoordinateSystems) endpoint.
   * @summary Delete
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} coordinateSystem Unique identifier addressing a coordinate system.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  deleteCoordinateSystem(cell: string, coordinateSystem: string, options?: RawAxiosRequestConfig): AxiosPromise<void>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Request a coordinate system specification for a given identifier.  Use parameter rotation_type to get the orientation part of the transformation offset of the coordinate system returned in the requested rotation angle type. If parameter rotation_type is not set, the orientation part of the transformation offset of the coordinate system is returned in the rotation angle type used on the robot controller. This can be useful for visualization purposes in the client application due to equivalent numbers with robot control panel visualization.  User coordinate systems can be configured on a robot controller during setup or added to the system via the [addCoordinateSystem](#/operations/addCoordinateSystem) endpoint.  Updating the robot controller\'s configuration either requires credentials or is not possible. With the endpoint [addCoordinateSystem](#/operations/addCoordinateSystem) you can create a coordinate system without changing the robot controller\'s configuration.
   * @summary Description
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} coordinateSystem Unique identifier addressing a coordinate system.
   * @param {RotationAngleTypes} [rotationType]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getCoordinateSystem(cell: string, coordinateSystem: string, rotationType?: RotationAngleTypes, options?: RawAxiosRequestConfig): AxiosPromise<CoordinateSystem>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Lists all specifications of coordinate systems from robot controllers and user coordinate systems added to the system via the [addCoordinateSystem](#/operations/addCoordinateSystem) endpoint. Use parameter rotation_type to get the orientation part of the transformation offset of the coordinate system returned in the requested rotation angle type. If parameter rotation_type is not set, the orientation part of the transformation offset of the coordinate system is returned in the rotation angle type used on the robot controller. This can be useful for visualization purposes in the client application due to equivalent numbers with robot control panel visualization.  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.  Updating the robot controller\'s configuration either requires credentials or is not possible. With the endpoint [addCoordinateSystem](#/operations/addCoordinateSystem) you can create a coordinate system without changing the robot controller\'s configuration.
   * @summary List
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {RotationAngleTypes} [rotationType]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  listCoordinateSystems(cell: string, rotationType?: RotationAngleTypes, options?: RawAxiosRequestConfig): AxiosPromise<ListResponse>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Transform a pose to another base.
   * @summary Transform
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} coordinateSystem Unique identifier addressing a coordinate system.
   * @param {Pose} pose
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  transformInCoordinateSystem(cell: string, coordinateSystem: string, pose: Pose, options?: RawAxiosRequestConfig): AxiosPromise<Pose>;
};
/**
 * CoordinateSystemsApi - object-oriented interface
 */
declare class CoordinateSystemsApi extends BaseAPI {
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Add a user coordinate system to the list of coordinate systems but not on a robot controller.  The coordinate system is defined by a name and an offset in another coordinate system referenced by the unique identifier of the reference coordinate system.  Will return the specification of the added coordinate systems which includes the unique identifier of the added coordinate system.  All available coordinate systems can be listed via the [listCoordinateSystems](#/operations/listCoordinateSystems) endpoint.
   * @summary Add
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {AddRequest} addRequest
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  addCoordinateSystem(cell: string, addRequest: AddRequest, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<CoordinateSystem, any, {}>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Removes a user coordinate system specified by the given identifier.  > **NOTE** > > If the coordinate system has originally been configured on the robot controller, it will remain on the controller even after this endpoint has been executed successfully..  This will remove the user coordinate system from the list of user coordinate systems but keep all dependent coordinate systems which use the deleted coordinate system as reference. Coordinate systems on the robot controller are not affected by this operation. They can be removed via the robot control panel only and will be removed in NOVA when the controller is removed. On virtual controllers, use the [deleteVirtualRobotCoordinateSystem](#/operations/deleteVirtualRobotCoordinateSystem) endpoint to remove coordinate systems from NOVA and the virtual controller.  All available coordinate systems can be listed via the [listCoordinateSystems](#/operations/listCoordinateSystems) endpoint.
   * @summary Delete
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} coordinateSystem Unique identifier addressing a coordinate system.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  deleteCoordinateSystem(cell: string, coordinateSystem: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<void, any, {}>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Request a coordinate system specification for a given identifier.  Use parameter rotation_type to get the orientation part of the transformation offset of the coordinate system returned in the requested rotation angle type. If parameter rotation_type is not set, the orientation part of the transformation offset of the coordinate system is returned in the rotation angle type used on the robot controller. This can be useful for visualization purposes in the client application due to equivalent numbers with robot control panel visualization.  User coordinate systems can be configured on a robot controller during setup or added to the system via the [addCoordinateSystem](#/operations/addCoordinateSystem) endpoint.  Updating the robot controller\'s configuration either requires credentials or is not possible. With the endpoint [addCoordinateSystem](#/operations/addCoordinateSystem) you can create a coordinate system without changing the robot controller\'s configuration.
   * @summary Description
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} coordinateSystem Unique identifier addressing a coordinate system.
   * @param {RotationAngleTypes} [rotationType]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getCoordinateSystem(cell: string, coordinateSystem: string, rotationType?: RotationAngleTypes, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<CoordinateSystem, any, {}>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Lists all specifications of coordinate systems from robot controllers and user coordinate systems added to the system via the [addCoordinateSystem](#/operations/addCoordinateSystem) endpoint. Use parameter rotation_type to get the orientation part of the transformation offset of the coordinate system returned in the requested rotation angle type. If parameter rotation_type is not set, the orientation part of the transformation offset of the coordinate system is returned in the rotation angle type used on the robot controller. This can be useful for visualization purposes in the client application due to equivalent numbers with robot control panel visualization.  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.  Updating the robot controller\'s configuration either requires credentials or is not possible. With the endpoint [addCoordinateSystem](#/operations/addCoordinateSystem) you can create a coordinate system without changing the robot controller\'s configuration.
   * @summary List
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {RotationAngleTypes} [rotationType]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  listCoordinateSystems(cell: string, rotationType?: RotationAngleTypes, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<ListResponse, any, {}>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Transform a pose to another base.
   * @summary Transform
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} coordinateSystem Unique identifier addressing a coordinate system.
   * @param {Pose} pose
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  transformInCoordinateSystem(cell: string, coordinateSystem: string, pose: Pose, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<Pose, any, {}>>;
}
/**
 * DeviceConfigurationApi - axios parameter creator
 */
declare const DeviceConfigurationApiAxiosParamCreator: (configuration?: Configuration) => {
  /**
   * **Required permissions:** `can_access_system` - View system status and metadata ___  Deprecated endpoint. Deletes **all** devices from the cell
   * @summary Delete Devices
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  clearDevices: (cell: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_access_system` - View system status and metadata ___  Deprecated endpoint.  Overwrite existing devices in an existing robot cell. The devices are added to the robot cell in the order they are specified in the request body.  Each device needs to have a unique identifier which is used to reference the device in Wandelscript.  Devices which can be configured in the cell:  - Robots - OPC UA devices  ## Parameters  - For more information about the available device configurations have a look at the **Schema** tab or in the  provided examples.
   * @summary Create Devices
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {Array<CreateDeviceRequestInner>} createDeviceRequestInner
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  createDevice: (cell: string, createDeviceRequestInner: Array<CreateDeviceRequestInner>, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_access_system` - View system status and metadata ___  Deprecated endpoint. Deletes a specific device from the cell.
   * @summary Delete Device
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} identifier
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  deleteDevice: (cell: string, identifier: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_access_system` - View system status and metadata ___  Deprecated endpoint. Returns information about a device.
   * @summary Device Information
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} identifier
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  getDevice: (cell: string, identifier: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_access_system` - View system status and metadata ___  Deprecated endpoint.  Lists all devices which are configured in the cell: - Robots - Databases - OPC UA devices
   * @summary List All Devices
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  listDevices: (cell: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
/**
 * DeviceConfigurationApi - functional programming interface
 */
declare const DeviceConfigurationApiFp: (configuration?: Configuration) => {
  /**
   * **Required permissions:** `can_access_system` - View system status and metadata ___  Deprecated endpoint. Deletes **all** devices from the cell
   * @summary Delete Devices
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  clearDevices(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
  /**
   * **Required permissions:** `can_access_system` - View system status and metadata ___  Deprecated endpoint.  Overwrite existing devices in an existing robot cell. The devices are added to the robot cell in the order they are specified in the request body.  Each device needs to have a unique identifier which is used to reference the device in Wandelscript.  Devices which can be configured in the cell:  - Robots - OPC UA devices  ## Parameters  - For more information about the available device configurations have a look at the **Schema** tab or in the  provided examples.
   * @summary Create Devices
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {Array<CreateDeviceRequestInner>} createDeviceRequestInner
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  createDevice(cell: string, createDeviceRequestInner: Array<CreateDeviceRequestInner>, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<any>>;
  /**
   * **Required permissions:** `can_access_system` - View system status and metadata ___  Deprecated endpoint. Deletes a specific device from the cell.
   * @summary Delete Device
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} identifier
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  deleteDevice(cell: string, identifier: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
  /**
   * **Required permissions:** `can_access_system` - View system status and metadata ___  Deprecated endpoint. Returns information about a device.
   * @summary Device Information
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} identifier
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  getDevice(cell: string, identifier: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<any>>;
  /**
   * **Required permissions:** `can_access_system` - View system status and metadata ___  Deprecated endpoint.  Lists all devices which are configured in the cell: - Robots - Databases - OPC UA devices
   * @summary List All Devices
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  listDevices(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<ListDevices200ResponseInner>>>;
};
/**
 * DeviceConfigurationApi - factory interface
 */
declare const DeviceConfigurationApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
  /**
   * **Required permissions:** `can_access_system` - View system status and metadata ___  Deprecated endpoint. Deletes **all** devices from the cell
   * @summary Delete Devices
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  clearDevices(cell: string, options?: RawAxiosRequestConfig): AxiosPromise<void>;
  /**
   * **Required permissions:** `can_access_system` - View system status and metadata ___  Deprecated endpoint.  Overwrite existing devices in an existing robot cell. The devices are added to the robot cell in the order they are specified in the request body.  Each device needs to have a unique identifier which is used to reference the device in Wandelscript.  Devices which can be configured in the cell:  - Robots - OPC UA devices  ## Parameters  - For more information about the available device configurations have a look at the **Schema** tab or in the  provided examples.
   * @summary Create Devices
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {Array<CreateDeviceRequestInner>} createDeviceRequestInner
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  createDevice(cell: string, createDeviceRequestInner: Array<CreateDeviceRequestInner>, options?: RawAxiosRequestConfig): AxiosPromise<any>;
  /**
   * **Required permissions:** `can_access_system` - View system status and metadata ___  Deprecated endpoint. Deletes a specific device from the cell.
   * @summary Delete Device
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} identifier
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  deleteDevice(cell: string, identifier: string, options?: RawAxiosRequestConfig): AxiosPromise<void>;
  /**
   * **Required permissions:** `can_access_system` - View system status and metadata ___  Deprecated endpoint. Returns information about a device.
   * @summary Device Information
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} identifier
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  getDevice(cell: string, identifier: string, options?: RawAxiosRequestConfig): AxiosPromise<any>;
  /**
   * **Required permissions:** `can_access_system` - View system status and metadata ___  Deprecated endpoint.  Lists all devices which are configured in the cell: - Robots - Databases - OPC UA devices
   * @summary List All Devices
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  listDevices(cell: string, options?: RawAxiosRequestConfig): AxiosPromise<Array<ListDevices200ResponseInner>>;
};
/**
 * DeviceConfigurationApi - object-oriented interface
 */
declare class DeviceConfigurationApi extends BaseAPI {
  /**
   * **Required permissions:** `can_access_system` - View system status and metadata ___  Deprecated endpoint. Deletes **all** devices from the cell
   * @summary Delete Devices
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  clearDevices(cell: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<void, any, {}>>;
  /**
   * **Required permissions:** `can_access_system` - View system status and metadata ___  Deprecated endpoint.  Overwrite existing devices in an existing robot cell. The devices are added to the robot cell in the order they are specified in the request body.  Each device needs to have a unique identifier which is used to reference the device in Wandelscript.  Devices which can be configured in the cell:  - Robots - OPC UA devices  ## Parameters  - For more information about the available device configurations have a look at the **Schema** tab or in the  provided examples.
   * @summary Create Devices
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {Array<CreateDeviceRequestInner>} createDeviceRequestInner
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  createDevice(cell: string, createDeviceRequestInner: Array<CreateDeviceRequestInner>, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<any, any, {}>>;
  /**
   * **Required permissions:** `can_access_system` - View system status and metadata ___  Deprecated endpoint. Deletes a specific device from the cell.
   * @summary Delete Device
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} identifier
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  deleteDevice(cell: string, identifier: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<void, any, {}>>;
  /**
   * **Required permissions:** `can_access_system` - View system status and metadata ___  Deprecated endpoint. Returns information about a device.
   * @summary Device Information
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} identifier
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  getDevice(cell: string, identifier: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<any, any, {}>>;
  /**
   * **Required permissions:** `can_access_system` - View system status and metadata ___  Deprecated endpoint.  Lists all devices which are configured in the cell: - Robots - Databases - OPC UA devices
   * @summary List All Devices
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  listDevices(cell: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<ListDevices200ResponseInner[], any, {}>>;
}
/**
 * LibraryProgramApi - axios parameter creator
 */
declare const LibraryProgramApiAxiosParamCreator: (configuration?: Configuration) => {
  /**
   * **Required permissions:** `can_manage_programs` - Create, update, or delete programs ___  <!-- theme: danger --> > **Experimental**  Creates a new program. The corresponding metadata is created as well.  ## Examples  ``` move via p2p() to [0, 0, 0, 0, 0, 0] move frame(\"flange\") to [1, 2, 0] move via line() to [1, 1, 0] a := planned_pose() ```  ``` {% from \'schneider_conveyor_v1.j2\' import schneider_conveyor_library -%}  {{ schneider_conveyor_library() }}  def start_main():     conveyor_speed_percentage = {{ conveyor_speed_percentage | round(4) }}     conveyer_speed = conveyor_speed_percentage*1500     schneider_conveyor_start(conveyer_speed) end ```
   * @summary Create Program
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} body
   * @param {string} [name]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  createProgram: (cell: string, body: string, name?: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_manage_programs` - Create, update, or delete programs ___  <!-- theme: danger --> > **Experimental** Deletes the program with the corresponding metadata. This action is irreversible. Does not delete the associated recipes.
   * @summary Delete Program
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} program Recieved from [listProgramMetadata](#/operations/listProgramMetadata) or from the response of [createProgram](#/operations/createProgram).
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  deleteProgram: (cell: string, program: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_manage_programs` - Create, update, or delete programs ___  <!-- theme: danger --> > **Experimental** Deletes the provided list of programs with the corresponding metadata. This action is irreversible. Does not delete the associated recipes.
   * @summary Delete Program List
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {Array<string>} programIds Received from [listProgramMetadata](#/operations/listProgramMetadata) or from the response of [createProgram](#/operations/createProgram).
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  deleteProgramList: (cell: string, programIds: Array<string>, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** Returns the content of the program. The identifier of the program is received upon creation or from the metadata list of all the programs.
   * @summary Get Program
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} program Recieved from [listProgramMetadata](#/operations/listProgramMetadata) or from the response of [createProgram](#/operations/createProgram).
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getProgram: (cell: string, program: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_manage_programs` - Create, update, or delete programs ___  <!-- theme: danger --> > **Experimental** Updates the content of the program. The update overwrites the existing content. The metadata is updated in correspondence.  ## Examples  ``` move via p2p() to [0, 0, 0, 0, 0, 0]  move frame(\"flange\") to [1, 2, 0]  move via line() to [1, 1, 0]  a := planned_pose()  ```  ``` {% from \'schneider_conveyor_v1.j2\' import schneider_conveyor_library -%}  {{ schneider_conveyor_library() }}  def start_main():     conveyor_speed_percentage = {{ conveyor_speed_percentage | round(4) }}     conveyer_speed = conveyor_speed_percentage*1500     schneider_conveyor_start(conveyer_speed) end ```
   * @summary Update Program
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} program Recieved from [listProgramMetadata](#/operations/listProgramMetadata) or from the response of [createProgram](#/operations/createProgram).
   * @param {string} body
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  updateProgram: (cell: string, program: string, body: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
/**
 * LibraryProgramApi - functional programming interface
 */
declare const LibraryProgramApiFp: (configuration?: Configuration) => {
  /**
   * **Required permissions:** `can_manage_programs` - Create, update, or delete programs ___  <!-- theme: danger --> > **Experimental**  Creates a new program. The corresponding metadata is created as well.  ## Examples  ``` move via p2p() to [0, 0, 0, 0, 0, 0] move frame(\"flange\") to [1, 2, 0] move via line() to [1, 1, 0] a := planned_pose() ```  ``` {% from \'schneider_conveyor_v1.j2\' import schneider_conveyor_library -%}  {{ schneider_conveyor_library() }}  def start_main():     conveyor_speed_percentage = {{ conveyor_speed_percentage | round(4) }}     conveyer_speed = conveyor_speed_percentage*1500     schneider_conveyor_start(conveyer_speed) end ```
   * @summary Create Program
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} body
   * @param {string} [name]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  createProgram(cell: string, body: string, name?: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ProgramMetadata>>;
  /**
   * **Required permissions:** `can_manage_programs` - Create, update, or delete programs ___  <!-- theme: danger --> > **Experimental** Deletes the program with the corresponding metadata. This action is irreversible. Does not delete the associated recipes.
   * @summary Delete Program
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} program Recieved from [listProgramMetadata](#/operations/listProgramMetadata) or from the response of [createProgram](#/operations/createProgram).
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  deleteProgram(cell: string, program: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ProgramMetadata>>;
  /**
   * **Required permissions:** `can_manage_programs` - Create, update, or delete programs ___  <!-- theme: danger --> > **Experimental** Deletes the provided list of programs with the corresponding metadata. This action is irreversible. Does not delete the associated recipes.
   * @summary Delete Program List
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {Array<string>} programIds Received from [listProgramMetadata](#/operations/listProgramMetadata) or from the response of [createProgram](#/operations/createProgram).
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  deleteProgramList(cell: string, programIds: Array<string>, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ListProgramMetadataResponse>>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** Returns the content of the program. The identifier of the program is received upon creation or from the metadata list of all the programs.
   * @summary Get Program
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} program Recieved from [listProgramMetadata](#/operations/listProgramMetadata) or from the response of [createProgram](#/operations/createProgram).
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getProgram(cell: string, program: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<string>>;
  /**
   * **Required permissions:** `can_manage_programs` - Create, update, or delete programs ___  <!-- theme: danger --> > **Experimental** Updates the content of the program. The update overwrites the existing content. The metadata is updated in correspondence.  ## Examples  ``` move via p2p() to [0, 0, 0, 0, 0, 0]  move frame(\"flange\") to [1, 2, 0]  move via line() to [1, 1, 0]  a := planned_pose()  ```  ``` {% from \'schneider_conveyor_v1.j2\' import schneider_conveyor_library -%}  {{ schneider_conveyor_library() }}  def start_main():     conveyor_speed_percentage = {{ conveyor_speed_percentage | round(4) }}     conveyer_speed = conveyor_speed_percentage*1500     schneider_conveyor_start(conveyer_speed) end ```
   * @summary Update Program
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} program Recieved from [listProgramMetadata](#/operations/listProgramMetadata) or from the response of [createProgram](#/operations/createProgram).
   * @param {string} body
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  updateProgram(cell: string, program: string, body: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ProgramMetadata>>;
};
/**
 * LibraryProgramApi - factory interface
 */
declare const LibraryProgramApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
  /**
   * **Required permissions:** `can_manage_programs` - Create, update, or delete programs ___  <!-- theme: danger --> > **Experimental**  Creates a new program. The corresponding metadata is created as well.  ## Examples  ``` move via p2p() to [0, 0, 0, 0, 0, 0] move frame(\"flange\") to [1, 2, 0] move via line() to [1, 1, 0] a := planned_pose() ```  ``` {% from \'schneider_conveyor_v1.j2\' import schneider_conveyor_library -%}  {{ schneider_conveyor_library() }}  def start_main():     conveyor_speed_percentage = {{ conveyor_speed_percentage | round(4) }}     conveyer_speed = conveyor_speed_percentage*1500     schneider_conveyor_start(conveyer_speed) end ```
   * @summary Create Program
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} body
   * @param {string} [name]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  createProgram(cell: string, body: string, name?: string, options?: RawAxiosRequestConfig): AxiosPromise<ProgramMetadata>;
  /**
   * **Required permissions:** `can_manage_programs` - Create, update, or delete programs ___  <!-- theme: danger --> > **Experimental** Deletes the program with the corresponding metadata. This action is irreversible. Does not delete the associated recipes.
   * @summary Delete Program
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} program Recieved from [listProgramMetadata](#/operations/listProgramMetadata) or from the response of [createProgram](#/operations/createProgram).
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  deleteProgram(cell: string, program: string, options?: RawAxiosRequestConfig): AxiosPromise<ProgramMetadata>;
  /**
   * **Required permissions:** `can_manage_programs` - Create, update, or delete programs ___  <!-- theme: danger --> > **Experimental** Deletes the provided list of programs with the corresponding metadata. This action is irreversible. Does not delete the associated recipes.
   * @summary Delete Program List
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {Array<string>} programIds Received from [listProgramMetadata](#/operations/listProgramMetadata) or from the response of [createProgram](#/operations/createProgram).
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  deleteProgramList(cell: string, programIds: Array<string>, options?: RawAxiosRequestConfig): AxiosPromise<ListProgramMetadataResponse>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** Returns the content of the program. The identifier of the program is received upon creation or from the metadata list of all the programs.
   * @summary Get Program
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} program Recieved from [listProgramMetadata](#/operations/listProgramMetadata) or from the response of [createProgram](#/operations/createProgram).
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getProgram(cell: string, program: string, options?: RawAxiosRequestConfig): AxiosPromise<string>;
  /**
   * **Required permissions:** `can_manage_programs` - Create, update, or delete programs ___  <!-- theme: danger --> > **Experimental** Updates the content of the program. The update overwrites the existing content. The metadata is updated in correspondence.  ## Examples  ``` move via p2p() to [0, 0, 0, 0, 0, 0]  move frame(\"flange\") to [1, 2, 0]  move via line() to [1, 1, 0]  a := planned_pose()  ```  ``` {% from \'schneider_conveyor_v1.j2\' import schneider_conveyor_library -%}  {{ schneider_conveyor_library() }}  def start_main():     conveyor_speed_percentage = {{ conveyor_speed_percentage | round(4) }}     conveyer_speed = conveyor_speed_percentage*1500     schneider_conveyor_start(conveyer_speed) end ```
   * @summary Update Program
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} program Recieved from [listProgramMetadata](#/operations/listProgramMetadata) or from the response of [createProgram](#/operations/createProgram).
   * @param {string} body
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  updateProgram(cell: string, program: string, body: string, options?: RawAxiosRequestConfig): AxiosPromise<ProgramMetadata>;
};
/**
 * LibraryProgramApi - object-oriented interface
 */
declare class LibraryProgramApi extends BaseAPI {
  /**
   * **Required permissions:** `can_manage_programs` - Create, update, or delete programs ___  <!-- theme: danger --> > **Experimental**  Creates a new program. The corresponding metadata is created as well.  ## Examples  ``` move via p2p() to [0, 0, 0, 0, 0, 0] move frame(\"flange\") to [1, 2, 0] move via line() to [1, 1, 0] a := planned_pose() ```  ``` {% from \'schneider_conveyor_v1.j2\' import schneider_conveyor_library -%}  {{ schneider_conveyor_library() }}  def start_main():     conveyor_speed_percentage = {{ conveyor_speed_percentage | round(4) }}     conveyer_speed = conveyor_speed_percentage*1500     schneider_conveyor_start(conveyer_speed) end ```
   * @summary Create Program
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} body
   * @param {string} [name]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  createProgram(cell: string, body: string, name?: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<ProgramMetadata, any, {}>>;
  /**
   * **Required permissions:** `can_manage_programs` - Create, update, or delete programs ___  <!-- theme: danger --> > **Experimental** Deletes the program with the corresponding metadata. This action is irreversible. Does not delete the associated recipes.
   * @summary Delete Program
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} program Recieved from [listProgramMetadata](#/operations/listProgramMetadata) or from the response of [createProgram](#/operations/createProgram).
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  deleteProgram(cell: string, program: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<ProgramMetadata, any, {}>>;
  /**
   * **Required permissions:** `can_manage_programs` - Create, update, or delete programs ___  <!-- theme: danger --> > **Experimental** Deletes the provided list of programs with the corresponding metadata. This action is irreversible. Does not delete the associated recipes.
   * @summary Delete Program List
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {Array<string>} programIds Received from [listProgramMetadata](#/operations/listProgramMetadata) or from the response of [createProgram](#/operations/createProgram).
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  deleteProgramList(cell: string, programIds: Array<string>, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<ListProgramMetadataResponse, any, {}>>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** Returns the content of the program. The identifier of the program is received upon creation or from the metadata list of all the programs.
   * @summary Get Program
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} program Recieved from [listProgramMetadata](#/operations/listProgramMetadata) or from the response of [createProgram](#/operations/createProgram).
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getProgram(cell: string, program: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<string, any, {}>>;
  /**
   * **Required permissions:** `can_manage_programs` - Create, update, or delete programs ___  <!-- theme: danger --> > **Experimental** Updates the content of the program. The update overwrites the existing content. The metadata is updated in correspondence.  ## Examples  ``` move via p2p() to [0, 0, 0, 0, 0, 0]  move frame(\"flange\") to [1, 2, 0]  move via line() to [1, 1, 0]  a := planned_pose()  ```  ``` {% from \'schneider_conveyor_v1.j2\' import schneider_conveyor_library -%}  {{ schneider_conveyor_library() }}  def start_main():     conveyor_speed_percentage = {{ conveyor_speed_percentage | round(4) }}     conveyer_speed = conveyor_speed_percentage*1500     schneider_conveyor_start(conveyer_speed) end ```
   * @summary Update Program
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} program Recieved from [listProgramMetadata](#/operations/listProgramMetadata) or from the response of [createProgram](#/operations/createProgram).
   * @param {string} body
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  updateProgram(cell: string, program: string, body: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<ProgramMetadata, any, {}>>;
}
/**
 * LibraryProgramMetadataApi - axios parameter creator
 */
declare const LibraryProgramMetadataApiAxiosParamCreator: (configuration?: Configuration) => {
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** Returns metadata of the corresponding program.
   * @summary Get Program Metadata
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} program Recieved from [listProgramMetadata](#/operations/listProgramMetadata) or from the response of [createProgram](#/operations/createProgram).
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getProgramMetadata: (cell: string, program: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** Returns a list of all the stored programs, represented by their metadata.
   * @summary List Program Metadata
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {boolean} [showHidden] If true, hidden programs, where the &#x60;is_hidden&#x60; flag is active, are included in the list.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  listProgramMetadata: (cell: string, showHidden?: boolean, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_manage_programs` - Create, update, or delete programs ___  <!-- theme: danger --> > **Experimental** Updates the metadata of the corresponding program. The update is partial, only the set fields get updated.
   * @summary Update Program Metadata
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} program Recieved from [listProgramMetadata](#/operations/listProgramMetadata) or from the response of [createProgram](#/operations/createProgram).
   * @param {UpdateProgramMetadataRequest} updateProgramMetadataRequest
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  updateProgramMetadata: (cell: string, program: string, updateProgramMetadataRequest: UpdateProgramMetadataRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_manage_programs` - Create, update, or delete programs ___  <!-- theme: danger --> > **Experimental** Uploads an image for the corresponding program. The image is served as a static file. The path to the image is stored in the metadata.
   * @summary Upload Program Metadata Image
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} program Recieved from [listProgramMetadata](#/operations/listProgramMetadata) or from the response of [createProgram](#/operations/createProgram).
   * @param {File} file
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  uploadProgramMetadataImage: (cell: string, program: string, file: File, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
/**
 * LibraryProgramMetadataApi - functional programming interface
 */
declare const LibraryProgramMetadataApiFp: (configuration?: Configuration) => {
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** Returns metadata of the corresponding program.
   * @summary Get Program Metadata
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} program Recieved from [listProgramMetadata](#/operations/listProgramMetadata) or from the response of [createProgram](#/operations/createProgram).
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getProgramMetadata(cell: string, program: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ProgramMetadata>>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** Returns a list of all the stored programs, represented by their metadata.
   * @summary List Program Metadata
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {boolean} [showHidden] If true, hidden programs, where the &#x60;is_hidden&#x60; flag is active, are included in the list.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  listProgramMetadata(cell: string, showHidden?: boolean, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ListProgramMetadataResponse>>;
  /**
   * **Required permissions:** `can_manage_programs` - Create, update, or delete programs ___  <!-- theme: danger --> > **Experimental** Updates the metadata of the corresponding program. The update is partial, only the set fields get updated.
   * @summary Update Program Metadata
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} program Recieved from [listProgramMetadata](#/operations/listProgramMetadata) or from the response of [createProgram](#/operations/createProgram).
   * @param {UpdateProgramMetadataRequest} updateProgramMetadataRequest
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  updateProgramMetadata(cell: string, program: string, updateProgramMetadataRequest: UpdateProgramMetadataRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ProgramMetadata>>;
  /**
   * **Required permissions:** `can_manage_programs` - Create, update, or delete programs ___  <!-- theme: danger --> > **Experimental** Uploads an image for the corresponding program. The image is served as a static file. The path to the image is stored in the metadata.
   * @summary Upload Program Metadata Image
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} program Recieved from [listProgramMetadata](#/operations/listProgramMetadata) or from the response of [createProgram](#/operations/createProgram).
   * @param {File} file
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  uploadProgramMetadataImage(cell: string, program: string, file: File, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ProgramMetadata>>;
};
/**
 * LibraryProgramMetadataApi - factory interface
 */
declare const LibraryProgramMetadataApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** Returns metadata of the corresponding program.
   * @summary Get Program Metadata
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} program Recieved from [listProgramMetadata](#/operations/listProgramMetadata) or from the response of [createProgram](#/operations/createProgram).
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getProgramMetadata(cell: string, program: string, options?: RawAxiosRequestConfig): AxiosPromise<ProgramMetadata>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** Returns a list of all the stored programs, represented by their metadata.
   * @summary List Program Metadata
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {boolean} [showHidden] If true, hidden programs, where the &#x60;is_hidden&#x60; flag is active, are included in the list.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  listProgramMetadata(cell: string, showHidden?: boolean, options?: RawAxiosRequestConfig): AxiosPromise<ListProgramMetadataResponse>;
  /**
   * **Required permissions:** `can_manage_programs` - Create, update, or delete programs ___  <!-- theme: danger --> > **Experimental** Updates the metadata of the corresponding program. The update is partial, only the set fields get updated.
   * @summary Update Program Metadata
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} program Recieved from [listProgramMetadata](#/operations/listProgramMetadata) or from the response of [createProgram](#/operations/createProgram).
   * @param {UpdateProgramMetadataRequest} updateProgramMetadataRequest
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  updateProgramMetadata(cell: string, program: string, updateProgramMetadataRequest: UpdateProgramMetadataRequest, options?: RawAxiosRequestConfig): AxiosPromise<ProgramMetadata>;
  /**
   * **Required permissions:** `can_manage_programs` - Create, update, or delete programs ___  <!-- theme: danger --> > **Experimental** Uploads an image for the corresponding program. The image is served as a static file. The path to the image is stored in the metadata.
   * @summary Upload Program Metadata Image
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} program Recieved from [listProgramMetadata](#/operations/listProgramMetadata) or from the response of [createProgram](#/operations/createProgram).
   * @param {File} file
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  uploadProgramMetadataImage(cell: string, program: string, file: File, options?: RawAxiosRequestConfig): AxiosPromise<ProgramMetadata>;
};
/**
 * LibraryProgramMetadataApi - object-oriented interface
 */
declare class LibraryProgramMetadataApi extends BaseAPI {
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** Returns metadata of the corresponding program.
   * @summary Get Program Metadata
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} program Recieved from [listProgramMetadata](#/operations/listProgramMetadata) or from the response of [createProgram](#/operations/createProgram).
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getProgramMetadata(cell: string, program: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<ProgramMetadata, any, {}>>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** Returns a list of all the stored programs, represented by their metadata.
   * @summary List Program Metadata
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {boolean} [showHidden] If true, hidden programs, where the &#x60;is_hidden&#x60; flag is active, are included in the list.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  listProgramMetadata(cell: string, showHidden?: boolean, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<ListProgramMetadataResponse, any, {}>>;
  /**
   * **Required permissions:** `can_manage_programs` - Create, update, or delete programs ___  <!-- theme: danger --> > **Experimental** Updates the metadata of the corresponding program. The update is partial, only the set fields get updated.
   * @summary Update Program Metadata
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} program Recieved from [listProgramMetadata](#/operations/listProgramMetadata) or from the response of [createProgram](#/operations/createProgram).
   * @param {UpdateProgramMetadataRequest} updateProgramMetadataRequest
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  updateProgramMetadata(cell: string, program: string, updateProgramMetadataRequest: UpdateProgramMetadataRequest, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<ProgramMetadata, any, {}>>;
  /**
   * **Required permissions:** `can_manage_programs` - Create, update, or delete programs ___  <!-- theme: danger --> > **Experimental** Uploads an image for the corresponding program. The image is served as a static file. The path to the image is stored in the metadata.
   * @summary Upload Program Metadata Image
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} program Recieved from [listProgramMetadata](#/operations/listProgramMetadata) or from the response of [createProgram](#/operations/createProgram).
   * @param {File} file
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  uploadProgramMetadataImage(cell: string, program: string, file: File, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<ProgramMetadata, any, {}>>;
}
/**
 * LibraryRecipeApi - axios parameter creator
 */
declare const LibraryRecipeApiAxiosParamCreator: (configuration?: Configuration) => {
  /**
   * **Required permissions:** `can_manage_programs` - Create, update, or delete programs ___  <!-- theme: danger --> > **Experimental** Creates a new recipe. The corresponding metadata is created as well.
   * @summary Create Recipe
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} programId The identifier of the program the recipe will be associated with.
   * @param {object} body
   * @param {string} [name] If no initial name is set, a default name based on the program and timestamp is created.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  createRecipe: (cell: string, programId: string, body: object, name?: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_manage_programs` - Create, update, or delete programs ___  # EXPERIMENTAL  > **Note:** This endpoint is experimental and might experience functional changes in the future.  Deletes a recipe. This action is irreversible.
   * @summary Delete Recipe
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} recipe Recieved from [listRecipeMetadata](#/operations/listRecipeMetadata) or from the response of [createRecipe](#/operations/createRecipe).
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  deleteRecipe: (cell: string, recipe: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_manage_programs` - Create, update, or delete programs ___  <!-- theme: danger --> > **Experimental** Deletes the provided list of recipes. This action is irreversible.
   * @summary Delete Recipe List
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {Array<string>} recipeIds Received from [listRecipeMetadata](#/operations/listRecipeMetadata) or from the response of [createRecipe](#/operations/createRecipe)
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  deleteRecipeList: (cell: string, recipeIds: Array<string>, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** Returns the content of a recipe. The identifier of the recipe is recieved on creation or from the metadata list of all the recipes.
   * @summary Get Recipe
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} recipe Recieved from [listRecipeMetadata](#/operations/listRecipeMetadata) or from the response of [createRecipe](#/operations/createRecipe).
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getRecipe: (cell: string, recipe: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_manage_programs` - Create, update, or delete programs ___  <!-- theme: danger --> > **Experimental** Updates an existing recipe. The update is partial, only the set fields get updated.
   * @summary Update Recipe
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} recipe Recieved from [listRecipeMetadata](#/operations/listRecipeMetadata) or from the response of [createRecipe](#/operations/createRecipe).
   * @param {object} body
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  updateRecipe: (cell: string, recipe: string, body: object, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
/**
 * LibraryRecipeApi - functional programming interface
 */
declare const LibraryRecipeApiFp: (configuration?: Configuration) => {
  /**
   * **Required permissions:** `can_manage_programs` - Create, update, or delete programs ___  <!-- theme: danger --> > **Experimental** Creates a new recipe. The corresponding metadata is created as well.
   * @summary Create Recipe
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} programId The identifier of the program the recipe will be associated with.
   * @param {object} body
   * @param {string} [name] If no initial name is set, a default name based on the program and timestamp is created.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  createRecipe(cell: string, programId: string, body: object, name?: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<RecipeMetadata>>;
  /**
   * **Required permissions:** `can_manage_programs` - Create, update, or delete programs ___  # EXPERIMENTAL  > **Note:** This endpoint is experimental and might experience functional changes in the future.  Deletes a recipe. This action is irreversible.
   * @summary Delete Recipe
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} recipe Recieved from [listRecipeMetadata](#/operations/listRecipeMetadata) or from the response of [createRecipe](#/operations/createRecipe).
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  deleteRecipe(cell: string, recipe: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<RecipeMetadata>>;
  /**
   * **Required permissions:** `can_manage_programs` - Create, update, or delete programs ___  <!-- theme: danger --> > **Experimental** Deletes the provided list of recipes. This action is irreversible.
   * @summary Delete Recipe List
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {Array<string>} recipeIds Received from [listRecipeMetadata](#/operations/listRecipeMetadata) or from the response of [createRecipe](#/operations/createRecipe)
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  deleteRecipeList(cell: string, recipeIds: Array<string>, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ListRecipeMetadataResponse>>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** Returns the content of a recipe. The identifier of the recipe is recieved on creation or from the metadata list of all the recipes.
   * @summary Get Recipe
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} recipe Recieved from [listRecipeMetadata](#/operations/listRecipeMetadata) or from the response of [createRecipe](#/operations/createRecipe).
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getRecipe(cell: string, recipe: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<object>>;
  /**
   * **Required permissions:** `can_manage_programs` - Create, update, or delete programs ___  <!-- theme: danger --> > **Experimental** Updates an existing recipe. The update is partial, only the set fields get updated.
   * @summary Update Recipe
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} recipe Recieved from [listRecipeMetadata](#/operations/listRecipeMetadata) or from the response of [createRecipe](#/operations/createRecipe).
   * @param {object} body
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  updateRecipe(cell: string, recipe: string, body: object, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<RecipeMetadata>>;
};
/**
 * LibraryRecipeApi - factory interface
 */
declare const LibraryRecipeApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
  /**
   * **Required permissions:** `can_manage_programs` - Create, update, or delete programs ___  <!-- theme: danger --> > **Experimental** Creates a new recipe. The corresponding metadata is created as well.
   * @summary Create Recipe
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} programId The identifier of the program the recipe will be associated with.
   * @param {object} body
   * @param {string} [name] If no initial name is set, a default name based on the program and timestamp is created.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  createRecipe(cell: string, programId: string, body: object, name?: string, options?: RawAxiosRequestConfig): AxiosPromise<RecipeMetadata>;
  /**
   * **Required permissions:** `can_manage_programs` - Create, update, or delete programs ___  # EXPERIMENTAL  > **Note:** This endpoint is experimental and might experience functional changes in the future.  Deletes a recipe. This action is irreversible.
   * @summary Delete Recipe
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} recipe Recieved from [listRecipeMetadata](#/operations/listRecipeMetadata) or from the response of [createRecipe](#/operations/createRecipe).
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  deleteRecipe(cell: string, recipe: string, options?: RawAxiosRequestConfig): AxiosPromise<RecipeMetadata>;
  /**
   * **Required permissions:** `can_manage_programs` - Create, update, or delete programs ___  <!-- theme: danger --> > **Experimental** Deletes the provided list of recipes. This action is irreversible.
   * @summary Delete Recipe List
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {Array<string>} recipeIds Received from [listRecipeMetadata](#/operations/listRecipeMetadata) or from the response of [createRecipe](#/operations/createRecipe)
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  deleteRecipeList(cell: string, recipeIds: Array<string>, options?: RawAxiosRequestConfig): AxiosPromise<ListRecipeMetadataResponse>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** Returns the content of a recipe. The identifier of the recipe is recieved on creation or from the metadata list of all the recipes.
   * @summary Get Recipe
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} recipe Recieved from [listRecipeMetadata](#/operations/listRecipeMetadata) or from the response of [createRecipe](#/operations/createRecipe).
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getRecipe(cell: string, recipe: string, options?: RawAxiosRequestConfig): AxiosPromise<object>;
  /**
   * **Required permissions:** `can_manage_programs` - Create, update, or delete programs ___  <!-- theme: danger --> > **Experimental** Updates an existing recipe. The update is partial, only the set fields get updated.
   * @summary Update Recipe
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} recipe Recieved from [listRecipeMetadata](#/operations/listRecipeMetadata) or from the response of [createRecipe](#/operations/createRecipe).
   * @param {object} body
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  updateRecipe(cell: string, recipe: string, body: object, options?: RawAxiosRequestConfig): AxiosPromise<RecipeMetadata>;
};
/**
 * LibraryRecipeApi - object-oriented interface
 */
declare class LibraryRecipeApi extends BaseAPI {
  /**
   * **Required permissions:** `can_manage_programs` - Create, update, or delete programs ___  <!-- theme: danger --> > **Experimental** Creates a new recipe. The corresponding metadata is created as well.
   * @summary Create Recipe
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} programId The identifier of the program the recipe will be associated with.
   * @param {object} body
   * @param {string} [name] If no initial name is set, a default name based on the program and timestamp is created.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  createRecipe(cell: string, programId: string, body: object, name?: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<RecipeMetadata, any, {}>>;
  /**
   * **Required permissions:** `can_manage_programs` - Create, update, or delete programs ___  # EXPERIMENTAL  > **Note:** This endpoint is experimental and might experience functional changes in the future.  Deletes a recipe. This action is irreversible.
   * @summary Delete Recipe
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} recipe Recieved from [listRecipeMetadata](#/operations/listRecipeMetadata) or from the response of [createRecipe](#/operations/createRecipe).
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  deleteRecipe(cell: string, recipe: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<RecipeMetadata, any, {}>>;
  /**
   * **Required permissions:** `can_manage_programs` - Create, update, or delete programs ___  <!-- theme: danger --> > **Experimental** Deletes the provided list of recipes. This action is irreversible.
   * @summary Delete Recipe List
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {Array<string>} recipeIds Received from [listRecipeMetadata](#/operations/listRecipeMetadata) or from the response of [createRecipe](#/operations/createRecipe)
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  deleteRecipeList(cell: string, recipeIds: Array<string>, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<ListRecipeMetadataResponse, any, {}>>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** Returns the content of a recipe. The identifier of the recipe is recieved on creation or from the metadata list of all the recipes.
   * @summary Get Recipe
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} recipe Recieved from [listRecipeMetadata](#/operations/listRecipeMetadata) or from the response of [createRecipe](#/operations/createRecipe).
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getRecipe(cell: string, recipe: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<object, any, {}>>;
  /**
   * **Required permissions:** `can_manage_programs` - Create, update, or delete programs ___  <!-- theme: danger --> > **Experimental** Updates an existing recipe. The update is partial, only the set fields get updated.
   * @summary Update Recipe
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} recipe Recieved from [listRecipeMetadata](#/operations/listRecipeMetadata) or from the response of [createRecipe](#/operations/createRecipe).
   * @param {object} body
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  updateRecipe(cell: string, recipe: string, body: object, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<RecipeMetadata, any, {}>>;
}
/**
 * LibraryRecipeMetadataApi - axios parameter creator
 */
declare const LibraryRecipeMetadataApiAxiosParamCreator: (configuration?: Configuration) => {
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** Returns the metadata of the recipe.
   * @summary Get Recipe Metadata
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} recipe Recieved from [listRecipeMetadata](#/operations/listRecipeMetadata) or from the response of [createRecipe](#/operations/createRecipe).
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getRecipeMetadata: (cell: string, recipe: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** List of all the stored recipes, represented by their metadata.
   * @summary List Recipe Metadata
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  listRecipeMetadata: (cell: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_manage_programs` - Create, update, or delete programs ___  <!-- theme: danger --> > **Experimental** Updates the metadata of a recipe. The update is partial, only the set fields get updated.
   * @summary Update Recipe Metadata
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} recipe Recieved from [listRecipeMetadata](#/operations/listRecipeMetadata) or from the response of [createRecipe](#/operations/createRecipe).
   * @param {UpdateRecipeMetadataRequest} updateRecipeMetadataRequest
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  updateRecipeMetadata: (cell: string, recipe: string, updateRecipeMetadataRequest: UpdateRecipeMetadataRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_manage_programs` - Create, update, or delete programs ___  <!-- theme: danger --> > **Experimental** Uploads an image for a recipe. The image is served as a static file and the path is stored in the metadata.
   * @summary Upload Recipe Metadata Image
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} recipe Recieved from [listRecipeMetadata](#/operations/listRecipeMetadata) or from the response of [createRecipe](#/operations/createRecipe).
   * @param {File} file
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  uploadRecipeMetadataImage: (cell: string, recipe: string, file: File, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
/**
 * LibraryRecipeMetadataApi - functional programming interface
 */
declare const LibraryRecipeMetadataApiFp: (configuration?: Configuration) => {
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** Returns the metadata of the recipe.
   * @summary Get Recipe Metadata
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} recipe Recieved from [listRecipeMetadata](#/operations/listRecipeMetadata) or from the response of [createRecipe](#/operations/createRecipe).
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getRecipeMetadata(cell: string, recipe: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<RecipeMetadata>>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** List of all the stored recipes, represented by their metadata.
   * @summary List Recipe Metadata
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  listRecipeMetadata(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ListRecipeMetadataResponse>>;
  /**
   * **Required permissions:** `can_manage_programs` - Create, update, or delete programs ___  <!-- theme: danger --> > **Experimental** Updates the metadata of a recipe. The update is partial, only the set fields get updated.
   * @summary Update Recipe Metadata
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} recipe Recieved from [listRecipeMetadata](#/operations/listRecipeMetadata) or from the response of [createRecipe](#/operations/createRecipe).
   * @param {UpdateRecipeMetadataRequest} updateRecipeMetadataRequest
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  updateRecipeMetadata(cell: string, recipe: string, updateRecipeMetadataRequest: UpdateRecipeMetadataRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<RecipeMetadata>>;
  /**
   * **Required permissions:** `can_manage_programs` - Create, update, or delete programs ___  <!-- theme: danger --> > **Experimental** Uploads an image for a recipe. The image is served as a static file and the path is stored in the metadata.
   * @summary Upload Recipe Metadata Image
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} recipe Recieved from [listRecipeMetadata](#/operations/listRecipeMetadata) or from the response of [createRecipe](#/operations/createRecipe).
   * @param {File} file
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  uploadRecipeMetadataImage(cell: string, recipe: string, file: File, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<RecipeMetadata>>;
};
/**
 * LibraryRecipeMetadataApi - factory interface
 */
declare const LibraryRecipeMetadataApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** Returns the metadata of the recipe.
   * @summary Get Recipe Metadata
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} recipe Recieved from [listRecipeMetadata](#/operations/listRecipeMetadata) or from the response of [createRecipe](#/operations/createRecipe).
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getRecipeMetadata(cell: string, recipe: string, options?: RawAxiosRequestConfig): AxiosPromise<RecipeMetadata>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** List of all the stored recipes, represented by their metadata.
   * @summary List Recipe Metadata
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  listRecipeMetadata(cell: string, options?: RawAxiosRequestConfig): AxiosPromise<ListRecipeMetadataResponse>;
  /**
   * **Required permissions:** `can_manage_programs` - Create, update, or delete programs ___  <!-- theme: danger --> > **Experimental** Updates the metadata of a recipe. The update is partial, only the set fields get updated.
   * @summary Update Recipe Metadata
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} recipe Recieved from [listRecipeMetadata](#/operations/listRecipeMetadata) or from the response of [createRecipe](#/operations/createRecipe).
   * @param {UpdateRecipeMetadataRequest} updateRecipeMetadataRequest
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  updateRecipeMetadata(cell: string, recipe: string, updateRecipeMetadataRequest: UpdateRecipeMetadataRequest, options?: RawAxiosRequestConfig): AxiosPromise<RecipeMetadata>;
  /**
   * **Required permissions:** `can_manage_programs` - Create, update, or delete programs ___  <!-- theme: danger --> > **Experimental** Uploads an image for a recipe. The image is served as a static file and the path is stored in the metadata.
   * @summary Upload Recipe Metadata Image
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} recipe Recieved from [listRecipeMetadata](#/operations/listRecipeMetadata) or from the response of [createRecipe](#/operations/createRecipe).
   * @param {File} file
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  uploadRecipeMetadataImage(cell: string, recipe: string, file: File, options?: RawAxiosRequestConfig): AxiosPromise<RecipeMetadata>;
};
/**
 * LibraryRecipeMetadataApi - object-oriented interface
 */
declare class LibraryRecipeMetadataApi extends BaseAPI {
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** Returns the metadata of the recipe.
   * @summary Get Recipe Metadata
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} recipe Recieved from [listRecipeMetadata](#/operations/listRecipeMetadata) or from the response of [createRecipe](#/operations/createRecipe).
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getRecipeMetadata(cell: string, recipe: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<RecipeMetadata, any, {}>>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** List of all the stored recipes, represented by their metadata.
   * @summary List Recipe Metadata
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  listRecipeMetadata(cell: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<ListRecipeMetadataResponse, any, {}>>;
  /**
   * **Required permissions:** `can_manage_programs` - Create, update, or delete programs ___  <!-- theme: danger --> > **Experimental** Updates the metadata of a recipe. The update is partial, only the set fields get updated.
   * @summary Update Recipe Metadata
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} recipe Recieved from [listRecipeMetadata](#/operations/listRecipeMetadata) or from the response of [createRecipe](#/operations/createRecipe).
   * @param {UpdateRecipeMetadataRequest} updateRecipeMetadataRequest
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  updateRecipeMetadata(cell: string, recipe: string, updateRecipeMetadataRequest: UpdateRecipeMetadataRequest, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<RecipeMetadata, any, {}>>;
  /**
   * **Required permissions:** `can_manage_programs` - Create, update, or delete programs ___  <!-- theme: danger --> > **Experimental** Uploads an image for a recipe. The image is served as a static file and the path is stored in the metadata.
   * @summary Upload Recipe Metadata Image
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} recipe Recieved from [listRecipeMetadata](#/operations/listRecipeMetadata) or from the response of [createRecipe](#/operations/createRecipe).
   * @param {File} file
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  uploadRecipeMetadataImage(cell: string, recipe: string, file: File, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<RecipeMetadata, any, {}>>;
}
/**
 * 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<RequestArgs>;
  /**
   * **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<RequestArgs>;
  /**
   * **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<RequestArgs>;
  /**
   * **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<RequestArgs>;
};
/**
 * 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<License>>;
  /**
   * **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<void>>;
  /**
   * **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<License>>;
  /**
   * **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<LicenseStatus>>;
};
/**
 * 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<License>;
  /**
   * **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<void>;
  /**
   * **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<License>;
  /**
   * **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<LicenseStatus>;
};
/**
 * 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<License, any, {}>>;
  /**
   * **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<void, any, {}>>;
  /**
   * **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<License, any, {}>>;
  /**
   * **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<LicenseStatus, any, {}>>;
}
/**
 * MotionApi - axios parameter creator
 */
declare const MotionApiAxiosParamCreator: (configuration?: Configuration) => {
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Delete all registered motions.
   * @summary All Motions
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  deleteAllMotions: (cell: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Remove a previously created motion from cache. Use [listMotions](#/operations/listMotions) to list all available motions. Motions are removed automatically if the motion group or the corresponding controller is disconnected.
   * @summary Remove
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motion This represents the UUID of a motion. Every executable or partially executable motion is cached and an UUID is returned. Indicate the UUID to execute the motion or retrieve information on the motion.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  deleteMotion: (cell: string, motion: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  <!-- theme: danger -->  > Websocket endpoint  Provide execution control over a previously planned trajectory. Enable the caller to attach I/O actions to the trajectory.  Understanding the 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 [planMotion](#/operations/planMotion).   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 is at the start location specified with InitializeMovementRequest.  ### 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 and not unlocked anymore.   To execute another trajectory, a new connection must be established.  #### 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  - InitializeMovementResponse is sent to signal the success or failure of the InitializeMovementRequest. - Movement responses are streamed after a StartMovementRequest successfully started the movement.   Movement responses are streamed in a rate that is defined as the multiple of the controller step-rate closest to   but not exceeding the rate configured by InitializeMovementRequest. - Standstill response is sent once the movement has finished or has come to a standstill due to a pause. - PauseMovementResponse is sent to signal the success of the PauseMovementRequest. It does not signal the end of the movement.   End of movement is signaled by standstill response. - PlaybackSpeedResponse is sent to signal the success of the PlaybackSpeedRequest. - MovementError with error details is sent in case of an unexpected error, 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 {ExecuteTrajectoryRequest} executeTrajectoryRequest
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  executeTrajectory: (cell: string, executeTrajectoryRequest: ExecuteTrajectoryRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Get the trajectory of a planned motion with defined `sample_time` in milliseconds (ms). The trajectory is a list of points containing cartesian and joint data. The cartesian data is in the requested coordinate system. To get a single point of the trajectory, please use the [getMotionTrajectorySample](#/operations/getMotionTrajectorySample) endpoint.
   * @summary Get Trajectory
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motion This represents the UUID of a motion. Every executable or partially executable motion is cached and an UUID is returned. Indicate the UUID to execute the motion or retrieve information on the motion.
   * @param {number} sampleTime The value of &#x60;sample_time&#x60; is the time in milliseconds (ms) between each point in the trajectory.
   * @param {string} [responsesCoordinateSystem] Unique identifier addressing a coordinate system to which the cartesian data of the responses should be converted. Default: world coordinate system.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getMotionTrajectory: (cell: string, motion: string, sampleTime: number, responsesCoordinateSystem?: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Get a single point at a certain location of a planned motion.  To get the whole trajectory, use the [getMotionTrajectory](#/operations/getMotionTrajectory) endpoint.
   * @summary Get Trajectory Sample
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motion This represents the UUID of a motion. Every executable or partially executable motion is cached and an UUID is returned. Indicate the UUID to execute the motion or retrieve information on the motion.
   * @param {number} [locationOnTrajectory]
   * @param {string} [responseCoordinateSystem] Unique identifier addressing a coordinate system for which the cartesian data of the response should be converted to. Default is the world coordinate system.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getMotionTrajectorySample: (cell: string, motion: string, locationOnTrajectory?: number, responseCoordinateSystem?: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Get the joint data of a planned motion. The planned motion contains only the joint information, to persistently store and reload it later. The data will be sampled equidistantly with defined `sample_time` in milliseconds (ms). If not provided, the data is returned as it is stored on Wandelbots NOVA system.  To request cartesian data for visualization purposes, use the [getMotionTrajectory](#/operations/getMotionTrajectory) endpoint. To get a single point of the planned motion, use the [getMotionTrajectorySample](#/operations/getMotionTrajectorySample) endpoint.
   * @summary Get Planned Motion
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motion This represents the UUID of a motion. Every executable or partially executable motion is cached and an UUID is returned. Indicate the UUID to execute the motion or retrieve information on the motion.
   * @param {number} [sampleTime] -| The value of &#x60;sample_time&#x60; is the time in milliseconds (ms) between each datapoint of the planned motion. Optional. If not provided, the data is returned as it is stored internally and equidistant sampling is not guaranteed.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getPlannedMotion: (cell: string, motion: string, sampleTime?: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___  Returns motion group models that are supported for planning.
   * @summary Motion Group Models for Planning
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getPlanningMotionGroupModels: (cell: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  List all currently planned and available motions. Use [planMotion](#/operations/planMotion) to plan a new motion. Motions are removed if the corresponding motion group or controller disconnects.
   * @summary List All Motions
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  listMotions: (cell: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Loads and validates the data of a planned motion into a motion session. The response contains information about the validated motion.  Validation can lead to three different results: - Fully valid: The whole planned motion can be executed from start to end. The response will contain the session to move the robot. - Partially valid: Only parts of the planned motion can be executed. The response will contain the session to move the robot and information about the failure for the part that is not executable. - Invalid: The planned motion can not be executed. The response will tell you, which information about the reason of failure.  If the motion is at least partially valid, the parts of the motion that are valid can be executed using the [streamMoveForward](#/operations/streamMoveForward) endpoint.  You can use the following workflows:   - Plan motions using the [planMotion](#/operations/planMotion) endpoint,   - Store the planned motion persistently,   - Use this endpoint to reload the stored motion and get a motion session for it.   - Execute the loaded motion using the [streamMoveForward](#/operations/streamMoveForward) endpoint.  OR:   - Generate a planned motion with [planTrajectory](#/operations/planTrajectory) or your own motion planner,   - Send the planned motion to this endpoint to validate it and get a motion session for it,   - Execute your motion using the [streamMoveForward](#/operations/streamMoveForward) endpoint.  Once a planned motion is validated, it is treated like a motion session and will appear in the list of available motions, see [listMotions](#/operations/listMotions) endpoint. You can then execute a motion session with the [streamMoveForward](#/operations/streamMoveForward) endpoint.
   * @summary Load Planned Motion
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {PlannedMotion} plannedMotion
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  loadPlannedMotion: (cell: string, plannedMotion: PlannedMotion, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___  <!-- theme: danger -->  > **Experimental**  Plans a collision-free PTP motion for a single motion group.  Use the following workflow to execute a planned trajectory: 1. Plan a collision-free movement/motion. 2. Validate and load the planned trajectory using the [loadPlannedMotion](#/operations/loadPlannedMotion) endpoint. 3. Execute the loaded trajectory using the [streamMove](#/operations/streamMove) endpoint.
   * @summary Plan Collision Free PTP
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {PlanCollisionFreePTPRequest} [planCollisionFreePTPRequest]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  planCollisionFreePTP: (cell: string, planCollisionFreePTPRequest?: PlanCollisionFreePTPRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Deprecated endpoint. Use [planTrajectory](#/operations/planTrajectory) and [loadPlannedMotion](#/operations/loadPlannedMotion) instead.  Plans a new motion for a single previously configured [motion group](#/operations/listMotionGroups). Motions are described by a sequence of motion commands starting with start joints. A motion is planned from standstill to standstill. A single motion has constant TCP and payload. Currently, I/O actions can\'t be attached to a motion to execute the action in realtime while a motion is executed. If an I/O is needed at a specific point, multiple motions need to be planned. If an I/O is needed to be set while a motion is executed, the endpoint [setOutputValues](#/operations/setOutputValues) could be used.
   * @summary Plan Motion
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {PlanRequest} planRequest
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  planMotion: (cell: string, planRequest: PlanRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **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. Validate and load the planned trajectory using the [loadPlannedMotion](#/operations/loadPlannedMotion) endpoint. 3. Execute the loaded trajectory using the [streamMove](#/operations/streamMove) endpoint.  If the trajectory is not executable, the PlanTrajectoryFailedResponse will contain the joint trajectory up until the error (e.g. a collision) occurred. 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<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Stops an active motion gracefully with deceleration until standstill while staying on the planned trajectory. When an active movement is stopped any further update request will be rejected. This call will immediately return even if the deceleration is still in progress. The active movement stream returns responses until the robot has reached standstill. Currently it is not possible to restart the motion. Please send in a feature request if you need to restart/continue the motion.
   * @summary Stop
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motion This represents the UUID of a motion. Every executable or partially executable motion is cached and an UUID is returned. Indicate the UUID to execute the motion or retrieve information on the motion.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  stopExecution: (cell: string, motion: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Deprecated endpoint. Use `executeTrajectory` instead.  Moves the motion group forward or backward along a previously planned motion. Or request to move the motion group via joint point-to-point to a given location on a planned motion. Or set the playback speed of the motion. Or stop the motion execution.
   * @summary Stream Move
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {StreamMoveRequest} streamMoveRequest
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  streamMove: (cell: string, streamMoveRequest: StreamMoveRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Deprecated endpoint. Use the [executeTrajectory](#/operations/executeTrajectory) endpoint instead. Request to move the motion group backward along a previously planned motion. Once started, you can stop a motion using the [stopExecution](#/operations/stopExecution) endpoint. Prerequisites, before starting the motion execution:  - The motion group is currently at the endpoint of the planned motion OR  - The motion was stopped using [stopExecution](#/operations/stopExecution) endpoint. Then it is possible to resume the motion execution from where it stopped OR  - The motion group was moved onto the motion using the [streamMoveToTrajectoryViaJointP2P](#/operations/streamMoveToTrajectoryViaJointP2P) endpoint.
   * @summary Stream Backward
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motion This represents the UUID of a motion. Every executable or partially executable motion is cached and an UUID is returned. Indicate the UUID to execute the motion or retrieve information on the motion.
   * @param {number} playbackSpeedInPercent Set the velocity for executed movements of the motion in percent. A percentage of 100% means that the robot moves as fast as possible without violating the limits. Setting this value does not affect the overall shape of the velocity profile. Everything is slowed down by the same factor. Therefore, this should only be used for teaching and trajectory evaluation purposes. If the process requires a certain velocity, the respective limits should be set when planning the motion. This will not change the velocity override of the controller. The controller velocity override value shall be 100% to ensure controllability of the motion group.
   * @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\&#39;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 {number} [startLocationOnTrajectory] Location the motion is requested to start at. The default value is the end of the trajectory. The location is a scalar value that defines a position along a path, typically ranging from 0 to &#x60;n&#x60;, where &#x60;n&#x60; 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.
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  streamMoveBackward: (cell: string, motion: string, playbackSpeedInPercent: number, responseRate?: number, responseCoordinateSystem?: string, startLocationOnTrajectory?: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Deprecated endpoint. Use the [executeTrajectory](#/operations/executeTrajectory) endpoint instead. Move the motion group forward along a previously planned motion. Once started, you can stop a motion using the [stopExecution](#/operations/stopExecution) endpoint. Prerequisites, before starting the motion execution:  - The motion group is currently at the start point of the planned motion OR  - The motion was stopped using [stopExecution](#/operations/stopExecution) endpoint. Then it is possible to resume the motion execution from where it stopped OR  - The motion group was moved onto the motion using the [streamMoveToTrajectoryViaJointP2P](#/operations/streamMoveToTrajectoryViaJointP2P) endpoint.
   * @summary Stream Forward
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motion This represents the UUID of a motion. Every executable or partially executable motion is cached and an UUID is returned. Indicate the UUID to execute the motion or retrieve information on the motion.
   * @param {number} playbackSpeedInPercent Set the velocity for executed movements of the motion in percent. A percentage of 100% means that the robot moves as fast as possible without violating the limits. Setting this value does not affect the overall shape of the velocity profile. Everything is slowed down by the same factor. Therefore, this should only be used for teaching and trajectory evaluation purposes. If the process requires a certain velocity, the respective limits should be set when planning the motion. This will not change the velocity override of the controller. The controller velocity override value shall be 100% to ensure controllability of the motion group.
   * @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\&#39;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 {number} [startLocationOnTrajectory] Location the motion is requested to start at. The default value is the beginning of the trajectory. The location is a scalar value that defines a position along a path, typically ranging from 0 to &#x60;n&#x60;, where &#x60;n&#x60; 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.
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  streamMoveForward: (cell: string, motion: string, playbackSpeedInPercent: number, responseRate?: number, responseCoordinateSystem?: string, startLocationOnTrajectory?: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Request to move the motion group via joint point-to-point to a given location on a planned motion. You must use this endpoint in order to start moving from an arbritrary location of the trajectory. Afterwards, you are able to call [streamMoveForward](#/operations/streamMoveForward) or [streamMoveBackward](#/operations/streamMoveBackward) to move along planned motion. Use the [stopExecution](#/operations/stopExecution) endpoint to stop the motion gracefully.
   * @summary Stream to Trajectory
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motion This represents the UUID of a motion. Every executable or partially executable motion is cached and an UUID is returned. Indicate the UUID to execute the motion or retrieve information on the motion.
   * @param {number} locationOnTrajectory
   * @param {Array<number>} [limitOverrideJointVelocityLimitsJoints] The joint velocity limits for the p2p motion to a previously planned motion.
   * @param {Array<number>} [limitOverrideJointAccelerationLimitsJoints] The joint acceleration limits for the p2p motion to a previously planned motion.
   * @param {number} [limitOverrideTcpVelocityLimit] Maximum allowed TCP velocity in [mm/s].
   * @param {number} [limitOverrideTcpAccelerationLimit] Maximum allowed TCP acceleration in [mm/s^2].
   * @param {number} [limitOverrideTcpOrientationVelocityLimit] Maximum allowed TCP rotation velocity in [rad/s].
   * @param {number} [limitOverrideTcpOrientationAccelerationLimit] Maximum allowed TCP rotation acceleration in [rad/s^2].
   * @param {string} [responsesCoordinateSystem]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  streamMoveToTrajectoryViaJointPTP: (cell: string, motion: string, locationOnTrajectory: number, limitOverrideJointVelocityLimitsJoints?: Array<number>, limitOverrideJointAccelerationLimitsJoints?: Array<number>, limitOverrideTcpVelocityLimit?: number, limitOverrideTcpAccelerationLimit?: number, limitOverrideTcpOrientationVelocityLimit?: number, limitOverrideTcpOrientationAccelerationLimit?: number, responsesCoordinateSystem?: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
/**
 * MotionApi - functional programming interface
 */
declare const MotionApiFp: (configuration?: Configuration) => {
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Delete all registered motions.
   * @summary All Motions
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  deleteAllMotions(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Remove a previously created motion from cache. Use [listMotions](#/operations/listMotions) to list all available motions. Motions are removed automatically if the motion group or the corresponding controller is disconnected.
   * @summary Remove
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motion This represents the UUID of a motion. Every executable or partially executable motion is cached and an UUID is returned. Indicate the UUID to execute the motion or retrieve information on the motion.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  deleteMotion(cell: string, motion: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  <!-- theme: danger -->  > Websocket endpoint  Provide execution control over a previously planned trajectory. Enable the caller to attach I/O actions to the trajectory.  Understanding the 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 [planMotion](#/operations/planMotion).   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 is at the start location specified with InitializeMovementRequest.  ### 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 and not unlocked anymore.   To execute another trajectory, a new connection must be established.  #### 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  - InitializeMovementResponse is sent to signal the success or failure of the InitializeMovementRequest. - Movement responses are streamed after a StartMovementRequest successfully started the movement.   Movement responses are streamed in a rate that is defined as the multiple of the controller step-rate closest to   but not exceeding the rate configured by InitializeMovementRequest. - Standstill response is sent once the movement has finished or has come to a standstill due to a pause. - PauseMovementResponse is sent to signal the success of the PauseMovementRequest. It does not signal the end of the movement.   End of movement is signaled by standstill response. - PlaybackSpeedResponse is sent to signal the success of the PlaybackSpeedRequest. - MovementError with error details is sent in case of an unexpected error, 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 {ExecuteTrajectoryRequest} executeTrajectoryRequest
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  executeTrajectory(cell: string, executeTrajectoryRequest: ExecuteTrajectoryRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ExecuteTrajectoryResponse>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Get the trajectory of a planned motion with defined `sample_time` in milliseconds (ms). The trajectory is a list of points containing cartesian and joint data. The cartesian data is in the requested coordinate system. To get a single point of the trajectory, please use the [getMotionTrajectorySample](#/operations/getMotionTrajectorySample) endpoint.
   * @summary Get Trajectory
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motion This represents the UUID of a motion. Every executable or partially executable motion is cached and an UUID is returned. Indicate the UUID to execute the motion or retrieve information on the motion.
   * @param {number} sampleTime The value of &#x60;sample_time&#x60; is the time in milliseconds (ms) between each point in the trajectory.
   * @param {string} [responsesCoordinateSystem] Unique identifier addressing a coordinate system to which the cartesian data of the responses should be converted. Default: world coordinate system.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getMotionTrajectory(cell: string, motion: string, sampleTime: number, responsesCoordinateSystem?: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<GetTrajectoryResponse>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Get a single point at a certain location of a planned motion.  To get the whole trajectory, use the [getMotionTrajectory](#/operations/getMotionTrajectory) endpoint.
   * @summary Get Trajectory Sample
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motion This represents the UUID of a motion. Every executable or partially executable motion is cached and an UUID is returned. Indicate the UUID to execute the motion or retrieve information on the motion.
   * @param {number} [locationOnTrajectory]
   * @param {string} [responseCoordinateSystem] Unique identifier addressing a coordinate system for which the cartesian data of the response should be converted to. Default is the world coordinate system.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getMotionTrajectorySample(cell: string, motion: string, locationOnTrajectory?: number, responseCoordinateSystem?: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<GetTrajectorySampleResponse>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Get the joint data of a planned motion. The planned motion contains only the joint information, to persistently store and reload it later. The data will be sampled equidistantly with defined `sample_time` in milliseconds (ms). If not provided, the data is returned as it is stored on Wandelbots NOVA system.  To request cartesian data for visualization purposes, use the [getMotionTrajectory](#/operations/getMotionTrajectory) endpoint. To get a single point of the planned motion, use the [getMotionTrajectorySample](#/operations/getMotionTrajectorySample) endpoint.
   * @summary Get Planned Motion
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motion This represents the UUID of a motion. Every executable or partially executable motion is cached and an UUID is returned. Indicate the UUID to execute the motion or retrieve information on the motion.
   * @param {number} [sampleTime] -| The value of &#x60;sample_time&#x60; is the time in milliseconds (ms) between each datapoint of the planned motion. Optional. If not provided, the data is returned as it is stored internally and equidistant sampling is not guaranteed.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getPlannedMotion(cell: string, motion: string, sampleTime?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<PlannedMotion>>;
  /**
   * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___  Returns motion group models that are supported for planning.
   * @summary Motion Group Models for Planning
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getPlanningMotionGroupModels(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<string>>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  List all currently planned and available motions. Use [planMotion](#/operations/planMotion) to plan a new motion. Motions are removed if the corresponding motion group or controller disconnects.
   * @summary List All Motions
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  listMotions(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<MotionIdsListResponse>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Loads and validates the data of a planned motion into a motion session. The response contains information about the validated motion.  Validation can lead to three different results: - Fully valid: The whole planned motion can be executed from start to end. The response will contain the session to move the robot. - Partially valid: Only parts of the planned motion can be executed. The response will contain the session to move the robot and information about the failure for the part that is not executable. - Invalid: The planned motion can not be executed. The response will tell you, which information about the reason of failure.  If the motion is at least partially valid, the parts of the motion that are valid can be executed using the [streamMoveForward](#/operations/streamMoveForward) endpoint.  You can use the following workflows:   - Plan motions using the [planMotion](#/operations/planMotion) endpoint,   - Store the planned motion persistently,   - Use this endpoint to reload the stored motion and get a motion session for it.   - Execute the loaded motion using the [streamMoveForward](#/operations/streamMoveForward) endpoint.  OR:   - Generate a planned motion with [planTrajectory](#/operations/planTrajectory) or your own motion planner,   - Send the planned motion to this endpoint to validate it and get a motion session for it,   - Execute your motion using the [streamMoveForward](#/operations/streamMoveForward) endpoint.  Once a planned motion is validated, it is treated like a motion session and will appear in the list of available motions, see [listMotions](#/operations/listMotions) endpoint. You can then execute a motion session with the [streamMoveForward](#/operations/streamMoveForward) endpoint.
   * @summary Load Planned Motion
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {PlannedMotion} plannedMotion
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  loadPlannedMotion(cell: string, plannedMotion: PlannedMotion, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<PlanResponse>>;
  /**
   * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___  <!-- theme: danger -->  > **Experimental**  Plans a collision-free PTP motion for a single motion group.  Use the following workflow to execute a planned trajectory: 1. Plan a collision-free movement/motion. 2. Validate and load the planned trajectory using the [loadPlannedMotion](#/operations/loadPlannedMotion) endpoint. 3. Execute the loaded trajectory using the [streamMove](#/operations/streamMove) endpoint.
   * @summary Plan Collision Free PTP
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {PlanCollisionFreePTPRequest} [planCollisionFreePTPRequest]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  planCollisionFreePTP(cell: string, planCollisionFreePTPRequest?: PlanCollisionFreePTPRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<PlanTrajectoryResponse>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Deprecated endpoint. Use [planTrajectory](#/operations/planTrajectory) and [loadPlannedMotion](#/operations/loadPlannedMotion) instead.  Plans a new motion for a single previously configured [motion group](#/operations/listMotionGroups). Motions are described by a sequence of motion commands starting with start joints. A motion is planned from standstill to standstill. A single motion has constant TCP and payload. Currently, I/O actions can\'t be attached to a motion to execute the action in realtime while a motion is executed. If an I/O is needed at a specific point, multiple motions need to be planned. If an I/O is needed to be set while a motion is executed, the endpoint [setOutputValues](#/operations/setOutputValues) could be used.
   * @summary Plan Motion
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {PlanRequest} planRequest
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  planMotion(cell: string, planRequest: PlanRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<PlanResponse>>;
  /**
   * **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. Validate and load the planned trajectory using the [loadPlannedMotion](#/operations/loadPlannedMotion) endpoint. 3. Execute the loaded trajectory using the [streamMove](#/operations/streamMove) endpoint.  If the trajectory is not executable, the PlanTrajectoryFailedResponse will contain the joint trajectory up until the error (e.g. a collision) occurred. 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<PlanTrajectoryResponse>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Stops an active motion gracefully with deceleration until standstill while staying on the planned trajectory. When an active movement is stopped any further update request will be rejected. This call will immediately return even if the deceleration is still in progress. The active movement stream returns responses until the robot has reached standstill. Currently it is not possible to restart the motion. Please send in a feature request if you need to restart/continue the motion.
   * @summary Stop
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motion This represents the UUID of a motion. Every executable or partially executable motion is cached and an UUID is returned. Indicate the UUID to execute the motion or retrieve information on the motion.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  stopExecution(cell: string, motion: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Deprecated endpoint. Use `executeTrajectory` instead.  Moves the motion group forward or backward along a previously planned motion. Or request to move the motion group via joint point-to-point to a given location on a planned motion. Or set the playback speed of the motion. Or stop the motion execution.
   * @summary Stream Move
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {StreamMoveRequest} streamMoveRequest
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  streamMove(cell: string, streamMoveRequest: StreamMoveRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<StreamMoveResponse>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Deprecated endpoint. Use the [executeTrajectory](#/operations/executeTrajectory) endpoint instead. Request to move the motion group backward along a previously planned motion. Once started, you can stop a motion using the [stopExecution](#/operations/stopExecution) endpoint. Prerequisites, before starting the motion execution:  - The motion group is currently at the endpoint of the planned motion OR  - The motion was stopped using [stopExecution](#/operations/stopExecution) endpoint. Then it is possible to resume the motion execution from where it stopped OR  - The motion group was moved onto the motion using the [streamMoveToTrajectoryViaJointP2P](#/operations/streamMoveToTrajectoryViaJointP2P) endpoint.
   * @summary Stream Backward
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motion This represents the UUID of a motion. Every executable or partially executable motion is cached and an UUID is returned. Indicate the UUID to execute the motion or retrieve information on the motion.
   * @param {number} playbackSpeedInPercent Set the velocity for executed movements of the motion in percent. A percentage of 100% means that the robot moves as fast as possible without violating the limits. Setting this value does not affect the overall shape of the velocity profile. Everything is slowed down by the same factor. Therefore, this should only be used for teaching and trajectory evaluation purposes. If the process requires a certain velocity, the respective limits should be set when planning the motion. This will not change the velocity override of the controller. The controller velocity override value shall be 100% to ensure controllability of the motion group.
   * @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\&#39;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 {number} [startLocationOnTrajectory] Location the motion is requested to start at. The default value is the end of the trajectory. The location is a scalar value that defines a position along a path, typically ranging from 0 to &#x60;n&#x60;, where &#x60;n&#x60; 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.
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  streamMoveBackward(cell: string, motion: string, playbackSpeedInPercent: number, responseRate?: number, responseCoordinateSystem?: string, startLocationOnTrajectory?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<StreamMoveResponse>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Deprecated endpoint. Use the [executeTrajectory](#/operations/executeTrajectory) endpoint instead. Move the motion group forward along a previously planned motion. Once started, you can stop a motion using the [stopExecution](#/operations/stopExecution) endpoint. Prerequisites, before starting the motion execution:  - The motion group is currently at the start point of the planned motion OR  - The motion was stopped using [stopExecution](#/operations/stopExecution) endpoint. Then it is possible to resume the motion execution from where it stopped OR  - The motion group was moved onto the motion using the [streamMoveToTrajectoryViaJointP2P](#/operations/streamMoveToTrajectoryViaJointP2P) endpoint.
   * @summary Stream Forward
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motion This represents the UUID of a motion. Every executable or partially executable motion is cached and an UUID is returned. Indicate the UUID to execute the motion or retrieve information on the motion.
   * @param {number} playbackSpeedInPercent Set the velocity for executed movements of the motion in percent. A percentage of 100% means that the robot moves as fast as possible without violating the limits. Setting this value does not affect the overall shape of the velocity profile. Everything is slowed down by the same factor. Therefore, this should only be used for teaching and trajectory evaluation purposes. If the process requires a certain velocity, the respective limits should be set when planning the motion. This will not change the velocity override of the controller. The controller velocity override value shall be 100% to ensure controllability of the motion group.
   * @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\&#39;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 {number} [startLocationOnTrajectory] Location the motion is requested to start at. The default value is the beginning of the trajectory. The location is a scalar value that defines a position along a path, typically ranging from 0 to &#x60;n&#x60;, where &#x60;n&#x60; 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.
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  streamMoveForward(cell: string, motion: string, playbackSpeedInPercent: number, responseRate?: number, responseCoordinateSystem?: string, startLocationOnTrajectory?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<StreamMoveResponse>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Request to move the motion group via joint point-to-point to a given location on a planned motion. You must use this endpoint in order to start moving from an arbritrary location of the trajectory. Afterwards, you are able to call [streamMoveForward](#/operations/streamMoveForward) or [streamMoveBackward](#/operations/streamMoveBackward) to move along planned motion. Use the [stopExecution](#/operations/stopExecution) endpoint to stop the motion gracefully.
   * @summary Stream to Trajectory
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motion This represents the UUID of a motion. Every executable or partially executable motion is cached and an UUID is returned. Indicate the UUID to execute the motion or retrieve information on the motion.
   * @param {number} locationOnTrajectory
   * @param {Array<number>} [limitOverrideJointVelocityLimitsJoints] The joint velocity limits for the p2p motion to a previously planned motion.
   * @param {Array<number>} [limitOverrideJointAccelerationLimitsJoints] The joint acceleration limits for the p2p motion to a previously planned motion.
   * @param {number} [limitOverrideTcpVelocityLimit] Maximum allowed TCP velocity in [mm/s].
   * @param {number} [limitOverrideTcpAccelerationLimit] Maximum allowed TCP acceleration in [mm/s^2].
   * @param {number} [limitOverrideTcpOrientationVelocityLimit] Maximum allowed TCP rotation velocity in [rad/s].
   * @param {number} [limitOverrideTcpOrientationAccelerationLimit] Maximum allowed TCP rotation acceleration in [rad/s^2].
   * @param {string} [responsesCoordinateSystem]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  streamMoveToTrajectoryViaJointPTP(cell: string, motion: string, locationOnTrajectory: number, limitOverrideJointVelocityLimitsJoints?: Array<number>, limitOverrideJointAccelerationLimitsJoints?: Array<number>, limitOverrideTcpVelocityLimit?: number, limitOverrideTcpAccelerationLimit?: number, limitOverrideTcpOrientationVelocityLimit?: number, limitOverrideTcpOrientationAccelerationLimit?: number, responsesCoordinateSystem?: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<StreamMoveResponse>>;
};
/**
 * MotionApi - factory interface
 */
declare const MotionApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Delete all registered motions.
   * @summary All Motions
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  deleteAllMotions(cell: string, options?: RawAxiosRequestConfig): AxiosPromise<void>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Remove a previously created motion from cache. Use [listMotions](#/operations/listMotions) to list all available motions. Motions are removed automatically if the motion group or the corresponding controller is disconnected.
   * @summary Remove
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motion This represents the UUID of a motion. Every executable or partially executable motion is cached and an UUID is returned. Indicate the UUID to execute the motion or retrieve information on the motion.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  deleteMotion(cell: string, motion: string, options?: RawAxiosRequestConfig): AxiosPromise<void>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  <!-- theme: danger -->  > Websocket endpoint  Provide execution control over a previously planned trajectory. Enable the caller to attach I/O actions to the trajectory.  Understanding the 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 [planMotion](#/operations/planMotion).   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 is at the start location specified with InitializeMovementRequest.  ### 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 and not unlocked anymore.   To execute another trajectory, a new connection must be established.  #### 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  - InitializeMovementResponse is sent to signal the success or failure of the InitializeMovementRequest. - Movement responses are streamed after a StartMovementRequest successfully started the movement.   Movement responses are streamed in a rate that is defined as the multiple of the controller step-rate closest to   but not exceeding the rate configured by InitializeMovementRequest. - Standstill response is sent once the movement has finished or has come to a standstill due to a pause. - PauseMovementResponse is sent to signal the success of the PauseMovementRequest. It does not signal the end of the movement.   End of movement is signaled by standstill response. - PlaybackSpeedResponse is sent to signal the success of the PlaybackSpeedRequest. - MovementError with error details is sent in case of an unexpected error, 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 {ExecuteTrajectoryRequest} executeTrajectoryRequest
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  executeTrajectory(cell: string, executeTrajectoryRequest: ExecuteTrajectoryRequest, options?: RawAxiosRequestConfig): AxiosPromise<ExecuteTrajectoryResponse>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Get the trajectory of a planned motion with defined `sample_time` in milliseconds (ms). The trajectory is a list of points containing cartesian and joint data. The cartesian data is in the requested coordinate system. To get a single point of the trajectory, please use the [getMotionTrajectorySample](#/operations/getMotionTrajectorySample) endpoint.
   * @summary Get Trajectory
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motion This represents the UUID of a motion. Every executable or partially executable motion is cached and an UUID is returned. Indicate the UUID to execute the motion or retrieve information on the motion.
   * @param {number} sampleTime The value of &#x60;sample_time&#x60; is the time in milliseconds (ms) between each point in the trajectory.
   * @param {string} [responsesCoordinateSystem] Unique identifier addressing a coordinate system to which the cartesian data of the responses should be converted. Default: world coordinate system.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getMotionTrajectory(cell: string, motion: string, sampleTime: number, responsesCoordinateSystem?: string, options?: RawAxiosRequestConfig): AxiosPromise<GetTrajectoryResponse>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Get a single point at a certain location of a planned motion.  To get the whole trajectory, use the [getMotionTrajectory](#/operations/getMotionTrajectory) endpoint.
   * @summary Get Trajectory Sample
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motion This represents the UUID of a motion. Every executable or partially executable motion is cached and an UUID is returned. Indicate the UUID to execute the motion or retrieve information on the motion.
   * @param {number} [locationOnTrajectory]
   * @param {string} [responseCoordinateSystem] Unique identifier addressing a coordinate system for which the cartesian data of the response should be converted to. Default is the world coordinate system.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getMotionTrajectorySample(cell: string, motion: string, locationOnTrajectory?: number, responseCoordinateSystem?: string, options?: RawAxiosRequestConfig): AxiosPromise<GetTrajectorySampleResponse>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Get the joint data of a planned motion. The planned motion contains only the joint information, to persistently store and reload it later. The data will be sampled equidistantly with defined `sample_time` in milliseconds (ms). If not provided, the data is returned as it is stored on Wandelbots NOVA system.  To request cartesian data for visualization purposes, use the [getMotionTrajectory](#/operations/getMotionTrajectory) endpoint. To get a single point of the planned motion, use the [getMotionTrajectorySample](#/operations/getMotionTrajectorySample) endpoint.
   * @summary Get Planned Motion
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motion This represents the UUID of a motion. Every executable or partially executable motion is cached and an UUID is returned. Indicate the UUID to execute the motion or retrieve information on the motion.
   * @param {number} [sampleTime] -| The value of &#x60;sample_time&#x60; is the time in milliseconds (ms) between each datapoint of the planned motion. Optional. If not provided, the data is returned as it is stored internally and equidistant sampling is not guaranteed.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getPlannedMotion(cell: string, motion: string, sampleTime?: number, options?: RawAxiosRequestConfig): AxiosPromise<PlannedMotion>;
  /**
   * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___  Returns motion group models that are supported for planning.
   * @summary Motion Group Models for Planning
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getPlanningMotionGroupModels(cell: string, options?: RawAxiosRequestConfig): AxiosPromise<Array<string>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  List all currently planned and available motions. Use [planMotion](#/operations/planMotion) to plan a new motion. Motions are removed if the corresponding motion group or controller disconnects.
   * @summary List All Motions
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  listMotions(cell: string, options?: RawAxiosRequestConfig): AxiosPromise<MotionIdsListResponse>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Loads and validates the data of a planned motion into a motion session. The response contains information about the validated motion.  Validation can lead to three different results: - Fully valid: The whole planned motion can be executed from start to end. The response will contain the session to move the robot. - Partially valid: Only parts of the planned motion can be executed. The response will contain the session to move the robot and information about the failure for the part that is not executable. - Invalid: The planned motion can not be executed. The response will tell you, which information about the reason of failure.  If the motion is at least partially valid, the parts of the motion that are valid can be executed using the [streamMoveForward](#/operations/streamMoveForward) endpoint.  You can use the following workflows:   - Plan motions using the [planMotion](#/operations/planMotion) endpoint,   - Store the planned motion persistently,   - Use this endpoint to reload the stored motion and get a motion session for it.   - Execute the loaded motion using the [streamMoveForward](#/operations/streamMoveForward) endpoint.  OR:   - Generate a planned motion with [planTrajectory](#/operations/planTrajectory) or your own motion planner,   - Send the planned motion to this endpoint to validate it and get a motion session for it,   - Execute your motion using the [streamMoveForward](#/operations/streamMoveForward) endpoint.  Once a planned motion is validated, it is treated like a motion session and will appear in the list of available motions, see [listMotions](#/operations/listMotions) endpoint. You can then execute a motion session with the [streamMoveForward](#/operations/streamMoveForward) endpoint.
   * @summary Load Planned Motion
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {PlannedMotion} plannedMotion
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  loadPlannedMotion(cell: string, plannedMotion: PlannedMotion, options?: RawAxiosRequestConfig): AxiosPromise<PlanResponse>;
  /**
   * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___  <!-- theme: danger -->  > **Experimental**  Plans a collision-free PTP motion for a single motion group.  Use the following workflow to execute a planned trajectory: 1. Plan a collision-free movement/motion. 2. Validate and load the planned trajectory using the [loadPlannedMotion](#/operations/loadPlannedMotion) endpoint. 3. Execute the loaded trajectory using the [streamMove](#/operations/streamMove) endpoint.
   * @summary Plan Collision Free PTP
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {PlanCollisionFreePTPRequest} [planCollisionFreePTPRequest]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  planCollisionFreePTP(cell: string, planCollisionFreePTPRequest?: PlanCollisionFreePTPRequest, options?: RawAxiosRequestConfig): AxiosPromise<PlanTrajectoryResponse>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Deprecated endpoint. Use [planTrajectory](#/operations/planTrajectory) and [loadPlannedMotion](#/operations/loadPlannedMotion) instead.  Plans a new motion for a single previously configured [motion group](#/operations/listMotionGroups). Motions are described by a sequence of motion commands starting with start joints. A motion is planned from standstill to standstill. A single motion has constant TCP and payload. Currently, I/O actions can\'t be attached to a motion to execute the action in realtime while a motion is executed. If an I/O is needed at a specific point, multiple motions need to be planned. If an I/O is needed to be set while a motion is executed, the endpoint [setOutputValues](#/operations/setOutputValues) could be used.
   * @summary Plan Motion
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {PlanRequest} planRequest
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  planMotion(cell: string, planRequest: PlanRequest, options?: RawAxiosRequestConfig): AxiosPromise<PlanResponse>;
  /**
   * **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. Validate and load the planned trajectory using the [loadPlannedMotion](#/operations/loadPlannedMotion) endpoint. 3. Execute the loaded trajectory using the [streamMove](#/operations/streamMove) endpoint.  If the trajectory is not executable, the PlanTrajectoryFailedResponse will contain the joint trajectory up until the error (e.g. a collision) occurred. 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<PlanTrajectoryResponse>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Stops an active motion gracefully with deceleration until standstill while staying on the planned trajectory. When an active movement is stopped any further update request will be rejected. This call will immediately return even if the deceleration is still in progress. The active movement stream returns responses until the robot has reached standstill. Currently it is not possible to restart the motion. Please send in a feature request if you need to restart/continue the motion.
   * @summary Stop
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motion This represents the UUID of a motion. Every executable or partially executable motion is cached and an UUID is returned. Indicate the UUID to execute the motion or retrieve information on the motion.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  stopExecution(cell: string, motion: string, options?: RawAxiosRequestConfig): AxiosPromise<void>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Deprecated endpoint. Use `executeTrajectory` instead.  Moves the motion group forward or backward along a previously planned motion. Or request to move the motion group via joint point-to-point to a given location on a planned motion. Or set the playback speed of the motion. Or stop the motion execution.
   * @summary Stream Move
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {StreamMoveRequest} streamMoveRequest
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  streamMove(cell: string, streamMoveRequest: StreamMoveRequest, options?: RawAxiosRequestConfig): AxiosPromise<StreamMoveResponse>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Deprecated endpoint. Use the [executeTrajectory](#/operations/executeTrajectory) endpoint instead. Request to move the motion group backward along a previously planned motion. Once started, you can stop a motion using the [stopExecution](#/operations/stopExecution) endpoint. Prerequisites, before starting the motion execution:  - The motion group is currently at the endpoint of the planned motion OR  - The motion was stopped using [stopExecution](#/operations/stopExecution) endpoint. Then it is possible to resume the motion execution from where it stopped OR  - The motion group was moved onto the motion using the [streamMoveToTrajectoryViaJointP2P](#/operations/streamMoveToTrajectoryViaJointP2P) endpoint.
   * @summary Stream Backward
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motion This represents the UUID of a motion. Every executable or partially executable motion is cached and an UUID is returned. Indicate the UUID to execute the motion or retrieve information on the motion.
   * @param {number} playbackSpeedInPercent Set the velocity for executed movements of the motion in percent. A percentage of 100% means that the robot moves as fast as possible without violating the limits. Setting this value does not affect the overall shape of the velocity profile. Everything is slowed down by the same factor. Therefore, this should only be used for teaching and trajectory evaluation purposes. If the process requires a certain velocity, the respective limits should be set when planning the motion. This will not change the velocity override of the controller. The controller velocity override value shall be 100% to ensure controllability of the motion group.
   * @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\&#39;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 {number} [startLocationOnTrajectory] Location the motion is requested to start at. The default value is the end of the trajectory. The location is a scalar value that defines a position along a path, typically ranging from 0 to &#x60;n&#x60;, where &#x60;n&#x60; 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.
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  streamMoveBackward(cell: string, motion: string, playbackSpeedInPercent: number, responseRate?: number, responseCoordinateSystem?: string, startLocationOnTrajectory?: number, options?: RawAxiosRequestConfig): AxiosPromise<StreamMoveResponse>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Deprecated endpoint. Use the [executeTrajectory](#/operations/executeTrajectory) endpoint instead. Move the motion group forward along a previously planned motion. Once started, you can stop a motion using the [stopExecution](#/operations/stopExecution) endpoint. Prerequisites, before starting the motion execution:  - The motion group is currently at the start point of the planned motion OR  - The motion was stopped using [stopExecution](#/operations/stopExecution) endpoint. Then it is possible to resume the motion execution from where it stopped OR  - The motion group was moved onto the motion using the [streamMoveToTrajectoryViaJointP2P](#/operations/streamMoveToTrajectoryViaJointP2P) endpoint.
   * @summary Stream Forward
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motion This represents the UUID of a motion. Every executable or partially executable motion is cached and an UUID is returned. Indicate the UUID to execute the motion or retrieve information on the motion.
   * @param {number} playbackSpeedInPercent Set the velocity for executed movements of the motion in percent. A percentage of 100% means that the robot moves as fast as possible without violating the limits. Setting this value does not affect the overall shape of the velocity profile. Everything is slowed down by the same factor. Therefore, this should only be used for teaching and trajectory evaluation purposes. If the process requires a certain velocity, the respective limits should be set when planning the motion. This will not change the velocity override of the controller. The controller velocity override value shall be 100% to ensure controllability of the motion group.
   * @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\&#39;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 {number} [startLocationOnTrajectory] Location the motion is requested to start at. The default value is the beginning of the trajectory. The location is a scalar value that defines a position along a path, typically ranging from 0 to &#x60;n&#x60;, where &#x60;n&#x60; 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.
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  streamMoveForward(cell: string, motion: string, playbackSpeedInPercent: number, responseRate?: number, responseCoordinateSystem?: string, startLocationOnTrajectory?: number, options?: RawAxiosRequestConfig): AxiosPromise<StreamMoveResponse>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Request to move the motion group via joint point-to-point to a given location on a planned motion. You must use this endpoint in order to start moving from an arbritrary location of the trajectory. Afterwards, you are able to call [streamMoveForward](#/operations/streamMoveForward) or [streamMoveBackward](#/operations/streamMoveBackward) to move along planned motion. Use the [stopExecution](#/operations/stopExecution) endpoint to stop the motion gracefully.
   * @summary Stream to Trajectory
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motion This represents the UUID of a motion. Every executable or partially executable motion is cached and an UUID is returned. Indicate the UUID to execute the motion or retrieve information on the motion.
   * @param {number} locationOnTrajectory
   * @param {Array<number>} [limitOverrideJointVelocityLimitsJoints] The joint velocity limits for the p2p motion to a previously planned motion.
   * @param {Array<number>} [limitOverrideJointAccelerationLimitsJoints] The joint acceleration limits for the p2p motion to a previously planned motion.
   * @param {number} [limitOverrideTcpVelocityLimit] Maximum allowed TCP velocity in [mm/s].
   * @param {number} [limitOverrideTcpAccelerationLimit] Maximum allowed TCP acceleration in [mm/s^2].
   * @param {number} [limitOverrideTcpOrientationVelocityLimit] Maximum allowed TCP rotation velocity in [rad/s].
   * @param {number} [limitOverrideTcpOrientationAccelerationLimit] Maximum allowed TCP rotation acceleration in [rad/s^2].
   * @param {string} [responsesCoordinateSystem]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  streamMoveToTrajectoryViaJointPTP(cell: string, motion: string, locationOnTrajectory: number, limitOverrideJointVelocityLimitsJoints?: Array<number>, limitOverrideJointAccelerationLimitsJoints?: Array<number>, limitOverrideTcpVelocityLimit?: number, limitOverrideTcpAccelerationLimit?: number, limitOverrideTcpOrientationVelocityLimit?: number, limitOverrideTcpOrientationAccelerationLimit?: number, responsesCoordinateSystem?: string, options?: RawAxiosRequestConfig): AxiosPromise<StreamMoveResponse>;
};
/**
 * MotionApi - object-oriented interface
 */
declare class MotionApi extends BaseAPI {
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Delete all registered motions.
   * @summary All Motions
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  deleteAllMotions(cell: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<void, any, {}>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Remove a previously created motion from cache. Use [listMotions](#/operations/listMotions) to list all available motions. Motions are removed automatically if the motion group or the corresponding controller is disconnected.
   * @summary Remove
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motion This represents the UUID of a motion. Every executable or partially executable motion is cached and an UUID is returned. Indicate the UUID to execute the motion or retrieve information on the motion.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  deleteMotion(cell: string, motion: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<void, any, {}>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  <!-- theme: danger -->  > Websocket endpoint  Provide execution control over a previously planned trajectory. Enable the caller to attach I/O actions to the trajectory.  Understanding the 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 [planMotion](#/operations/planMotion).   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 is at the start location specified with InitializeMovementRequest.  ### 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 and not unlocked anymore.   To execute another trajectory, a new connection must be established.  #### 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  - InitializeMovementResponse is sent to signal the success or failure of the InitializeMovementRequest. - Movement responses are streamed after a StartMovementRequest successfully started the movement.   Movement responses are streamed in a rate that is defined as the multiple of the controller step-rate closest to   but not exceeding the rate configured by InitializeMovementRequest. - Standstill response is sent once the movement has finished or has come to a standstill due to a pause. - PauseMovementResponse is sent to signal the success of the PauseMovementRequest. It does not signal the end of the movement.   End of movement is signaled by standstill response. - PlaybackSpeedResponse is sent to signal the success of the PlaybackSpeedRequest. - MovementError with error details is sent in case of an unexpected error, 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 {ExecuteTrajectoryRequest} executeTrajectoryRequest
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  executeTrajectory(cell: string, executeTrajectoryRequest: ExecuteTrajectoryRequest, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<ExecuteTrajectoryResponse, any, {}>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Get the trajectory of a planned motion with defined `sample_time` in milliseconds (ms). The trajectory is a list of points containing cartesian and joint data. The cartesian data is in the requested coordinate system. To get a single point of the trajectory, please use the [getMotionTrajectorySample](#/operations/getMotionTrajectorySample) endpoint.
   * @summary Get Trajectory
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motion This represents the UUID of a motion. Every executable or partially executable motion is cached and an UUID is returned. Indicate the UUID to execute the motion or retrieve information on the motion.
   * @param {number} sampleTime The value of &#x60;sample_time&#x60; is the time in milliseconds (ms) between each point in the trajectory.
   * @param {string} [responsesCoordinateSystem] Unique identifier addressing a coordinate system to which the cartesian data of the responses should be converted. Default: world coordinate system.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getMotionTrajectory(cell: string, motion: string, sampleTime: number, responsesCoordinateSystem?: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<GetTrajectoryResponse, any, {}>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Get a single point at a certain location of a planned motion.  To get the whole trajectory, use the [getMotionTrajectory](#/operations/getMotionTrajectory) endpoint.
   * @summary Get Trajectory Sample
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motion This represents the UUID of a motion. Every executable or partially executable motion is cached and an UUID is returned. Indicate the UUID to execute the motion or retrieve information on the motion.
   * @param {number} [locationOnTrajectory]
   * @param {string} [responseCoordinateSystem] Unique identifier addressing a coordinate system for which the cartesian data of the response should be converted to. Default is the world coordinate system.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getMotionTrajectorySample(cell: string, motion: string, locationOnTrajectory?: number, responseCoordinateSystem?: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<GetTrajectorySampleResponse, any, {}>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Get the joint data of a planned motion. The planned motion contains only the joint information, to persistently store and reload it later. The data will be sampled equidistantly with defined `sample_time` in milliseconds (ms). If not provided, the data is returned as it is stored on Wandelbots NOVA system.  To request cartesian data for visualization purposes, use the [getMotionTrajectory](#/operations/getMotionTrajectory) endpoint. To get a single point of the planned motion, use the [getMotionTrajectorySample](#/operations/getMotionTrajectorySample) endpoint.
   * @summary Get Planned Motion
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motion This represents the UUID of a motion. Every executable or partially executable motion is cached and an UUID is returned. Indicate the UUID to execute the motion or retrieve information on the motion.
   * @param {number} [sampleTime] -| The value of &#x60;sample_time&#x60; is the time in milliseconds (ms) between each datapoint of the planned motion. Optional. If not provided, the data is returned as it is stored internally and equidistant sampling is not guaranteed.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getPlannedMotion(cell: string, motion: string, sampleTime?: number, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<PlannedMotion, any, {}>>;
  /**
   * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___  Returns motion group models that are supported for planning.
   * @summary Motion Group Models for Planning
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getPlanningMotionGroupModels(cell: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<string[], any, {}>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  List all currently planned and available motions. Use [planMotion](#/operations/planMotion) to plan a new motion. Motions are removed if the corresponding motion group or controller disconnects.
   * @summary List All Motions
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  listMotions(cell: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<MotionIdsListResponse, any, {}>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Loads and validates the data of a planned motion into a motion session. The response contains information about the validated motion.  Validation can lead to three different results: - Fully valid: The whole planned motion can be executed from start to end. The response will contain the session to move the robot. - Partially valid: Only parts of the planned motion can be executed. The response will contain the session to move the robot and information about the failure for the part that is not executable. - Invalid: The planned motion can not be executed. The response will tell you, which information about the reason of failure.  If the motion is at least partially valid, the parts of the motion that are valid can be executed using the [streamMoveForward](#/operations/streamMoveForward) endpoint.  You can use the following workflows:   - Plan motions using the [planMotion](#/operations/planMotion) endpoint,   - Store the planned motion persistently,   - Use this endpoint to reload the stored motion and get a motion session for it.   - Execute the loaded motion using the [streamMoveForward](#/operations/streamMoveForward) endpoint.  OR:   - Generate a planned motion with [planTrajectory](#/operations/planTrajectory) or your own motion planner,   - Send the planned motion to this endpoint to validate it and get a motion session for it,   - Execute your motion using the [streamMoveForward](#/operations/streamMoveForward) endpoint.  Once a planned motion is validated, it is treated like a motion session and will appear in the list of available motions, see [listMotions](#/operations/listMotions) endpoint. You can then execute a motion session with the [streamMoveForward](#/operations/streamMoveForward) endpoint.
   * @summary Load Planned Motion
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {PlannedMotion} plannedMotion
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  loadPlannedMotion(cell: string, plannedMotion: PlannedMotion, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<PlanResponse, any, {}>>;
  /**
   * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___  <!-- theme: danger -->  > **Experimental**  Plans a collision-free PTP motion for a single motion group.  Use the following workflow to execute a planned trajectory: 1. Plan a collision-free movement/motion. 2. Validate and load the planned trajectory using the [loadPlannedMotion](#/operations/loadPlannedMotion) endpoint. 3. Execute the loaded trajectory using the [streamMove](#/operations/streamMove) endpoint.
   * @summary Plan Collision Free PTP
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {PlanCollisionFreePTPRequest} [planCollisionFreePTPRequest]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  planCollisionFreePTP(cell: string, planCollisionFreePTPRequest?: PlanCollisionFreePTPRequest, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<PlanTrajectoryResponse, any, {}>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Deprecated endpoint. Use [planTrajectory](#/operations/planTrajectory) and [loadPlannedMotion](#/operations/loadPlannedMotion) instead.  Plans a new motion for a single previously configured [motion group](#/operations/listMotionGroups). Motions are described by a sequence of motion commands starting with start joints. A motion is planned from standstill to standstill. A single motion has constant TCP and payload. Currently, I/O actions can\'t be attached to a motion to execute the action in realtime while a motion is executed. If an I/O is needed at a specific point, multiple motions need to be planned. If an I/O is needed to be set while a motion is executed, the endpoint [setOutputValues](#/operations/setOutputValues) could be used.
   * @summary Plan Motion
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {PlanRequest} planRequest
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  planMotion(cell: string, planRequest: PlanRequest, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<PlanResponse, any, {}>>;
  /**
   * **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. Validate and load the planned trajectory using the [loadPlannedMotion](#/operations/loadPlannedMotion) endpoint. 3. Execute the loaded trajectory using the [streamMove](#/operations/streamMove) endpoint.  If the trajectory is not executable, the PlanTrajectoryFailedResponse will contain the joint trajectory up until the error (e.g. a collision) occurred. 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<PlanTrajectoryResponse, any, {}>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Stops an active motion gracefully with deceleration until standstill while staying on the planned trajectory. When an active movement is stopped any further update request will be rejected. This call will immediately return even if the deceleration is still in progress. The active movement stream returns responses until the robot has reached standstill. Currently it is not possible to restart the motion. Please send in a feature request if you need to restart/continue the motion.
   * @summary Stop
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motion This represents the UUID of a motion. Every executable or partially executable motion is cached and an UUID is returned. Indicate the UUID to execute the motion or retrieve information on the motion.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  stopExecution(cell: string, motion: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<void, any, {}>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Deprecated endpoint. Use `executeTrajectory` instead.  Moves the motion group forward or backward along a previously planned motion. Or request to move the motion group via joint point-to-point to a given location on a planned motion. Or set the playback speed of the motion. Or stop the motion execution.
   * @summary Stream Move
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {StreamMoveRequest} streamMoveRequest
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  streamMove(cell: string, streamMoveRequest: StreamMoveRequest, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<StreamMoveResponse, any, {}>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Deprecated endpoint. Use the [executeTrajectory](#/operations/executeTrajectory) endpoint instead. Request to move the motion group backward along a previously planned motion. Once started, you can stop a motion using the [stopExecution](#/operations/stopExecution) endpoint. Prerequisites, before starting the motion execution:  - The motion group is currently at the endpoint of the planned motion OR  - The motion was stopped using [stopExecution](#/operations/stopExecution) endpoint. Then it is possible to resume the motion execution from where it stopped OR  - The motion group was moved onto the motion using the [streamMoveToTrajectoryViaJointP2P](#/operations/streamMoveToTrajectoryViaJointP2P) endpoint.
   * @summary Stream Backward
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motion This represents the UUID of a motion. Every executable or partially executable motion is cached and an UUID is returned. Indicate the UUID to execute the motion or retrieve information on the motion.
   * @param {number} playbackSpeedInPercent Set the velocity for executed movements of the motion in percent. A percentage of 100% means that the robot moves as fast as possible without violating the limits. Setting this value does not affect the overall shape of the velocity profile. Everything is slowed down by the same factor. Therefore, this should only be used for teaching and trajectory evaluation purposes. If the process requires a certain velocity, the respective limits should be set when planning the motion. This will not change the velocity override of the controller. The controller velocity override value shall be 100% to ensure controllability of the motion group.
   * @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\&#39;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 {number} [startLocationOnTrajectory] Location the motion is requested to start at. The default value is the end of the trajectory. The location is a scalar value that defines a position along a path, typically ranging from 0 to &#x60;n&#x60;, where &#x60;n&#x60; 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.
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  streamMoveBackward(cell: string, motion: string, playbackSpeedInPercent: number, responseRate?: number, responseCoordinateSystem?: string, startLocationOnTrajectory?: number, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<StreamMoveResponse, any, {}>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Deprecated endpoint. Use the [executeTrajectory](#/operations/executeTrajectory) endpoint instead. Move the motion group forward along a previously planned motion. Once started, you can stop a motion using the [stopExecution](#/operations/stopExecution) endpoint. Prerequisites, before starting the motion execution:  - The motion group is currently at the start point of the planned motion OR  - The motion was stopped using [stopExecution](#/operations/stopExecution) endpoint. Then it is possible to resume the motion execution from where it stopped OR  - The motion group was moved onto the motion using the [streamMoveToTrajectoryViaJointP2P](#/operations/streamMoveToTrajectoryViaJointP2P) endpoint.
   * @summary Stream Forward
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motion This represents the UUID of a motion. Every executable or partially executable motion is cached and an UUID is returned. Indicate the UUID to execute the motion or retrieve information on the motion.
   * @param {number} playbackSpeedInPercent Set the velocity for executed movements of the motion in percent. A percentage of 100% means that the robot moves as fast as possible without violating the limits. Setting this value does not affect the overall shape of the velocity profile. Everything is slowed down by the same factor. Therefore, this should only be used for teaching and trajectory evaluation purposes. If the process requires a certain velocity, the respective limits should be set when planning the motion. This will not change the velocity override of the controller. The controller velocity override value shall be 100% to ensure controllability of the motion group.
   * @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\&#39;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 {number} [startLocationOnTrajectory] Location the motion is requested to start at. The default value is the beginning of the trajectory. The location is a scalar value that defines a position along a path, typically ranging from 0 to &#x60;n&#x60;, where &#x60;n&#x60; 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.
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  streamMoveForward(cell: string, motion: string, playbackSpeedInPercent: number, responseRate?: number, responseCoordinateSystem?: string, startLocationOnTrajectory?: number, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<StreamMoveResponse, any, {}>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Request to move the motion group via joint point-to-point to a given location on a planned motion. You must use this endpoint in order to start moving from an arbritrary location of the trajectory. Afterwards, you are able to call [streamMoveForward](#/operations/streamMoveForward) or [streamMoveBackward](#/operations/streamMoveBackward) to move along planned motion. Use the [stopExecution](#/operations/stopExecution) endpoint to stop the motion gracefully.
   * @summary Stream to Trajectory
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motion This represents the UUID of a motion. Every executable or partially executable motion is cached and an UUID is returned. Indicate the UUID to execute the motion or retrieve information on the motion.
   * @param {number} locationOnTrajectory
   * @param {Array<number>} [limitOverrideJointVelocityLimitsJoints] The joint velocity limits for the p2p motion to a previously planned motion.
   * @param {Array<number>} [limitOverrideJointAccelerationLimitsJoints] The joint acceleration limits for the p2p motion to a previously planned motion.
   * @param {number} [limitOverrideTcpVelocityLimit] Maximum allowed TCP velocity in [mm/s].
   * @param {number} [limitOverrideTcpAccelerationLimit] Maximum allowed TCP acceleration in [mm/s^2].
   * @param {number} [limitOverrideTcpOrientationVelocityLimit] Maximum allowed TCP rotation velocity in [rad/s].
   * @param {number} [limitOverrideTcpOrientationAccelerationLimit] Maximum allowed TCP rotation acceleration in [rad/s^2].
   * @param {string} [responsesCoordinateSystem]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  streamMoveToTrajectoryViaJointPTP(cell: string, motion: string, locationOnTrajectory: number, limitOverrideJointVelocityLimitsJoints?: Array<number>, limitOverrideJointAccelerationLimitsJoints?: Array<number>, limitOverrideTcpVelocityLimit?: number, limitOverrideTcpAccelerationLimit?: number, limitOverrideTcpOrientationVelocityLimit?: number, limitOverrideTcpOrientationAccelerationLimit?: number, responsesCoordinateSystem?: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<StreamMoveResponse, any, {}>>;
}
/**
 * MotionGroupApi - axios parameter creator
 */
declare const MotionGroupApiAxiosParamCreator: (configuration?: Configuration) => {
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Activate the motion group and keep the motion group in an active status. To activate all motion groups of a robot controller, use this endpoint. It will return all activated motion groups of that controller.  When activating motion groups, it is not possible to interact with the controller in any other way.  To deactivate a motion group, use [deactivateMotionGroup](#/operations/deactivateMotionGroup).
   * @summary Activate All
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} controller
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  activateAllMotionGroups: (cell: string, controller: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Activate the motion group and keep the motion group in an active status. To manually activate a motion group, use this endpoint.  When activating a motion group, interacting with the controller in other ways is not possible.  To deactivate a motion group, use [deactivateMotionGroup](#/operations/deactivateMotionGroup).
   * @summary Activate
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  activateMotionGroup: (cell: string, motionGroup: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Deactivate a motion group. Activate the motion group and keeps the motion group in an active status.  The robot controller streams information about all active motion groups. Deactivate motion groups that you no longer use.  When deactivating motion groups, it is not possible to interact with the controller in any other way.
   * @summary Deactivate
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  deactivateMotionGroup: (cell: string, motionGroup: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  List all active motion groups. A motion group is active if it is currently used by a controller.
   * @summary List Active
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  listMotionGroups: (cell: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
/**
 * MotionGroupApi - functional programming interface
 */
declare const MotionGroupApiFp: (configuration?: Configuration) => {
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Activate the motion group and keep the motion group in an active status. To activate all motion groups of a robot controller, use this endpoint. It will return all activated motion groups of that controller.  When activating motion groups, it is not possible to interact with the controller in any other way.  To deactivate a motion group, use [deactivateMotionGroup](#/operations/deactivateMotionGroup).
   * @summary Activate All
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} controller
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  activateAllMotionGroups(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<MotionGroupInstanceList>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Activate the motion group and keep the motion group in an active status. To manually activate a motion group, use this endpoint.  When activating a motion group, interacting with the controller in other ways is not possible.  To deactivate a motion group, use [deactivateMotionGroup](#/operations/deactivateMotionGroup).
   * @summary Activate
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  activateMotionGroup(cell: string, motionGroup: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<MotionGroupInstance>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Deactivate a motion group. Activate the motion group and keeps the motion group in an active status.  The robot controller streams information about all active motion groups. Deactivate motion groups that you no longer use.  When deactivating motion groups, it is not possible to interact with the controller in any other way.
   * @summary Deactivate
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  deactivateMotionGroup(cell: string, motionGroup: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  List all active motion groups. A motion group is active if it is currently used by a controller.
   * @summary List Active
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  listMotionGroups(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<MotionGroupInstanceList>>;
};
/**
 * MotionGroupApi - factory interface
 */
declare const MotionGroupApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Activate the motion group and keep the motion group in an active status. To activate all motion groups of a robot controller, use this endpoint. It will return all activated motion groups of that controller.  When activating motion groups, it is not possible to interact with the controller in any other way.  To deactivate a motion group, use [deactivateMotionGroup](#/operations/deactivateMotionGroup).
   * @summary Activate All
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} controller
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  activateAllMotionGroups(cell: string, controller: string, options?: RawAxiosRequestConfig): AxiosPromise<MotionGroupInstanceList>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Activate the motion group and keep the motion group in an active status. To manually activate a motion group, use this endpoint.  When activating a motion group, interacting with the controller in other ways is not possible.  To deactivate a motion group, use [deactivateMotionGroup](#/operations/deactivateMotionGroup).
   * @summary Activate
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  activateMotionGroup(cell: string, motionGroup: string, options?: RawAxiosRequestConfig): AxiosPromise<MotionGroupInstance>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Deactivate a motion group. Activate the motion group and keeps the motion group in an active status.  The robot controller streams information about all active motion groups. Deactivate motion groups that you no longer use.  When deactivating motion groups, it is not possible to interact with the controller in any other way.
   * @summary Deactivate
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  deactivateMotionGroup(cell: string, motionGroup: string, options?: RawAxiosRequestConfig): AxiosPromise<void>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  List all active motion groups. A motion group is active if it is currently used by a controller.
   * @summary List Active
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  listMotionGroups(cell: string, options?: RawAxiosRequestConfig): AxiosPromise<MotionGroupInstanceList>;
};
/**
 * MotionGroupApi - object-oriented interface
 */
declare class MotionGroupApi extends BaseAPI {
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Activate the motion group and keep the motion group in an active status. To activate all motion groups of a robot controller, use this endpoint. It will return all activated motion groups of that controller.  When activating motion groups, it is not possible to interact with the controller in any other way.  To deactivate a motion group, use [deactivateMotionGroup](#/operations/deactivateMotionGroup).
   * @summary Activate All
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} controller
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  activateAllMotionGroups(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<MotionGroupInstanceList, any, {}>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Activate the motion group and keep the motion group in an active status. To manually activate a motion group, use this endpoint.  When activating a motion group, interacting with the controller in other ways is not possible.  To deactivate a motion group, use [deactivateMotionGroup](#/operations/deactivateMotionGroup).
   * @summary Activate
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  activateMotionGroup(cell: string, motionGroup: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<MotionGroupInstance, any, {}>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Deactivate a motion group. Activate the motion group and keeps the motion group in an active status.  The robot controller streams information about all active motion groups. Deactivate motion groups that you no longer use.  When deactivating motion groups, it is not possible to interact with the controller in any other way.
   * @summary Deactivate
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  deactivateMotionGroup(cell: string, motionGroup: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<void, any, {}>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  List all active motion groups. A motion group is active if it is currently used by a controller.
   * @summary List Active
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  listMotionGroups(cell: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<MotionGroupInstanceList, any, {}>>;
}
/**
 * MotionGroupInfosApi - axios parameter creator
 */
declare const MotionGroupInfosApiAxiosParamCreator: (configuration?: Configuration) => {
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Gets the currently selected payload of the motion group. The payload is defined as the sum of all weights attached to the flange/endpoint of the motion group, e.g. sum of the tools and workpiece weight that are currently attached.
   * @summary Selected Payload
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getActivePayload: (cell: string, motionGroup: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Get the internal selected TCP of a connected device.
   * @summary Selected TCP
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {RotationAngleTypes} [rotationType]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getActiveTcp: (cell: string, motionGroup: string, rotationType?: RotationAngleTypes, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **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 of Device
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {string} [tcp] The identifier of the tool center point (TCP) to be used for tcp_pose in response. If not set, the flange pose is returned as tcp_pose.
   * @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, motionGroup: string, tcp?: string, responseCoordinateSystem?: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Shows the options the motion group offers in regard to the information service.  Some motion groups may not provide all information services, e.g. some manufacturers don\'t have a blending zone concept.
   * @summary Capabilities
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getInfoCapabilities: (cell: string, motionGroup: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Get static properties of the motion group. Those properties are used internally for motion group plannning. Only supported motion groups will return a valid response.
   * @summary Get Static Properties
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getMotionGroupSpecification: (cell: string, motionGroup: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Returns the configured mounting pose offset in relation to world coordinate system and the motion groups coordinate system.
   * @summary Device Mounting
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getMounting: (cell: string, motionGroup: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  <!-- theme: danger -->  > **Experimental**  Get the complete configuration which can be passed to the planner-optimizer (incl. motion group description, limits etc.)
   * @summary Optimizer Configuration
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {string} [tcp]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getOptimizerConfiguration: (cell: string, motionGroup: string, tcp?: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Get the safety setup and limitations of a connected device, which restricts the device. Safety settings are configured globally on the robot controller and are valid for all the connected devices (like robots).
   * @summary Safety Setup and Limitations
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getSafetySetup: (cell: string, motionGroup: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Lists all defined payloads of the motion group. The payload is defined as the sum of all weights attached to the flange/endpoint of the motion group, e.g. sum of the tools and workpiece weight that are currently attached.
   * @summary List Payloads
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  listPayloads: (cell: string, motionGroup: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Get all internal configured TCPs of a connected device.
   * @summary List TCPs
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {RotationAngleTypes} [rotationType]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  listTcps: (cell: string, motionGroup: string, rotationType?: RotationAngleTypes, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Receive updates of the motion group state. The stream will be closed from the server if the controller is disconnected.
   * @summary Stream State of Device
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @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\&#39;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 {string} [tcp] The identifier of the tool center point (TCP) to be used for tcp_pose in response. If not set, the flange pose is returned as tcp_pose.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  streamMotionGroupState: (cell: string, motionGroup: string, responseRate?: number, responseCoordinateSystem?: string, tcp?: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
/**
 * MotionGroupInfosApi - functional programming interface
 */
declare const MotionGroupInfosApiFp: (configuration?: Configuration) => {
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Gets the currently selected payload of the motion group. The payload is defined as the sum of all weights attached to the flange/endpoint of the motion group, e.g. sum of the tools and workpiece weight that are currently attached.
   * @summary Selected Payload
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getActivePayload(cell: string, motionGroup: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Payload>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Get the internal selected TCP of a connected device.
   * @summary Selected TCP
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {RotationAngleTypes} [rotationType]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getActiveTcp(cell: string, motionGroup: string, rotationType?: RotationAngleTypes, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<RobotTcp>>;
  /**
   * **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 of Device
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {string} [tcp] The identifier of the tool center point (TCP) to be used for tcp_pose in response. If not set, the flange pose is returned as tcp_pose.
   * @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, motionGroup: string, tcp?: string, responseCoordinateSystem?: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<MotionGroupStateResponse>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Shows the options the motion group offers in regard to the information service.  Some motion groups may not provide all information services, e.g. some manufacturers don\'t have a blending zone concept.
   * @summary Capabilities
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getInfoCapabilities(cell: string, motionGroup: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<InfoServiceCapabilities>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Get static properties of the motion group. Those properties are used internally for motion group plannning. Only supported motion groups will return a valid response.
   * @summary Get Static Properties
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getMotionGroupSpecification(cell: string, motionGroup: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<MotionGroupSpecification>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Returns the configured mounting pose offset in relation to world coordinate system and the motion groups coordinate system.
   * @summary Device Mounting
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getMounting(cell: string, motionGroup: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Mounting>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  <!-- theme: danger -->  > **Experimental**  Get the complete configuration which can be passed to the planner-optimizer (incl. motion group description, limits etc.)
   * @summary Optimizer Configuration
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {string} [tcp]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getOptimizerConfiguration(cell: string, motionGroup: string, tcp?: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<OptimizerSetup>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Get the safety setup and limitations of a connected device, which restricts the device. Safety settings are configured globally on the robot controller and are valid for all the connected devices (like robots).
   * @summary Safety Setup and Limitations
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getSafetySetup(cell: string, motionGroup: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<SafetySetup>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Lists all defined payloads of the motion group. The payload is defined as the sum of all weights attached to the flange/endpoint of the motion group, e.g. sum of the tools and workpiece weight that are currently attached.
   * @summary List Payloads
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  listPayloads(cell: string, motionGroup: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ListPayloadsResponse>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Get all internal configured TCPs of a connected device.
   * @summary List TCPs
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {RotationAngleTypes} [rotationType]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  listTcps(cell: string, motionGroup: string, rotationType?: RotationAngleTypes, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ListTcpsResponse>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Receive updates of the motion group state. The stream will be closed from the server if the controller is disconnected.
   * @summary Stream State of Device
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @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\&#39;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 {string} [tcp] The identifier of the tool center point (TCP) to be used for tcp_pose in response. If not set, the flange pose is returned as tcp_pose.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  streamMotionGroupState(cell: string, motionGroup: string, responseRate?: number, responseCoordinateSystem?: string, tcp?: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<MotionGroupStateResponse>>;
};
/**
 * MotionGroupInfosApi - factory interface
 */
declare const MotionGroupInfosApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Gets the currently selected payload of the motion group. The payload is defined as the sum of all weights attached to the flange/endpoint of the motion group, e.g. sum of the tools and workpiece weight that are currently attached.
   * @summary Selected Payload
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getActivePayload(cell: string, motionGroup: string, options?: RawAxiosRequestConfig): AxiosPromise<Payload>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Get the internal selected TCP of a connected device.
   * @summary Selected TCP
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {RotationAngleTypes} [rotationType]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getActiveTcp(cell: string, motionGroup: string, rotationType?: RotationAngleTypes, options?: RawAxiosRequestConfig): AxiosPromise<RobotTcp>;
  /**
   * **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 of Device
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {string} [tcp] The identifier of the tool center point (TCP) to be used for tcp_pose in response. If not set, the flange pose is returned as tcp_pose.
   * @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, motionGroup: string, tcp?: string, responseCoordinateSystem?: string, options?: RawAxiosRequestConfig): AxiosPromise<MotionGroupStateResponse>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Shows the options the motion group offers in regard to the information service.  Some motion groups may not provide all information services, e.g. some manufacturers don\'t have a blending zone concept.
   * @summary Capabilities
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getInfoCapabilities(cell: string, motionGroup: string, options?: RawAxiosRequestConfig): AxiosPromise<InfoServiceCapabilities>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Get static properties of the motion group. Those properties are used internally for motion group plannning. Only supported motion groups will return a valid response.
   * @summary Get Static Properties
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getMotionGroupSpecification(cell: string, motionGroup: string, options?: RawAxiosRequestConfig): AxiosPromise<MotionGroupSpecification>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Returns the configured mounting pose offset in relation to world coordinate system and the motion groups coordinate system.
   * @summary Device Mounting
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getMounting(cell: string, motionGroup: string, options?: RawAxiosRequestConfig): AxiosPromise<Mounting>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  <!-- theme: danger -->  > **Experimental**  Get the complete configuration which can be passed to the planner-optimizer (incl. motion group description, limits etc.)
   * @summary Optimizer Configuration
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {string} [tcp]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getOptimizerConfiguration(cell: string, motionGroup: string, tcp?: string, options?: RawAxiosRequestConfig): AxiosPromise<OptimizerSetup>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Get the safety setup and limitations of a connected device, which restricts the device. Safety settings are configured globally on the robot controller and are valid for all the connected devices (like robots).
   * @summary Safety Setup and Limitations
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getSafetySetup(cell: string, motionGroup: string, options?: RawAxiosRequestConfig): AxiosPromise<SafetySetup>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Lists all defined payloads of the motion group. The payload is defined as the sum of all weights attached to the flange/endpoint of the motion group, e.g. sum of the tools and workpiece weight that are currently attached.
   * @summary List Payloads
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  listPayloads(cell: string, motionGroup: string, options?: RawAxiosRequestConfig): AxiosPromise<ListPayloadsResponse>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Get all internal configured TCPs of a connected device.
   * @summary List TCPs
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {RotationAngleTypes} [rotationType]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  listTcps(cell: string, motionGroup: string, rotationType?: RotationAngleTypes, options?: RawAxiosRequestConfig): AxiosPromise<ListTcpsResponse>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Receive updates of the motion group state. The stream will be closed from the server if the controller is disconnected.
   * @summary Stream State of Device
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @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\&#39;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 {string} [tcp] The identifier of the tool center point (TCP) to be used for tcp_pose in response. If not set, the flange pose is returned as tcp_pose.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  streamMotionGroupState(cell: string, motionGroup: string, responseRate?: number, responseCoordinateSystem?: string, tcp?: string, options?: RawAxiosRequestConfig): AxiosPromise<MotionGroupStateResponse>;
};
/**
 * MotionGroupInfosApi - object-oriented interface
 */
declare class MotionGroupInfosApi extends BaseAPI {
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Gets the currently selected payload of the motion group. The payload is defined as the sum of all weights attached to the flange/endpoint of the motion group, e.g. sum of the tools and workpiece weight that are currently attached.
   * @summary Selected Payload
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getActivePayload(cell: string, motionGroup: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<Payload, any, {}>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Get the internal selected TCP of a connected device.
   * @summary Selected TCP
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {RotationAngleTypes} [rotationType]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getActiveTcp(cell: string, motionGroup: string, rotationType?: RotationAngleTypes, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<RobotTcp, any, {}>>;
  /**
   * **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 of Device
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {string} [tcp] The identifier of the tool center point (TCP) to be used for tcp_pose in response. If not set, the flange pose is returned as tcp_pose.
   * @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, motionGroup: string, tcp?: string, responseCoordinateSystem?: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<MotionGroupStateResponse, any, {}>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Shows the options the motion group offers in regard to the information service.  Some motion groups may not provide all information services, e.g. some manufacturers don\'t have a blending zone concept.
   * @summary Capabilities
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getInfoCapabilities(cell: string, motionGroup: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<InfoServiceCapabilities, any, {}>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Get static properties of the motion group. Those properties are used internally for motion group plannning. Only supported motion groups will return a valid response.
   * @summary Get Static Properties
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getMotionGroupSpecification(cell: string, motionGroup: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<MotionGroupSpecification, any, {}>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Returns the configured mounting pose offset in relation to world coordinate system and the motion groups coordinate system.
   * @summary Device Mounting
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getMounting(cell: string, motionGroup: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<Mounting, any, {}>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  <!-- theme: danger -->  > **Experimental**  Get the complete configuration which can be passed to the planner-optimizer (incl. motion group description, limits etc.)
   * @summary Optimizer Configuration
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {string} [tcp]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getOptimizerConfiguration(cell: string, motionGroup: string, tcp?: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<OptimizerSetup, any, {}>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Get the safety setup and limitations of a connected device, which restricts the device. Safety settings are configured globally on the robot controller and are valid for all the connected devices (like robots).
   * @summary Safety Setup and Limitations
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getSafetySetup(cell: string, motionGroup: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<SafetySetup, any, {}>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Lists all defined payloads of the motion group. The payload is defined as the sum of all weights attached to the flange/endpoint of the motion group, e.g. sum of the tools and workpiece weight that are currently attached.
   * @summary List Payloads
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  listPayloads(cell: string, motionGroup: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<ListPayloadsResponse, any, {}>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Get all internal configured TCPs of a connected device.
   * @summary List TCPs
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {RotationAngleTypes} [rotationType]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  listTcps(cell: string, motionGroup: string, rotationType?: RotationAngleTypes, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<ListTcpsResponse, any, {}>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Receive updates of the motion group state. The stream will be closed from the server if the controller is disconnected.
   * @summary Stream State of Device
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @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\&#39;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 {string} [tcp] The identifier of the tool center point (TCP) to be used for tcp_pose in response. If not set, the flange pose is returned as tcp_pose.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  streamMotionGroupState(cell: string, motionGroup: string, responseRate?: number, responseCoordinateSystem?: string, tcp?: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<MotionGroupStateResponse, any, {}>>;
}
/**
 * MotionGroupJoggingApi - axios parameter creator
 */
declare const MotionGroupJoggingApiAxiosParamCreator: (configuration?: Configuration) => {
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Move TCP along/around a specified direction vector with a specified velocity via a websocket.  The purpose of a direction jogging motion is to move a device in exactly one direction with a specified maximum velocity. The sign of the velocity determines the direction of the movement: Positive [+] or Negative [-]. The velocity is given in [mm/s]. In contrast to a planned motion, a jogging motion can be changed dynamically while the motion group is in motion.  Only one single client at a time can jog a particular motion group. If another client tries to jog the same motion group at the same time, the second call will fail.  The movement of the motion group will start as soon as: * the motion group is not in motion * the websocket connection is established * the first request has been sent  As long as the jogging motion is ongoing, responses will be sent continuously and contain the current state of the motion group. The responses will be sent with the specified rate according to the *response_rate* parameter of the initial websocket request. While in motion, the desired direction and velocity can be changed by sending a new request to the same websocket. The motion and sending of the replies will stop when: * a [stopJogging](#/operations/stopJogging) request was received, processed, and the movement stopped   The motion group state will be published in the original command stream until the motion group has stopped * the client cancels the stream (not recommended, because final stopping position will not be returned from the stream)  When a physical limit (e.g. workspace boundary) is reached, the motion group will stop moving in the desired direction. The stream, howewer, will continue to send the state until the client cancels the stream or sends the [stopJogging](#/operations/stopJogging) request.  Singularities are avoided during a jogging motion. This avoidance can result in deviations from the specified direction. The amount of deviation depends on the robot type and current velocity. These mechanisms can lead to a small deviation from the specified direction. The size of deviation is depending on robot type and current velocity.   **Usage example:**  1. Open a websocket via Python and start the jogging motion: ```bash > python -m websockets \"ws://<IP of Wandelbots NOVA API>/api/v1/cells/<your cell id>/motion-groups/move-tcp\" ``` 2. Send the following message to the server to move current TCP two parts up in the z direction and one part in the negative y direction with 0.2 mm/s along the specified direction vector: ```json {   \"motion_group\": \"<your motion group id>\",   \"position_direction\": {     \"y\": -0.5,     \"z\": 1   },   \"rotation_direction\": {},   \"position_velocity\": 0.2,   \"response_rate\": 500 } ``` The NOVA API clients support jogging motions without the need to manually open a websocket.  > **NOTE** > > If the jogging movement is stopped immediately, ensure that > > - A websocket connection is established. Websockets can be kept open until the robot\'s movement is done as opposed to a simple HTTP GET request. > > - The motion group is not in motion by another jogging movement or a planned movement.   > **NOTE** > > If the robot does not move, ensure that > > - The joint velocity values are not zero, > > - The motion group is not in a state where it cannot move further (e.g. joint limit reached).  > **NOTE** > > If the specified velocities are higher than the maximum allowed by the robot controller, the motion group will move with the maximum allowed velocities.
   * @summary Stream Cartesian
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {DirectionJoggingRequest} directionJoggingRequest
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  directionJogging: (cell: string, directionJoggingRequest: DirectionJoggingRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Shows the options the motion group offers in regard to jogging. Some motion groups may not provide all information services, e.g. it is physically not possible to move a one-axis-turntable in a linear way.
   * @summary Capabilities
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getJoggingCapabilities: (cell: string, motionGroup: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Move one or more joints of a motion group with specified velocities via a websocket.  The purpose of a joint jogging motion is to maneuver a motion group in one or more joints with a specified velocity for each joint. The sign of the velocity determines the direction of the joint movement. The velocity is given in [rad/s]. In contrast to a planned motion, a jogging motion can be changed dynamically while the motion group is in motion.  Only one single client at a time can jog a particular motion group. If another client tries to jog the same motion group at the same time, the second call will fail.  The movement of the motion group will start as soon as: * the motion group is not in motion * the websocket connection is established * the first request has been sent  As long as the jogging motion is ongoing, responses will be sent continuously and contain the current state of the motion group. The responses will be sent with the specified rate according to the *response_rate* parameter of the initial websocket request. While in motion, the desired joint velocity can be changed by sending a new request to the same websocket. The motion and sending of the replies will stop when: * a [stopJogging](#/operations/stopJogging) request was received, processed, and the movement stopped   Motion group state will be published in the original command stream until the motion group has fully stopped * the client cancels the stream (not recommended, because final stopping position will not be returned from the stream)  When a physical limit (e.g. joint limit) is reached, the motion group will stop moving in the desired direction. The stream, howewer, will continue to send the state until the client cancels the stream or sends the [stopJogging](#/operations/stopJogging) request.  **Usage example:**  1. Open a websocket via Python and start the jogging motion: ```bash > python -m websockets \"ws://<IP of Wandelbots NOVA API>/api/v1/cells/<your cell id>/motion-groups/move-joint\" ``` 2. Send the following message to move with a velocity of 0.1 rad/s (negative) for joint 5 and 0.2 rad/s for joint 6: ```json {   \"motion_group\": \"<your motion group id>\",   \"joint_velocities\": [0, 0, 0, 0, -0.1, 0.2],   \"response_rate\": 500 } ``` The provided NOVA API clients also natively support jogging motions, without the need to manually open a websocket.  > **NOTE** > > If the jogging movement is stopped immediately, ensure that > > - A websocket connection is established. Websockets can be kept open until the robot\'s movement is done as opposed to a simple HTTP GET request. > > - The motion group is not in motion by another jogging movement or a planned movement.   > **NOTE** > > If the robot does not move, ensure that > > - The joint velocity values are not zero, > > - The motion group is not in a state where it cannot move further (e.g. joint limit reached).  > **NOTE** > > If the specified velocities are higher than the maximum allowed by the robot controller, the motion group will move with the maximum allowed velocities.
   * @summary Stream Joints
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {JointJoggingRequest} jointJoggingRequest
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  jointJogging: (cell: string, jointJoggingRequest: JointJoggingRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Stops an ongoing jogging movement as fast as possible. Until the motion group reaches standstill, it decelerates and keeps the last specified direction.  This call will immediately return even if the deceleration is still in progress. After a stop request has been received, no further updates to the ongoing jogging movement are possible.  State responses will be sent via the jogging stream until the motion group reaches standstill.
   * @summary Stop
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  stopJogging: (cell: string, motionGroup: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
/**
 * MotionGroupJoggingApi - functional programming interface
 */
declare const MotionGroupJoggingApiFp: (configuration?: Configuration) => {
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Move TCP along/around a specified direction vector with a specified velocity via a websocket.  The purpose of a direction jogging motion is to move a device in exactly one direction with a specified maximum velocity. The sign of the velocity determines the direction of the movement: Positive [+] or Negative [-]. The velocity is given in [mm/s]. In contrast to a planned motion, a jogging motion can be changed dynamically while the motion group is in motion.  Only one single client at a time can jog a particular motion group. If another client tries to jog the same motion group at the same time, the second call will fail.  The movement of the motion group will start as soon as: * the motion group is not in motion * the websocket connection is established * the first request has been sent  As long as the jogging motion is ongoing, responses will be sent continuously and contain the current state of the motion group. The responses will be sent with the specified rate according to the *response_rate* parameter of the initial websocket request. While in motion, the desired direction and velocity can be changed by sending a new request to the same websocket. The motion and sending of the replies will stop when: * a [stopJogging](#/operations/stopJogging) request was received, processed, and the movement stopped   The motion group state will be published in the original command stream until the motion group has stopped * the client cancels the stream (not recommended, because final stopping position will not be returned from the stream)  When a physical limit (e.g. workspace boundary) is reached, the motion group will stop moving in the desired direction. The stream, howewer, will continue to send the state until the client cancels the stream or sends the [stopJogging](#/operations/stopJogging) request.  Singularities are avoided during a jogging motion. This avoidance can result in deviations from the specified direction. The amount of deviation depends on the robot type and current velocity. These mechanisms can lead to a small deviation from the specified direction. The size of deviation is depending on robot type and current velocity.   **Usage example:**  1. Open a websocket via Python and start the jogging motion: ```bash > python -m websockets \"ws://<IP of Wandelbots NOVA API>/api/v1/cells/<your cell id>/motion-groups/move-tcp\" ``` 2. Send the following message to the server to move current TCP two parts up in the z direction and one part in the negative y direction with 0.2 mm/s along the specified direction vector: ```json {   \"motion_group\": \"<your motion group id>\",   \"position_direction\": {     \"y\": -0.5,     \"z\": 1   },   \"rotation_direction\": {},   \"position_velocity\": 0.2,   \"response_rate\": 500 } ``` The NOVA API clients support jogging motions without the need to manually open a websocket.  > **NOTE** > > If the jogging movement is stopped immediately, ensure that > > - A websocket connection is established. Websockets can be kept open until the robot\'s movement is done as opposed to a simple HTTP GET request. > > - The motion group is not in motion by another jogging movement or a planned movement.   > **NOTE** > > If the robot does not move, ensure that > > - The joint velocity values are not zero, > > - The motion group is not in a state where it cannot move further (e.g. joint limit reached).  > **NOTE** > > If the specified velocities are higher than the maximum allowed by the robot controller, the motion group will move with the maximum allowed velocities.
   * @summary Stream Cartesian
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {DirectionJoggingRequest} directionJoggingRequest
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  directionJogging(cell: string, directionJoggingRequest: DirectionJoggingRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<JoggingResponse>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Shows the options the motion group offers in regard to jogging. Some motion groups may not provide all information services, e.g. it is physically not possible to move a one-axis-turntable in a linear way.
   * @summary Capabilities
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getJoggingCapabilities(cell: string, motionGroup: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<JoggingServiceCapabilities>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Move one or more joints of a motion group with specified velocities via a websocket.  The purpose of a joint jogging motion is to maneuver a motion group in one or more joints with a specified velocity for each joint. The sign of the velocity determines the direction of the joint movement. The velocity is given in [rad/s]. In contrast to a planned motion, a jogging motion can be changed dynamically while the motion group is in motion.  Only one single client at a time can jog a particular motion group. If another client tries to jog the same motion group at the same time, the second call will fail.  The movement of the motion group will start as soon as: * the motion group is not in motion * the websocket connection is established * the first request has been sent  As long as the jogging motion is ongoing, responses will be sent continuously and contain the current state of the motion group. The responses will be sent with the specified rate according to the *response_rate* parameter of the initial websocket request. While in motion, the desired joint velocity can be changed by sending a new request to the same websocket. The motion and sending of the replies will stop when: * a [stopJogging](#/operations/stopJogging) request was received, processed, and the movement stopped   Motion group state will be published in the original command stream until the motion group has fully stopped * the client cancels the stream (not recommended, because final stopping position will not be returned from the stream)  When a physical limit (e.g. joint limit) is reached, the motion group will stop moving in the desired direction. The stream, howewer, will continue to send the state until the client cancels the stream or sends the [stopJogging](#/operations/stopJogging) request.  **Usage example:**  1. Open a websocket via Python and start the jogging motion: ```bash > python -m websockets \"ws://<IP of Wandelbots NOVA API>/api/v1/cells/<your cell id>/motion-groups/move-joint\" ``` 2. Send the following message to move with a velocity of 0.1 rad/s (negative) for joint 5 and 0.2 rad/s for joint 6: ```json {   \"motion_group\": \"<your motion group id>\",   \"joint_velocities\": [0, 0, 0, 0, -0.1, 0.2],   \"response_rate\": 500 } ``` The provided NOVA API clients also natively support jogging motions, without the need to manually open a websocket.  > **NOTE** > > If the jogging movement is stopped immediately, ensure that > > - A websocket connection is established. Websockets can be kept open until the robot\'s movement is done as opposed to a simple HTTP GET request. > > - The motion group is not in motion by another jogging movement or a planned movement.   > **NOTE** > > If the robot does not move, ensure that > > - The joint velocity values are not zero, > > - The motion group is not in a state where it cannot move further (e.g. joint limit reached).  > **NOTE** > > If the specified velocities are higher than the maximum allowed by the robot controller, the motion group will move with the maximum allowed velocities.
   * @summary Stream Joints
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {JointJoggingRequest} jointJoggingRequest
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  jointJogging(cell: string, jointJoggingRequest: JointJoggingRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<JoggingResponse>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Stops an ongoing jogging movement as fast as possible. Until the motion group reaches standstill, it decelerates and keeps the last specified direction.  This call will immediately return even if the deceleration is still in progress. After a stop request has been received, no further updates to the ongoing jogging movement are possible.  State responses will be sent via the jogging stream until the motion group reaches standstill.
   * @summary Stop
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  stopJogging(cell: string, motionGroup: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
};
/**
 * MotionGroupJoggingApi - factory interface
 */
declare const MotionGroupJoggingApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Move TCP along/around a specified direction vector with a specified velocity via a websocket.  The purpose of a direction jogging motion is to move a device in exactly one direction with a specified maximum velocity. The sign of the velocity determines the direction of the movement: Positive [+] or Negative [-]. The velocity is given in [mm/s]. In contrast to a planned motion, a jogging motion can be changed dynamically while the motion group is in motion.  Only one single client at a time can jog a particular motion group. If another client tries to jog the same motion group at the same time, the second call will fail.  The movement of the motion group will start as soon as: * the motion group is not in motion * the websocket connection is established * the first request has been sent  As long as the jogging motion is ongoing, responses will be sent continuously and contain the current state of the motion group. The responses will be sent with the specified rate according to the *response_rate* parameter of the initial websocket request. While in motion, the desired direction and velocity can be changed by sending a new request to the same websocket. The motion and sending of the replies will stop when: * a [stopJogging](#/operations/stopJogging) request was received, processed, and the movement stopped   The motion group state will be published in the original command stream until the motion group has stopped * the client cancels the stream (not recommended, because final stopping position will not be returned from the stream)  When a physical limit (e.g. workspace boundary) is reached, the motion group will stop moving in the desired direction. The stream, howewer, will continue to send the state until the client cancels the stream or sends the [stopJogging](#/operations/stopJogging) request.  Singularities are avoided during a jogging motion. This avoidance can result in deviations from the specified direction. The amount of deviation depends on the robot type and current velocity. These mechanisms can lead to a small deviation from the specified direction. The size of deviation is depending on robot type and current velocity.   **Usage example:**  1. Open a websocket via Python and start the jogging motion: ```bash > python -m websockets \"ws://<IP of Wandelbots NOVA API>/api/v1/cells/<your cell id>/motion-groups/move-tcp\" ``` 2. Send the following message to the server to move current TCP two parts up in the z direction and one part in the negative y direction with 0.2 mm/s along the specified direction vector: ```json {   \"motion_group\": \"<your motion group id>\",   \"position_direction\": {     \"y\": -0.5,     \"z\": 1   },   \"rotation_direction\": {},   \"position_velocity\": 0.2,   \"response_rate\": 500 } ``` The NOVA API clients support jogging motions without the need to manually open a websocket.  > **NOTE** > > If the jogging movement is stopped immediately, ensure that > > - A websocket connection is established. Websockets can be kept open until the robot\'s movement is done as opposed to a simple HTTP GET request. > > - The motion group is not in motion by another jogging movement or a planned movement.   > **NOTE** > > If the robot does not move, ensure that > > - The joint velocity values are not zero, > > - The motion group is not in a state where it cannot move further (e.g. joint limit reached).  > **NOTE** > > If the specified velocities are higher than the maximum allowed by the robot controller, the motion group will move with the maximum allowed velocities.
   * @summary Stream Cartesian
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {DirectionJoggingRequest} directionJoggingRequest
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  directionJogging(cell: string, directionJoggingRequest: DirectionJoggingRequest, options?: RawAxiosRequestConfig): AxiosPromise<JoggingResponse>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Shows the options the motion group offers in regard to jogging. Some motion groups may not provide all information services, e.g. it is physically not possible to move a one-axis-turntable in a linear way.
   * @summary Capabilities
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getJoggingCapabilities(cell: string, motionGroup: string, options?: RawAxiosRequestConfig): AxiosPromise<JoggingServiceCapabilities>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Move one or more joints of a motion group with specified velocities via a websocket.  The purpose of a joint jogging motion is to maneuver a motion group in one or more joints with a specified velocity for each joint. The sign of the velocity determines the direction of the joint movement. The velocity is given in [rad/s]. In contrast to a planned motion, a jogging motion can be changed dynamically while the motion group is in motion.  Only one single client at a time can jog a particular motion group. If another client tries to jog the same motion group at the same time, the second call will fail.  The movement of the motion group will start as soon as: * the motion group is not in motion * the websocket connection is established * the first request has been sent  As long as the jogging motion is ongoing, responses will be sent continuously and contain the current state of the motion group. The responses will be sent with the specified rate according to the *response_rate* parameter of the initial websocket request. While in motion, the desired joint velocity can be changed by sending a new request to the same websocket. The motion and sending of the replies will stop when: * a [stopJogging](#/operations/stopJogging) request was received, processed, and the movement stopped   Motion group state will be published in the original command stream until the motion group has fully stopped * the client cancels the stream (not recommended, because final stopping position will not be returned from the stream)  When a physical limit (e.g. joint limit) is reached, the motion group will stop moving in the desired direction. The stream, howewer, will continue to send the state until the client cancels the stream or sends the [stopJogging](#/operations/stopJogging) request.  **Usage example:**  1. Open a websocket via Python and start the jogging motion: ```bash > python -m websockets \"ws://<IP of Wandelbots NOVA API>/api/v1/cells/<your cell id>/motion-groups/move-joint\" ``` 2. Send the following message to move with a velocity of 0.1 rad/s (negative) for joint 5 and 0.2 rad/s for joint 6: ```json {   \"motion_group\": \"<your motion group id>\",   \"joint_velocities\": [0, 0, 0, 0, -0.1, 0.2],   \"response_rate\": 500 } ``` The provided NOVA API clients also natively support jogging motions, without the need to manually open a websocket.  > **NOTE** > > If the jogging movement is stopped immediately, ensure that > > - A websocket connection is established. Websockets can be kept open until the robot\'s movement is done as opposed to a simple HTTP GET request. > > - The motion group is not in motion by another jogging movement or a planned movement.   > **NOTE** > > If the robot does not move, ensure that > > - The joint velocity values are not zero, > > - The motion group is not in a state where it cannot move further (e.g. joint limit reached).  > **NOTE** > > If the specified velocities are higher than the maximum allowed by the robot controller, the motion group will move with the maximum allowed velocities.
   * @summary Stream Joints
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {JointJoggingRequest} jointJoggingRequest
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  jointJogging(cell: string, jointJoggingRequest: JointJoggingRequest, options?: RawAxiosRequestConfig): AxiosPromise<JoggingResponse>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Stops an ongoing jogging movement as fast as possible. Until the motion group reaches standstill, it decelerates and keeps the last specified direction.  This call will immediately return even if the deceleration is still in progress. After a stop request has been received, no further updates to the ongoing jogging movement are possible.  State responses will be sent via the jogging stream until the motion group reaches standstill.
   * @summary Stop
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  stopJogging(cell: string, motionGroup: string, options?: RawAxiosRequestConfig): AxiosPromise<void>;
};
/**
 * MotionGroupJoggingApi - object-oriented interface
 */
declare class MotionGroupJoggingApi extends BaseAPI {
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Move TCP along/around a specified direction vector with a specified velocity via a websocket.  The purpose of a direction jogging motion is to move a device in exactly one direction with a specified maximum velocity. The sign of the velocity determines the direction of the movement: Positive [+] or Negative [-]. The velocity is given in [mm/s]. In contrast to a planned motion, a jogging motion can be changed dynamically while the motion group is in motion.  Only one single client at a time can jog a particular motion group. If another client tries to jog the same motion group at the same time, the second call will fail.  The movement of the motion group will start as soon as: * the motion group is not in motion * the websocket connection is established * the first request has been sent  As long as the jogging motion is ongoing, responses will be sent continuously and contain the current state of the motion group. The responses will be sent with the specified rate according to the *response_rate* parameter of the initial websocket request. While in motion, the desired direction and velocity can be changed by sending a new request to the same websocket. The motion and sending of the replies will stop when: * a [stopJogging](#/operations/stopJogging) request was received, processed, and the movement stopped   The motion group state will be published in the original command stream until the motion group has stopped * the client cancels the stream (not recommended, because final stopping position will not be returned from the stream)  When a physical limit (e.g. workspace boundary) is reached, the motion group will stop moving in the desired direction. The stream, howewer, will continue to send the state until the client cancels the stream or sends the [stopJogging](#/operations/stopJogging) request.  Singularities are avoided during a jogging motion. This avoidance can result in deviations from the specified direction. The amount of deviation depends on the robot type and current velocity. These mechanisms can lead to a small deviation from the specified direction. The size of deviation is depending on robot type and current velocity.   **Usage example:**  1. Open a websocket via Python and start the jogging motion: ```bash > python -m websockets \"ws://<IP of Wandelbots NOVA API>/api/v1/cells/<your cell id>/motion-groups/move-tcp\" ``` 2. Send the following message to the server to move current TCP two parts up in the z direction and one part in the negative y direction with 0.2 mm/s along the specified direction vector: ```json {   \"motion_group\": \"<your motion group id>\",   \"position_direction\": {     \"y\": -0.5,     \"z\": 1   },   \"rotation_direction\": {},   \"position_velocity\": 0.2,   \"response_rate\": 500 } ``` The NOVA API clients support jogging motions without the need to manually open a websocket.  > **NOTE** > > If the jogging movement is stopped immediately, ensure that > > - A websocket connection is established. Websockets can be kept open until the robot\'s movement is done as opposed to a simple HTTP GET request. > > - The motion group is not in motion by another jogging movement or a planned movement.   > **NOTE** > > If the robot does not move, ensure that > > - The joint velocity values are not zero, > > - The motion group is not in a state where it cannot move further (e.g. joint limit reached).  > **NOTE** > > If the specified velocities are higher than the maximum allowed by the robot controller, the motion group will move with the maximum allowed velocities.
   * @summary Stream Cartesian
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {DirectionJoggingRequest} directionJoggingRequest
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  directionJogging(cell: string, directionJoggingRequest: DirectionJoggingRequest, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<JoggingResponse, any, {}>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Shows the options the motion group offers in regard to jogging. Some motion groups may not provide all information services, e.g. it is physically not possible to move a one-axis-turntable in a linear way.
   * @summary Capabilities
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getJoggingCapabilities(cell: string, motionGroup: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<JoggingServiceCapabilities, any, {}>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Move one or more joints of a motion group with specified velocities via a websocket.  The purpose of a joint jogging motion is to maneuver a motion group in one or more joints with a specified velocity for each joint. The sign of the velocity determines the direction of the joint movement. The velocity is given in [rad/s]. In contrast to a planned motion, a jogging motion can be changed dynamically while the motion group is in motion.  Only one single client at a time can jog a particular motion group. If another client tries to jog the same motion group at the same time, the second call will fail.  The movement of the motion group will start as soon as: * the motion group is not in motion * the websocket connection is established * the first request has been sent  As long as the jogging motion is ongoing, responses will be sent continuously and contain the current state of the motion group. The responses will be sent with the specified rate according to the *response_rate* parameter of the initial websocket request. While in motion, the desired joint velocity can be changed by sending a new request to the same websocket. The motion and sending of the replies will stop when: * a [stopJogging](#/operations/stopJogging) request was received, processed, and the movement stopped   Motion group state will be published in the original command stream until the motion group has fully stopped * the client cancels the stream (not recommended, because final stopping position will not be returned from the stream)  When a physical limit (e.g. joint limit) is reached, the motion group will stop moving in the desired direction. The stream, howewer, will continue to send the state until the client cancels the stream or sends the [stopJogging](#/operations/stopJogging) request.  **Usage example:**  1. Open a websocket via Python and start the jogging motion: ```bash > python -m websockets \"ws://<IP of Wandelbots NOVA API>/api/v1/cells/<your cell id>/motion-groups/move-joint\" ``` 2. Send the following message to move with a velocity of 0.1 rad/s (negative) for joint 5 and 0.2 rad/s for joint 6: ```json {   \"motion_group\": \"<your motion group id>\",   \"joint_velocities\": [0, 0, 0, 0, -0.1, 0.2],   \"response_rate\": 500 } ``` The provided NOVA API clients also natively support jogging motions, without the need to manually open a websocket.  > **NOTE** > > If the jogging movement is stopped immediately, ensure that > > - A websocket connection is established. Websockets can be kept open until the robot\'s movement is done as opposed to a simple HTTP GET request. > > - The motion group is not in motion by another jogging movement or a planned movement.   > **NOTE** > > If the robot does not move, ensure that > > - The joint velocity values are not zero, > > - The motion group is not in a state where it cannot move further (e.g. joint limit reached).  > **NOTE** > > If the specified velocities are higher than the maximum allowed by the robot controller, the motion group will move with the maximum allowed velocities.
   * @summary Stream Joints
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {JointJoggingRequest} jointJoggingRequest
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  jointJogging(cell: string, jointJoggingRequest: JointJoggingRequest, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<JoggingResponse, any, {}>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Stops an ongoing jogging movement as fast as possible. Until the motion group reaches standstill, it decelerates and keeps the last specified direction.  This call will immediately return even if the deceleration is still in progress. After a stop request has been received, no further updates to the ongoing jogging movement are possible.  State responses will be sent via the jogging stream until the motion group reaches standstill.
   * @summary Stop
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  stopJogging(cell: string, motionGroup: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<void, any, {}>>;
}
/**
 * MotionGroupKinematicApi - axios parameter creator
 */
declare const MotionGroupKinematicApiAxiosParamCreator: (configuration?: Configuration) => {
  /**
   * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___  Calculate the joint positions of a motion group in order to move its TCP to a specific pose (Inverse Kinematic Solutions). All solutions are within the configured joint limits of the robot and not in a singular position of the robot.  Return all joint positions as list of distinct joint positions in [rad] with their respective inverse feedback.  Will be empty when unreachable, e.g. outside joint position limits, singular.  Does not include multiple solutions where the robot links are in the same postition. Those can occur when single joints are allowed to move in a range larger than 360 degrees.
   * @summary All Joint Positions from TCP Pose
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {AllJointPositionsRequest} allJointPositionsRequest
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  calculateAllInverseKinematic: (cell: string, motionGroup: string, allJointPositionsRequest: AllJointPositionsRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___  Calculates the TCP pose from a joint position sample using the forward kinematics of the motion-group.
   * @summary TcpPose from JointPosition
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {TcpPoseRequest} tcpPoseRequest
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  calculateForwardKinematic: (cell: string, motionGroup: string, tcpPoseRequest: TcpPoseRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___  Calculate the joint positions the motion-group needs to apply for its TCP to be in a specified pose (Inverse Kinematic Solution).  If multiple solutions are found, the one nearest to the given specified joint position is picked. * For all supported robot models, except the Fanuc CRX line, the returned joint position is guaranteed to have the same configuration (often referred to as ELBOW_UP, WRIST_DOWN, SHOULDER_RIGHT, f.e.) as the specified reference joint position. If the position limit of any single joint allows it to be in a range larger than 2 PI, the respective joint value in the result will be as close as possible to its reference value. * For the Fanuc CRX line the solution is selected to have the smallest distance measured by the norm of its difference to the reference joint position.  The returned joint position is guaranteed to be within the joint limits and not in a singular position of the robot.
   * @summary Nearest JointPosition from TcpPose
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {JointPositionRequest} jointPositionRequest
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  calculateInverseKinematic: (cell: string, motionGroup: string, jointPositionRequest: JointPositionRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Get the kinematic endpoints provided for the specified motion-group.
   * @summary Capabilities
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getKinematicCapabilities: (cell: string, motionGroup: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
/**
 * MotionGroupKinematicApi - functional programming interface
 */
declare const MotionGroupKinematicApiFp: (configuration?: Configuration) => {
  /**
   * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___  Calculate the joint positions of a motion group in order to move its TCP to a specific pose (Inverse Kinematic Solutions). All solutions are within the configured joint limits of the robot and not in a singular position of the robot.  Return all joint positions as list of distinct joint positions in [rad] with their respective inverse feedback.  Will be empty when unreachable, e.g. outside joint position limits, singular.  Does not include multiple solutions where the robot links are in the same postition. Those can occur when single joints are allowed to move in a range larger than 360 degrees.
   * @summary All Joint Positions from TCP Pose
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {AllJointPositionsRequest} allJointPositionsRequest
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  calculateAllInverseKinematic(cell: string, motionGroup: string, allJointPositionsRequest: AllJointPositionsRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<AllJointPositionsResponse>>;
  /**
   * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___  Calculates the TCP pose from a joint position sample using the forward kinematics of the motion-group.
   * @summary TcpPose from JointPosition
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {TcpPoseRequest} tcpPoseRequest
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  calculateForwardKinematic(cell: string, motionGroup: string, tcpPoseRequest: TcpPoseRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Pose>>;
  /**
   * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___  Calculate the joint positions the motion-group needs to apply for its TCP to be in a specified pose (Inverse Kinematic Solution).  If multiple solutions are found, the one nearest to the given specified joint position is picked. * For all supported robot models, except the Fanuc CRX line, the returned joint position is guaranteed to have the same configuration (often referred to as ELBOW_UP, WRIST_DOWN, SHOULDER_RIGHT, f.e.) as the specified reference joint position. If the position limit of any single joint allows it to be in a range larger than 2 PI, the respective joint value in the result will be as close as possible to its reference value. * For the Fanuc CRX line the solution is selected to have the smallest distance measured by the norm of its difference to the reference joint position.  The returned joint position is guaranteed to be within the joint limits and not in a singular position of the robot.
   * @summary Nearest JointPosition from TcpPose
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {JointPositionRequest} jointPositionRequest
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  calculateInverseKinematic(cell: string, motionGroup: string, jointPositionRequest: JointPositionRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Joints>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Get the kinematic endpoints provided for the specified motion-group.
   * @summary Capabilities
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getKinematicCapabilities(cell: string, motionGroup: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<KinematicServiceCapabilities>>;
};
/**
 * MotionGroupKinematicApi - factory interface
 */
declare const MotionGroupKinematicApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
  /**
   * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___  Calculate the joint positions of a motion group in order to move its TCP to a specific pose (Inverse Kinematic Solutions). All solutions are within the configured joint limits of the robot and not in a singular position of the robot.  Return all joint positions as list of distinct joint positions in [rad] with their respective inverse feedback.  Will be empty when unreachable, e.g. outside joint position limits, singular.  Does not include multiple solutions where the robot links are in the same postition. Those can occur when single joints are allowed to move in a range larger than 360 degrees.
   * @summary All Joint Positions from TCP Pose
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {AllJointPositionsRequest} allJointPositionsRequest
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  calculateAllInverseKinematic(cell: string, motionGroup: string, allJointPositionsRequest: AllJointPositionsRequest, options?: RawAxiosRequestConfig): AxiosPromise<AllJointPositionsResponse>;
  /**
   * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___  Calculates the TCP pose from a joint position sample using the forward kinematics of the motion-group.
   * @summary TcpPose from JointPosition
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {TcpPoseRequest} tcpPoseRequest
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  calculateForwardKinematic(cell: string, motionGroup: string, tcpPoseRequest: TcpPoseRequest, options?: RawAxiosRequestConfig): AxiosPromise<Pose>;
  /**
   * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___  Calculate the joint positions the motion-group needs to apply for its TCP to be in a specified pose (Inverse Kinematic Solution).  If multiple solutions are found, the one nearest to the given specified joint position is picked. * For all supported robot models, except the Fanuc CRX line, the returned joint position is guaranteed to have the same configuration (often referred to as ELBOW_UP, WRIST_DOWN, SHOULDER_RIGHT, f.e.) as the specified reference joint position. If the position limit of any single joint allows it to be in a range larger than 2 PI, the respective joint value in the result will be as close as possible to its reference value. * For the Fanuc CRX line the solution is selected to have the smallest distance measured by the norm of its difference to the reference joint position.  The returned joint position is guaranteed to be within the joint limits and not in a singular position of the robot.
   * @summary Nearest JointPosition from TcpPose
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {JointPositionRequest} jointPositionRequest
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  calculateInverseKinematic(cell: string, motionGroup: string, jointPositionRequest: JointPositionRequest, options?: RawAxiosRequestConfig): AxiosPromise<Joints>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Get the kinematic endpoints provided for the specified motion-group.
   * @summary Capabilities
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getKinematicCapabilities(cell: string, motionGroup: string, options?: RawAxiosRequestConfig): AxiosPromise<KinematicServiceCapabilities>;
};
/**
 * MotionGroupKinematicApi - object-oriented interface
 */
declare class MotionGroupKinematicApi extends BaseAPI {
  /**
   * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___  Calculate the joint positions of a motion group in order to move its TCP to a specific pose (Inverse Kinematic Solutions). All solutions are within the configured joint limits of the robot and not in a singular position of the robot.  Return all joint positions as list of distinct joint positions in [rad] with their respective inverse feedback.  Will be empty when unreachable, e.g. outside joint position limits, singular.  Does not include multiple solutions where the robot links are in the same postition. Those can occur when single joints are allowed to move in a range larger than 360 degrees.
   * @summary All Joint Positions from TCP Pose
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {AllJointPositionsRequest} allJointPositionsRequest
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  calculateAllInverseKinematic(cell: string, motionGroup: string, allJointPositionsRequest: AllJointPositionsRequest, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<AllJointPositionsResponse, any, {}>>;
  /**
   * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___  Calculates the TCP pose from a joint position sample using the forward kinematics of the motion-group.
   * @summary TcpPose from JointPosition
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {TcpPoseRequest} tcpPoseRequest
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  calculateForwardKinematic(cell: string, motionGroup: string, tcpPoseRequest: TcpPoseRequest, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<Pose, any, {}>>;
  /**
   * **Required permissions:** `can_plan_motion` - Plan robot motions and trajectories ___  Calculate the joint positions the motion-group needs to apply for its TCP to be in a specified pose (Inverse Kinematic Solution).  If multiple solutions are found, the one nearest to the given specified joint position is picked. * For all supported robot models, except the Fanuc CRX line, the returned joint position is guaranteed to have the same configuration (often referred to as ELBOW_UP, WRIST_DOWN, SHOULDER_RIGHT, f.e.) as the specified reference joint position. If the position limit of any single joint allows it to be in a range larger than 2 PI, the respective joint value in the result will be as close as possible to its reference value. * For the Fanuc CRX line the solution is selected to have the smallest distance measured by the norm of its difference to the reference joint position.  The returned joint position is guaranteed to be within the joint limits and not in a singular position of the robot.
   * @summary Nearest JointPosition from TcpPose
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {JointPositionRequest} jointPositionRequest
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  calculateInverseKinematic(cell: string, motionGroup: string, jointPositionRequest: JointPositionRequest, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<Joints, any, {}>>;
  /**
   * **Required permissions:** `can_operate_controllers` - Operate and monitor robot controllers ___  Get the kinematic endpoints provided for the specified motion-group.
   * @summary Capabilities
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} motionGroup The motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getKinematicCapabilities(cell: string, motionGroup: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<KinematicServiceCapabilities, any, {}>>;
}
/**
 * ProgramApi - axios parameter creator
 */
declare const ProgramApiAxiosParamCreator: (configuration?: Configuration) => {
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  This endpoint accepts a program written in Wandelscript and if desired, initial arguments (in the form of a dict). It will then execute this Wandelscript asynchronously. It returns a program runner reference which can be used to query the state of the program runner.  ## Parameters See the **Schema** tab for information about the request body.  ## Returns A program runner reference which can be used to query the state of the program runner.  ## Receiving state updates Receive state updates of the program runner via polling the `/programs/runners/{runner_id}/`  ### Via polling You can receive updates about the state of the program runner by polling the `/programs/runners/{runner_id}/` endpoint. ```
   * @summary Create Program Runner
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {Request} request
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  createProgramRunner: (cell: string, request: Request, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  Execute a program in Wandelscript. The Wandelscript can also move multiple robots by using the \'do with\' syntax.  The execute operation will be started from the current joint configuration of any addressed robot(s).  Addressed robots have to be in control mode for the execute operation to succeed.  A request to this endpoint will block this endpoint until the program has been executed, or until an error occurs.  The executed movement is returned in case of a succesful execution. Otherwise an error (e.g. out of reach, singularity), is returned.  The Wandelscript can either be submitted as is, using Content-type text/plain, or as content-type application/json with the Wandelscript under \"code\" alongside a set of values provided under \"initial_state\".  * [WandelEngine & Wandelscript Documentation](/docs/docs/wandelscript)
   * @summary Execute Program
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {CodeWithArguments} codeWithArguments
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  executeProgram: (cell: string, codeWithArguments: CodeWithArguments, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  Returns information about a program currently executed.  When a program is finished: Program response, result, collected Wandelscript logs, etc.  When a program is running: Running status, current executed line, etc.  ## Parameters - **runner_id**: The id of the program runner
   * @summary Get Program Runner
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} runner
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getProgramRunner: (cell: string, runner: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  Get details about all existing program runners.
   * @summary List Program Runners
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  listProgramRunners: (cell: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  Migrate a program  ## Parameters See the **Schema** tab for information about the request body
   * @summary Migrate Program
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {Request1} request1
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  migrateProgram: (cell: string, request1: Request1, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  Plan a program based on the specified robot type.  The plan operation can be used to check if a Wandelscript is executable, given the current joint configuration of the robot.  If the Wandelscript is executable, the result contains the motion path. If the Wandelscript is not executable, e.g. points that are out of reach, or the joints encounter a singularity, the reason is returned.  The plan operation can be used in other operating modes besides control mode.  The Wandelscript can either be submitted as is, using Content-type text/plain, or as content-type application/json with the Wandelscript under \"code\" alongside a set of values provided under \"initial_state\".  The plan operation can be used in other operating modes besides control mode.  The Wandelscript can either be submitted as is, using Content-type text/plain, or as Content-type application/json with the Wandelscript under \"code\" alongside a set of values provided under \"initial_state\".  * [WandelEngine & Wandelscript Documentation](/docs/docs/wandelscript)
   * @summary Plan Program
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {Request} request
   * @param {string} [identifier]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  planProgram: (cell: string, request: Request, identifier?: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  Stop all runners.
   * @summary Stop All Program Runners
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  stopAllProgramRunner: (cell: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  Stop a specific program runner. If the indicated runner was not running, an error will be returned.  ## Parameters - **runner_id**: The id of the program runner
   * @summary Stop Program Runner
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} runner
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  stopProgramRunner: (cell: string, runner: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
/**
 * ProgramApi - functional programming interface
 */
declare const ProgramApiFp: (configuration?: Configuration) => {
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  This endpoint accepts a program written in Wandelscript and if desired, initial arguments (in the form of a dict). It will then execute this Wandelscript asynchronously. It returns a program runner reference which can be used to query the state of the program runner.  ## Parameters See the **Schema** tab for information about the request body.  ## Returns A program runner reference which can be used to query the state of the program runner.  ## Receiving state updates Receive state updates of the program runner via polling the `/programs/runners/{runner_id}/`  ### Via polling You can receive updates about the state of the program runner by polling the `/programs/runners/{runner_id}/` endpoint. ```
   * @summary Create Program Runner
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {Request} request
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  createProgramRunner(cell: string, request: Request, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ProgramRunnerReference>>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  Execute a program in Wandelscript. The Wandelscript can also move multiple robots by using the \'do with\' syntax.  The execute operation will be started from the current joint configuration of any addressed robot(s).  Addressed robots have to be in control mode for the execute operation to succeed.  A request to this endpoint will block this endpoint until the program has been executed, or until an error occurs.  The executed movement is returned in case of a succesful execution. Otherwise an error (e.g. out of reach, singularity), is returned.  The Wandelscript can either be submitted as is, using Content-type text/plain, or as content-type application/json with the Wandelscript under \"code\" alongside a set of values provided under \"initial_state\".  * [WandelEngine & Wandelscript Documentation](/docs/docs/wandelscript)
   * @summary Execute Program
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {CodeWithArguments} codeWithArguments
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  executeProgram(cell: string, codeWithArguments: CodeWithArguments, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ProgramRun>>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  Returns information about a program currently executed.  When a program is finished: Program response, result, collected Wandelscript logs, etc.  When a program is running: Running status, current executed line, etc.  ## Parameters - **runner_id**: The id of the program runner
   * @summary Get Program Runner
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} runner
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getProgramRunner(cell: string, runner: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ProgramRun>>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  Get details about all existing program runners.
   * @summary List Program Runners
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  listProgramRunners(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<ProgramRunnerReference>>>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  Migrate a program  ## Parameters See the **Schema** tab for information about the request body
   * @summary Migrate Program
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {Request1} request1
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  migrateProgram(cell: string, request1: Request1, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<string>>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  Plan a program based on the specified robot type.  The plan operation can be used to check if a Wandelscript is executable, given the current joint configuration of the robot.  If the Wandelscript is executable, the result contains the motion path. If the Wandelscript is not executable, e.g. points that are out of reach, or the joints encounter a singularity, the reason is returned.  The plan operation can be used in other operating modes besides control mode.  The Wandelscript can either be submitted as is, using Content-type text/plain, or as content-type application/json with the Wandelscript under \"code\" alongside a set of values provided under \"initial_state\".  The plan operation can be used in other operating modes besides control mode.  The Wandelscript can either be submitted as is, using Content-type text/plain, or as Content-type application/json with the Wandelscript under \"code\" alongside a set of values provided under \"initial_state\".  * [WandelEngine & Wandelscript Documentation](/docs/docs/wandelscript)
   * @summary Plan Program
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {Request} request
   * @param {string} [identifier]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  planProgram(cell: string, request: Request, identifier?: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ProgramRun>>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  Stop all runners.
   * @summary Stop All Program Runners
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  stopAllProgramRunner(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<any>>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  Stop a specific program runner. If the indicated runner was not running, an error will be returned.  ## Parameters - **runner_id**: The id of the program runner
   * @summary Stop Program Runner
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} runner
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  stopProgramRunner(cell: string, runner: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
};
/**
 * ProgramApi - factory interface
 */
declare const ProgramApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  This endpoint accepts a program written in Wandelscript and if desired, initial arguments (in the form of a dict). It will then execute this Wandelscript asynchronously. It returns a program runner reference which can be used to query the state of the program runner.  ## Parameters See the **Schema** tab for information about the request body.  ## Returns A program runner reference which can be used to query the state of the program runner.  ## Receiving state updates Receive state updates of the program runner via polling the `/programs/runners/{runner_id}/`  ### Via polling You can receive updates about the state of the program runner by polling the `/programs/runners/{runner_id}/` endpoint. ```
   * @summary Create Program Runner
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {Request} request
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  createProgramRunner(cell: string, request: Request, options?: RawAxiosRequestConfig): AxiosPromise<ProgramRunnerReference>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  Execute a program in Wandelscript. The Wandelscript can also move multiple robots by using the \'do with\' syntax.  The execute operation will be started from the current joint configuration of any addressed robot(s).  Addressed robots have to be in control mode for the execute operation to succeed.  A request to this endpoint will block this endpoint until the program has been executed, or until an error occurs.  The executed movement is returned in case of a succesful execution. Otherwise an error (e.g. out of reach, singularity), is returned.  The Wandelscript can either be submitted as is, using Content-type text/plain, or as content-type application/json with the Wandelscript under \"code\" alongside a set of values provided under \"initial_state\".  * [WandelEngine & Wandelscript Documentation](/docs/docs/wandelscript)
   * @summary Execute Program
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {CodeWithArguments} codeWithArguments
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  executeProgram(cell: string, codeWithArguments: CodeWithArguments, options?: RawAxiosRequestConfig): AxiosPromise<ProgramRun>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  Returns information about a program currently executed.  When a program is finished: Program response, result, collected Wandelscript logs, etc.  When a program is running: Running status, current executed line, etc.  ## Parameters - **runner_id**: The id of the program runner
   * @summary Get Program Runner
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} runner
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getProgramRunner(cell: string, runner: string, options?: RawAxiosRequestConfig): AxiosPromise<ProgramRun>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  Get details about all existing program runners.
   * @summary List Program Runners
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  listProgramRunners(cell: string, options?: RawAxiosRequestConfig): AxiosPromise<Array<ProgramRunnerReference>>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  Migrate a program  ## Parameters See the **Schema** tab for information about the request body
   * @summary Migrate Program
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {Request1} request1
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  migrateProgram(cell: string, request1: Request1, options?: RawAxiosRequestConfig): AxiosPromise<string>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  Plan a program based on the specified robot type.  The plan operation can be used to check if a Wandelscript is executable, given the current joint configuration of the robot.  If the Wandelscript is executable, the result contains the motion path. If the Wandelscript is not executable, e.g. points that are out of reach, or the joints encounter a singularity, the reason is returned.  The plan operation can be used in other operating modes besides control mode.  The Wandelscript can either be submitted as is, using Content-type text/plain, or as content-type application/json with the Wandelscript under \"code\" alongside a set of values provided under \"initial_state\".  The plan operation can be used in other operating modes besides control mode.  The Wandelscript can either be submitted as is, using Content-type text/plain, or as Content-type application/json with the Wandelscript under \"code\" alongside a set of values provided under \"initial_state\".  * [WandelEngine & Wandelscript Documentation](/docs/docs/wandelscript)
   * @summary Plan Program
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {Request} request
   * @param {string} [identifier]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  planProgram(cell: string, request: Request, identifier?: string, options?: RawAxiosRequestConfig): AxiosPromise<ProgramRun>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  Stop all runners.
   * @summary Stop All Program Runners
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  stopAllProgramRunner(cell: string, options?: RawAxiosRequestConfig): AxiosPromise<any>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  Stop a specific program runner. If the indicated runner was not running, an error will be returned.  ## Parameters - **runner_id**: The id of the program runner
   * @summary Stop Program Runner
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} runner
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  stopProgramRunner(cell: string, runner: string, options?: RawAxiosRequestConfig): AxiosPromise<void>;
};
/**
 * ProgramApi - object-oriented interface
 */
declare class ProgramApi extends BaseAPI {
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  This endpoint accepts a program written in Wandelscript and if desired, initial arguments (in the form of a dict). It will then execute this Wandelscript asynchronously. It returns a program runner reference which can be used to query the state of the program runner.  ## Parameters See the **Schema** tab for information about the request body.  ## Returns A program runner reference which can be used to query the state of the program runner.  ## Receiving state updates Receive state updates of the program runner via polling the `/programs/runners/{runner_id}/`  ### Via polling You can receive updates about the state of the program runner by polling the `/programs/runners/{runner_id}/` endpoint. ```
   * @summary Create Program Runner
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {Request} request
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  createProgramRunner(cell: string, request: Request, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<ProgramRunnerReference, any, {}>>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  Execute a program in Wandelscript. The Wandelscript can also move multiple robots by using the \'do with\' syntax.  The execute operation will be started from the current joint configuration of any addressed robot(s).  Addressed robots have to be in control mode for the execute operation to succeed.  A request to this endpoint will block this endpoint until the program has been executed, or until an error occurs.  The executed movement is returned in case of a succesful execution. Otherwise an error (e.g. out of reach, singularity), is returned.  The Wandelscript can either be submitted as is, using Content-type text/plain, or as content-type application/json with the Wandelscript under \"code\" alongside a set of values provided under \"initial_state\".  * [WandelEngine & Wandelscript Documentation](/docs/docs/wandelscript)
   * @summary Execute Program
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {CodeWithArguments} codeWithArguments
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  executeProgram(cell: string, codeWithArguments: CodeWithArguments, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<ProgramRun, any, {}>>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  Returns information about a program currently executed.  When a program is finished: Program response, result, collected Wandelscript logs, etc.  When a program is running: Running status, current executed line, etc.  ## Parameters - **runner_id**: The id of the program runner
   * @summary Get Program Runner
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} runner
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getProgramRunner(cell: string, runner: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<ProgramRun, any, {}>>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  Get details about all existing program runners.
   * @summary List Program Runners
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  listProgramRunners(cell: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<ProgramRunnerReference[], any, {}>>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  Migrate a program  ## Parameters See the **Schema** tab for information about the request body
   * @summary Migrate Program
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {Request1} request1
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  migrateProgram(cell: string, request1: Request1, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<string, any, {}>>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  Plan a program based on the specified robot type.  The plan operation can be used to check if a Wandelscript is executable, given the current joint configuration of the robot.  If the Wandelscript is executable, the result contains the motion path. If the Wandelscript is not executable, e.g. points that are out of reach, or the joints encounter a singularity, the reason is returned.  The plan operation can be used in other operating modes besides control mode.  The Wandelscript can either be submitted as is, using Content-type text/plain, or as content-type application/json with the Wandelscript under \"code\" alongside a set of values provided under \"initial_state\".  The plan operation can be used in other operating modes besides control mode.  The Wandelscript can either be submitted as is, using Content-type text/plain, or as Content-type application/json with the Wandelscript under \"code\" alongside a set of values provided under \"initial_state\".  * [WandelEngine & Wandelscript Documentation](/docs/docs/wandelscript)
   * @summary Plan Program
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {Request} request
   * @param {string} [identifier]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  planProgram(cell: string, request: Request, identifier?: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<ProgramRun, any, {}>>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  Stop all runners.
   * @summary Stop All Program Runners
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  stopAllProgramRunner(cell: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<any, any, {}>>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  Stop a specific program runner. If the indicated runner was not running, an error will be returned.  ## Parameters - **runner_id**: The id of the program runner
   * @summary Stop Program Runner
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} runner
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  stopProgramRunner(cell: string, runner: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<void, any, {}>>;
}
/**
 * ProgramOperatorApi - axios parameter creator
 */
declare const ProgramOperatorApiAxiosParamCreator: (configuration?: Configuration) => {
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** This endpoint initiates the execution of a program stored in the program library. A program is started with the a specific program id that exists in the program library.
   * @summary Run Program from Library
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {CreateProgramRunRequest} createProgramRunRequest
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  createProgramRun: (cell: string, createProgramRunRequest: CreateProgramRunRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** Creates a new trigger that automatically runs a program when certain conditions are met. Each trigger has a different configuration, and the configuration must be valid for the provided trigger type.
   * @summary Create Trigger
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {CreateTriggerRequest} createTriggerRequest
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  createTrigger: (cell: string, createTriggerRequest: CreateTriggerRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** Delete an existing trigger.
   * @summary Delete Trigger
   * @param {string} trigger The identifier of the trigger.
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  deleteTrigger: (trigger: string, cell: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** Retrieves all program runs, including past and current executions. Use the optional `state` parameter to filter the results by their status.
   * @summary Get All Program Runs
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} [state]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getAllProgramRuns: (cell: string, state?: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** Returns all triggers in the system with the program runs caused by each trigger. You can use the program run id to get more details about a specific program run.
   * @summary Get All Triggers
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getAllTriggers: (cell: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** Retrieves detailed information about a specific program run.
   * @summary Get Program Run
   * @param {string} run
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getProgramRun: (run: string, cell: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** Retrieves detailed information about a specific trigger.
   * @summary Get Trigger
   * @param {string} trigger The identifier of the trigger.
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getTrigger: (trigger: string, cell: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** Updates the details of an existing trigger The exact behavior of switching a trigger from active to inactive or vice versa is not defined yet.
   * @summary Update Trigger
   * @param {string} trigger the id of the trigger
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {UpdateTriggerRequest} updateTriggerRequest
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  updateTrigger: (trigger: string, cell: string, updateTriggerRequest: UpdateTriggerRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
/**
 * ProgramOperatorApi - functional programming interface
 */
declare const ProgramOperatorApiFp: (configuration?: Configuration) => {
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** This endpoint initiates the execution of a program stored in the program library. A program is started with the a specific program id that exists in the program library.
   * @summary Run Program from Library
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {CreateProgramRunRequest} createProgramRunRequest
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  createProgramRun(cell: string, createProgramRunRequest: CreateProgramRunRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<CreateProgramRun200Response>>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** Creates a new trigger that automatically runs a program when certain conditions are met. Each trigger has a different configuration, and the configuration must be valid for the provided trigger type.
   * @summary Create Trigger
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {CreateTriggerRequest} createTriggerRequest
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  createTrigger(cell: string, createTriggerRequest: CreateTriggerRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<CreateTrigger200Response>>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** Delete an existing trigger.
   * @summary Delete Trigger
   * @param {string} trigger The identifier of the trigger.
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  deleteTrigger(trigger: string, cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** Retrieves all program runs, including past and current executions. Use the optional `state` parameter to filter the results by their status.
   * @summary Get All Program Runs
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} [state]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getAllProgramRuns(cell: string, state?: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<GetAllProgramRuns200Response>>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** Returns all triggers in the system with the program runs caused by each trigger. You can use the program run id to get more details about a specific program run.
   * @summary Get All Triggers
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getAllTriggers(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<GetAllTriggers200Response>>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** Retrieves detailed information about a specific program run.
   * @summary Get Program Run
   * @param {string} run
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getProgramRun(run: string, cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ProgramRunObject>>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** Retrieves detailed information about a specific trigger.
   * @summary Get Trigger
   * @param {string} trigger The identifier of the trigger.
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getTrigger(trigger: string, cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<TriggerObject>>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** Updates the details of an existing trigger The exact behavior of switching a trigger from active to inactive or vice versa is not defined yet.
   * @summary Update Trigger
   * @param {string} trigger the id of the trigger
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {UpdateTriggerRequest} updateTriggerRequest
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  updateTrigger(trigger: string, cell: string, updateTriggerRequest: UpdateTriggerRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<TriggerObject>>;
};
/**
 * ProgramOperatorApi - factory interface
 */
declare const ProgramOperatorApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** This endpoint initiates the execution of a program stored in the program library. A program is started with the a specific program id that exists in the program library.
   * @summary Run Program from Library
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {CreateProgramRunRequest} createProgramRunRequest
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  createProgramRun(cell: string, createProgramRunRequest: CreateProgramRunRequest, options?: RawAxiosRequestConfig): AxiosPromise<CreateProgramRun200Response>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** Creates a new trigger that automatically runs a program when certain conditions are met. Each trigger has a different configuration, and the configuration must be valid for the provided trigger type.
   * @summary Create Trigger
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {CreateTriggerRequest} createTriggerRequest
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  createTrigger(cell: string, createTriggerRequest: CreateTriggerRequest, options?: RawAxiosRequestConfig): AxiosPromise<CreateTrigger200Response>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** Delete an existing trigger.
   * @summary Delete Trigger
   * @param {string} trigger The identifier of the trigger.
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  deleteTrigger(trigger: string, cell: string, options?: RawAxiosRequestConfig): AxiosPromise<void>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** Retrieves all program runs, including past and current executions. Use the optional `state` parameter to filter the results by their status.
   * @summary Get All Program Runs
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} [state]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getAllProgramRuns(cell: string, state?: string, options?: RawAxiosRequestConfig): AxiosPromise<GetAllProgramRuns200Response>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** Returns all triggers in the system with the program runs caused by each trigger. You can use the program run id to get more details about a specific program run.
   * @summary Get All Triggers
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getAllTriggers(cell: string, options?: RawAxiosRequestConfig): AxiosPromise<GetAllTriggers200Response>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** Retrieves detailed information about a specific program run.
   * @summary Get Program Run
   * @param {string} run
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getProgramRun(run: string, cell: string, options?: RawAxiosRequestConfig): AxiosPromise<ProgramRunObject>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** Retrieves detailed information about a specific trigger.
   * @summary Get Trigger
   * @param {string} trigger The identifier of the trigger.
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getTrigger(trigger: string, cell: string, options?: RawAxiosRequestConfig): AxiosPromise<TriggerObject>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** Updates the details of an existing trigger The exact behavior of switching a trigger from active to inactive or vice versa is not defined yet.
   * @summary Update Trigger
   * @param {string} trigger the id of the trigger
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {UpdateTriggerRequest} updateTriggerRequest
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  updateTrigger(trigger: string, cell: string, updateTriggerRequest: UpdateTriggerRequest, options?: RawAxiosRequestConfig): AxiosPromise<TriggerObject>;
};
/**
 * ProgramOperatorApi - object-oriented interface
 */
declare class ProgramOperatorApi extends BaseAPI {
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** This endpoint initiates the execution of a program stored in the program library. A program is started with the a specific program id that exists in the program library.
   * @summary Run Program from Library
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {CreateProgramRunRequest} createProgramRunRequest
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  createProgramRun(cell: string, createProgramRunRequest: CreateProgramRunRequest, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<CreateProgramRun200Response, any, {}>>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** Creates a new trigger that automatically runs a program when certain conditions are met. Each trigger has a different configuration, and the configuration must be valid for the provided trigger type.
   * @summary Create Trigger
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {CreateTriggerRequest} createTriggerRequest
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  createTrigger(cell: string, createTriggerRequest: CreateTriggerRequest, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<CreateTrigger200Response, any, {}>>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** Delete an existing trigger.
   * @summary Delete Trigger
   * @param {string} trigger The identifier of the trigger.
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  deleteTrigger(trigger: string, cell: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<void, any, {}>>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** Retrieves all program runs, including past and current executions. Use the optional `state` parameter to filter the results by their status.
   * @summary Get All Program Runs
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} [state]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getAllProgramRuns(cell: string, state?: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<GetAllProgramRuns200Response, any, {}>>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** Returns all triggers in the system with the program runs caused by each trigger. You can use the program run id to get more details about a specific program run.
   * @summary Get All Triggers
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getAllTriggers(cell: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<GetAllTriggers200Response, any, {}>>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** Retrieves detailed information about a specific program run.
   * @summary Get Program Run
   * @param {string} run
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getProgramRun(run: string, cell: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<ProgramRunObject, any, {}>>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** Retrieves detailed information about a specific trigger.
   * @summary Get Trigger
   * @param {string} trigger The identifier of the trigger.
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getTrigger(trigger: string, cell: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<TriggerObject, any, {}>>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  <!-- theme: danger --> > **Experimental** Updates the details of an existing trigger The exact behavior of switching a trigger from active to inactive or vice versa is not defined yet.
   * @summary Update Trigger
   * @param {string} trigger the id of the trigger
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {UpdateTriggerRequest} updateTriggerRequest
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  updateTrigger(trigger: string, cell: string, updateTriggerRequest: UpdateTriggerRequest, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<TriggerObject, any, {}>>;
}
/**
 * ProgramValuesApi - axios parameter creator
 */
declare const ProgramValuesApiAxiosParamCreator: (configuration?: Configuration) => {
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  Deprecated endpoint. Delete all values from the database.
   * @summary Delete All Values
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  clearProgramsValues: (cell: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  Deprecated endpoint.  Add or overwrite one or more values in the database.  PREREQUISITE: The database has been added as a device. Add the database with [createDevice](#/operations/createDevice).  The database itself is a key-value store.  For reference of possible data types see:  * [Documentation for elementary data types](/docs/docs/wandelscript/data-types/#elementary-types)
   * @summary Add Value(s)
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {{ [key: string]: CollectionValue; }} requestBody
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  createProgramsValue: (cell: string, requestBody: {
    [key: string]: CollectionValue;
  }, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  Delete a value from the database.
   * @summary Delete Value
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} key
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  deleteProgramValue: (cell: string, key: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  Deprecated endpoint.  Return a value stored in the database.  PREREQUISITE: The database has been added as a device. Add the database with [createDevice](#/operations/createDevice).  The database itself is a key-value store.  For reference of possible data types see:  * [Documentation for elementary data types](/docs/docs/wandelscript/data-types/#elementary-types)
   * @summary Get Value
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} key
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  getProgramValue: (cell: string, key: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  Deprecated endpoint.  Gets all values that are stored in the database.  PREREQUISITE: The database has been added as a device. Add the database with [createDevice](#/operations/createDevice).  The database itself is a key-value storage. For reference of possible data types see:  * [Documentation for elementary data types](/docs/docs/wandelscript/data-types/#elementary-types)
   * @summary Get Values
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  listProgramsValues: (cell: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  Deprecated endpoint.  Creates or updates a value in the database.  PREREQUISITE: The database has been added as a device. Add the database with [createDevice](#/operations/createDevice).  The database itself is a key-value store.  For reference of possible data types see:  * [Documentation for elementary data types](/docs/docs/wandelscript/data-types/#elementary-types)
   * @summary Create or Update Value
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} key
   * @param {Value} value
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  updateProgramValue: (cell: string, key: string, value: Value, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
/**
 * ProgramValuesApi - functional programming interface
 */
declare const ProgramValuesApiFp: (configuration?: Configuration) => {
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  Deprecated endpoint. Delete all values from the database.
   * @summary Delete All Values
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  clearProgramsValues(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  Deprecated endpoint.  Add or overwrite one or more values in the database.  PREREQUISITE: The database has been added as a device. Add the database with [createDevice](#/operations/createDevice).  The database itself is a key-value store.  For reference of possible data types see:  * [Documentation for elementary data types](/docs/docs/wandelscript/data-types/#elementary-types)
   * @summary Add Value(s)
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {{ [key: string]: CollectionValue; }} requestBody
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  createProgramsValue(cell: string, requestBody: {
    [key: string]: CollectionValue;
  }, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  Delete a value from the database.
   * @summary Delete Value
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} key
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  deleteProgramValue(cell: string, key: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  Deprecated endpoint.  Return a value stored in the database.  PREREQUISITE: The database has been added as a device. Add the database with [createDevice](#/operations/createDevice).  The database itself is a key-value store.  For reference of possible data types see:  * [Documentation for elementary data types](/docs/docs/wandelscript/data-types/#elementary-types)
   * @summary Get Value
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} key
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  getProgramValue(cell: string, key: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ResponseGetValueProgramsValuesKeyGet>>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  Deprecated endpoint.  Gets all values that are stored in the database.  PREREQUISITE: The database has been added as a device. Add the database with [createDevice](#/operations/createDevice).  The database itself is a key-value storage. For reference of possible data types see:  * [Documentation for elementary data types](/docs/docs/wandelscript/data-types/#elementary-types)
   * @summary Get Values
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  listProgramsValues(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<{
    [key: string]: ResponseGetValuesProgramsValuesGetValue;
  }>>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  Deprecated endpoint.  Creates or updates a value in the database.  PREREQUISITE: The database has been added as a device. Add the database with [createDevice](#/operations/createDevice).  The database itself is a key-value store.  For reference of possible data types see:  * [Documentation for elementary data types](/docs/docs/wandelscript/data-types/#elementary-types)
   * @summary Create or Update Value
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} key
   * @param {Value} value
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  updateProgramValue(cell: string, key: string, value: Value, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
};
/**
 * ProgramValuesApi - factory interface
 */
declare const ProgramValuesApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  Deprecated endpoint. Delete all values from the database.
   * @summary Delete All Values
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  clearProgramsValues(cell: string, options?: RawAxiosRequestConfig): AxiosPromise<void>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  Deprecated endpoint.  Add or overwrite one or more values in the database.  PREREQUISITE: The database has been added as a device. Add the database with [createDevice](#/operations/createDevice).  The database itself is a key-value store.  For reference of possible data types see:  * [Documentation for elementary data types](/docs/docs/wandelscript/data-types/#elementary-types)
   * @summary Add Value(s)
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {{ [key: string]: CollectionValue; }} requestBody
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  createProgramsValue(cell: string, requestBody: {
    [key: string]: CollectionValue;
  }, options?: RawAxiosRequestConfig): AxiosPromise<void>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  Delete a value from the database.
   * @summary Delete Value
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} key
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  deleteProgramValue(cell: string, key: string, options?: RawAxiosRequestConfig): AxiosPromise<void>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  Deprecated endpoint.  Return a value stored in the database.  PREREQUISITE: The database has been added as a device. Add the database with [createDevice](#/operations/createDevice).  The database itself is a key-value store.  For reference of possible data types see:  * [Documentation for elementary data types](/docs/docs/wandelscript/data-types/#elementary-types)
   * @summary Get Value
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} key
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  getProgramValue(cell: string, key: string, options?: RawAxiosRequestConfig): AxiosPromise<ResponseGetValueProgramsValuesKeyGet>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  Deprecated endpoint.  Gets all values that are stored in the database.  PREREQUISITE: The database has been added as a device. Add the database with [createDevice](#/operations/createDevice).  The database itself is a key-value storage. For reference of possible data types see:  * [Documentation for elementary data types](/docs/docs/wandelscript/data-types/#elementary-types)
   * @summary Get Values
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  listProgramsValues(cell: string, options?: RawAxiosRequestConfig): AxiosPromise<{
    [key: string]: ResponseGetValuesProgramsValuesGetValue;
  }>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  Deprecated endpoint.  Creates or updates a value in the database.  PREREQUISITE: The database has been added as a device. Add the database with [createDevice](#/operations/createDevice).  The database itself is a key-value store.  For reference of possible data types see:  * [Documentation for elementary data types](/docs/docs/wandelscript/data-types/#elementary-types)
   * @summary Create or Update Value
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} key
   * @param {Value} value
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  updateProgramValue(cell: string, key: string, value: Value, options?: RawAxiosRequestConfig): AxiosPromise<void>;
};
/**
 * ProgramValuesApi - object-oriented interface
 */
declare class ProgramValuesApi extends BaseAPI {
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  Deprecated endpoint. Delete all values from the database.
   * @summary Delete All Values
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  clearProgramsValues(cell: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<void, any, {}>>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  Deprecated endpoint.  Add or overwrite one or more values in the database.  PREREQUISITE: The database has been added as a device. Add the database with [createDevice](#/operations/createDevice).  The database itself is a key-value store.  For reference of possible data types see:  * [Documentation for elementary data types](/docs/docs/wandelscript/data-types/#elementary-types)
   * @summary Add Value(s)
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {{ [key: string]: CollectionValue; }} requestBody
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  createProgramsValue(cell: string, requestBody: {
    [key: string]: CollectionValue;
  }, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<void, any, {}>>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  Delete a value from the database.
   * @summary Delete Value
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} key
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  deleteProgramValue(cell: string, key: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<void, any, {}>>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  Deprecated endpoint.  Return a value stored in the database.  PREREQUISITE: The database has been added as a device. Add the database with [createDevice](#/operations/createDevice).  The database itself is a key-value store.  For reference of possible data types see:  * [Documentation for elementary data types](/docs/docs/wandelscript/data-types/#elementary-types)
   * @summary Get Value
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} key
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  getProgramValue(cell: string, key: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<ResponseGetValueProgramsValuesKeyGet, any, {}>>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  Deprecated endpoint.  Gets all values that are stored in the database.  PREREQUISITE: The database has been added as a device. Add the database with [createDevice](#/operations/createDevice).  The database itself is a key-value storage. For reference of possible data types see:  * [Documentation for elementary data types](/docs/docs/wandelscript/data-types/#elementary-types)
   * @summary Get Values
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  listProgramsValues(cell: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<{
    [key: string]: ResponseGetValuesProgramsValuesGetValue;
  }, any, {}>>;
  /**
   * **Required permissions:** `can_operate_programs` - Execute and monitor programs ___  Deprecated endpoint.  Creates or updates a value in the database.  PREREQUISITE: The database has been added as a device. Add the database with [createDevice](#/operations/createDevice).  The database itself is a key-value store.  For reference of possible data types see:  * [Documentation for elementary data types](/docs/docs/wandelscript/data-types/#elementary-types)
   * @summary Create or Update Value
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} key
   * @param {Value} value
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  updateProgramValue(cell: string, key: string, value: Value, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<void, any, {}>>;
}
/**
 * StoreCollisionComponentsApi - axios parameter creator
 */
declare const StoreCollisionComponentsApiAxiosParamCreator: (configuration?: Configuration) => {
  /**
   * **Required permissions:** `can_write_collision_world` - Write collision models and scenes ___  Deletes the stored collider.  <!-- theme: danger --> > 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<RequestArgs>;
  /**
   * **Required permissions:** `can_write_collision_world` - Write collision models and scenes ___  Deletes the stored link chain.  <!-- theme: danger --> > 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<RequestArgs>;
  /**
   * **Required permissions:** `can_write_collision_world` - Write collision models and scenes ___  Deletes the stored tool.  <!-- theme: danger --> > 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<RequestArgs>;
  /**
   * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___  Deprecated endpoint. Use [getCollisionModel](https://portal.wandelbots.io/docs/api/v2/ui/#/operations/getMotionGroupCollisionModel) instead.  Returns the default collision link chain for a given motion group model.  See [getPlanningMotionGroupModels](#/operations/getPlanningMotionGroupModels) 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.  Use the `stored_link_chain` or `link_chain` field in [storeCollisionScene](#/operations/storeCollisionScene) to attach additional shapes to the link reference frames. Additional shapes may overlap each other per link and may also overlap the respective link\'s default shape.
   * @summary Get Default Link Chain
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {GetDefaultLinkChainMotionGroupModelEnum} motionGroupModel Unique identifier for the type of a motion group (robot model).  Get the model name for a configured motion group from [getOptimizerConfiguration](#/operations/getOptimizerConfiguration).
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  getDefaultLinkChain: (cell: string, motionGroupModel: GetDefaultLinkChainMotionGroupModelEnum, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **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<RequestArgs>;
  /**
   * **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<RequestArgs>;
  /**
   * **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<RequestArgs>;
  /**
   * **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<RequestArgs>;
  /**
   * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___  Returns a list of colliders in a scene. This excludes colliders that are part of a motion group.
   * @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<RequestArgs>;
  /**
   * **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<RequestArgs>;
  /**
   * **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<RequestArgs>;
  /**
   * **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<RequestArgs>;
  /**
   * **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<RequestArgs>;
};
/**
 * StoreCollisionComponentsApi - functional programming interface
 */
declare const StoreCollisionComponentsApiFp: (configuration?: Configuration) => {
  /**
   * **Required permissions:** `can_write_collision_world` - Write collision models and scenes ___  Deletes the stored collider.  <!-- theme: danger --> > 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<void>>;
  /**
   * **Required permissions:** `can_write_collision_world` - Write collision models and scenes ___  Deletes the stored link chain.  <!-- theme: danger --> > 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<void>>;
  /**
   * **Required permissions:** `can_write_collision_world` - Write collision models and scenes ___  Deletes the stored tool.  <!-- theme: danger --> > 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<void>>;
  /**
   * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___  Deprecated endpoint. Use [getCollisionModel](https://portal.wandelbots.io/docs/api/v2/ui/#/operations/getMotionGroupCollisionModel) instead.  Returns the default collision link chain for a given motion group model.  See [getPlanningMotionGroupModels](#/operations/getPlanningMotionGroupModels) 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.  Use the `stored_link_chain` or `link_chain` field in [storeCollisionScene](#/operations/storeCollisionScene) to attach additional shapes to the link reference frames. Additional shapes may overlap each other per link and may also overlap the respective link\'s default shape.
   * @summary Get Default Link Chain
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {GetDefaultLinkChainMotionGroupModelEnum} motionGroupModel Unique identifier for the type of a motion group (robot model).  Get the model name for a configured motion group from [getOptimizerConfiguration](#/operations/getOptimizerConfiguration).
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  getDefaultLinkChain(cell: string, motionGroupModel: GetDefaultLinkChainMotionGroupModelEnum, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<{
    [key: string]: Collider;
  }>>>;
  /**
   * **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<Collider>>;
  /**
   * **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<Array<{
    [key: string]: Collider;
  }>>>;
  /**
   * **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 colliders in a scene. This excludes colliders that are part of a motion group.
   * @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 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_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<Collider>>;
  /**
   * **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<Array<{
    [key: string]: Collider;
  }>>>;
  /**
   * **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.  <!-- theme: danger --> > 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<void>;
  /**
   * **Required permissions:** `can_write_collision_world` - Write collision models and scenes ___  Deletes the stored link chain.  <!-- theme: danger --> > 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<void>;
  /**
   * **Required permissions:** `can_write_collision_world` - Write collision models and scenes ___  Deletes the stored tool.  <!-- theme: danger --> > 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<void>;
  /**
   * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___  Deprecated endpoint. Use [getCollisionModel](https://portal.wandelbots.io/docs/api/v2/ui/#/operations/getMotionGroupCollisionModel) instead.  Returns the default collision link chain for a given motion group model.  See [getPlanningMotionGroupModels](#/operations/getPlanningMotionGroupModels) 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.  Use the `stored_link_chain` or `link_chain` field in [storeCollisionScene](#/operations/storeCollisionScene) to attach additional shapes to the link reference frames. Additional shapes may overlap each other per link and may also overlap the respective link\'s default shape.
   * @summary Get Default Link Chain
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {GetDefaultLinkChainMotionGroupModelEnum} motionGroupModel Unique identifier for the type of a motion group (robot model).  Get the model name for a configured motion group from [getOptimizerConfiguration](#/operations/getOptimizerConfiguration).
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  getDefaultLinkChain(cell: string, motionGroupModel: GetDefaultLinkChainMotionGroupModelEnum, options?: RawAxiosRequestConfig): AxiosPromise<Array<{
    [key: string]: Collider;
  }>>;
  /**
   * **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<Collider>;
  /**
   * **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<Array<{
    [key: string]: Collider;
  }>>;
  /**
   * **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 colliders in a scene. This excludes colliders that are part of a motion group.
   * @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 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_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<Collider>;
  /**
   * **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<Array<{
    [key: string]: Collider;
  }>>;
  /**
   * **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.  <!-- theme: danger --> > 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<void, any, {}>>;
  /**
   * **Required permissions:** `can_write_collision_world` - Write collision models and scenes ___  Deletes the stored link chain.  <!-- theme: danger --> > 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<void, any, {}>>;
  /**
   * **Required permissions:** `can_write_collision_world` - Write collision models and scenes ___  Deletes the stored tool.  <!-- theme: danger --> > 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<void, any, {}>>;
  /**
   * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___  Deprecated endpoint. Use [getCollisionModel](https://portal.wandelbots.io/docs/api/v2/ui/#/operations/getMotionGroupCollisionModel) instead.  Returns the default collision link chain for a given motion group model.  See [getPlanningMotionGroupModels](#/operations/getPlanningMotionGroupModels) 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.  Use the `stored_link_chain` or `link_chain` field in [storeCollisionScene](#/operations/storeCollisionScene) to attach additional shapes to the link reference frames. Additional shapes may overlap each other per link and may also overlap the respective link\'s default shape.
   * @summary Get Default Link Chain
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {GetDefaultLinkChainMotionGroupModelEnum} motionGroupModel Unique identifier for the type of a motion group (robot model).  Get the model name for a configured motion group from [getOptimizerConfiguration](#/operations/getOptimizerConfiguration).
   * @param {*} [options] Override http request option.
   * @deprecated
   * @throws {RequiredError}
   */
  getDefaultLinkChain(cell: string, motionGroupModel: GetDefaultLinkChainMotionGroupModelEnum, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<{
    [key: string]: Collider;
  }[], any, {}>>;
  /**
   * **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<Collider, any, {}>>;
  /**
   * **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 colliders in a scene. This excludes colliders that are part of a motion group.
   * @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 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_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<Collider, any, {}>>;
  /**
   * **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, {}>>;
}
declare const GetDefaultLinkChainMotionGroupModelEnum: {
  readonly Abb101003715: "ABB_1010_037_15";
  readonly Abb110004754: "ABB_1100_0475_4";
  readonly Abb11000584: "ABB_1100_058_4";
  readonly Abb1200077: "ABB_1200_07_7";
  readonly Abb1200583: "ABB_120_058_3";
  readonly Abb13000911: "ABB_1300_09_11";
  readonly Abb130011510: "ABB_1300_115_10";
  readonly Abb13001412: "ABB_1300_14_12";
  readonly Abb1300147: "ABB_1300_14_7";
  readonly Abb14001445: "ABB_1400_144_5";
  readonly Abb1400816: "ABB_140_081_6";
  readonly Abb1520Id154: "ABB_1520ID_15_4";
  readonly Abb16001210: "ABB_1600_12_10";
  readonly Abb1600126: "ABB_1600_12_6";
  readonly Abb160014510: "ABB_1600_145_10";
  readonly Abb16001456: "ABB_1600_145_6";
  readonly Abb1660Id1554: "ABB_1660ID_155_4";
  readonly Abb2600Id18515: "ABB_2600ID_185_15";
  readonly Abb2600Id2008: "ABB_2600ID_200_8";
  readonly Abb260016512: "ABB_2600_165_12";
  readonly Abb260016520: "ABB_2600_165_20";
  readonly Abb260018512: "ABB_2600_185_12";
  readonly Abb460020545: "ABB_4600_205_45";
  readonly Abb460020560: "ABB_4600_205_60";
  readonly Abb460025020: "ABB_4600_250_20";
  readonly Abb460025540: "ABB_4600_255_40";
  readonly Abb6730210310: "ABB_6730_210_310";
  readonly Abb6730240290: "ABB_6730_240_290";
  readonly FanucArcMate100iD: "FANUC_ARC_Mate_100iD";
  readonly FanucArcMate100iD10L: "FANUC_ARC_Mate_100iD10L";
  readonly FanucArcMate100iD16S: "FANUC_ARC_Mate_100iD16S";
  readonly FanucArcMate100iD8L: "FANUC_ARC_Mate_100iD8L";
  readonly FanucArcMate120iD: "FANUC_ARC_Mate_120iD";
  readonly FanucArcMate120iD12L: "FANUC_ARC_Mate_120iD12L";
  readonly FanucArcMate50iD: "FANUC_ARC_Mate_50iD";
  readonly FanucArcMate50iD7L: "FANUC_ARC_Mate_50iD7L";
  readonly FanucCr14iAl: "FANUC_CR14iAL";
  readonly FanucCr15iA: "FANUC_CR15iA";
  readonly FanucCr35iA: "FANUC_CR35iA";
  readonly FanucCr35iB: "FANUC_CR35iB";
  readonly FanucCr4iA: "FANUC_CR4iA";
  readonly FanucCr7iA: "FANUC_CR7iA";
  readonly FanucCr7iAl: "FANUC_CR7iAL";
  readonly FanucCrx10iA: "FANUC_CRX10iA";
  readonly FanucCrx10iAl: "FANUC_CRX10iAL";
  readonly FanucCrx20iAl: "FANUC_CRX20iAL";
  readonly FanucCrx25iA: "FANUC_CRX25iA";
  readonly FanucCrx30iA: "FANUC_CRX30iA";
  readonly FanucCrx5iA: "FANUC_CRX5iA";
  readonly FanucLrMate200iD: "FANUC_LR_Mate_200iD";
  readonly FanucLrMate200iD4S: "FANUC_LR_Mate_200iD4S";
  readonly FanucLrMate200iD7L: "FANUC_LR_Mate_200iD7L";
  readonly FanucM10iD10L: "FANUC_M10iD10L";
  readonly FanucM10iD12: "FANUC_M10iD12";
  readonly FanucM10iD16S: "FANUC_M10iD16S";
  readonly FanucM10iD8L: "FANUC_M10iD8L";
  readonly FanucM20iB25: "FANUC_M20iB25";
  readonly FanucM20iB25C: "FANUC_M20iB25C";
  readonly FanucM20iB35S: "FANUC_M20iB35S";
  readonly FanucM20iD12L: "FANUC_M20iD12L";
  readonly FanucM20iD25: "FANUC_M20iD25";
  readonly FanucM20iD35: "FANUC_M20iD35";
  readonly FanucM710iC20L: "FANUC_M710iC20L";
  readonly FanucM900iB280L: "FANUC_M900iB280L";
  readonly FanucM900iB360E: "FANUC_M900iB360E";
  readonly FanucR2000iC125L: "FANUC_R2000iC125L";
  readonly FanucR2000iC210F: "FANUC_R2000iC210F";
  readonly KukaDkp5002: "KUKA_DKP500_2";
  readonly KukaKr10R1100: "KUKA_KR10_R1100";
  readonly KukaKr10R11002: "KUKA_KR10_R1100_2";
  readonly KukaKr10R900: "KUKA_KR10_R900";
  readonly KukaKr10R9002: "KUKA_KR10_R900_2";
  readonly KukaKr120R2700: "KUKA_KR120_R2700";
  readonly KukaKr120R27002: "KUKA_KR120_R2700_2";
  readonly KukaKr120R31002: "KUKA_KR120_R3100_2";
  readonly KukaKr120R39002K: "KUKA_KR120_R3900_2_K";
  readonly KukaKr12R18102: "KUKA_KR12_R1810_2";
  readonly KukaKr150R2: "KUKA_KR150_R2";
  readonly KukaKr16R1610: "KUKA_KR16_R1610";
  readonly KukaKr16R16102: "KUKA_KR16_R1610_2";
  readonly KukaKr16R2010: "KUKA_KR16_R2010";
  readonly KukaKr16R20102: "KUKA_KR16_R2010_2";
  readonly KukaKr20R1810: "KUKA_KR20_R1810";
  readonly KukaKr20R18102: "KUKA_KR20_R1810_2";
  readonly KukaKr210R2700: "KUKA_KR210_R2700";
  readonly KukaKr210R2700Extra: "KUKA_KR210_R2700_extra";
  readonly KukaKr210R27002: "KUKA_KR210_R2700_2";
  readonly KukaKr210R3100: "KUKA_KR210_R3100";
  readonly KukaKr210R31002: "KUKA_KR210_R3100_2";
  readonly KukaKr210R3300: "KUKA_KR210_R3300";
  readonly KukaKr210R33002: "KUKA_KR210_R3300_2";
  readonly KukaKr240R2700: "KUKA_KR240_R2700";
  readonly KukaKr240R2900: "KUKA_KR240_R2900";
  readonly KukaKr240R37002: "KUKA_KR240_R3700_2";
  readonly KukaKr250R27002: "KUKA_KR250_R2700_2";
  readonly KukaKr270R2700: "KUKA_KR270_R2700";
  readonly KukaKr270R3100: "KUKA_KR270_R3100";
  readonly KukaKr270R31002: "KUKA_KR270_R3100_2";
  readonly KukaKr30R2100: "KUKA_KR30_R2100";
  readonly KukaKr30R3: "KUKA_KR30_R3";
  readonly KukaKr360L2403: "KUKA_KR360_L240_3";
  readonly KukaKr360R2830: "KUKA_KR360_R2830";
  readonly KukaKr3R540: "KUKA_KR3_R540";
  readonly KukaKr4R600: "KUKA_KR4_R600";
  readonly KukaKr50R2500: "KUKA_KR50_R2500";
  readonly KukaKr60R3: "KUKA_KR60_R3";
  readonly KukaKr6R1820: "KUKA_KR6_R1820";
  readonly KukaKr6R700: "KUKA_KR6_R700";
  readonly KukaKr6R7002: "KUKA_KR6_R700_2";
  readonly KukaKr6R900: "KUKA_KR6_R900";
  readonly KukaKr6R9002: "KUKA_KR6_R900_2";
  readonly KukaKr70R2100: "KUKA_KR70_R2100";
  readonly KukaLbrIisy11R1300: "KUKA_LBR_IISY_11_R1300";
  readonly UniversalRobotsUr10: "UniversalRobots_UR10";
  readonly UniversalRobotsUr10e: "UniversalRobots_UR10e";
  readonly UniversalRobotsUr12e: "UniversalRobots_UR12e";
  readonly UniversalRobotsUr16e: "UniversalRobots_UR16e";
  readonly UniversalRobotsUr20e: "UniversalRobots_UR20e";
  readonly UniversalRobotsUr3: "UniversalRobots_UR3";
  readonly UniversalRobotsUr3e: "UniversalRobots_UR3e";
  readonly UniversalRobotsUr5: "UniversalRobots_UR5";
  readonly UniversalRobotsUr5e: "UniversalRobots_UR5e";
  readonly UniversalRobotsUr7e: "UniversalRobots_UR7e";
  readonly YaskawaAr1440: "Yaskawa_AR1440";
  readonly YaskawaAr1440E: "Yaskawa_AR1440E";
  readonly YaskawaAr1730: "Yaskawa_AR1730";
  readonly YaskawaAr2010: "Yaskawa_AR2010";
  readonly YaskawaAr3120: "Yaskawa_AR3120";
  readonly YaskawaAr700: "Yaskawa_AR700";
  readonly YaskawaAr900: "Yaskawa_AR900";
  readonly YaskawaGp110: "Yaskawa_GP110";
  readonly YaskawaGp110B: "Yaskawa_GP110B";
  readonly YaskawaGp110H: "Yaskawa_GP110H";
  readonly YaskawaGp12: "Yaskawa_GP12";
  readonly YaskawaGp165R: "Yaskawa_GP165R";
  readonly YaskawaGp180: "Yaskawa_GP180";
  readonly YaskawaGp180H: "Yaskawa_GP180H";
  readonly YaskawaGp180120: "Yaskawa_GP180_120";
  readonly YaskawaGp200R: "Yaskawa_GP200R";
  readonly YaskawaGp200S: "Yaskawa_GP200S";
  readonly YaskawaGp20Hl: "Yaskawa_GP20HL";
  readonly YaskawaGp215: "Yaskawa_GP215";
  readonly YaskawaGp225: "Yaskawa_GP225";
  readonly YaskawaGp225H: "Yaskawa_GP225H";
  readonly YaskawaGp25: "Yaskawa_GP25";
  readonly YaskawaGp250: "Yaskawa_GP250";
  readonly YaskawaGp25Sv: "Yaskawa_GP25SV";
  readonly YaskawaGp2512: "Yaskawa_GP25_12";
  readonly YaskawaGp280: "Yaskawa_GP280";
  readonly YaskawaGp280L: "Yaskawa_GP280L";
  readonly YaskawaGp300R: "Yaskawa_GP300R";
  readonly YaskawaGp35L: "Yaskawa_GP35L";
  readonly YaskawaGp4: "Yaskawa_GP4";
  readonly YaskawaGp400: "Yaskawa_GP400";
  readonly YaskawaGp400R: "Yaskawa_GP400R";
  readonly YaskawaGp50: "Yaskawa_GP50";
  readonly YaskawaGp600: "Yaskawa_GP600";
  readonly YaskawaGp7: "Yaskawa_GP7";
  readonly YaskawaGp70L: "Yaskawa_GP70L";
  readonly YaskawaGp8: "Yaskawa_GP8";
  readonly YaskawaGp88: "Yaskawa_GP88";
  readonly YaskawaGp8L: "Yaskawa_GP8L";
  readonly YaskawaHc10: "Yaskawa_HC10";
  readonly YaskawaHc10Dtp: "Yaskawa_HC10DTP";
  readonly YaskawaHc20Dtp: "Yaskawa_HC20DTP";
  readonly YaskawaHc30Pl: "Yaskawa_HC30PL";
  readonly YaskawaTurn1: "Yaskawa_TURN1";
  readonly YaskawaTurn2: "Yaskawa_TURN2";
  readonly YaskawaTurn3: "Yaskawa_TURN3";
};
type GetDefaultLinkChainMotionGroupModelEnum = typeof GetDefaultLinkChainMotionGroupModelEnum[keyof typeof GetDefaultLinkChainMotionGroupModelEnum];
/**
 * StoreCollisionScenesApi - axios parameter creator
 */
declare const StoreCollisionScenesApiAxiosParamCreator: (configuration?: Configuration) => {
  /**
   * **Required permissions:** `can_write_collision_world` - Write collision models and scenes ___  Deletes the stored scene.  <!-- theme: danger --> > This will delete persistently stored data.
   * @summary Delete Scene
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} scene Unique identifier addressing a collision scene.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  deleteStoredCollisionScene: (cell: string, scene: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___  Returns the stored scene.
   * @summary Get Scene
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} scene Unique identifier addressing a collision scene.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getStoredCollisionScene: (cell: string, scene: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___  Returns a list of stored scenes.
   * @summary List Scenes
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  listStoredCollisionScenes: (cell: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_write_collision_world` - Write collision models and scenes ___  Creates or replaces the stored collision scene.  The scene is assembled from components as defined in the request body.  An error is returned if a stored object does not exist.
   * @summary Store Scene
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} scene Unique identifier addressing a collision scene.
   * @param {CollisionSceneAssembly} collisionSceneAssembly
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  storeCollisionScene: (cell: string, scene: string, collisionSceneAssembly: CollisionSceneAssembly, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
/**
 * StoreCollisionScenesApi - functional programming interface
 */
declare const StoreCollisionScenesApiFp: (configuration?: Configuration) => {
  /**
   * **Required permissions:** `can_write_collision_world` - Write collision models and scenes ___  Deletes the stored scene.  <!-- theme: danger --> > This will delete persistently stored data.
   * @summary Delete Scene
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} scene Unique identifier addressing a collision scene.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  deleteStoredCollisionScene(cell: string, scene: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
  /**
   * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___  Returns the stored scene.
   * @summary Get Scene
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} scene Unique identifier addressing a collision scene.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getStoredCollisionScene(cell: string, scene: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<CollisionScene>>;
  /**
   * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___  Returns a list of stored scenes.
   * @summary List Scenes
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  listStoredCollisionScenes(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<{
    [key: string]: CollisionScene;
  }>>;
  /**
   * **Required permissions:** `can_write_collision_world` - Write collision models and scenes ___  Creates or replaces the stored collision scene.  The scene is assembled from components as defined in the request body.  An error is returned if a stored object does not exist.
   * @summary Store Scene
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} scene Unique identifier addressing a collision scene.
   * @param {CollisionSceneAssembly} collisionSceneAssembly
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  storeCollisionScene(cell: string, scene: string, collisionSceneAssembly: CollisionSceneAssembly, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<CollisionScene>>;
};
/**
 * StoreCollisionScenesApi - factory interface
 */
declare const StoreCollisionScenesApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
  /**
   * **Required permissions:** `can_write_collision_world` - Write collision models and scenes ___  Deletes the stored scene.  <!-- theme: danger --> > This will delete persistently stored data.
   * @summary Delete Scene
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} scene Unique identifier addressing a collision scene.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  deleteStoredCollisionScene(cell: string, scene: string, options?: RawAxiosRequestConfig): AxiosPromise<void>;
  /**
   * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___  Returns the stored scene.
   * @summary Get Scene
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} scene Unique identifier addressing a collision scene.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getStoredCollisionScene(cell: string, scene: string, options?: RawAxiosRequestConfig): AxiosPromise<CollisionScene>;
  /**
   * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___  Returns a list of stored scenes.
   * @summary List Scenes
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  listStoredCollisionScenes(cell: string, options?: RawAxiosRequestConfig): AxiosPromise<{
    [key: string]: CollisionScene;
  }>;
  /**
   * **Required permissions:** `can_write_collision_world` - Write collision models and scenes ___  Creates or replaces the stored collision scene.  The scene is assembled from components as defined in the request body.  An error is returned if a stored object does not exist.
   * @summary Store Scene
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} scene Unique identifier addressing a collision scene.
   * @param {CollisionSceneAssembly} collisionSceneAssembly
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  storeCollisionScene(cell: string, scene: string, collisionSceneAssembly: CollisionSceneAssembly, options?: RawAxiosRequestConfig): AxiosPromise<CollisionScene>;
};
/**
 * StoreCollisionScenesApi - object-oriented interface
 */
declare class StoreCollisionScenesApi extends BaseAPI {
  /**
   * **Required permissions:** `can_write_collision_world` - Write collision models and scenes ___  Deletes the stored scene.  <!-- theme: danger --> > This will delete persistently stored data.
   * @summary Delete Scene
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} scene Unique identifier addressing a collision scene.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  deleteStoredCollisionScene(cell: string, scene: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<void, any, {}>>;
  /**
   * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___  Returns the stored scene.
   * @summary Get Scene
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} scene Unique identifier addressing a collision scene.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getStoredCollisionScene(cell: string, scene: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<CollisionScene, any, {}>>;
  /**
   * **Required permissions:** `can_read_collision_world` - Read collision models and scenes ___  Returns a list of stored scenes.
   * @summary List Scenes
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  listStoredCollisionScenes(cell: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<{
    [key: string]: CollisionScene;
  }, any, {}>>;
  /**
   * **Required permissions:** `can_write_collision_world` - Write collision models and scenes ___  Creates or replaces the stored collision scene.  The scene is assembled from components as defined in the request body.  An error is returned if a stored object does not exist.
   * @summary Store Scene
   * @param {string} cell Unique identifier addressing a cell in all API calls.
   * @param {string} scene Unique identifier addressing a collision scene.
   * @param {CollisionSceneAssembly} collisionSceneAssembly
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  storeCollisionScene(cell: string, scene: string, collisionSceneAssembly: CollisionSceneAssembly, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<CollisionScene, any, {}>>;
}
/**
 * StoreObjectApi - axios parameter creator
 */
declare const StoreObjectApiAxiosParamCreator: (configuration?: Configuration) => {
  /**
   * **Required permissions:** `can_write_objects` - Write stored objects ___  Delete all objects.  <!-- theme: danger --> > 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<RequestArgs>;
  /**
   * **Required permissions:** `can_write_objects` - Write stored objects ___  Delete an object  <!-- theme: danger --> > 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<RequestArgs>;
  /**
   * **Required permissions:** `can_read_objects` - Read stored objects ___  Get the object.  This request returns the object and any metadata attached to it.
   * @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<RequestArgs>;
  /**
   * **Required permissions:** `can_read_objects` - Read stored objects ___  Get object metadata.  Objects can be large. Therefore this request only returns metadata without fetching the object\'s content.
   * @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<RequestArgs>;
  /**
   * **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<RequestArgs>;
  /**
   * **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<RequestArgs>;
};
/**
 * StoreObjectApi - functional programming interface
 */
declare const StoreObjectApiFp: (configuration?: Configuration) => {
  /**
   * **Required permissions:** `can_write_objects` - Write stored objects ___  Delete all objects.  <!-- theme: danger --> > 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<void>>;
  /**
   * **Required permissions:** `can_write_objects` - Write stored objects ___  Delete an object  <!-- theme: danger --> > 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<void>>;
  /**
   * **Required permissions:** `can_read_objects` - Read stored objects ___  Get the object.  This request returns the object and any metadata attached to it.
   * @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<File>>;
  /**
   * **Required permissions:** `can_read_objects` - Read stored objects ___  Get object metadata.  Objects can be large. Therefore this request only returns metadata without fetching the object\'s content.
   * @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<void>>;
  /**
   * **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<Array<string>>>;
  /**
   * **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<void>>;
};
/**
 * StoreObjectApi - factory interface
 */
declare const StoreObjectApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
  /**
   * **Required permissions:** `can_write_objects` - Write stored objects ___  Delete all objects.  <!-- theme: danger --> > 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<void>;
  /**
   * **Required permissions:** `can_write_objects` - Write stored objects ___  Delete an object  <!-- theme: danger --> > 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<void>;
  /**
   * **Required permissions:** `can_read_objects` - Read stored objects ___  Get the object.  This request returns the object and any metadata attached to it.
   * @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<File>;
  /**
   * **Required permissions:** `can_read_objects` - Read stored objects ___  Get object metadata.  Objects can be large. Therefore this request only returns metadata without fetching the object\'s content.
   * @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<void>;
  /**
   * **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<Array<string>>;
  /**
   * **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<void>;
};
/**
 * StoreObjectApi - object-oriented interface
 */
declare class StoreObjectApi extends BaseAPI {
  /**
   * **Required permissions:** `can_write_objects` - Write stored objects ___  Delete all objects.  <!-- theme: danger --> > 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<void, any, {}>>;
  /**
   * **Required permissions:** `can_write_objects` - Write stored objects ___  Delete an object  <!-- theme: danger --> > 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<void, any, {}>>;
  /**
   * **Required permissions:** `can_read_objects` - Read stored objects ___  Get the object.  This request returns the object and any metadata attached to it.
   * @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<File, any, {}>>;
  /**
   * **Required permissions:** `can_read_objects` - Read stored objects ___  Get object metadata.  Objects can be large. Therefore this request only returns metadata without fetching the object\'s content.
   * @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<void, any, {}>>;
  /**
   * **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<string[], any, {}>>;
  /**
   * **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<void, any, {}>>;
}
/**
 * SystemApi - axios parameter creator
 */
declare const SystemApiAxiosParamCreator: (configuration?: Configuration) => {
  /**
   * **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<RequestArgs>;
  /**
   * **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<RequestArgs>;
  /**
   * **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<RequestArgs>;
  /**
   * **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<RequestArgs>;
  /**
   * **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 an error occurs, the API Request is sent 3 times. If the error persists, the old Wandelbots NOVA version is restored.
   * @summary Update Wandelbots NOVA version
   * @param {UpdateNovaVersionRequest} updateNovaVersionRequest
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  updateNovaVersion: (updateNovaVersionRequest: UpdateNovaVersionRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
/**
 * SystemApi - functional programming interface
 */
declare const SystemApiFp: (configuration?: Configuration) => {
  /**
   * **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<string>>;
  /**
   * **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<File>>;
  /**
   * **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<Array<ServiceStatus>>>;
  /**
   * **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<string>>;
  /**
   * **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 an error occurs, the API Request is sent 3 times. If the error persists, the old Wandelbots NOVA version is restored.
   * @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<void>>;
};
/**
 * SystemApi - factory interface
 */
declare const SystemApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
  /**
   * **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<string>;
  /**
   * **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<File>;
  /**
   * **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<Array<ServiceStatus>>;
  /**
   * **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<string>;
  /**
   * **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 an error occurs, the API Request is sent 3 times. If the error persists, the old Wandelbots NOVA version is restored.
   * @summary Update Wandelbots NOVA version
   * @param {UpdateNovaVersionRequest} updateNovaVersionRequest
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  updateNovaVersion(updateNovaVersionRequest: UpdateNovaVersionRequest, options?: RawAxiosRequestConfig): AxiosPromise<void>;
};
/**
 * SystemApi - object-oriented interface
 */
declare class SystemApi extends BaseAPI {
  /**
   * **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<string, any, {}>>;
  /**
   * **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<File, any, {}>>;
  /**
   * **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<ServiceStatus[], any, {}>>;
  /**
   * **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<string, any, {}>>;
  /**
   * **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 an error occurs, the API Request is sent 3 times. If the error persists, the old Wandelbots NOVA version is restored.
   * @summary Update Wandelbots NOVA version
   * @param {UpdateNovaVersionRequest} updateNovaVersionRequest
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  updateNovaVersion(updateNovaVersionRequest: UpdateNovaVersionRequest, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<void, any, {}>>;
}
/**
 * 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<RequestArgs>;
};
/**
 * 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<ApiVersion>>;
};
/**
 * 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<ApiVersion>;
};
/**
 * 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<ApiVersion, any, {}>>;
}
/**
 * VirtualRobotApi - axios parameter creator
 */
declare const VirtualRobotApiAxiosParamCreator: (configuration?: Configuration) => {
  /**
   * **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 {number} id The controller specific motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getMotionGroupState: (cell: string, controller: string, id: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **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<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___  Gets the description and value of a virtual controller I/O.
   * @summary Get I/O
   * @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} io The io id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getVirtualRobotIOValue: (cell: string, controller: string, io: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___  Lists all inputs/outputs of the virtual controller. Every input/output contains the description and the value.  As a virtual robot can have up to thousand inputs/outputs, be ready to handle a large response. Use [List Descriptions](List Descriptions) to get a detailed description of an input/output.
   * @summary List Inputs/Outputs
   * @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}
   */
  listIOs: (cell: string, controller: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **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. We recommend to only use the endpoint when the motion group is in monitor mode. In case 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 {number} id The controller specific motion-group id.
   * @param {MotionGroupJoints} motionGroupJoints
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  setMotionGroupState: (cell: string, controller: string, id: number, motionGroupJoints: MotionGroupJoints, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___  Sets the value of a virtual controller I/O.
   * @summary Set I/O
   * @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} io The io id.
   * @param {boolean} [bool]
   * @param {string} [integer]
   * @param {number} [_double]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  setVirtualRobotIOValue: (cell: string, controller: string, io: string, bool?: boolean, integer?: string, _double?: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
/**
 * VirtualRobotApi - functional programming interface
 */
declare const VirtualRobotApiFp: (configuration?: Configuration) => {
  /**
   * **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 {number} id The controller specific motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getMotionGroupState(cell: string, controller: string, id: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<MotionGroupJoints>>;
  /**
   * **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<MotionGroupInfos>>;
  /**
   * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___  Gets the description and value of a virtual controller I/O.
   * @summary Get I/O
   * @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} io The io id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getVirtualRobotIOValue(cell: string, controller: string, io: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<IO>>;
  /**
   * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___  Lists all inputs/outputs of the virtual controller. Every input/output contains the description and the value.  As a virtual robot can have up to thousand inputs/outputs, be ready to handle a large response. Use [List Descriptions](List Descriptions) to get a detailed description of an input/output.
   * @summary List Inputs/Outputs
   * @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}
   */
  listIOs(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<IOs>>;
  /**
   * **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. We recommend to only use the endpoint when the motion group is in monitor mode. In case 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 {number} id The controller specific motion-group id.
   * @param {MotionGroupJoints} motionGroupJoints
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  setMotionGroupState(cell: string, controller: string, id: number, motionGroupJoints: MotionGroupJoints, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<object>>;
  /**
   * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___  Sets the value of a virtual controller I/O.
   * @summary Set I/O
   * @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} io The io id.
   * @param {boolean} [bool]
   * @param {string} [integer]
   * @param {number} [_double]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  setVirtualRobotIOValue(cell: string, controller: string, io: string, bool?: boolean, integer?: string, _double?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<object>>;
};
/**
 * VirtualRobotApi - factory interface
 */
declare const VirtualRobotApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
  /**
   * **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 {number} id The controller specific motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getMotionGroupState(cell: string, controller: string, id: number, options?: RawAxiosRequestConfig): AxiosPromise<MotionGroupJoints>;
  /**
   * **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<MotionGroupInfos>;
  /**
   * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___  Gets the description and value of a virtual controller I/O.
   * @summary Get I/O
   * @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} io The io id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getVirtualRobotIOValue(cell: string, controller: string, io: string, options?: RawAxiosRequestConfig): AxiosPromise<IO>;
  /**
   * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___  Lists all inputs/outputs of the virtual controller. Every input/output contains the description and the value.  As a virtual robot can have up to thousand inputs/outputs, be ready to handle a large response. Use [List Descriptions](List Descriptions) to get a detailed description of an input/output.
   * @summary List Inputs/Outputs
   * @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}
   */
  listIOs(cell: string, controller: string, options?: RawAxiosRequestConfig): AxiosPromise<IOs>;
  /**
   * **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. We recommend to only use the endpoint when the motion group is in monitor mode. In case 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 {number} id The controller specific motion-group id.
   * @param {MotionGroupJoints} motionGroupJoints
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  setMotionGroupState(cell: string, controller: string, id: number, motionGroupJoints: MotionGroupJoints, options?: RawAxiosRequestConfig): AxiosPromise<object>;
  /**
   * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___  Sets the value of a virtual controller I/O.
   * @summary Set I/O
   * @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} io The io id.
   * @param {boolean} [bool]
   * @param {string} [integer]
   * @param {number} [_double]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  setVirtualRobotIOValue(cell: string, controller: string, io: string, bool?: boolean, integer?: string, _double?: number, options?: RawAxiosRequestConfig): AxiosPromise<object>;
};
/**
 * VirtualRobotApi - object-oriented interface
 */
declare class VirtualRobotApi extends BaseAPI {
  /**
   * **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 {number} id The controller specific motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getMotionGroupState(cell: string, controller: string, id: number, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<MotionGroupJoints, any, {}>>;
  /**
   * **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<MotionGroupInfos, any, {}>>;
  /**
   * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___  Gets the description and value of a virtual controller I/O.
   * @summary Get I/O
   * @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} io The io id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getVirtualRobotIOValue(cell: string, controller: string, io: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<IO, any, {}>>;
  /**
   * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___  Lists all inputs/outputs of the virtual controller. Every input/output contains the description and the value.  As a virtual robot can have up to thousand inputs/outputs, be ready to handle a large response. Use [List Descriptions](List Descriptions) to get a detailed description of an input/output.
   * @summary List Inputs/Outputs
   * @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}
   */
  listIOs(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<IOs, any, {}>>;
  /**
   * **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. We recommend to only use the endpoint when the motion group is in monitor mode. In case 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 {number} id The controller specific motion-group id.
   * @param {MotionGroupJoints} motionGroupJoints
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  setMotionGroupState(cell: string, controller: string, id: number, motionGroupJoints: MotionGroupJoints, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<object, any, {}>>;
  /**
   * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___  Sets the value of a virtual controller I/O.
   * @summary Set I/O
   * @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} io The io id.
   * @param {boolean} [bool]
   * @param {string} [integer]
   * @param {number} [_double]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  setVirtualRobotIOValue(cell: string, controller: string, io: string, bool?: boolean, integer?: string, _double?: number, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<object, any, {}>>;
}
/**
 * VirtualRobotBehaviorApi - axios parameter creator
 */
declare const VirtualRobotBehaviorApiAxiosParamCreator: (configuration?: Configuration) => {
  /**
   * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___  This stream provides the commanded joint state and sets a motion groups joint configuration, e.g. to move a motion group. The concept is that an application is using the Motion Service to move a motion group. The Motion Service is commanding the desired joint configuration of a motion group.  Physical motion groups move to this joint configuration.  With physical motion groups, this takes some time and only works if possible.  And you have the *actual* joint state - the current real motion group configuration.  Again, this stream is providing *commanded* joint state! It is __not__ providing the *actual* joint state! (Please file a request - if you need a stream of the *actual* joint state)  When the virtual controller receives joint commands the joint configuration is immediately adapted to match the incoming joint configurations. CAUTION: Incoming joint configurations are not visualized and their velocity limits are not checked. we don\'t even check limits!  Possible use cases are: 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 group.  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.  <!-- theme: danger -->  > **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 {ExternalJointStreamDatapoint} externalJointStreamDatapoint
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  externalJointsStream: (cell: string, controller: string, externalJointStreamDatapoint: ExternalJointStreamDatapoint, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___  Get the current robot motion group behavior - please see the setter [setMotionGroupBehavior](#/operations/setMotionGroupBehavior) and the enum for details.
   * @summary 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 {number} id The controller specific motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getMotionGroupBehavior: (cell: string, controller: string, id: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___  Switch robot motion group behavior.
   * @summary Switch 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 {number} id The controller specific motion-group id.
   * @param {Behavior} [behavior]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  setMotionGroupBehavior: (cell: string, controller: string, id: number, behavior?: Behavior, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
/**
 * VirtualRobotBehaviorApi - functional programming interface
 */
declare const VirtualRobotBehaviorApiFp: (configuration?: Configuration) => {
  /**
   * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___  This stream provides the commanded joint state and sets a motion groups joint configuration, e.g. to move a motion group. The concept is that an application is using the Motion Service to move a motion group. The Motion Service is commanding the desired joint configuration of a motion group.  Physical motion groups move to this joint configuration.  With physical motion groups, this takes some time and only works if possible.  And you have the *actual* joint state - the current real motion group configuration.  Again, this stream is providing *commanded* joint state! It is __not__ providing the *actual* joint state! (Please file a request - if you need a stream of the *actual* joint state)  When the virtual controller receives joint commands the joint configuration is immediately adapted to match the incoming joint configurations. CAUTION: Incoming joint configurations are not visualized and their velocity limits are not checked. we don\'t even check limits!  Possible use cases are: 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 group.  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.  <!-- theme: danger -->  > **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 {ExternalJointStreamDatapoint} externalJointStreamDatapoint
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  externalJointsStream(cell: string, controller: string, externalJointStreamDatapoint: ExternalJointStreamDatapoint, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<MotionGroupJoints>>;
  /**
   * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___  Get the current robot motion group behavior - please see the setter [setMotionGroupBehavior](#/operations/setMotionGroupBehavior) and the enum for details.
   * @summary 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 {number} id The controller specific motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getMotionGroupBehavior(cell: string, controller: string, id: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<MotionGroupBehaviorGetter>>;
  /**
   * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___  Switch robot motion group behavior.
   * @summary Switch 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 {number} id The controller specific motion-group id.
   * @param {Behavior} [behavior]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  setMotionGroupBehavior(cell: string, controller: string, id: number, behavior?: Behavior, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<object>>;
};
/**
 * VirtualRobotBehaviorApi - factory interface
 */
declare const VirtualRobotBehaviorApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
  /**
   * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___  This stream provides the commanded joint state and sets a motion groups joint configuration, e.g. to move a motion group. The concept is that an application is using the Motion Service to move a motion group. The Motion Service is commanding the desired joint configuration of a motion group.  Physical motion groups move to this joint configuration.  With physical motion groups, this takes some time and only works if possible.  And you have the *actual* joint state - the current real motion group configuration.  Again, this stream is providing *commanded* joint state! It is __not__ providing the *actual* joint state! (Please file a request - if you need a stream of the *actual* joint state)  When the virtual controller receives joint commands the joint configuration is immediately adapted to match the incoming joint configurations. CAUTION: Incoming joint configurations are not visualized and their velocity limits are not checked. we don\'t even check limits!  Possible use cases are: 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 group.  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.  <!-- theme: danger -->  > **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 {ExternalJointStreamDatapoint} externalJointStreamDatapoint
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  externalJointsStream(cell: string, controller: string, externalJointStreamDatapoint: ExternalJointStreamDatapoint, options?: RawAxiosRequestConfig): AxiosPromise<MotionGroupJoints>;
  /**
   * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___  Get the current robot motion group behavior - please see the setter [setMotionGroupBehavior](#/operations/setMotionGroupBehavior) and the enum for details.
   * @summary 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 {number} id The controller specific motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getMotionGroupBehavior(cell: string, controller: string, id: number, options?: RawAxiosRequestConfig): AxiosPromise<MotionGroupBehaviorGetter>;
  /**
   * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___  Switch robot motion group behavior.
   * @summary Switch 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 {number} id The controller specific motion-group id.
   * @param {Behavior} [behavior]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  setMotionGroupBehavior(cell: string, controller: string, id: number, behavior?: Behavior, options?: RawAxiosRequestConfig): AxiosPromise<object>;
};
/**
 * VirtualRobotBehaviorApi - object-oriented interface
 */
declare class VirtualRobotBehaviorApi extends BaseAPI {
  /**
   * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___  This stream provides the commanded joint state and sets a motion groups joint configuration, e.g. to move a motion group. The concept is that an application is using the Motion Service to move a motion group. The Motion Service is commanding the desired joint configuration of a motion group.  Physical motion groups move to this joint configuration.  With physical motion groups, this takes some time and only works if possible.  And you have the *actual* joint state - the current real motion group configuration.  Again, this stream is providing *commanded* joint state! It is __not__ providing the *actual* joint state! (Please file a request - if you need a stream of the *actual* joint state)  When the virtual controller receives joint commands the joint configuration is immediately adapted to match the incoming joint configurations. CAUTION: Incoming joint configurations are not visualized and their velocity limits are not checked. we don\'t even check limits!  Possible use cases are: 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 group.  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.  <!-- theme: danger -->  > **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 {ExternalJointStreamDatapoint} externalJointStreamDatapoint
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  externalJointsStream(cell: string, controller: string, externalJointStreamDatapoint: ExternalJointStreamDatapoint, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<MotionGroupJoints, any, {}>>;
  /**
   * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___  Get the current robot motion group behavior - please see the setter [setMotionGroupBehavior](#/operations/setMotionGroupBehavior) and the enum for details.
   * @summary 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 {number} id The controller specific motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getMotionGroupBehavior(cell: string, controller: string, id: number, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<MotionGroupBehaviorGetter, any, {}>>;
  /**
   * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___  Switch robot motion group behavior.
   * @summary Switch 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 {number} id The controller specific motion-group id.
   * @param {Behavior} [behavior]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  setMotionGroupBehavior(cell: string, controller: string, id: number, behavior?: Behavior, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<object, any, {}>>;
}
/**
 * VirtualRobotModeApi - axios parameter creator
 */
declare const VirtualRobotModeApiAxiosParamCreator: (configuration?: Configuration) => {
  /**
   * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___  Get the cycle time of controller communication in [ms].
   * @summary 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<RequestArgs>;
  /**
   * **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 regardless of the controller type. There, the Emergency Stop state is visible as the `safety_state`.  > **NOTE** > > The Emergency Stop state can only be changed when using virtual robot controllers.
   * @summary Get E-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}
   */
  getEStop: (cell: string, controller: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **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 Operating 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<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___  Activates the Emergency Stop on the virtual robot controller.  Activating the Emergency Stop stops the execution of all motions on virtual and physical robot controllers. To return to normal operation, the Emergency Stop needs to be released.  Use [getCurrentMotionGroupState](#/operations/getCurrentMotionGroupState) to get the Emergency Stop state regardless of the controller type. There, the Emergency Stop state is visible as the `safety_state`.  > **NOTE** > > The Emergency Stop state can only be changed via API when using virtual robot controllers.
   * @summary Push E-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 {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  pushEStop: (cell: string, controller: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___  Releases the Emergency Stop on the virtual robot controller.   Activating the Emergency Stop stops the execution of all motions on virtual and physical robot controllers. To return to normal operation, the Emergency Stop needs to be released.  Use [getCurrentMotionGroupState](#/operations/getCurrentMotionGroupState) to get the Emergency Stop state regardless of the controller type. There, the Emergency Stop state is visible as the `safety_state`.  > **NOTE** > > The Emergency Stop state can only be changed via API when using virtual robot controllers.
   * @summary Release E-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 {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  releaseEStop: (cell: string, controller: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **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 Operating 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 {SetOperationModeModeEnum} mode
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  setOperationMode: (cell: string, controller: string, mode: SetOperationModeModeEnum, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
/**
 * VirtualRobotModeApi - functional programming interface
 */
declare const VirtualRobotModeApiFp: (configuration?: Configuration) => {
  /**
   * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___  Get the cycle time of controller communication in [ms].
   * @summary 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<CycleTime>>;
  /**
   * **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 regardless of the controller type. There, the Emergency Stop state is visible as the `safety_state`.  > **NOTE** > > The Emergency Stop state can only be changed when using virtual robot controllers.
   * @summary Get E-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}
   */
  getEStop(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Flag>>;
  /**
   * **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 Operating 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<OpMode>>;
  /**
   * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___  Activates the Emergency Stop on the virtual robot controller.  Activating the Emergency Stop stops the execution of all motions on virtual and physical robot controllers. To return to normal operation, the Emergency Stop needs to be released.  Use [getCurrentMotionGroupState](#/operations/getCurrentMotionGroupState) to get the Emergency Stop state regardless of the controller type. There, the Emergency Stop state is visible as the `safety_state`.  > **NOTE** > > The Emergency Stop state can only be changed via API when using virtual robot controllers.
   * @summary Push E-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 {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  pushEStop(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<object>>;
  /**
   * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___  Releases the Emergency Stop on the virtual robot controller.   Activating the Emergency Stop stops the execution of all motions on virtual and physical robot controllers. To return to normal operation, the Emergency Stop needs to be released.  Use [getCurrentMotionGroupState](#/operations/getCurrentMotionGroupState) to get the Emergency Stop state regardless of the controller type. There, the Emergency Stop state is visible as the `safety_state`.  > **NOTE** > > The Emergency Stop state can only be changed via API when using virtual robot controllers.
   * @summary Release E-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 {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  releaseEStop(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<object>>;
  /**
   * **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 Operating 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 {SetOperationModeModeEnum} mode
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  setOperationMode(cell: string, controller: string, mode: SetOperationModeModeEnum, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<object>>;
};
/**
 * VirtualRobotModeApi - factory interface
 */
declare const VirtualRobotModeApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
  /**
   * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___  Get the cycle time of controller communication in [ms].
   * @summary 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<CycleTime>;
  /**
   * **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 regardless of the controller type. There, the Emergency Stop state is visible as the `safety_state`.  > **NOTE** > > The Emergency Stop state can only be changed when using virtual robot controllers.
   * @summary Get E-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}
   */
  getEStop(cell: string, controller: string, options?: RawAxiosRequestConfig): AxiosPromise<Flag>;
  /**
   * **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 Operating 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<OpMode>;
  /**
   * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___  Activates the Emergency Stop on the virtual robot controller.  Activating the Emergency Stop stops the execution of all motions on virtual and physical robot controllers. To return to normal operation, the Emergency Stop needs to be released.  Use [getCurrentMotionGroupState](#/operations/getCurrentMotionGroupState) to get the Emergency Stop state regardless of the controller type. There, the Emergency Stop state is visible as the `safety_state`.  > **NOTE** > > The Emergency Stop state can only be changed via API when using virtual robot controllers.
   * @summary Push E-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 {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  pushEStop(cell: string, controller: string, options?: RawAxiosRequestConfig): AxiosPromise<object>;
  /**
   * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___  Releases the Emergency Stop on the virtual robot controller.   Activating the Emergency Stop stops the execution of all motions on virtual and physical robot controllers. To return to normal operation, the Emergency Stop needs to be released.  Use [getCurrentMotionGroupState](#/operations/getCurrentMotionGroupState) to get the Emergency Stop state regardless of the controller type. There, the Emergency Stop state is visible as the `safety_state`.  > **NOTE** > > The Emergency Stop state can only be changed via API when using virtual robot controllers.
   * @summary Release E-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 {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  releaseEStop(cell: string, controller: string, options?: RawAxiosRequestConfig): AxiosPromise<object>;
  /**
   * **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 Operating 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 {SetOperationModeModeEnum} mode
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  setOperationMode(cell: string, controller: string, mode: SetOperationModeModeEnum, options?: RawAxiosRequestConfig): AxiosPromise<object>;
};
/**
 * VirtualRobotModeApi - object-oriented interface
 */
declare class VirtualRobotModeApi extends BaseAPI {
  /**
   * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___  Get the cycle time of controller communication in [ms].
   * @summary 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<CycleTime, any, {}>>;
  /**
   * **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 regardless of the controller type. There, the Emergency Stop state is visible as the `safety_state`.  > **NOTE** > > The Emergency Stop state can only be changed when using virtual robot controllers.
   * @summary Get E-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}
   */
  getEStop(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<Flag, any, {}>>;
  /**
   * **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 Operating 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<OpMode, any, {}>>;
  /**
   * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___  Activates the Emergency Stop on the virtual robot controller.  Activating the Emergency Stop stops the execution of all motions on virtual and physical robot controllers. To return to normal operation, the Emergency Stop needs to be released.  Use [getCurrentMotionGroupState](#/operations/getCurrentMotionGroupState) to get the Emergency Stop state regardless of the controller type. There, the Emergency Stop state is visible as the `safety_state`.  > **NOTE** > > The Emergency Stop state can only be changed via API when using virtual robot controllers.
   * @summary Push E-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 {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  pushEStop(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<object, any, {}>>;
  /**
   * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___  Releases the Emergency Stop on the virtual robot controller.   Activating the Emergency Stop stops the execution of all motions on virtual and physical robot controllers. To return to normal operation, the Emergency Stop needs to be released.  Use [getCurrentMotionGroupState](#/operations/getCurrentMotionGroupState) to get the Emergency Stop state regardless of the controller type. There, the Emergency Stop state is visible as the `safety_state`.  > **NOTE** > > The Emergency Stop state can only be changed via API when using virtual robot controllers.
   * @summary Release E-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 {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  releaseEStop(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<object, any, {}>>;
  /**
   * **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 Operating 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 {SetOperationModeModeEnum} mode
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  setOperationMode(cell: string, controller: string, mode: SetOperationModeModeEnum, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<object, any, {}>>;
}
declare const SetOperationModeModeEnum: {
  readonly OperationModeManual: "OPERATION_MODE_MANUAL";
  readonly OperationModeAuto: "OPERATION_MODE_AUTO";
};
type SetOperationModeModeEnum = typeof SetOperationModeModeEnum[keyof typeof SetOperationModeModeEnum];
/**
 * VirtualRobotSetupApi - axios parameter creator
 */
declare const VirtualRobotSetupApiAxiosParamCreator: (configuration?: Configuration) => {
  /**
   * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___  Adds a coordinate system to the robot controller.  > **NOTE** > > Upon adding or removing a coordinate system, virtual robots are restarted to apply the new configuration. > What happens during restart: > - Robot visualization may temporarily disappear or appear outdated in the UI. > - Coordinate system changes are not immediately visible in visualizations. > - Existing connections to the virtual robot are closed and re-established, which introduces a short delay before NOVA is fully operational again. > > The API call itself **does not wait until the restart and synchronization are complete**. This means that > immediately after a successful response, the new coordinate system may not 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 {CoordinateSystem} coordinateSystem
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  addVirtualRobotCoordinateSystem: (cell: string, controller: string, coordinateSystem: CoordinateSystem, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___  Adds a new [TCP](https://docs.wandelbots.io/latest/vocabulary#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** > Upon adding or updating a TCP, virtual robots are restarted to apply the new configuration. > What happens during restart: > - Robot visualization may temporarily disappear. > - TCP visualization may be delayed or outdated during the first run. > - Existing connections to the virtual robot are closed and re-established, which introduces a short delay before the TCP is available for use. > > The API call itself **does not wait until the restart and synchronization are complete**. This means that > immediately after a successful response, the TCP may not be available for visualization or program execution.
   * @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 {number} id The controller specific motion-group id.
   * @param {RobotTcp} robotTcp
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  addVirtualRobotTcp: (cell: string, controller: string, id: number, robotTcp: RobotTcp, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **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 which use the deleted coordinate system as a reference.  **Important notes:** - When a new coordinate system is added/removed, the **virtual robot is restarted** in the background in order to apply the new configuration. - During this restart:   - Robot visualization may temporarily disappear or appear outdated in the UI.   - coordinate system changes are not immediately visible in visualizations.   - All existing connections to the 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 > **NOTE** > > Upon adding or removing a coordinate system, virtual robots are restarted to apply the new configuration. > What happens during restart: > - Robot visualization may temporarily disappear or appear outdated in the UI. > - Coordinate system changes are not immediately visible in visualizations. > - Existing connections to the virtual robot are closed and re-established, which introduces a short delay before NOVA is fully operational again. > > The API call itself **does not wait until the restart and synchronization are complete**. This means that > immediately after a successful response, the new coordinate system may not be available for visualization or program execution.
   * @summary Remove 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}
   */
  deleteVirtualRobotCoordinateSystem: (cell: string, controller: string, coordinateSystem: string, deleteDependent?: boolean, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **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** > Upon removing a TCP, virtual robots are restarted to apply the new configuration. > What happens during restart: > - Robot visualization may temporarily disappear. > - TCP visualization may be delayed or outdated during the first run. > - Existing connections to the virtual robot are closed and re-established, which introduces a short delay before the TCP is removed. > > The API call itself **does not wait until the restart and synchronization are complete**. This means that immediately after a successful response, the TCP may not be removed.
   * @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 {number} id The controller specific motion-group id.
   * @param {string} tcp The unique identifier of a TCP.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  deleteVirtualRobotTcp: (cell: string, controller: string, id: number, tcp: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **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 {number} id The controller specific motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getVirtualRobotMounting: (cell: string, controller: string, id: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **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}
   */
  listVirtualRobotCoordinateSystems: (cell: string, controller: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___  Lists TCPs of the motion group. An empty TCP list is valid, for example 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 {number} id The controller specific motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  listVirtualRobotTcps: (cell: string, controller: string, id: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
  /**
   * **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 name - An offset in another coordinate system, referenced by the unique identifier of the reference coordinate system.  > **NOTE** > Changing the mounting configuration is considered a configuration change. > > Upon updating the mounting to another coordinate system, virtual robots are restarted to apply the new configuration. > What happens during restart: > - Robot visualization may temporarily disappear or not reflect the updated mounting. > - Motion group state and coordinate system alignment may not be instantly updated. > - Existing connections to the virtual robot are closed and re-established, which introduces a short delay before NOVA is fully operational again. > > The API call itself **does not wait until the restart and synchronization are complete**. This means that > immediately after a successful response, the new mounting may not be available for visualization or program execution.
   * @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 {number} id The controller specific motion-group id.
   * @param {CoordinateSystem} coordinateSystem
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  setVirtualRobotMounting: (cell: string, controller: string, id: number, coordinateSystem: CoordinateSystem, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
/**
 * VirtualRobotSetupApi - functional programming interface
 */
declare const VirtualRobotSetupApiFp: (configuration?: Configuration) => {
  /**
   * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___  Adds a coordinate system to the robot controller.  > **NOTE** > > Upon adding or removing a coordinate system, virtual robots are restarted to apply the new configuration. > What happens during restart: > - Robot visualization may temporarily disappear or appear outdated in the UI. > - Coordinate system changes are not immediately visible in visualizations. > - Existing connections to the virtual robot are closed and re-established, which introduces a short delay before NOVA is fully operational again. > > The API call itself **does not wait until the restart and synchronization are complete**. This means that > immediately after a successful response, the new coordinate system may not 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 {CoordinateSystem} coordinateSystem
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  addVirtualRobotCoordinateSystem(cell: string, controller: string, coordinateSystem: CoordinateSystem, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<object>>;
  /**
   * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___  Adds a new [TCP](https://docs.wandelbots.io/latest/vocabulary#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** > Upon adding or updating a TCP, virtual robots are restarted to apply the new configuration. > What happens during restart: > - Robot visualization may temporarily disappear. > - TCP visualization may be delayed or outdated during the first run. > - Existing connections to the virtual robot are closed and re-established, which introduces a short delay before the TCP is available for use. > > The API call itself **does not wait until the restart and synchronization are complete**. This means that > immediately after a successful response, the TCP may not be available for visualization or program execution.
   * @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 {number} id The controller specific motion-group id.
   * @param {RobotTcp} robotTcp
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  addVirtualRobotTcp(cell: string, controller: string, id: number, robotTcp: RobotTcp, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<object>>;
  /**
   * **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 which use the deleted coordinate system as a reference.  **Important notes:** - When a new coordinate system is added/removed, the **virtual robot is restarted** in the background in order to apply the new configuration. - During this restart:   - Robot visualization may temporarily disappear or appear outdated in the UI.   - coordinate system changes are not immediately visible in visualizations.   - All existing connections to the 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 > **NOTE** > > Upon adding or removing a coordinate system, virtual robots are restarted to apply the new configuration. > What happens during restart: > - Robot visualization may temporarily disappear or appear outdated in the UI. > - Coordinate system changes are not immediately visible in visualizations. > - Existing connections to the virtual robot are closed and re-established, which introduces a short delay before NOVA is fully operational again. > > The API call itself **does not wait until the restart and synchronization are complete**. This means that > immediately after a successful response, the new coordinate system may not be available for visualization or program execution.
   * @summary Remove 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}
   */
  deleteVirtualRobotCoordinateSystem(cell: string, controller: string, coordinateSystem: string, deleteDependent?: boolean, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<object>>;
  /**
   * **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** > Upon removing a TCP, virtual robots are restarted to apply the new configuration. > What happens during restart: > - Robot visualization may temporarily disappear. > - TCP visualization may be delayed or outdated during the first run. > - Existing connections to the virtual robot are closed and re-established, which introduces a short delay before the TCP is removed. > > The API call itself **does not wait until the restart and synchronization are complete**. This means that immediately after a successful response, the TCP may not be removed.
   * @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 {number} id The controller specific motion-group id.
   * @param {string} tcp The unique identifier of a TCP.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  deleteVirtualRobotTcp(cell: string, controller: string, id: number, tcp: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<object>>;
  /**
   * **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 {number} id The controller specific motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getVirtualRobotMounting(cell: string, controller: string, id: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<CoordinateSystem>>;
  /**
   * **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}
   */
  listVirtualRobotCoordinateSystems(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<CoordinateSystems>>;
  /**
   * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___  Lists TCPs of the motion group. An empty TCP list is valid, for example 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 {number} id The controller specific motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  listVirtualRobotTcps(cell: string, controller: string, id: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<RobotTcps>>;
  /**
   * **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 name - An offset in another coordinate system, referenced by the unique identifier of the reference coordinate system.  > **NOTE** > Changing the mounting configuration is considered a configuration change. > > Upon updating the mounting to another coordinate system, virtual robots are restarted to apply the new configuration. > What happens during restart: > - Robot visualization may temporarily disappear or not reflect the updated mounting. > - Motion group state and coordinate system alignment may not be instantly updated. > - Existing connections to the virtual robot are closed and re-established, which introduces a short delay before NOVA is fully operational again. > > The API call itself **does not wait until the restart and synchronization are complete**. This means that > immediately after a successful response, the new mounting may not be available for visualization or program execution.
   * @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 {number} id The controller specific motion-group id.
   * @param {CoordinateSystem} coordinateSystem
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  setVirtualRobotMounting(cell: string, controller: string, id: number, coordinateSystem: CoordinateSystem, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<CoordinateSystem>>;
};
/**
 * VirtualRobotSetupApi - factory interface
 */
declare const VirtualRobotSetupApiFactory: (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** > > Upon adding or removing a coordinate system, virtual robots are restarted to apply the new configuration. > What happens during restart: > - Robot visualization may temporarily disappear or appear outdated in the UI. > - Coordinate system changes are not immediately visible in visualizations. > - Existing connections to the virtual robot are closed and re-established, which introduces a short delay before NOVA is fully operational again. > > The API call itself **does not wait until the restart and synchronization are complete**. This means that > immediately after a successful response, the new coordinate system may not 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 {CoordinateSystem} coordinateSystem
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  addVirtualRobotCoordinateSystem(cell: string, controller: string, coordinateSystem: CoordinateSystem, options?: RawAxiosRequestConfig): AxiosPromise<object>;
  /**
   * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___  Adds a new [TCP](https://docs.wandelbots.io/latest/vocabulary#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** > Upon adding or updating a TCP, virtual robots are restarted to apply the new configuration. > What happens during restart: > - Robot visualization may temporarily disappear. > - TCP visualization may be delayed or outdated during the first run. > - Existing connections to the virtual robot are closed and re-established, which introduces a short delay before the TCP is available for use. > > The API call itself **does not wait until the restart and synchronization are complete**. This means that > immediately after a successful response, the TCP may not be available for visualization or program execution.
   * @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 {number} id The controller specific motion-group id.
   * @param {RobotTcp} robotTcp
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  addVirtualRobotTcp(cell: string, controller: string, id: number, robotTcp: RobotTcp, options?: RawAxiosRequestConfig): AxiosPromise<object>;
  /**
   * **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 which use the deleted coordinate system as a reference.  **Important notes:** - When a new coordinate system is added/removed, the **virtual robot is restarted** in the background in order to apply the new configuration. - During this restart:   - Robot visualization may temporarily disappear or appear outdated in the UI.   - coordinate system changes are not immediately visible in visualizations.   - All existing connections to the 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 > **NOTE** > > Upon adding or removing a coordinate system, virtual robots are restarted to apply the new configuration. > What happens during restart: > - Robot visualization may temporarily disappear or appear outdated in the UI. > - Coordinate system changes are not immediately visible in visualizations. > - Existing connections to the virtual robot are closed and re-established, which introduces a short delay before NOVA is fully operational again. > > The API call itself **does not wait until the restart and synchronization are complete**. This means that > immediately after a successful response, the new coordinate system may not be available for visualization or program execution.
   * @summary Remove 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}
   */
  deleteVirtualRobotCoordinateSystem(cell: string, controller: string, coordinateSystem: string, deleteDependent?: boolean, options?: RawAxiosRequestConfig): AxiosPromise<object>;
  /**
   * **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** > Upon removing a TCP, virtual robots are restarted to apply the new configuration. > What happens during restart: > - Robot visualization may temporarily disappear. > - TCP visualization may be delayed or outdated during the first run. > - Existing connections to the virtual robot are closed and re-established, which introduces a short delay before the TCP is removed. > > The API call itself **does not wait until the restart and synchronization are complete**. This means that immediately after a successful response, the TCP may not be removed.
   * @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 {number} id The controller specific motion-group id.
   * @param {string} tcp The unique identifier of a TCP.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  deleteVirtualRobotTcp(cell: string, controller: string, id: number, tcp: string, options?: RawAxiosRequestConfig): AxiosPromise<object>;
  /**
   * **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 {number} id The controller specific motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getVirtualRobotMounting(cell: string, controller: string, id: number, options?: RawAxiosRequestConfig): AxiosPromise<CoordinateSystem>;
  /**
   * **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}
   */
  listVirtualRobotCoordinateSystems(cell: string, controller: string, options?: RawAxiosRequestConfig): AxiosPromise<CoordinateSystems>;
  /**
   * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___  Lists TCPs of the motion group. An empty TCP list is valid, for example 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 {number} id The controller specific motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  listVirtualRobotTcps(cell: string, controller: string, id: number, options?: RawAxiosRequestConfig): AxiosPromise<RobotTcps>;
  /**
   * **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 name - An offset in another coordinate system, referenced by the unique identifier of the reference coordinate system.  > **NOTE** > Changing the mounting configuration is considered a configuration change. > > Upon updating the mounting to another coordinate system, virtual robots are restarted to apply the new configuration. > What happens during restart: > - Robot visualization may temporarily disappear or not reflect the updated mounting. > - Motion group state and coordinate system alignment may not be instantly updated. > - Existing connections to the virtual robot are closed and re-established, which introduces a short delay before NOVA is fully operational again. > > The API call itself **does not wait until the restart and synchronization are complete**. This means that > immediately after a successful response, the new mounting may not be available for visualization or program execution.
   * @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 {number} id The controller specific motion-group id.
   * @param {CoordinateSystem} coordinateSystem
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  setVirtualRobotMounting(cell: string, controller: string, id: number, coordinateSystem: CoordinateSystem, options?: RawAxiosRequestConfig): AxiosPromise<CoordinateSystem>;
};
/**
 * VirtualRobotSetupApi - object-oriented interface
 */
declare class VirtualRobotSetupApi extends BaseAPI {
  /**
   * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___  Adds a coordinate system to the robot controller.  > **NOTE** > > Upon adding or removing a coordinate system, virtual robots are restarted to apply the new configuration. > What happens during restart: > - Robot visualization may temporarily disappear or appear outdated in the UI. > - Coordinate system changes are not immediately visible in visualizations. > - Existing connections to the virtual robot are closed and re-established, which introduces a short delay before NOVA is fully operational again. > > The API call itself **does not wait until the restart and synchronization are complete**. This means that > immediately after a successful response, the new coordinate system may not 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 {CoordinateSystem} coordinateSystem
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  addVirtualRobotCoordinateSystem(cell: string, controller: string, coordinateSystem: CoordinateSystem, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<object, any, {}>>;
  /**
   * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___  Adds a new [TCP](https://docs.wandelbots.io/latest/vocabulary#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** > Upon adding or updating a TCP, virtual robots are restarted to apply the new configuration. > What happens during restart: > - Robot visualization may temporarily disappear. > - TCP visualization may be delayed or outdated during the first run. > - Existing connections to the virtual robot are closed and re-established, which introduces a short delay before the TCP is available for use. > > The API call itself **does not wait until the restart and synchronization are complete**. This means that > immediately after a successful response, the TCP may not be available for visualization or program execution.
   * @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 {number} id The controller specific motion-group id.
   * @param {RobotTcp} robotTcp
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  addVirtualRobotTcp(cell: string, controller: string, id: number, robotTcp: RobotTcp, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<object, any, {}>>;
  /**
   * **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 which use the deleted coordinate system as a reference.  **Important notes:** - When a new coordinate system is added/removed, the **virtual robot is restarted** in the background in order to apply the new configuration. - During this restart:   - Robot visualization may temporarily disappear or appear outdated in the UI.   - coordinate system changes are not immediately visible in visualizations.   - All existing connections to the 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 > **NOTE** > > Upon adding or removing a coordinate system, virtual robots are restarted to apply the new configuration. > What happens during restart: > - Robot visualization may temporarily disappear or appear outdated in the UI. > - Coordinate system changes are not immediately visible in visualizations. > - Existing connections to the virtual robot are closed and re-established, which introduces a short delay before NOVA is fully operational again. > > The API call itself **does not wait until the restart and synchronization are complete**. This means that > immediately after a successful response, the new coordinate system may not be available for visualization or program execution.
   * @summary Remove 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}
   */
  deleteVirtualRobotCoordinateSystem(cell: string, controller: string, coordinateSystem: string, deleteDependent?: boolean, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<object, any, {}>>;
  /**
   * **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** > Upon removing a TCP, virtual robots are restarted to apply the new configuration. > What happens during restart: > - Robot visualization may temporarily disappear. > - TCP visualization may be delayed or outdated during the first run. > - Existing connections to the virtual robot are closed and re-established, which introduces a short delay before the TCP is removed. > > The API call itself **does not wait until the restart and synchronization are complete**. This means that immediately after a successful response, the TCP may not be removed.
   * @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 {number} id The controller specific motion-group id.
   * @param {string} tcp The unique identifier of a TCP.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  deleteVirtualRobotTcp(cell: string, controller: string, id: number, tcp: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<object, any, {}>>;
  /**
   * **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 {number} id The controller specific motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  getVirtualRobotMounting(cell: string, controller: string, id: number, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<CoordinateSystem, any, {}>>;
  /**
   * **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}
   */
  listVirtualRobotCoordinateSystems(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<CoordinateSystems, any, {}>>;
  /**
   * **Required permissions:** `can_operate_virtual_controllers` - Operate and configure virtual controllers ___  Lists TCPs of the motion group. An empty TCP list is valid, for example 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 {number} id The controller specific motion-group id.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  listVirtualRobotTcps(cell: string, controller: string, id: number, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<RobotTcps, any, {}>>;
  /**
   * **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 name - An offset in another coordinate system, referenced by the unique identifier of the reference coordinate system.  > **NOTE** > Changing the mounting configuration is considered a configuration change. > > Upon updating the mounting to another coordinate system, virtual robots are restarted to apply the new configuration. > What happens during restart: > - Robot visualization may temporarily disappear or not reflect the updated mounting. > - Motion group state and coordinate system alignment may not be instantly updated. > - Existing connections to the virtual robot are closed and re-established, which introduces a short delay before NOVA is fully operational again. > > The API call itself **does not wait until the restart and synchronization are complete**. This means that > immediately after a successful response, the new mounting may not be available for visualization or program execution.
   * @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 {number} id The controller specific motion-group id.
   * @param {CoordinateSystem} coordinateSystem
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   */
  setVirtualRobotMounting(cell: string, controller: string, id: number, coordinateSystem: CoordinateSystem, options?: RawAxiosRequestConfig): Promise<_$axios.AxiosResponse<CoordinateSystem, any, {}>>;
}
//#endregion
export { AbbController, AbbControllerEgmServer, AbbControllerKindEnum, ActivateLicenseRequest, AddRequest, AllJointPositionsRequest, AllJointPositionsResponse, ApiVersion, App, ApplicationApi, ApplicationApiAxiosParamCreator, ApplicationApiFactory, ApplicationApiFp, ArrayInput, ArrayOutput, BASE_PATH, BaseAPI, Behavior, BlendingAuto, BlendingAutoBlendingNameEnum, BlendingPosition, BlendingPositionBlendingNameEnum, Box, Box2, Box2BoxTypeEnum, Box2ShapeTypeEnum, Box3, Box3ShapeTypeEnum, Box3TypeEnum, BoxTypeEnum, COLLECTION_FORMATS, Capsule, Capsule2, Capsule2ShapeTypeEnum, Capsule3, Capsule3ShapeTypeEnum, Capture, Cell, CellApi, CellApiAxiosParamCreator, CellApiFactory, CellApiFp, Circle, CodeWithArguments, CollectionValue, Collider, ColliderInput, ColliderOutput, ColliderOutputShape, ColliderShape, Collision, CollisionContact, CollisionMotionGroup, CollisionMotionGroupAssembly, CollisionRobotConfigurationInput, CollisionRobotConfigurationOutput, CollisionScene, CollisionSceneAssembly, Command, CommandSettings, Comparator, Compound, Configuration, ConfigurationParameters, ContainerEnvironmentInner, ContainerImage, ContainerImageSecretsInner, ContainerResources, ContainerStorage, ControllerApi, ControllerApiAxiosParamCreator, ControllerApiFactory, ControllerApiFp, ControllerCapabilities, ControllerIOsApi, ControllerIOsApiAxiosParamCreator, ControllerIOsApiFactory, ControllerIOsApiFp, ControllerInstance, ControllerInstanceList, ConvexHull, ConvexHull2, ConvexHull2ShapeTypeEnum, ConvexHull3, ConvexHull3ShapeTypeEnum, CoordinateSystem, CoordinateSystems, CoordinateSystemsApi, CoordinateSystemsApiAxiosParamCreator, CoordinateSystemsApiFactory, CoordinateSystemsApiFp, CreateDeviceRequestInner, CreateProgramRun200Response, CreateProgramRunRequest, CreateTrigger200Response, CreateTriggerRequest, CubicSpline, CubicSplineCubicSplineParameter, CubicSplineParameter, CycleTime, Cylinder, Cylinder2, Cylinder2ShapeTypeEnum, Cylinder3, Cylinder3ShapeTypeEnum, DHParameter, DeviceConfigurationApi, DeviceConfigurationApiAxiosParamCreator, DeviceConfigurationApiFactory, DeviceConfigurationApiFp, Direction, DirectionJoggingRequest, ExecuteTrajectoryRequest, ExecuteTrajectoryResponse, ExecutionResult, ExternalJointStreamDatapoint, ExternalJointStreamDatapointValue, FanucController, FanucControllerKindEnum, FeedbackCollision, FeedbackCollisionErrorFeedbackNameEnum, FeedbackJointLimitExceeded, FeedbackJointLimitExceededErrorFeedbackNameEnum, FeedbackOutOfWorkspace, FeedbackOutOfWorkspaceErrorFeedbackNameEnum, FeedbackSingularity, FeedbackSingularityErrorFeedbackNameEnum, Flag, ForceVector, Geometry, GetAllProgramRuns200Response, GetAllTriggers200Response, GetDefaultLinkChainMotionGroupModelEnum, GetModeResponse, GetTrajectoryResponse, GetTrajectorySampleResponse, GoogleProtobufAny, HTTPExceptionResponse, HTTPValidationError, HTTPValidationError2, IO, IODescription, IODescriptionTypeEnum, IODescriptionUnitEnum, IODescriptionValueTypeEnum, IODirectionEnum, IOValue, IOs, ImageCredentials, InfoServiceCapabilities, InitializeMovementRequest, InitializeMovementResponse, InitializeMovementResponseInitResponse, JoggingResponse, JoggingResponseMovementStateEnum, JoggingServiceCapabilities, JointJoggingRequest, JointLimit, JointLimitExceeded, JointLimitJointEnum, JointPositionRequest, JointTrajectory, Joints, KinematicServiceCapabilities, KukaController, KukaControllerKindEnum, KukaControllerRsiServer, LibraryProgramApi, LibraryProgramApiAxiosParamCreator, LibraryProgramApiFactory, LibraryProgramApiFp, LibraryProgramMetadataApi, LibraryProgramMetadataApiAxiosParamCreator, LibraryProgramMetadataApiFactory, LibraryProgramMetadataApiFp, LibraryRecipeApi, LibraryRecipeApiAxiosParamCreator, LibraryRecipeApiFactory, LibraryRecipeApiFp, LibraryRecipeMetadataApi, LibraryRecipeMetadataApiAxiosParamCreator, LibraryRecipeMetadataApiFactory, LibraryRecipeMetadataApiFp, License, LicenseApi, LicenseApiAxiosParamCreator, LicenseApiFactory, LicenseApiFp, LicenseStatus, LicenseStatusEnum, LimitSettings, LimitsOverride, ListDevices200ResponseInner, ListIODescriptionsResponse, ListIOValuesResponse, ListPayloadsResponse, ListProgramMetadataResponse, ListRecipeMetadataResponse, ListResponse, ListTcpsResponse, Manufacturer, ModeChangeResponse, ModelError, MotionApi, MotionApiAxiosParamCreator, MotionApiFactory, MotionApiFp, MotionCommand, MotionCommandBlending, MotionCommandPath, MotionGroupApi, MotionGroupApiAxiosParamCreator, MotionGroupApiFactory, MotionGroupApiFp, MotionGroupBehaviorGetter, MotionGroupInfo, MotionGroupInfos, MotionGroupInfosApi, MotionGroupInfosApiAxiosParamCreator, MotionGroupInfosApiFactory, MotionGroupInfosApiFp, MotionGroupInstance, MotionGroupInstanceList, MotionGroupJoggingApi, MotionGroupJoggingApiAxiosParamCreator, MotionGroupJoggingApiFactory, MotionGroupJoggingApiFp, MotionGroupJoints, MotionGroupKinematicApi, MotionGroupKinematicApiAxiosParamCreator, MotionGroupKinematicApiFactory, MotionGroupKinematicApiFp, MotionGroupPhysical, MotionGroupSpecification, MotionGroupState, MotionGroupStateJointLimitReached, MotionGroupStateResponse, MotionId, MotionIdsListResponse, MotionVector, Mounting, MoveRequest, MoveResponse, MoveToTrajectoryViaJointPTPRequest, Movement, MovementError, MovementErrorError, MovementMovement, OpMode, OpModeModeEnum, OpcuaNodeValueTriggerConfig, OpcuaNodeValueTriggerConfigNodeValue, OptimizerSetup, OutOfWorkspace, Path, PathCartesianPTP, PathCartesianPTPPathDefinitionNameEnum, PathCircle, PathCirclePathDefinitionNameEnum, PathCubicSpline, PathCubicSplinePathDefinitionNameEnum, PathJointPTP, PathJointPTPPathDefinitionNameEnum, PathLine, PathLinePathDefinitionNameEnum, PauseMovementRequest, PauseMovementResponse, PauseMovementResponsePauseResponse, PauseOnIO, Payload, PlanCollisionFreePTPRequest, PlanCollisionFreePTPRequestTarget, PlanFailedOnTrajectoryResponse, PlanFailedResponse, PlanRequest, PlanResponse, PlanSuccessfulResponse, PlanTrajectoryFailedResponse, PlanTrajectoryFailedResponseErrorFeedback, PlanTrajectoryRequest, PlanTrajectoryResponse, PlanTrajectoryResponseResponse, Plane2, Plane2ShapeTypeEnum, Plane3, Plane3ShapeTypeEnum, PlannedMotion, PlannerPose, PlanningLimits, PlanningLimitsLimitRange, PlaybackSpeedRequest, PlaybackSpeedResponse, PlaybackSpeedResponsePlaybackSpeedResponse, PointCloud, Pose, Pose2, ProgramApi, ProgramApiAxiosParamCreator, ProgramApiFactory, ProgramApiFp, ProgramMetadata, ProgramOperatorApi, ProgramOperatorApiAxiosParamCreator, ProgramOperatorApiFactory, ProgramOperatorApiFp, ProgramRun, ProgramRunObject, ProgramRunState, ProgramRunnerReference, ProgramValuesApi, ProgramValuesApiAxiosParamCreator, ProgramValuesApiFactory, ProgramValuesApiFp, PyjectoryDatatypesCorePose, PyjectoryDatatypesSerializerOrientation, PyjectoryDatatypesSerializerPose, PyjectoryDatatypesSerializerPosition, PyripheryEtcdETCDConfiguration, PyripheryHardwareIsaacIsaacConfiguration, PyripheryOpcuaOPCUAConfiguration, PyripheryPyraeControllerControllerConfiguration, PyripheryPyraeRobotRobotConfiguration, PyripheryPyraeRobotRobotConfigurationTypeEnum, PyripheryRoboticsConfigurableCollisionSceneConfigurableCollisionSceneConfigurationInput, PyripheryRoboticsConfigurableCollisionSceneConfigurableCollisionSceneConfigurationOutput, PyripheryRoboticsRobotcellTimerConfiguration, PyripheryRoboticsRobotcellTimerConfigurationTypeEnum, PyripheryRoboticsSimulationRobotWithViewOpen3dConfiguration, PyripheryRoboticsSimulationSimulatedIOConfiguration, PyripheryRoboticsSimulationSimulatedOPCUAConfiguration, Quaternion, RecipeMetadata, Rectangle, Rectangle2, Rectangle2ShapeTypeEnum, Rectangle3, Rectangle3ShapeTypeEnum, RectangularCapsule, RectangularCapsule2, RectangularCapsule2ShapeTypeEnum, RectangularCapsule3, RectangularCapsule3ShapeTypeEnum, ReleaseChannel, Request, Request1, RequestArgs, RequiredError, ResponseGetValueProgramsValuesKeyGet, ResponseGetValuesProgramsValuesGetValue, RobotController, RobotControllerConfiguration, RobotControllerState, RobotControllerStateOperationModeEnum, RobotControllerStateSafetyStateEnum, RobotLinkGeometry, RobotState, RobotSystemMode, RobotTcp, RobotTcps, RotationAngleTypes, RotationAngles, SafetyConfiguration, SafetySetup, SafetySetupSafetySettings, SafetySetupSafetySettingsSafetyStateEnum, SafetySetupSafetyZone, SafetyZone, SafetyZoneLimits, SafetyZoneViolation, ServiceStatus, ServiceStatusPhase, ServiceStatusSeverity, ServiceStatusStatus, SetDefaultModeModeEnum, SetIO, SetOperationModeModeEnum, SetPlaybackSpeed, SingleJointLimit, SingleJointLimitJointEnum, Singularity, SingularitySingularityTypeEnum, SingularityTypeEnum, Sphere, Sphere2, Sphere2ShapeTypeEnum, Sphere3, Sphere3ShapeTypeEnum, Standstill, StandstillReason, StandstillStandstill, StartMovementRequest, StartOnIO, Status, StopResponse, StopResponseStopCodeEnum, StoreCollisionComponentsApi, StoreCollisionComponentsApiAxiosParamCreator, StoreCollisionComponentsApiFactory, StoreCollisionComponentsApiFp, StoreCollisionScenesApi, StoreCollisionScenesApiAxiosParamCreator, StoreCollisionScenesApiFactory, StoreCollisionScenesApiFp, StoreObjectApi, StoreObjectApiAxiosParamCreator, StoreObjectApiFactory, StoreObjectApiFp, StoreValue, StreamMoveBackward, StreamMoveForward, StreamMovePlaybackSpeed, StreamMoveRequest, StreamMoveResponse, StreamMoveToTrajectory, StreamStop, SystemApi, SystemApiAxiosParamCreator, SystemApiFactory, SystemApiFp, TcpPose, TcpPoseRequest, ToolGeometry, TrajectorySample, TriggerObject, TriggerType, UniversalrobotsController, UniversalrobotsControllerKindEnum, UpdateNovaVersionRequest, UpdateProgramMetadataRequest, UpdateRecipeMetadataRequest, UpdateTriggerRequest, ValidationError, ValidationError2, ValidationError2LocInner, ValidationErrorLocInner, Value, Vector3d, VersionApi, VersionApiAxiosParamCreator, VersionApiFactory, VersionApiFp, VersionNumber, VirtualController, VirtualControllerKindEnum, VirtualControllerTypes, VirtualRobotApi, VirtualRobotApiAxiosParamCreator, VirtualRobotApiFactory, VirtualRobotApiFp, VirtualRobotBehaviorApi, VirtualRobotBehaviorApiAxiosParamCreator, VirtualRobotBehaviorApiFactory, VirtualRobotBehaviorApiFp, VirtualRobotConfiguration, VirtualRobotModeApi, VirtualRobotModeApiAxiosParamCreator, VirtualRobotModeApiFactory, VirtualRobotModeApiFp, VirtualRobotSetupApi, VirtualRobotSetupApiAxiosParamCreator, VirtualRobotSetupApiFactory, VirtualRobotSetupApiFp, WaitForIOEventComparisonTypeEnum, YaskawaController, YaskawaControllerKindEnum, operationServerMap };