@wandelbots/nova-js/dist/Nova-Bd4sVjdb.d.mts

Official JS client for the Wandelbots API

import { n as MockNovaInstance, t as AutoReconnectingWebsocket } from "./AutoReconnectingWebsocket-BSt-vnzX.mjs";
import * as _$axios from "axios";
import { AxiosInstance, AxiosPromise, RawAxiosRequestConfig } from "axios";

//#region node_modules/.pnpm/@wandelbots+nova-api@26.5.1/node_modules/@wandelbots/nova-api/dist/v2/index.d.ts
//#region v2/configuration.d.ts
/**
 * Wandelbots NOVA API
 * Interact with robots in an easy and intuitive way.
 *
 * The version of the OpenAPI document: 2.5.0
 *
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
 * https://openapi-generator.tech
 * Do not edit the class manually.
 */
interface AWSv4Configuration {
  options?: {
    region?: string;
    service?: string;
  };
  credentials?: {
    accessKeyId?: string;
    secretAccessKey?: string;
    sessionToken?: string;
  };
}
interface ConfigurationParameters {
  apiKey?: string | Promise<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 v2/base.d.ts
declare const BASE_PATH: string;
declare const COLLECTION_FORMATS: {
  csv: string;
  ssv: string;
  tsv: string;
  pipes: string;
};
interface RequestArgs {
  url: string;
  options: RawAxiosRequestConfig;
}
declare class BaseAPI {
  protected basePath: string;
  protected axios: AxiosInstance;
  protected configuration: Configuration | undefined;
  constructor(configuration?: Configuration, basePath?: string, axios?: AxiosInstance);
}
declare class RequiredError extends Error {
  field: string;
  constructor(field: string, msg?: string);
}
interface ServerMap {
  [key: string]: {
    url: string;
    description: string;
  }[];
}
declare const operationServerMap: ServerMap; //#endregion
//#region v2/api.d.ts
interface AbbConfdata {
  /**
   * Quadrant number for axis 1. Quadrant n means the axis angle is in the interval [n*90deg, (n+1)*90deg). Can be negative.
   */
  'cf1': number;
  /**
   * Quadrant number for axis 4. Quadrant n means the axis angle is in the interval [n*90deg, (n+1)*90deg). Can be negative.
   */
  'cf4': number;
  /**
   * Quadrant number for axis 6. Quadrant n means the axis angle is in the interval [n*90deg, (n+1)*90deg). Can be negative.
   */
  'cf6': number;
  /**
   * 3 branch bits composing the kinematic configuration: - Bit 0 (Wrist): 0 = positive axis 5 angle `NO_FLIP`, 1 = negative `FLIP`. - Bit 1 (Elbow): 0 = in front of lower arm `DOWN`, 1 = behind `UP`. - Bit 2 (Shoulder): 0 = in front of axis 1 `LEFT`, 1 = behind `RIGHT`.
   */
  'cfx': number;
}
/**
 * A pose combined with ABB kinematic configuration data, `confdata`.
 */
interface AbbConfiguredPose {
  'pose': AbbPose;
  'confdata': AbbConfdata;
}
/**
 * The configuration of a physical ABB robot controller has to contain IP address. Additionally an EGM server configuration has to be specified in order to control the robot. Deploying the server is a functionality of this API.
 */
interface AbbController {
  'kind': AbbControllerKindEnum;
  'controller_ip': string;
  /**
   * Default values: 80, 443. If custom value is set, field is required.
   */
  'controller_port': number;
  'egm_server': AbbControllerEgmServer;
}
declare const AbbControllerKindEnum: {
  readonly AbbController: "AbbController";
};
type AbbControllerKindEnum = typeof AbbControllerKindEnum[keyof typeof AbbControllerKindEnum];
/**
 * The EGM server runs inside of the cell, thus its IP must be in the same network as the \'controller_ip\'
 */
interface AbbControllerEgmServer {
  'ip': string;
  'port': number;
}
/**
 * ABB pose with position (`x`, `y`, `z`) and quaternion orientation (`q1`, `q2`, `q3`, `q4`).
 */
interface AbbPose {
  'x': number;
  'y': number;
  'z': number;
  'q1': number;
  'q2': number;
  'q3': number;
  'q4': number;
}
/**
 * The authentication token to fetch the license from the license server.
 */
interface ActivateLicenseRequest {
  'owner_refresh_token': string;
}
interface AddTrajectoryError {
  'message'?: string;
  /**
   * - The location is a scalar value that defines a position along a path, typically ranging from 0 to `n`,   where `n` denotes the number of motion commands - Each integer value of the location corresponds to a specific motion command,   while non-integer values interpolate positions within the segments. - The location is calculated from the joint path
   */
  'location'?: number;
  'data'?: AddTrajectoryErrorData;
}
/**
 * @type AddTrajectoryErrorData
 */
type AddTrajectoryErrorData = {
  kind: 'CollisionError';
} & CollisionError | {
  kind: 'InconsistentTrajectorySizeError';
} & InconsistentTrajectorySizeError | {
  kind: 'InvalidDofError';
} & InvalidDofError | {
  kind: 'JointLimitExceededError';
} & JointLimitExceededError | {
  kind: 'NanValueError';
} & NanValueError | {
  kind: 'TcpRequiredError';
} & TcpRequiredError | {
  kind: 'TorqueExceededError';
} & TorqueExceededError;
interface AddTrajectoryRequest {
  /**
   * Unique identifier of the motion group the trajectory is planned for.
   */
  'motion_group': string;
  /**
   * The trajectory consisting of a list of joint positions and an equal number of corresponding timestamps.
   */
  'trajectory': JointTrajectory;
  /**
   * Unique identifier of the tool the trajectory is planned for.
   */
  'tcp'?: string;
}
/**
 * The response signals if the trajectory is valid or faulty, resulting in an executable, partially executable or non-executable state. - valid trajectory: response contains only the unique identifier for the trajectory - trajectory has error on path: response contains the unique identifier for the trajectory and information about the failure. It is executable up to the point of failure. - trajectory has error at start or invalid data: response contains only information about the failure.  To execute the trajectory, use the unique identifier for calling [executeTrajectory](#/operations/executeTrajectory). If you want to validate your trajectory before execution, execute it with a virtual motion group and check the state in the response stream of [executeTrajectory](#/operations/executeTrajectory).
 */
interface AddTrajectoryResponse {
  /**
   * The unique identifier of the trajectory. Use this identifier to execute the trajectory with the [executeTrajectory](#/operations/executeTrajectory) endpoint.
   */
  'trajectory'?: string;
  /**
   * Always check this field first. If this field is present, the trajectory has an error and is only partially or not executable.
   */
  'error'?: AddTrajectoryError;
}
/**
 * @type AddVirtualControllerMotionGroupRequest
 * Request body wrapper for `addVirtualControllerMotionGroup`. Allow callers to either reference a predefined motion group model or upload a full JSON configuration that the backend extracts into a motion group description.
 */
type AddVirtualControllerMotionGroupRequest = MotionGroupFromJson | MotionGroupFromType;
interface ApiVersion {
  /**
   * The version of the API.
   */
  'version': string;
}
/**
 * An App is defined by a webserver, packed inside a container, serving a web-application.
 */
interface App {
  /**
   * The name of the provided application. The name must be unique within the cell and is used as a identifier for addressing the application in all API calls , e.g., when updating the application.  It also defines where the application is reachable (/$cell/$name).  It must be a valid k8s label name as defined by [RFC 1035](https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#rfc-1035-label-names).
   */
  'name': string;
  /**
   * The path of the icon for the App (/$cell/$name/$app_icon).
   */
  'app_icon': string;
  'container_image': ContainerImage;
  /**
   * The port the containerized webserver is listening on.
   */
  'port'?: number;
  /**
   * A list of environment variables with name and their value. These can be used to configure the containerized application, and turn features on or off.
   */
  'environment'?: Array<ContainerEnvironmentInner>;
  'storage'?: ContainerStorage;
  'resources'?: ContainerResources;
  /**
   * Defines the URL path suffix used to check the application\'s health status. The complete health check URL is constructed as `/$cell/$name/$health_path`. When the application is working as expected, the endpoint returns an HTTP 200 status code.  If not specified, the system will default to using the application icon path suffix (the value of `app_icon`) as the health check endpoint, resulting in `/$cell/$name/$app_icon`.  If the health check fails (no response or non-200 status code), the system will automatically restart the application container to restore service.
   */
  'health_path'?: string;
  /**
   * Defines the URL path suffix used to provide an endpoint for diagnosis data collection. The complete diagnosis check URL is constructed as `/$cell/$name/$diagnosis_path`.  The endpoint is called when a diagnosis package is requested via the diagnosis API. The endpoint needs to return the data within a zip file `application/zip` response.
   */
  'diagnosis_path'?: string;
}
/**
 * Per-joint constraint beyond the 8 inverse kinematic branches. Maps a joint index (0-based) to an allowed angle interval (in radians).
 */
interface AxisRange {
  'axis': number;
  'range': LimitRange;
}
/**
 * ## BEHAVIOR_AUTOMATIC This is the default behavior. The motion groups of the controller take commanded joint configuration as actual joint state. Configures the compliance of the virtual robot with the normal ControllerState cycle time. If set, the virtual robot will act like a physical one, e.g., with a cycle time of 8ms to respond to a new joint state command. ## BEHAVIOR_AUTOMATIC_NOT_COMPLY_WITH_CYCLETIME Configures the compliance of the virtual robot with the normal ControllerState cycle time. If set, the robot will respond as fast as possible, limited only by software execution speed. Because of that, the execution of a movement requires less time than with BEHAVIOR_AUTOMATIC. ## BEHAVIOR_EXTERNAL_SOURCE The external client is the only source of actual joint state changes. This mode is used to enable third party software indicating the current joint state via [externalJointsStream](#/operations/externalJointsStream).
 */
declare const Behavior: {
  readonly BehaviorAutomatic: "BEHAVIOR_AUTOMATIC";
  readonly BehaviorAutomaticNotComplyWithCycletime: "BEHAVIOR_AUTOMATIC_NOT_COMPLY_WITH_CYCLETIME";
  readonly BehaviorExternalSource: "BEHAVIOR_EXTERNAL_SOURCE";
};
type Behavior = typeof Behavior[keyof typeof Behavior];
interface BlendingAuto {
  /**
   * Auto-blending is used to keep a constant velocity when blending between two motion commands. To use auto-blending, the TCP velocity limit must be set. It changes the TCP path around the target point of the motion command. The value represents the percentage of the original velocity. Auto-blending is always performed in cartesian space.
   */
  'min_velocity_in_percent'?: number;
  'blending_name': BlendingAutoBlendingNameEnum;
}
declare const BlendingAutoBlendingNameEnum: {
  readonly BlendingAuto: "BlendingAuto";
};
type BlendingAutoBlendingNameEnum = typeof BlendingAutoBlendingNameEnum[keyof typeof BlendingAutoBlendingNameEnum];
interface BlendingPosition {
  /**
   * Specifies the maximum radius in [mm] around the motion command\'s target point where the TCP path can be altered to blend the motion command into the following one. If auto-blending blends too much of the resulting trajectory, use position-blending to restrict the blending zone radius.
   */
  'position_zone_radius'?: number;
  /**
   * Specifies the maximum blending percentage based on the trajectory length in position space around the motion command\'s target point. Percentage indicated in 0.0 - 100.0.
   */
  'position_zone_percentage'?: number;
  /**
   * Specifies the maximum radius in [rad] for orientation blending around the motion command\'s target orientation. At the target\'s orientation, the TCP orientation can be altered to blend into the following motion.
   */
  'orientation_zone_radius'?: number;
  /**
   * Specifies the maximum blending percentage for orientation blending based on the trajectory length in orientation space. Percentage indicated in 0.0 - 100.0.
   */
  'orientation_zone_percentage'?: number;
  /**
   * Specifies the maximum radius in [rad] for joint space blending around the motion command\'s target joint configuration. At the target joint configuration, the joint path can be altered to blend into the following motion.
   */
  'joints_zone_radius'?: number;
  /**
   * Specifies the maximum blending percentage for joint space blending based on the trajectory length in joint space. Percentage indicated in 0.0 to 100.0.
   */
  'joints_zone_percentage'?: number;
  /**
   * Defines the space in which blending is performed.
   */
  'space'?: BlendingSpace;
  'blending_name': BlendingPositionBlendingNameEnum;
}
declare const BlendingPositionBlendingNameEnum: {
  readonly BlendingPosition: "BlendingPosition";
};
type BlendingPositionBlendingNameEnum = typeof BlendingPositionBlendingNameEnum[keyof typeof BlendingPositionBlendingNameEnum];
/**
 * Defines the space in which blending is performed. - `JOINT`: Zone blending is performed in joint space - `CARTESIAN`: Auto-blending is performed in cartesian space
 */
declare const BlendingSpace: {
  readonly Joint: "JOINT";
  readonly Cartesian: "CARTESIAN";
};
type BlendingSpace = typeof BlendingSpace[keyof typeof BlendingSpace];
/**
 * Value of a digital input/output.
 */
interface BooleanValue {
  'value': boolean;
  'value_type': BooleanValueValueTypeEnum;
}
declare const BooleanValueValueTypeEnum: {
  readonly Boolean: "boolean";
};
type BooleanValueValueTypeEnum = typeof BooleanValueValueTypeEnum[keyof typeof BooleanValueValueTypeEnum];
/**
 * Defines a cuboid shape centred around an origin.  If a margin is applied to the box type full, it is added to all size values. The shape will keep its edges. The hollow box type consists of thin boxes that make up its walls. If a margin is applied to the box type hollow, its size values are reduced by the margin.
 */
interface Box {
  'shape_type': BoxShapeTypeEnum;
  /**
   * The dimension in x-direction in [mm].
   */
  'size_x': number;
  /**
   * The dimension in y-direction in [mm].
   */
  'size_y': number;
  /**
   * The dimension in z-direction in [mm].
   */
  'size_z': number;
  /**
   * The box type defines if the box is hollow or full.
   */
  'box_type': BoxBoxTypeEnum;
}
declare const BoxShapeTypeEnum: {
  readonly Box: "box";
};
type BoxShapeTypeEnum = typeof BoxShapeTypeEnum[keyof typeof BoxShapeTypeEnum];
declare const BoxBoxTypeEnum: {
  readonly Hollow: "HOLLOW";
  readonly Full: "FULL";
};
type BoxBoxTypeEnum = typeof BoxBoxTypeEnum[keyof typeof BoxBoxTypeEnum];
interface BusIODescription {
  /**
   * Unique identifier of the input/output.
   */
  'io': string;
  /**
   * Name of the input/output. Customize it using the respective BUS service, e.g., [addProfinetIO](#/operations/addProfinetIO) for PROFINET service.
   */
  'name': string;
  'direction': IODirection;
  'value_type': IOValueType;
  'unit'?: UnitType;
  'min'?: IOBoundary;
  'max'?: IOBoundary;
}
/**
 * MODBUS client inputs/outputs service configuration.
 */
interface BusIOModbusClient {
  'bus_type': BusIOModbusClientBusTypeEnum;
  'network': BusIOModbusTCPClient;
}
declare const BusIOModbusClientBusTypeEnum: {
  readonly ModbusClient: "modbus_client";
};
type BusIOModbusClientBusTypeEnum = typeof BusIOModbusClientBusTypeEnum[keyof typeof BusIOModbusClientBusTypeEnum];
/**
 * MODBUS server inputs/outputs service configuration.
 */
interface BusIOModbusServer {
  'bus_type': BusIOModbusServerBusTypeEnum;
  'network': BusIOModbusTCPServer;
  /**
   * Number of connections this MODBUS server can handle.
   */
  'connections': number;
  /**
   * Size of the Coils memory area.
   */
  'coils_size': number;
  /**
   * Size of the Discrete Inputs memory area.
   */
  'discrete_inputs_size': number;
  /**
   * Size of the Holding Registers memory area.
   */
  'holding_registers_size': number;
  /**
   * Size of the Input Registers memory area.
   */
  'input_registers_size': number;
}
declare const BusIOModbusServerBusTypeEnum: {
  readonly ModbusServer: "modbus_server";
};
type BusIOModbusServerBusTypeEnum = typeof BusIOModbusServerBusTypeEnum[keyof typeof BusIOModbusServerBusTypeEnum];
interface BusIOModbusTCPClient {
  'network_type'?: BusIOModbusTCPClientNetworkTypeEnum;
  /**
   * IP address of the MODBUS server to establish communication with.
   */
  'ip': string;
  /**
   * Port number of the MODBUS server to establish communication with.
   */
  'port': number;
}
declare const BusIOModbusTCPClientNetworkTypeEnum: {
  readonly Tcp: "tcp";
};
type BusIOModbusTCPClientNetworkTypeEnum = typeof BusIOModbusTCPClientNetworkTypeEnum[keyof typeof BusIOModbusTCPClientNetworkTypeEnum];
interface BusIOModbusTCPServer {
  'network_type'?: BusIOModbusTCPServerNetworkTypeEnum;
  /**
   * Port number of the MODBUS server to establish communication with.
   */
  'port': number;
}
declare const BusIOModbusTCPServerNetworkTypeEnum: {
  readonly Tcp: "tcp";
};
type BusIOModbusTCPServerNetworkTypeEnum = typeof BusIOModbusTCPServerNetworkTypeEnum[keyof typeof BusIOModbusTCPServerNetworkTypeEnum];
/**
 * Virtual MODBUS inputs/outputs service configuration.
 */
interface BusIOModbusVirtual {
  'bus_type': BusIOModbusVirtualBusTypeEnum;
}
declare const BusIOModbusVirtualBusTypeEnum: {
  readonly ModbusVirtual: "modbus_virtual";
};
type BusIOModbusVirtualBusTypeEnum = typeof BusIOModbusVirtualBusTypeEnum[keyof typeof BusIOModbusVirtualBusTypeEnum];
/**
 * PROFINET BUS inputs/outputs service configuration.
 */
interface BusIOProfinet {
  'bus_type': BusIOProfinetBusTypeEnum;
  /**
   * Used to enable IP communication through the same physical ethernet interface while PROFINET driver is active.  Optional for SR-IOV-based bus I/O recreation. If omitted and an existing PROFINET bus I/O configuration for the same MAC address already exists, the previous network settings are reused.
   */
  'network_config'?: BusIOProfinetNetwork;
  /**
   * IP address of the PLC to establish PROFINET communication with.  The IP address is used to configure the host machine\'s firewall. The firewall configuration is applied while the BUS input/output service is active. Without proper firewall configuration, PROFINET device discovery, configuration exchanges, and real-time cyclic data communication will fail.
   */
  'plc_ip': string;
  /**
   * MAC address of the physical ethernet interface that you want to use for PROFINET communication.
   */
  'mac': string;
  /**
   * Optional PROFINET slot configuration.  If not provided, the default configuration is used for backward compatibility: one slot with a size of 64 bytes.
   */
  'slots'?: Array<BusIOProfinetSlot>;
  /**
   * @deprecated
   */
  'default_route'?: BusIOProfinetDefaultRoute;
}
declare const BusIOProfinetBusTypeEnum: {
  readonly Profinet: "profinet";
};
type BusIOProfinetBusTypeEnum = typeof BusIOProfinetBusTypeEnum[keyof typeof BusIOProfinetBusTypeEnum];
/**
 * Current default route configuration of your NOVA instance. The default route is a setting that tells data where to go if there isn’t a specific path already known for its destination. Usually this will be the path to your router, enabling accessing the internet. On Linux, use `ip route show` to view your default routes and match the output `default via <gateway> dev <interface> ...` to get your gateway and interface.
 */
interface BusIOProfinetDefaultRoute {
  /**
   * Gateway for the default route.
   */
  'gateway': string;
  /**
   * Interface for the default route.
   */
  'interface': string;
}
/**
 * Network configuration or IPv4 record of the virtual ethernet interface (pnio1) created by the PROFINET driver. The IPv4 record is used in combination with the Name of Station (NoS) to identify your device in the PROFINET network.  The `ip_config` will be used as IPv4 record if no REMA XML file is already present on your machine and no `rema_xml_content` is provided.
 */
interface BusIOProfinetIpConfig {
  /**
   * IP address for the device\'s virtual ethernet interface (pnio1).
   */
  'ip': string;
  /**
   * Network mask for the device\'s virtual ethernet interface (pnio1).
   */
  'netmask': string;
  /**
   * Gateway for connections to other devices outside of the virtual ethernet interface\'s subnet.
   */
  'gateway': string;
}
interface BusIOProfinetNetwork {
  /**
   * Name of Station (NoS) of the PROFINET device. The NoS is used in combination with IPv4 record to identify your device in the PROFINET network. The `device_name` will be used as NoS if no REMA XML file is already present on your machine and no `rema_xml_content` is provided.
   */
  'device_name'?: string;
  'ip_config'?: BusIOProfinetIpConfig;
  /**
   * Content of the PROFINET REMA XML file. Is used when PROFINET service is added for the first time to create the REMA XML file that holds data to be kept for the next session. Stores information like IP address, Name of Station (NoS) and hardware configuration. If you use a PROFINET controller to assign an IP address to the PROFINET device, this information will be written to the REMA XML file.  Refer to the PDF version of the \"PN Driver I/O Base programming interface\" documentation for more information and an example REMA file.
   */
  'rema_xml_content'?: string;
}
/**
 * Configuration for one PROFINET process data slot.
 */
interface BusIOProfinetSlot {
  /**
   * Slot identifier on the PROFINET device.
   */
  'slot': number;
  /**
   * Process data size in bytes for the input direction (device → controller).
   */
  'input_size_bytes': number;
  /**
   * Process data size in bytes for the output direction (controller → device).
   */
  'output_size_bytes': number;
}
/**
 * Virtual PROFINET BUS inputs/outputs service configuration.
 */
interface BusIOProfinetVirtual {
  'bus_type': BusIOProfinetVirtualBusTypeEnum;
}
declare const BusIOProfinetVirtualBusTypeEnum: {
  readonly ProfinetVirtual: "profinet_virtual";
};
type BusIOProfinetVirtualBusTypeEnum = typeof BusIOProfinetVirtualBusTypeEnum[keyof typeof BusIOProfinetVirtualBusTypeEnum];
/**
 * Snap7 BUS inputs/outputs service configuration.
 */
interface BusIOSnap7 {
  'bus_type': BusIOSnap7BusTypeEnum;
  /**
   * IP address or hostname of the Siemens PLC or PLCSIM Advanced endpoint.
   */
  'address': string;
  /**
   * Rack number of the PLC CPU. Standard value for S7-1200/1500 is 0.
   */
  'rack'?: number;
  /**
   * Slot number of the PLC CPU. Standard value for S7-1200/1500 is 1.
   */
  'slot'?: number;
}
declare const BusIOSnap7BusTypeEnum: {
  readonly Snap7: "snap7";
};
type BusIOSnap7BusTypeEnum = typeof BusIOSnap7BusTypeEnum[keyof typeof BusIOSnap7BusTypeEnum];
/**
 * @type BusIOType
 */
type BusIOType = {
  bus_type: 'modbus_client';
} & BusIOModbusClient | {
  bus_type: 'modbus_server';
} & BusIOModbusServer | {
  bus_type: 'modbus_virtual';
} & BusIOModbusVirtual | {
  bus_type: 'profinet';
} & BusIOProfinet | {
  bus_type: 'profinet_virtual';
} & BusIOProfinetVirtual | {
  bus_type: 'snap7';
} & BusIOSnap7;
interface BusIOsState {
  'state': BusIOsStateEnum;
  /**
   * A message providing additional information on the input/output service, e.g., BUS service status, encountered errors. May be empty if no additional information is available.
   */
  'message'?: string;
}
/**
 * Current state of the BUS input/output service.
 */
declare const BusIOsStateEnum: {
  readonly BusIosStateUnknown: "BUS_IOS_STATE_UNKNOWN";
  readonly BusIosStateInitializing: "BUS_IOS_STATE_INITIALIZING";
  readonly BusIosStateConnected: "BUS_IOS_STATE_CONNECTED";
  readonly BusIosStateDisconnected: "BUS_IOS_STATE_DISCONNECTED";
};
type BusIOsStateEnum = typeof BusIOsStateEnum[keyof typeof BusIOsStateEnum];
/**
 * A capability granted to the authenticated user. If `resource_ids` is absent or empty, the capability is granted globally without resource restriction.
 */
interface CapabilityEntry {
  /**
   * Capability relation name.
   */
  'capability': string;
  /**
   * Resource identifiers the capability is scoped to. Absent or empty means the capability is granted globally. Resource IDs are deduplicated and sorted in ascending order.
   */
  'resource_ids'?: Array<string>;
}
/**
 * Defines a cylindrical shape with 2 semi-spheres on the top and bottom. Centred around origin, symmetric around z-axis.
 */
interface Capsule {
  'shape_type': CapsuleShapeTypeEnum;
  /**
   * The radius of the cylinder and semi-spheres in [mm].
   */
  'radius': number;
  /**
   * The height of the inner cylinder in [mm].
   */
  'cylinder_height': number;
}
declare const CapsuleShapeTypeEnum: {
  readonly Capsule: "capsule";
};
type CapsuleShapeTypeEnum = typeof CapsuleShapeTypeEnum[keyof typeof CapsuleShapeTypeEnum];
interface CartesianLimits {
  'velocity'?: number;
  'acceleration'?: number;
  /**
   * > **NOTE** > > This limit type is experimental and its behavior may change in future releases.
   */
  'jerk'?: number;
  'orientation_velocity'?: number;
  'orientation_acceleration'?: number;
  /**
   * > **NOTE** > > This limit type is experimental and its behavior may change in future releases.
   */
  'orientation_jerk'?: number;
}
/**
 * To create a robot cell, only a valid name is required. Once created, a robot cell provides access to the Wandelbots NOVA foundation services. The configuration can be customized, e.g., robot controllers, also within apps.
 */
interface Cell {
  [key: string]: any;
  /**
   * A unique name for the cell used as an identifier for addressing the cell in all API calls. It must be a valid k8s label name as defined by [RFC 1123](https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#dns-label-names).
   */
  'name': string;
  /**
   * Wandelbots NOVA version of the cell. This version must not exceed the current system version.
   */
  'version'?: string;
  /**
   * A description of the cell.
   */
  'description'?: string;
  'controllers'?: Array<RobotController>;
  'apps'?: Array<App>;
}
/**
 * @type CloudConfigStatus
 */
type CloudConfigStatus = {
  status: 'configured';
} & CloudConfigStatusConfigured | {
  status: 'not_configured';
} & CloudConfigStatusNotConfigured;
interface CloudConfigStatusConfigured {
  'status': CloudConfigStatusConfiguredStatusEnum;
  'config': CloudConfiguration;
}
declare const CloudConfigStatusConfiguredStatusEnum: {
  readonly Configured: "configured";
};
type CloudConfigStatusConfiguredStatusEnum = typeof CloudConfigStatusConfiguredStatusEnum[keyof typeof CloudConfigStatusConfiguredStatusEnum];
interface CloudConfigStatusNotConfigured {
  'status': CloudConfigStatusNotConfiguredStatusEnum;
}
declare const CloudConfigStatusNotConfiguredStatusEnum: {
  readonly NotConfigured: "not_configured";
};
type CloudConfigStatusNotConfiguredStatusEnum = typeof CloudConfigStatusNotConfiguredStatusEnum[keyof typeof CloudConfigStatusNotConfiguredStatusEnum];
interface CloudConfiguration {
  'cloud_hostname': string;
  /**
   * Instance identifier received from cloud registration
   */
  'instance': number;
}
interface CloudConnectionError {
  'error': CloudConnectionErrorError;
}
/**
 * @type CloudConnectionErrorError
 */
type CloudConnectionErrorError = {
  code: 'invalid_cloud_token';
} & CloudConnectionErrorInvalidToken | {
  code: 'leafnode_connection_error';
} & CloudConnectionErrorLeafnodeConnectionError | {
  code: 'leafnode_connection_timeout';
} & CloudConnectionErrorLeafnodeConnectionTimeout | {
  code: 'leafnode_restart_timeout';
} & CloudConnectionErrorLeafnodeRestartTimeout | {
  code: 'nats_connection_failed';
} & CloudConnectionErrorNatsFailed | {
  code: 'unexpected_cloud_response';
} & CloudConnectionErrorUnexpectedResponse;
interface CloudConnectionErrorInvalidToken {
  'code': CloudConnectionErrorInvalidTokenCodeEnum;
  'message': string;
  'details': CloudConnectionErrorInvalidTokenDetails;
}
declare const CloudConnectionErrorInvalidTokenCodeEnum: {
  readonly InvalidCloudToken: "invalid_cloud_token";
};
type CloudConnectionErrorInvalidTokenCodeEnum = typeof CloudConnectionErrorInvalidTokenCodeEnum[keyof typeof CloudConnectionErrorInvalidTokenCodeEnum];
interface CloudConnectionErrorInvalidTokenDetails {
  'cloud_response': CloudConnectionErrorInvalidTokenDetailsCloudResponse;
}
interface CloudConnectionErrorInvalidTokenDetailsCloudResponse {
  'status': number;
  'headers'?: any;
  'body': string;
}
interface CloudConnectionErrorLeafnodeConnectionError {
  'code': CloudConnectionErrorLeafnodeConnectionErrorCodeEnum;
  'message': string;
  'details': CloudConnectionErrorLeafnodeConnectionErrorDetails;
}
declare const CloudConnectionErrorLeafnodeConnectionErrorCodeEnum: {
  readonly LeafnodeConnectionError: "leafnode_connection_error";
};
type CloudConnectionErrorLeafnodeConnectionErrorCodeEnum = typeof CloudConnectionErrorLeafnodeConnectionErrorCodeEnum[keyof typeof CloudConnectionErrorLeafnodeConnectionErrorCodeEnum];
interface CloudConnectionErrorLeafnodeConnectionErrorDetails {
  'log_line': string;
}
interface CloudConnectionErrorLeafnodeConnectionTimeout {
  'code': CloudConnectionErrorLeafnodeConnectionTimeoutCodeEnum;
  'message': string;
}
declare const CloudConnectionErrorLeafnodeConnectionTimeoutCodeEnum: {
  readonly LeafnodeConnectionTimeout: "leafnode_connection_timeout";
};
type CloudConnectionErrorLeafnodeConnectionTimeoutCodeEnum = typeof CloudConnectionErrorLeafnodeConnectionTimeoutCodeEnum[keyof typeof CloudConnectionErrorLeafnodeConnectionTimeoutCodeEnum];
interface CloudConnectionErrorLeafnodeRestartTimeout {
  'code': CloudConnectionErrorLeafnodeRestartTimeoutCodeEnum;
  'message': string;
}
declare const CloudConnectionErrorLeafnodeRestartTimeoutCodeEnum: {
  readonly LeafnodeRestartTimeout: "leafnode_restart_timeout";
};
type CloudConnectionErrorLeafnodeRestartTimeoutCodeEnum = typeof CloudConnectionErrorLeafnodeRestartTimeoutCodeEnum[keyof typeof CloudConnectionErrorLeafnodeRestartTimeoutCodeEnum];
interface CloudConnectionErrorNatsFailed {
  'code': CloudConnectionErrorNatsFailedCodeEnum;
  'message': string;
  'details': CloudConnectionErrorNatsFailedDetails;
}
declare const CloudConnectionErrorNatsFailedCodeEnum: {
  readonly NatsConnectionFailed: "nats_connection_failed";
};
type CloudConnectionErrorNatsFailedCodeEnum = typeof CloudConnectionErrorNatsFailedCodeEnum[keyof typeof CloudConnectionErrorNatsFailedCodeEnum];
interface CloudConnectionErrorNatsFailedDetails {
  'nats_server_url': string;
  'nats_error_message': string;
}
interface CloudConnectionErrorUnexpectedResponse {
  'code': CloudConnectionErrorUnexpectedResponseCodeEnum;
  'message': string;
  'details': CloudConnectionErrorUnexpectedResponseDetails;
}
declare const CloudConnectionErrorUnexpectedResponseCodeEnum: {
  readonly UnexpectedCloudResponse: "unexpected_cloud_response";
};
type CloudConnectionErrorUnexpectedResponseCodeEnum = typeof CloudConnectionErrorUnexpectedResponseCodeEnum[keyof typeof CloudConnectionErrorUnexpectedResponseCodeEnum];
interface CloudConnectionErrorUnexpectedResponseDetails {
  'cloud_response': CloudConnectionErrorUnexpectedResponseDetailsCloudResponse;
}
interface CloudConnectionErrorUnexpectedResponseDetailsCloudResponse {
  'status': number;
  'headers': {
    [key: string]: any;
  };
  'body': string;
}
interface CloudConnectionRequest {
  'cloud_hostname': string;
  /**
   * Auth token of the user registering the instance. This must be a valid oauth token granting access to the NOVA Cloud API.
   */
  'token': string;
  /**
   * Human-readable name to identify the instance in the fleet manager dashboard.
   */
  'instance_name': string;
  /**
   * Optional local network url for the instance, used to link users directly from the fleet manager. If not specified, will be inferred from the request URL.
   */
  'instance_url'?: string;
}
interface CloudDisconnectionError {
  'error': CloudConnectionErrorLeafnodeRestartTimeout;
}
interface CloudDisconnectionStatusDisconnected {
  'status': CloudDisconnectionStatusDisconnectedStatusEnum;
}
declare const CloudDisconnectionStatusDisconnectedStatusEnum: {
  readonly Disconnected: "disconnected";
};
type CloudDisconnectionStatusDisconnectedStatusEnum = typeof CloudDisconnectionStatusDisconnectedStatusEnum[keyof typeof CloudDisconnectionStatusDisconnectedStatusEnum];
interface CloudDisconnectionStatusDisconnecting {
  'status': CloudDisconnectionStatusDisconnectingStatusEnum;
}
declare const CloudDisconnectionStatusDisconnectingStatusEnum: {
  readonly Disconnecting: "disconnecting";
};
type CloudDisconnectionStatusDisconnectingStatusEnum = typeof CloudDisconnectionStatusDisconnectingStatusEnum[keyof typeof CloudDisconnectionStatusDisconnectingStatusEnum];
interface CloudRegistrationSuccessResponse {
  /**
   * Instance identifier received from cloud registration
   */
  'instance': number;
}
/**
 * Defines a collider with a single shape.  A collider is an object that is used for collision detection. It defines the `shape` that is attached with the offset of `pose` to a reference frame.  Use colliders to: - Define the shape of a workpiece. The reference frame is the scene origin. - Define the shape of a link in a motion group. The reference frame is the link coordinate system. - Define the shape of a tool. The reference frame is the flange coordinate system.
 */
interface Collider {
  'shape': ColliderShape;
  'pose'?: Pose;
  /**
   * Increases the shape\'s size in all dimensions. Applied in [mm]. Can be used to keep a safe distance to the shape.
   */
  'margin'?: number;
}
/**
 * @type ColliderShape
 */
type ColliderShape = {
  shape_type: 'box';
} & Box | {
  shape_type: 'capsule';
} & Capsule | {
  shape_type: 'convex_hull';
} & ConvexHull | {
  shape_type: 'cylinder';
} & Cylinder | {
  shape_type: 'plane';
} & Plane | {
  shape_type: 'rectangle';
} & Rectangle | {
  shape_type: 'rectangular_capsule';
} & RectangularCapsule | {
  shape_type: 'sphere';
} & Sphere;
/**
 * An inline Collider object wrapped for discriminator support.
 */
interface ColliderValue {
  /**
   * Discriminator value indicating an inline value.
   */
  'source': ColliderValueSourceEnum;
  /**
   * The inline Collider definition.
   */
  'collider': Collider;
}
declare const ColliderValueSourceEnum: {
  readonly Value: "value";
};
type ColliderValueSourceEnum = typeof ColliderValueSourceEnum[keyof typeof ColliderValueSourceEnum];
/**
 * @type ColliderValueOrKey
 * Either an inline Collider object or a storage key referencing a stored Collider. Discriminated by the \"source\" property.
 */
type ColliderValueOrKey = {
  source: 'key';
} & StorageKey | {
  source: 'value';
} & ColliderValue;
interface Collision {
  'id_of_a'?: string;
  'id_of_b'?: string;
  'id_of_layer'?: string;
  /**
   * A three-dimensional vector [x, y, z] with double precision.
   */
  'normal_root_on_b'?: Array<number>;
  'position_on_a'?: CollisionContact;
  'position_on_b'?: CollisionContact;
}
interface CollisionContact {
  /**
   * A three-dimensional vector [x, y, z] with double precision.
   */
  'local'?: Array<number>;
  /**
   * A three-dimensional vector [x, y, z] with double precision.
   */
  'root'?: Array<number>;
}
interface CollisionError {
  'kind': CollisionErrorKindEnum;
  'collision'?: FeedbackCollision;
}
declare const CollisionErrorKindEnum: {
  readonly CollisionError: "CollisionError";
};
type CollisionErrorKindEnum = typeof CollisionErrorKindEnum[keyof typeof CollisionErrorKindEnum];
/**
 * @type CollisionFreeAlgorithm
 * Configuration for collision-free path planning algorithms. Different algorithms may have different parameters and behavior.  Recommendation: - For **cells with many obstacles**, use the RRTConnect algorithm. Use it as a starting point. - For **simple cells with very few obstacles** and when a faster solution is needed, try the MidpointInsertion algorithm.
 */
type CollisionFreeAlgorithm = MidpointInsertionAlgorithm | RRTConnectAlgorithm;
interface CollisionMotionGroup {
  /**
   * A link chain is a kinematic chain of links that is connected via joints. A motion group can be used to control the motion of the joints in a link chain.  A link is a group of colliders that is attached to the link reference frame.  The reference frame of a link is obtained after applying all sets of Denavit-Hartenberg-parameters from base to (including) the link index.  This means that the reference frame of the link is on the rotation axis of the next joint in the kinematic chain. Example: For a motion group with 2 joints, the collider reference frame (CRF) for link 1 is on the rotation axis of joint 2. The chain looks like: - Origin >> Mounting >> Base >> (CRF Base) Joint 0 >> Link 0 >> (CRF Link 0) Joint 1 >> Link 1 >> (CRF Link 1) Flange (CRF Tool) >> TCP  Adjacent links in the kinematic chain of the motion group are not checked for mutual collision.
   */
  'link_chain'?: Array<{
    [key: string]: Collider;
  }>;
  /**
   * Defines the shape of a tool.  A tool is a dictionary of colliders.  All colliders that make up a tool are attached to the flange frame of the motion group.
   */
  'tool'?: {
    [key: string]: Collider;
  };
  /**
   * If true, self-collision detection is enabled for the motion group.  Self-collision detection checks if links in the kinematic chain of the motion group collide with each other. Adjacent links in the kinematic chain of the motion group are not checked for mutual collision. The tool is treated like a link at the end of the kinematic chain. It is checked against all links except the last one.  Default is true.
   */
  'self_collision_detection'?: boolean;
}
interface CollisionSetup {
  /**
   * A collection of identifiable colliders.
   */
  'colliders'?: {
    [key: string]: Collider;
  };
  /**
   * A link chain is a kinematic chain of links that is connected via joints. A motion group can be used to control the motion of the joints in a link chain.  A link is a group of colliders that is attached to the link reference frame.  The reference frame of a link is obtained after applying all sets of Denavit-Hartenberg-parameters from base to (including) the link index.  This means that the reference frame of the link is on the rotation axis of the next joint in the kinematic chain. Example: For a motion group with 2 joints, the collider reference frame (CRF) for link 1 is on the rotation axis of joint 2. The chain looks like: - Origin >> Mounting >> Base >> (CRF Base) Joint 0 >> Link 0 >> (CRF Link 0) Joint 1 >> Link 1 >> (CRF Link 1) Flange (CRF Tool) >> TCP  Adjacent links in the kinematic chain of the motion group are not checked for mutual collision.
   */
  'link_chain'?: Array<{
    [key: string]: Collider;
  }>;
  /**
   * Defines the shape of a tool.  A tool is a dictionary of colliders.  All colliders that make up a tool are attached to the flange frame of the motion group.
   */
  'tool'?: {
    [key: string]: Collider;
  };
  /**
   * If true, self-collision detection is enabled for the motion group.  Self-collision detection checks if links in the kinematic chain of the motion group collide with each other. Adjacent links in the kinematic chain of the motion group are not checked for mutual collision. The tool is treated like a link at the end of the kinematic chain. It is checked against all links except the last one.  Default is true.
   */
  'self_collision_detection'?: boolean;
}
/**
 * An inline collision setup wrapped for discriminator support. Colliders, tool, and link_chain can each be either inline values or storage key references.
 */
interface CollisionSetupValue {
  /**
   * Discriminator value indicating an inline value.
   */
  'source': CollisionSetupValueSourceEnum;
  /**
   * A dictionary of colliders where each value is either an inline Collider object or a string key referencing a stored Collider.
   */
  'colliders'?: {
    [key: string]: ColliderValueOrKey;
  };
  /**
   * The shape of the motion group links. Either an inline LinkChain or a store key.
   */
  'link_chain'?: LinkChainValueOrKey;
  /**
   * Shape of the tool. Either an inline tool collider or a store key.
   */
  'tool'?: ToolValueOrKey;
  /**
   * If true, self-collision detection is enabled. Default is true.
   */
  'self_collision_detection'?: boolean;
}
declare const CollisionSetupValueSourceEnum: {
  readonly Value: "value";
};
type CollisionSetupValueSourceEnum = typeof CollisionSetupValueSourceEnum[keyof typeof CollisionSetupValueSourceEnum];
/**
 * @type CollisionSetupValueOrKey
 * Either an inline collision setup or a storage key referencing a complete stored CollisionSetup. Discriminated by the \"source\" property.
 */
type CollisionSetupValueOrKey = {
  source: 'key';
} & StorageKey | {
  source: 'value';
} & CollisionSetupValue;
/**
 * Comparator for the comparison of two values. The comparator is used to compare two values and return a boolean result. The default comparator is unknown.
 */
declare const Comparator: {
  readonly ComparatorEquals: "COMPARATOR_EQUALS";
  readonly ComparatorNotEquals: "COMPARATOR_NOT_EQUALS";
  readonly ComparatorGreater: "COMPARATOR_GREATER";
  readonly ComparatorGreaterEqual: "COMPARATOR_GREATER_EQUAL";
  readonly ComparatorLess: "COMPARATOR_LESS";
  readonly ComparatorLessEqual: "COMPARATOR_LESS_EQUAL";
};
type Comparator = typeof Comparator[keyof typeof Comparator];
/**
 * @type ConfigurationArchiveStatus
 * Result of a backup operation.
 */
type ConfigurationArchiveStatus = {
  status: 'creating';
} & ConfigurationArchiveStatusCreating | {
  status: 'error';
} & ConfigurationArchiveStatusError | {
  status: 'success';
} & ConfigurationArchiveStatusSuccess;
interface ConfigurationArchiveStatusCreating {
  /**
   * Backup is in progress.
   */
  'status': ConfigurationArchiveStatusCreatingStatusEnum;
  /**
   * Current completion ratio (0 – 1).
   */
  'progress': number;
}
declare const ConfigurationArchiveStatusCreatingStatusEnum: {
  readonly Creating: "creating";
};
type ConfigurationArchiveStatusCreatingStatusEnum = typeof ConfigurationArchiveStatusCreatingStatusEnum[keyof typeof ConfigurationArchiveStatusCreatingStatusEnum];
interface ConfigurationArchiveStatusError {
  'status': ConfigurationArchiveStatusErrorStatusEnum;
  /**
   * Human-readable explanation of the failure.
   */
  'message': string;
}
declare const ConfigurationArchiveStatusErrorStatusEnum: {
  readonly Error: "error";
};
type ConfigurationArchiveStatusErrorStatusEnum = typeof ConfigurationArchiveStatusErrorStatusEnum[keyof typeof ConfigurationArchiveStatusErrorStatusEnum];
interface ConfigurationArchiveStatusSuccess {
  /**
   * Backup successfully created.
   */
  'status': ConfigurationArchiveStatusSuccessStatusEnum;
}
declare const ConfigurationArchiveStatusSuccessStatusEnum: {
  readonly Success: "success";
};
type ConfigurationArchiveStatusSuccessStatusEnum = typeof ConfigurationArchiveStatusSuccessStatusEnum[keyof typeof ConfigurationArchiveStatusSuccessStatusEnum];
/**
 * Configuration resource object.
 */
interface ConfigurationResource {
  /**
   * Identifier of a configuration resource.
   */
  'id': string;
  /**
   * Human-readable name of the configuration resource.
   */
  'name': string;
  /**
   * Array of configuration resources.
   */
  'children'?: Array<ConfigurationResource>;
}
interface ConfiguredPose {
  'pose': Pose;
  'kinematic_configuration': KinematicConfiguration;
}
interface ConfiguredPoseInverse422Response {
  'detail'?: Array<ValidationError>;
}
interface ConfiguredPoseInverseFailedResponse {
  'joint_positions': Array<Array<number>>;
  'feedbacks'?: Array<InverseFeedbackAtIndex>;
}
interface ConfiguredPoseInverseRequest {
  /**
   * Identifies a single motion group model. See [getMotionGroupModels](#/operations/getMotionGroupModels) for supported types.
   */
  'motion_group_model': string;
  'tcp_poses': Array<ConfiguredPose>;
  'tcp_offset'?: Pose;
  /**
   * Offset from the world frame to the motion group base.
   */
  'mounting'?: Pose;
  /**
   * Joint position limits, indexed starting from base. The unit depends on the type of joint: For revolute joints, the limit is given in [rad]; for prismatic joints, it is given in [mm].
   */
  'joint_position_limits'?: Array<LimitRange>;
  /**
   * Collision layers to be respected by the motion planner when planning for a single motion group. Each setup represents one layer, e.g., the safety zones and shapes or a fine grained tool and workpiece model. Layers are checked individually along the trajectory and independently of other layers.  To respect the safety zones of the controller and check for collision: 1. Fetch the safety zones, link and tool shapes from the controller. 2. Add the fetched zones, links and tools to a layer. 3. Create other layers from your own 3D data as needed. 4. Plan trajectory. 5. The response highlights the layer in which a collision was detected by key.
   */
  'collision_setups'?: {
    [key: string]: CollisionSetup;
  };
}
interface ConfiguredPoseInverseResponse {
  'response': ConfiguredPoseInverseResponseResponse;
}
/**
 * @type ConfiguredPoseInverseResponseResponse
 */
type ConfiguredPoseInverseResponseResponse = Array<Array<number>> | ConfiguredPoseInverseFailedResponse;
/**
 * Defines a rotationally constrained pose in 3D space. The orientation is constrained to rotations around a single axis.
 */
interface ConstrainedPose {
  /**
   * A three-dimensional vector [x, y, z] with double precision.
   */
  'position': Array<number>;
  'orientation': number;
}
interface ContainerEnvironmentInner {
  'name': string;
  'value': string;
}
/**
 * A user provided, custom container image and the required credentials to pull it from a registry.
 */
interface ContainerImage {
  /**
   * The location of a container image in the form of `<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 maximum memory allocated to this application.
   */
  'memory_limit'?: string;
}
/**
 * The path and capacity of a volume that retains data across application restarts. The maximal requestable capacity is 300Mi. If you need more capacity consider using [storeObject](#/operations/storeObject).
 */
interface ContainerStorage {
  'mount_path': string;
  /**
   * The amount of requested storage capacity.
   */
  'capacity': string;
}
/**
 * The data type to describe a robot controller.
 */
interface ControllerDescription {
  'connected_motion_groups': Array<string>;
  /**
   * Can this controller be moved through freedrive (true), or not (false).
   */
  'supports_freedrive': boolean;
  /**
   * Can this controller be controlled with NOVA (true) or is it only possible to read data (false).
   */
  'supports_control': boolean;
  /**
   * True if NOVA supports reading safety zone-, tool- and link-geometries for this motion group. Safety zones are used to define areas where the robot should slow down or stop. If false, NOVA can\'t guarantee that the executed motions respect safety zones defined on the controller.
   */
  'supports_safety_zones': boolean;
}
interface ConvertVendorConfiguredPose422Response {
  'detail'?: Array<ValidationError>;
}
interface Co