vda-5050-lib/common/vda-5050-types-3.0.d.ts

Universal VDA 5050 library for Node.js and browsers

/**
 * The last will message of the mobile robot. Has to be sent with retain flag. Once the
 * mobile robot comes online, it has to send this message on its connect topic, with the
 * connectionState enum set to "ONLINE". The last will message is to be configured with the
 * connection state set to "CONNECTIONBROKEN".
 * Thus, if the mobile robot disconnects from the broker, fleet control gets notified via
 * the topic "connection". If the mobile robot is disconnecting in an orderly fashion (e.g.
 * shutting down, sleeping), the mobile robot is to publish a message on this topic with the
 * connectionState set to "DISCONNECTED".
 */
export interface Connection {
    /**
     * ONLINE: connection between mobile robot and broker is active. OFFLINE: connection between
     * mobile robot and broker has gone offline in a coordinated way. HIBERNATING: connection
     * between mobile robot and broker is active, but mobile robot does not state messages. This
     * mode is intended for power-saving or communication reduction. The mobile robot can resume
     * to ONLINE when instructed. CONNECTION_BROKEN: The connection between mobile robot and
     * broker has unexpectedly ended.
     */
    connectionState: ConnectionState;
    /**
     * Header ID of the message. The headerId is defined per topic and incremented by 1 with
     * each sent (but not necessarily received) message.
     */
    headerId: number;
    /**
     * Manufacturer of the mobile robot.
     */
    manufacturer: string;
    /**
     * Serial number of the mobile robot.
     */
    serialNumber: string;
    /**
     * Timestamp in ISO8601 format (YYYY-MM-DDTHH:mm:ss.fffZ).
     */
    timestamp: string;
    /**
     * Version of the protocol [Major].[Minor].[Patch]
     */
    version: string;
    [property: string]: any;
}
/**
 * ONLINE: connection between mobile robot and broker is active. OFFLINE: connection between
 * mobile robot and broker has gone offline in a coordinated way. HIBERNATING: connection
 * between mobile robot and broker is active, but mobile robot does not state messages. This
 * mode is intended for power-saving or communication reduction. The mobile robot can resume
 * to ONLINE when instructed. CONNECTION_BROKEN: The connection between mobile robot and
 * broker has unexpectedly ended.
 */
export declare enum ConnectionState {
    ConnectionBroken = "CONNECTION_BROKEN",
    Hibernating = "HIBERNATING",
    Offline = "OFFLINE",
    Online = "ONLINE"
}
/**
 * The factsheet provides basic information about a specific mobile robot type series. This
 * information allows comparison of different mobile robot types and can be applied for the
 * planning, dimensioning and simulation of a mobile robot system. The factsheet also
 * includes information about mobile robot communication interfaces which are required for
 * the integration of a mobile robot type series into a VD[M]A-5050-compliant fleet control.
 */
export interface Factsheet {
    /**
     * Header ID of the message. The headerId is defined per topic and incremented by 1 with
     * each sent (but not necessarily received) message.
     */
    headerId: number;
    /**
     * Abstract specification of load capabilities
     */
    loadSpecification: LoadSpecification;
    /**
     * Manufacturer of the mobile robot
     */
    manufacturer: string;
    mobileRobotConfiguration?: MobileRobotConfiguration;
    /**
     * Detailed definition of mobile robot geometry
     */
    mobileRobotGeometry: MobileRobotGeometry;
    /**
     * These parameters specify the basic physical properties of the mobile robot
     */
    physicalParameters: PhysicalParameters;
    /**
     * Supported features of VDA5050 protocol
     */
    protocolFeatures: ProtocolFeatures;
    /**
     * This JSON-object describes the protocol limitations of the mobile robot. If a parameter
     * is not defined or set to zero then there is no explicit limit for this parameter.
     */
    protocolLimits: ProtocolLimits;
    /**
     * Serial number of the mobile robot
     */
    serialNumber: string;
    /**
     * Timestamp in ISO8601 format (YYYY-MM-DDTHH:mm:ss.fffZ).
     */
    timestamp: string;
    /**
     * These parameters generally specify the class and the capabilities of the mobile robot
     */
    typeSpecification: TypeSpecification;
    /**
     * Version of the protocol [Major].[Minor].[Patch]
     */
    version: string;
    [property: string]: any;
}
/**
 * Abstract specification of load capabilities
 */
export interface LoadSpecification {
    /**
     * List of load positions / load handling devices. This lists contains the valid values for
     * the parameter “state.loads[].loadPosition” and for the action parameter “lhd” of the
     * actions pick and drop. If this list doesn’t exist or is empty, the mobile robot has no
     * load handling device.
     */
    loadPositions?: string[];
    /**
     * List of load-sets that can be handled by the mobile robot
     */
    loadSets?: LoadSet[];
    [property: string]: any;
}
export interface LoadSet {
    /**
     * Bounding box reference as defined in parameter loads[] in state-message
     */
    boundingBoxReference?: LoadSetBoundingBoxReference;
    /**
     * Free text description of the load handling set
     */
    description?: string;
    /**
     * Approximate time for dropping the load
     */
    dropTime?: number;
    loadDimensions?: LoadSetLoadDimensions;
    /**
     * List of load positions btw. load handling devices, this load-set is valid for. If this
     * parameter does not exist or is empty, this load-set is valid for all load handling
     * devices on this mobile robot.
     */
    loadPositions?: string[];
    /**
     * Type of load e.g., EPAL, XLT1200, ….
     */
    loadType: string;
    /**
     * Maximum allowed acceleration for this load-type and –weight
     */
    maximumAcceleration?: number;
    /**
     * Maximum allowed deceleration for this load-type and –weight
     */
    maximumDeceleration?: number;
    /**
     * Maximum allowed depth for this load-type and –weight. references to boundingBoxReference
     */
    maximumLoadhandlingDepth?: number;
    /**
     * Maximum allowed height for handling of this load-type and –weight. references to
     * boundingBoxReference
     */
    maximumLoadhandlingHeight?: number;
    /**
     * Maximum allowed tilt for this load-type and –weight
     */
    maximumLoadhandlingTilt?: number;
    /**
     * Maximum allowed speed for this load-type and –weight
     */
    maximumSpeed?: number;
    /**
     * Maximum weight of loadtype
     */
    maximumWeight?: number;
    /**
     * Minimum allowed depth for this load-type and –weight. references to boundingBoxReference
     */
    minimumLoadhandlingDepth?: number;
    /**
     * Minimum allowed height for handling of this load-type and –weight. References to
     * boundingBoxReference
     */
    minimumLoadhandlingHeight?: number;
    /**
     * Minimum allowed tilt for this load-type and –weight
     */
    minimumLoadhandlingTilt?: number;
    /**
     * Approximate time for picking up the load
     */
    pickTime?: number;
    /**
     * Unique name of the load set, e.g., DEFAULT, SET1, ...
     */
    setName: string;
    [property: string]: any;
}
/**
 * Bounding box reference as defined in parameter loads[] in state-message
 */
export interface LoadSetBoundingBoxReference {
    /**
     * Orientation of the loads bounding box. Important for tugger trains, etc.
     */
    theta?: number;
    /**
     * X-coordinate of the point of reference.
     */
    x: number;
    /**
     * Y-coordinate of the point of reference.
     */
    y: number;
    /**
     * Z-coordinate of the point of reference.
     */
    z: number;
    [property: string]: any;
}
export interface LoadSetLoadDimensions {
    /**
     * Absolute height of the load´s bounding box. Optional: Set value only if known.
     */
    height?: number;
    /**
     * Absolute length (along the mobile robot’s coordinate system’s x-axis) of the load's
     * bounding box in meters.
     */
    length: number;
    /**
     * Absolute width (along the mobile robot’s coordinate system’s y-axis) of the load's
     * bounding box in meters.
     */
    width: number;
    [property: string]: any;
}
export interface MobileRobotConfiguration {
    /**
     * Information about battery charging parameters.
     */
    "batteryCharging "?: BatteryCharging;
    /**
     * Information about the mobile robot's network connection. The listed information shall not
     * be updated while the mobile robot is operating.
     */
    network?: Network;
    /**
     * Array containing various hardware and software versions running on the mobile robot.
     */
    versions?: Version[];
    [property: string]: any;
}
/**
 * Information about battery charging parameters.
 */
export interface BatteryCharging {
    /**
     * Specifies the critical charging level in percent at or below which the fleet control
     * should only send orders that command the mobile robot to a charging station.
     */
    criticalLowChargingLevel?: number;
    /**
     * Specifies the maximum desired charging level in percent.
     */
    maximumDesiredChargingLevel?: number;
    /**
     * Specifies the desired minimum charging time in seconds.
     */
    minimumChargingTime?: number;
    /**
     * Specifies the minimum desired charging level in percent.
     */
    minimumDesiredChargingLevel?: number;
    [property: string]: any;
}
/**
 * Information about the mobile robot's network connection. The listed information shall not
 * be updated while the mobile robot is operating.
 */
export interface Network {
    /**
     * Default gateway used by the mobile robot.
     */
    defaultGateway?: string;
    /**
     * List of DNS servers used by the mobile robot.
     */
    dnsServers?: string[];
    /**
     * A priori assigned IP address of the mobile robot used to communicate with the MQTT
     * broker. Note that this IP address should not be modified/changed during operations.
     */
    localIpAddress?: string;
    /**
     * Network subnet mask.
     */
    netmask?: string;
    /**
     * List of NTP servers used by the mobile robot.
     */
    ntpServers?: string[];
    [property: string]: any;
}
export interface Version {
    /**
     * The key of the version.
     */
    key: string;
    /**
     * The value of the version.
     */
    value: string;
    [property: string]: any;
}
/**
 * Detailed definition of mobile robot geometry
 */
export interface MobileRobotGeometry {
    envelopes2d?: Envelopes2D[];
    /**
     * List of mobile robot envelope curves in 3D (german: „Hüllkurven“)
     */
    envelopes3d?: Envelopes3D[];
    /**
     * List of wheels, containing wheel-arrangement and geometry
     */
    wheelDefinitions?: WheelDefinition[];
    [property: string]: any;
}
export interface Envelopes2D {
    /**
     * Free text: description of envelope curve set
     */
    description?: string;
    /**
     * Identifier of the envelope curve set.
     */
    envelope2dId: string;
    /**
     * The envelope curve in defined as a polygon. It shall be assumed as closed. Only simple
     * polygons shall be used.
     */
    vertices: Envelopes2DVertex[];
    [property: string]: any;
}
export interface Envelopes2DVertex {
    /**
     * X-position of polygon-point
     */
    x: number;
    /**
     * Y-position of polygon-point
     */
    y: number;
    [property: string]: any;
}
export interface Envelopes3D {
    /**
     * 3D-envelope curve data, format specified in ‚format‘
     */
    data?: {
        [key: string]: any;
    };
    /**
     * Free text: description of envelope curve set
     */
    description?: string;
    /**
     * Identifier of the envelope curve set.
     */
    envelope3dId: string;
    /**
     * Format of data, e.g., DXF
     */
    format: string;
    /**
     * Protocol and url-definition for downloading the 3D-envelope curve data, e.g.,
     * ftp://xxx.yyy.com/ac4dgvhoif5tghji
     */
    url?: string;
    [property: string]: any;
}
export interface WheelDefinition {
    /**
     * Nominal displacement of the wheel’s center to the rotation point (necessary for caster
     * wheels). If the parameter is not defined, it is assumed to be 0
     */
    centerDisplacement?: number;
    /**
     * Free text: can be used by the manufacturer to define constraints
     */
    constraints?: string;
    /**
     * Nominal diameter of wheel
     */
    diameter: number;
    /**
     * True: wheel is actively driven
     */
    isActiveDriven: boolean;
    /**
     * True: wheel is actively steered
     */
    isActiveSteered: boolean;
    position: Position;
    /**
     * Wheel type. Extensible enum: DRIVE, CASTER, FIXED, MECANUM
     */
    type: string;
    /**
     * Nominal width of wheel
     */
    width: number;
    [property: string]: any;
}
export interface Position {
    /**
     * Orientation of wheel in mobile robot coordinate system Necessary for fixed wheels
     */
    theta?: number;
    /**
     * X-position in mobile robot coordinate system
     */
    x: number;
    /**
     * Y-position in mobile robot coordinate system
     */
    y: number;
    [property: string]: any;
}
/**
 * These parameters specify the basic physical properties of the mobile robot
 */
export interface PhysicalParameters {
    /**
     * Length of the mobile robot
     */
    length: number;
    /**
     * Maximum acceleration with maximum load
     */
    maximumAcceleration: number;
    /**
     * Maximum rotation speed of the mobile robot
     */
    maximumAngularSpeed?: number;
    /**
     * Maximum deceleration with maximum load
     */
    maximumDeceleration: number;
    /**
     * Maximum height of mobile robot
     */
    maximumHeight: number;
    /**
     * Maximum speed of the mobile robot
     */
    maximumSpeed: number;
    /**
     * Minimal controlled continuous rotation speed of the mobile robot
     */
    minimumAngularSpeed?: number;
    /**
     * Minimum height of mobile robot
     */
    minimumHeight: number;
    /**
     * Minimal controlled continuous speed of the mobile robot
     */
    minimumSpeed: number;
    /**
     * Width of the mobile robot
     */
    width: number;
    [property: string]: any;
}
/**
 * Supported features of VDA5050 protocol
 */
export interface ProtocolFeatures {
    /**
     * List of all actions with parameters supported by this mobile robot. This includes
     * standard actions specified in VDA 5050 and manufacturer-specific actions
     */
    mobileRobotActions: MobileRobotAction[];
    /**
     * List of supported and/or required optional parameters. Optional parameters, that are not
     * listed here, are assumed to be not supported by the mobile robot.
     */
    optionalParameters: OptionalParameter[];
    [property: string]: any;
}
export interface MobileRobotAction {
    /**
     * Free text: description of the action
     */
    actionDescription?: string;
    /**
     * Kist of parameters. if not defined, the action has no parameters
     */
    actionParameters?: MobileRobotActionActionParameter[];
    /**
     * Free text: description of the result
     */
    actionResult?: string;
    /**
     * List of allowed scopes for using this action-type. INSTANT: usable as instantAction,
     * NODE: usable on nodes, EDGE: usable on edges, ZONE: usable as zone action.
     */
    actionScopes: ActionScope[];
    /**
     * Unique actionType corresponding to action.actionType
     */
    actionType: string;
    /**
     * Array of possible blocking types for defined action.
     */
    blockingTypes?: BlockingTypeElement[];
    /**
     * True: action can be cancelled via cancelOrder. False: action cannot be cancelled.
     */
    cancelAllowed: string;
    /**
     * True: action can be paused via startPause. False: action cannot be paused.
     */
    pauseAllowed: string;
    [property: string]: any;
}
export interface MobileRobotActionActionParameter {
    /**
     * Free text: description of the parameter
     */
    description?: string;
    /**
     * True: optional parameter
     */
    isOptional?: boolean;
    /**
     * Key-String for Parameter
     */
    key: string;
    /**
     * Data type of Value, possible data types are: BOOL, NUMBER, INTEGER, STRING, OBJECT, ARRAY
     */
    valueDataType: ValueDataType;
    [property: string]: any;
}
/**
 * Data type of Value, possible data types are: BOOL, NUMBER, INTEGER, STRING, OBJECT, ARRAY
 */
export declare enum ValueDataType {
    Array = "ARRAY",
    Bool = "BOOL",
    Integer = "INTEGER",
    Number = "NUMBER",
    Object = "OBJECT",
    String = "STRING"
}
export declare enum ActionScope {
    Edge = "EDGE",
    Instant = "INSTANT",
    Node = "NODE",
    Zone = "ZONE"
}
/**
 * Regulates if the action is allowed to be executed during movement and/or parallel to
 * other actions. NONE: allows driving and other actions; SINGLE: allows driving but no
 * other actions; SOFT: allows other actions but not driving; HARD: is the only allowed
 * action at that time.
 */
export declare enum BlockingTypeElement {
    Hard = "HARD",
    None = "NONE",
    Single = "SINGLE",
    Soft = "SOFT"
}
export interface OptionalParameter {
    /**
     * Free text. Description of optional parameter. E.g., reason, why the optional parameter
     * ‚direction‘ is necessary for this mobile robot type and which values it can contain. The
     * parameter ‘nodeMarker’ must contain unsigned interger-numbers only. Nurbs-Support is
     * limited to straight lines and circle segments.
     */
    description?: string;
    /**
     * Full name of optional parameter, e.g., “order.nodes.nodePosition.allowedDeviationTheta”
     */
    parameter: string;
    /**
     * Type of support for the optional parameter, the following values are possible: SUPPORTED:
     * optional parameter is supported like specified. REQUIRED: optional parameter is required
     * for proper mobile robot operation.
     */
    support: Support;
    [property: string]: any;
}
/**
 * Type of support for the optional parameter, the following values are possible: SUPPORTED:
 * optional parameter is supported like specified. REQUIRED: optional parameter is required
 * for proper mobile robot operation.
 */
export declare enum Support {
    Required = "REQUIRED",
    Supported = "SUPPORTED"
}
/**
 * This JSON-object describes the protocol limitations of the mobile robot. If a parameter
 * is not defined or set to zero then there is no explicit limit for this parameter.
 */
export interface ProtocolLimits {
    /**
     * Maximum lengths of arrays
     */
    maximumArrayLengths: MaximumArrayLengths;
    /**
     * Maximum lengths of strings
     */
    maximumStringLengths: MaximumStringLengths;
    /**
     * Timing information
     */
    timing: Timing;
    [property: string]: any;
}
/**
 * Maximum lengths of arrays
 */
export interface MaximumArrayLengths {
    /**
     * Maximum number of parameters per action processable by the mobile robot
     */
    "actions.actionsParameters"?: number;
    /**
     * Maximum number of actions per edge processable by the mobile robot
     */
    "edge.actions"?: number;
    /**
     * Maximum number of error references sent by the mobile robot for each error
     */
    "error.errorReferences"?: number;
    /**
     * Maximum number of info references sent by the mobile robot for each information
     */
    "information.infoReferences"?: number;
    /**
     * Maximum number of instant actions per message processable by the mobile robot
     */
    instantActions?: number;
    /**
     * Maximum number of actions per node processable by the mobile robot
     */
    "node.actions"?: number;
    /**
     * Maximum number of edges per order processable by the mobile robot
     */
    "order.edges"?: number;
    /**
     * Maximum number of nodes per order processable by the mobile robot
     */
    "order.nodes"?: number;
    /**
     * Maximum number of actionStates sent by the mobile robot
     */
    "state.actionStates"?: number;
    /**
     * Maximum number of edgeStates sent by the mobile robot, maximum number of edges in base of
     * mobile robot
     */
    "state.edgeStates"?: number;
    /**
     * Maximum number of errors sent by the mobile robot in one state-message
     */
    "state.errors"?: number;
    /**
     * Maximum number of information objects sent by the mobile robot in one state-message
     */
    "state.information"?: number;
    /**
     * Maximum number of instantActionStates sent by the mobile robot
     */
    "state.instantActionStates"?: number;
    /**
     * Maximum number of load-objects sent by the mobile robot
     */
    "state.loads"?: number;
    /**
     * Maximum number of nodeStates sent by the mobile robot, maximum number of nodes in base of
     * mobile robot
     */
    "state.nodeStates"?: number;
    /**
     * Maximum number of zoneActionStates sent by the mobile robot
     */
    "state.zoneActionStates"?: number;
    /**
     * Maximum number of control points per trajectory processable by the mobile robot
     */
    "trajectory.controlPoints"?: number;
    /**
     * Maximum number of knots per trajectory processable by the mobile robot
     */
    "trajectory.knotVector"?: number;
    /**
     * Maximum number of zones per zoneSet processable by the mobile robot
     */
    "zoneSet.zones"?: number;
    [property: string]: any;
}
/**
 * Maximum lengths of strings
 */
export interface MaximumStringLengths {
    /**
     * If true ID-strings need to contain numerical values only
     */
    idNumericalOnly?: boolean;
    /**
     * Maximum length of ID-Strings. Affected parameters: order.orderId, node.nodeId,
     * nodePosition.mapId, action.actionId, edge.edgeId
     */
    maximumIdLength?: number;
    /**
     * Maximum length of loadId Strings
     */
    maximumLoadIdLength?: number;
    /**
     * Maximum MQTT Message length
     */
    maximumMessageLength?: number;
    /**
     * Maximum length of all other parts in MQTT-topics. Affected parameters: order.timestamp,
     * order.version, order.manufacturer, instantActions.timestamp, instantActions.version,
     * instantActions.manufacturer, state.timestamp, state.version, state.manufacturer,
     * visualization.timestamp, visualization.version, visualization.manufacturer,
     * connection.timestamp, connection.version, connection.manufacturer
     */
    maximumTopicElementLength?: number;
    /**
     * Maximum length of serial-number part in MQTT-topics. Affected Parameters:
     * order.serialNumber, instantActions.serialNumber, state.SerialNumber,
     * visualization.serialNumber, connection.serialNumber
     */
    maximumTopicSerialLength?: number;
    [property: string]: any;
}
/**
 * Timing information
 */
export interface Timing {
    /**
     * Default interval for sending state-messages if not defined, the default value from the
     * main document is used
     */
    defaultStateInterval?: number;
    /**
     * Minimum interval sending order messages to the mobile robot
     */
    minimumOrderInterval: number;
    /**
     * Minimum interval for sending state-messages
     */
    minimumStateInterval: number;
    /**
     * Default interval for sending messages on visualization topic
     */
    visualizationInterval?: number;
    [property: string]: any;
}
/**
 * These parameters generally specify the class and the capabilities of the mobile robot
 */
export interface TypeSpecification {
    /**
     * Simplified description of localization type.
     */
    localizationTypes: string[];
    /**
     * Maximum loadable mass
     */
    maximumLoadMass: number;
    /**
     * Simplified description of mobile robot class. Extensible enum: FORKLIFT, CONVEYOR,
     * TUGGER, CARRIER
     */
    mobileRobotClass: string;
    /**
     * Simplified description of mobile robots kinematics-type. Extensible enum: DIFFERENTIAL,
     * OMNIDIRECTIONAL, THREE_WHEEL
     */
    mobileRobotKinematics?: string;
    /**
     * List of path planning types supported by the mobile robot, sorted by priority
     */
    navigationTypes: string[];
    /**
     * Free text human readable description of the mobile robot type series
     */
    seriesDescription?: string;
    /**
     * Free text generalized series name as specified by manufacturer
     */
    seriesName: string;
    /**
     * Array of zone types supported by the mobile robot.
     */
    supportedZones?: ZoneType[];
    mobileRobotKinematic: any;
    [property: string]: any;
}
/**
 * Zone category.
 */
export declare enum ZoneType {
    Action = "ACTION",
    Bidirected = "BIDIRECTED",
    Blocked = "BLOCKED",
    CoordinatedReplanning = "COORDINATED_REPLANNING",
    Directed = "DIRECTED",
    LineGuided = "LINE_GUIDED",
    Penalty = "PENALTY",
    Priority = "PRIORITY",
    Release = "RELEASE",
    SpeedLimit = "SPEED_LIMIT"
}
/**
 * JSON Schema for publishing instantActions that the mobile robot is to execute as soon as
 * they arrive.
 */
export interface InstantActions {
    actions: InstantActionsAction[];
    /**
     * headerId of the message. The headerId is defined per topic and incremented by 1 with each
     * sent (but not necessarily received) message.
     */
    headerId: number;
    /**
     * Manufacturer of the mobile robot
     */
    manufacturer: string;
    /**
     * Serial number of the mobile robot.
     */
    serialNumber: string;
    /**
     * Timestamp in ISO8601 format (YYYY-MM-DDTHH:mm:ss.fffZ).
     */
    timestamp: string;
    /**
     * Version of the protocol [Major].[Minor].[Patch]
     */
    version: string;
    [property: string]: any;
}
/**
 * Describes an action that the mobile robot can perform.
 */
export interface InstantActionsAction {
    /**
     * Additional information on the action.
     */
    actionDescriptor?: string;
    /**
     * Unique ID to identify the action and map them to the actionState in the state.
     * Suggestion: Use UUID.
     */
    actionId: string;
    /**
     * Action parameters for the indicated action, e.g., deviceId, loadId, external Triggers.
     */
    actionParameters?: PurpleActionParameter[];
    /**
     * Name of action. Identifies the function of the action.
     */
    actionType: string;
    /**
     * The blocking type of an instant action is always NONE: action can happen in parallel with
     * others, including movement.
     */
    blockingType: PurpleBlockingType;
    [property: string]: any;
}
export interface PurpleActionParameter {
    /**
     * The key of the action parameter.
     */
    key: string;
    /**
     * The value of the action parameter
     */
    value: any[] | boolean | number | number | {
        [key: string]: any;
    } | string;
    [property: string]: any;
}
/**
 * The blocking type of an instant action is always NONE: action can happen in parallel with
 * others, including movement.
 */
export declare enum PurpleBlockingType {
    None = "NONE"
}
/**
 * The message schema to communicate orders from fleet control to the mobile robot.
 */
export interface Order {
    /**
     * Directional connection between two nodes. Array of edge objects to be traversed for
     * fulfilling the order. One node is enough for a valid order. Leave edge list empty for
     * that case.
     */
    edges: Edge[];
    /**
     * headerId of the message. The headerId is defined per topic and incremented by 1 with each
     * sent (but not necessarily received) message.
     */
    headerId: number;
    /**
     * Manufacturer of the mobile robot
     */
    manufacturer: string;
    /**
     * Array of nodes objects to be traversed for fulfilling the order. One node is enough for a
     * valid order. Leave edge list empty for that case.
     */
    nodes: Node[];
    /**
     * Additional human-readable information only for visualization purposes; this shall not be
     * used for any logical processes.
     */
    orderDescription?: string;
    /**
     * Order Identification. This is to be used to identify multiple order messages that belong
     * to the same order.
     */
    orderId: string;
    /**
     * Order update identification. It is unique per orderId, starting at 0 for a new order. If
     * an order update is rejected, this field shall be passed in the rejection message.
     */
    orderUpdateId: number;
    /**
     * Serial number of the mobile robot.
     */
    serialNumber: string;
    /**
     * Timestamp in ISO8601 format (YYYY-MM-DDTHH:mm:ss.fffZ).
     */
    timestamp: string;
    /**
     * Version of the protocol [Major].[Minor].[Patch]
     */
    version: string;
    [property: string]: any;
}
export interface Edge {
    /**
     * Array of action objects with detailed information.
     */
    actions: EdgeAction[];
    corridor?: Corridor;
    /**
     * Sets direction at junctions for line-guided or wire-guided mobile robots, to be defined
     * initially (mobile robot-individual).
     */
    direction?: string;
    /**
     * Additional information on the edge.
     */
    edgeDescriptor?: string;
    /**
     * Identifier of the edge. May not be unique among the edges of the same order.
     */
    edgeId: string;
    /**
     * Distance of the path from the start node to the end node in meters. Optional: This value
     * is used by line-guided mobile robots to decrease their speed before reaching a stop
     * position.
     */
    length?: number;
    /**
     * Permitted maximum height of the mobile robot, including the load, on edge in meters.
     */
    maximumMobileRobotHeight?: number;
    /**
     * Permitted maximum speed on the edge in m/s. Speed is defined by the fastest measurement
     * of the mobile robot.
     */
    maximumSpeed?: number;
    /**
     * Maximum rotation speed in rad/s. Optional: No limit, if not set.
     */
    maxRotationSpeed?: number;
    /**
     * Permitted minimal height of the load handling device on the edge in meters
     */
    minimumLoadHandlingDeviceHeight?: number;
    /**
     * Orientation of the mobile robot on the edge. The value orientationType defines if it has
     * to be interpreted relative to the global project specific map coordinate system or
     * tangential to the edge. In case of interpreted tangential to the edge 0.0 = forwards and
     * PI = backwards. Example: orientation Pi/2 rad will lead to a rotation of 90 degrees. If
     * mobile robot starts in different orientation, rotate the mobile robot on the edge to the
     * desired orientation if rotationAllowed is set to True. If rotationAllowed is False,
     * rotate before entering the edge. If that is not possible, reject the order. If no
     * trajectory is defined, apply the rotation to the direct path between the two connecting
     * nodes of the edge. If a trajectory is defined for the edge, apply the orientation to the
     * trajectory.
     */
    orientation?: number;
    /**
     * Enum {GLOBAL, TANGENTIAL}: GLOBAL: relative to the global project specific map coordinate
     * system; TANGENTIAL: tangential to the edge. If not defined, the default value is
     * TANGENTIAL.
     */
    orientationType?: string;
    /**
     * True: Desired edge orientation shall be reached before entering the edge. False: Mobile
     * robot can rotate into the desired orientation on the edge. Default: False.
     */
    reachOrientationBeforeEntering?: boolean;
    /**
     * True indicates that the edge is part of the base. False indicates that the edge is part
     * of the horizon.
     */
    released: boolean;
    /**
     * Number to track the sequence of nodes and edges in an order and to simplify order
     * updates. The sequenceId is shared between nodes and edges and defines the sequence of
     * traversal.
     */
    sequenceId: number;
    /**
     * Trajectory JSON-object for this edge as a NURBS. Defines the curve, on which the mobile
     * robot should move between the start node and the end node. Optional: Can be omitted, if
     * mobile robot cannot process trajectories or if mobile robot plans its own trajectory.
     */
    trajectory?: Trajectory;
    [property: string]: any;
}
/**
 * Describes an action that the mobile robot can perform.
 */
export interface EdgeAction {
    /**
     * Additional information on the action.
     */
    actionDescriptor?: string;
    /**
     * Unique ID to identify the action and map them to the actionState in the state.
     * Suggestion: Use UUIDs.
     */
    actionId: string;
    /**
     * Action parameters for the indicated action, e.g., deviceId, loadId, external Triggers.
     */
    actionParameters?: FluffyActionParameter[];
    /**
     * Name of the action. Identifies the function of the action.
     */
    actionType: string;
    /**
     * Regulates if the action is allowed to be executed during movement and/or parallel to
     * other actions. NONE: allows driving and other actions; SINGLE: allows driving but no
     * other actions; SOFT: allows other actions but not driving; HARD: is the only allowed
     * action at that time.
     */
    blockingType: BlockingTypeElement;
    /**
     * True: action can enter RETRIABLE state if it fails. False: action enters FAILED state
     * directly after it fails. Default: false.
     */
    retriable?: boolean;
    [property: string]: any;
}
export interface FluffyActionParameter {
    /**
     * The key of the action parameter.
     */
    key: string;
    /**
     * The value of the action parameter
     */
    value: any[] | boolean | number | number | {
        [key: string]: any;
    } | string;
    [property: string]: any;
}
/**
 * Definition of boundaries in which a mobile robot can deviate from its trajectory, e. g.
 * to avoid obstacles.
 */
export interface Corridor {
    /**
     * Defines whether the boundaries are valid for the kinematic center or the contour of the
     * mobile robot.
     */
    corridorReferencePoint?: CorridorReferencePoint;
    /**
     * Defines the width of the corridor in meters to the left related to the trajectory of the
     * mobile robot.
     */
    leftWidth: number;
    /**
     * Defines how the robot shall behave in case its release of a corridor expires or gets
     * revoked by the fleet control. Default: STOP
     */
    releaseLossBehavior?: ReleaseLossBehavior;
    /**
     * Optional flag that indicates if the robot must request approval from the fleet control.
     * If not defined, no release is required.
     */
    releaseRequired?: boolean;
    /**
     * Defines the width of the corridor in meters to the right related to the trajectory of the
     * mobile robot.
     */
    rightWidth: number;
    [property: string]: any;
}
/**
 * Defines whether the boundaries are valid for the kinematic center or the contour of the
 * mobile robot.
 */
export declare enum CorridorReferencePoint {
    Contour = "CONTOUR",
    KinematicCenter = "KINEMATIC_CENTER"
}
/**
 * Defines how the robot shall behave in case its release of a corridor expires or gets
 * revoked by the fleet control. Default: STOP
 */
export declare enum ReleaseLossBehavior {
    Return = "RETURN",
    Stop = "STOP"
}
/**
 * Trajectory JSON-object for this edge as a NURBS. Defines the curve, on which the mobile
 * robot should move between the start node and the end node. Optional: Can be omitted, if
 * mobile robot cannot process trajectories or if mobile robot plans its own trajectory.
 *
 * Reports the trajectory that has been defined a priori within a layout or was sent for
 * this edge as part of the order.
 */
export interface Trajectory {
    /**
     * List of JSON controlPoint objects defining the control points of the NURBS, which
     * includes the beginning and end point.
     */
    controlPoints: ControlPoint[];
    /**
     * Degree of the NURBS curve defining the trajectory. If not defined, the default value is 1.
     */
    degree?: number;
    /**
     * Sequence of parameter values that determines where and how the control points affect the
     * NURBS curve.
     */
    knotVector?: number[];
    [property: string]: any;
}
export interface ControlPoint {
    /**
     * The weight, with which this control point pulls on the curve. When not defined, the
     * default will be 1.0.
     */
    weight?: number;
    /**
     * X coordinate described in the world coordinate system.
     */
    x: number;
    /**
     * Y coordinate described in the world coordinate system.
     */
    y: number;
    [property: string]: any;
}
export interface Node {
    /**
     * Array of actions to be executed on a node. Empty array, if no actions required.
     */
    actions: EdgeAction[];
    /**
     * Additional information on the node.
     */
    nodeDescriptor?: string;
    /**
     * Identifier of the node. May not be unique among the nodes of the same order.
     */
    nodeId: string;
    /**
     * Defines the position on a map in a global project-specific world coordinate system. Each
     * floor has its own map. All maps must use the same project specific global origin.
     * Optional for mobile robot-types that do not require the node position (e.g., line-guided
     * mobile robots).
     */
    nodePosition?: NodeNodePosition;
    /**
     * True indicates that the node is part of the base. False indicates that the node is part
     * of the horizon.
     */
    released: boolean;
    /**
     * Number to track the sequence of nodes and edges in an order and to simplify order
     * updates. The main purpose is to distinguish between a node which is passed more than once
     * within one orderId. The sequenceId is shared between nodes and edges and defines the
     * sequence of traversal.
     */
    sequenceId: number;
    [property: string]: any;
}
/**
 * Defines the position on a map in a global project-specific world coordinate system. Each
 * floor has its own map. All maps must use the same project specific global origin.
 * Optional for mobile robot-types that do not require the node position (e.g., line-guided
 * mobile robots).
 */
export interface NodeNodePosition {
    /**
     * Indicates how big the deviation of theta angle can be. The lowest acceptable angle is
     * theta - allowedDeviationTheta and the highest acceptable angle is theta +
     * allowedDeviationTheta.
     */
    allowedDeviationTheta?: number;
    /**
     * Indicates how precisely a mobile robot shall match the position of a node for it to be
     * considered traversed. If a = b= 0.0: no deviation is allowed, which means the mobile
     * robot shall reach or pass the node position with the mobile robot control point as
     * precisely as is technically possible for the mobile robot. This applies also if
     * allowedDeviationXY is smaller than what is technically viable for the mobile robot. If
     * the mobile robot supports this attribute, but it is not defined for this node by fleet
     * control the mobile robot shall assume the value of a and b as 0.0. The coordinates of the
     * node defines the center of the ellipse.
     */
    allowedDeviationXY?: AllowedDeviationXY;
    /**
     * Unique identification of the map in which the position is referenced.
     */
    mapId: string;
    /**
     * Absolute orientation of the mobile robot on the node. Optional: mobile robot can plan the
     * path by itself. If defined, the mobile robot has to assume the theta angle on this node.
     * If previous edge disallows rotation, the mobile robot must rotate on the node. If
     * following edge has a differing orientation defined but disallows rotation, the mobile
     * robot is to rotate on the node to the edges desired rotation before entering the edge.
     */
    theta?: number;
    /**
     * X-position on the map in reference to the map coordinate system. Precision is up to the
     * specific implementation.
     */
    x: number;
    /**
     * Y-position on the map in reference to the map coordinate system. Precision is up to the
     * specific implementation.
     */
    y: number;
    [property: string]: any;
}
/**
 * Indicates how precisely a mobile robot shall match the position of a node for it to be
 * considered traversed. If a = b= 0.0: no deviation is allowed, which means the mobile
 * robot shall reach or pass the node position with the mobile robot control point as
 * precisely as is technically possible for the mobile robot. This applies also if
 * allowedDeviationXY is smaller than what is technically viable for the mobile robot. If
 * the mobile robot supports this attribute, but it is not defined for this node by fleet
 * control the mobile robot shall assume the value of a and b as 0.0. The coordinates of the
 * node defines the center of the ellipse.
 */
export interface AllowedDeviationXY {
    /**
     * Length of the ellipse semi-major axis in meters
     */
    a: number;
    /**
     * Length of the ellipse semi-minor axis in meters
     */
    b: number;
    /**
     * Rotation angle in radians
     */
    theta: number;
    [property: string]: any;
}
/**
 * Responses from fleet control to mobile robot's requests.
 */
export interface Responses {
    /**
     * Header ID of the message. The headerId is defined per topic and incremented by 1 with
     * each sent (but not necessarily received) message.
     */
    headerId: number;
    /**
     * Manufacturer of the mobile robot.
     */
    manufacturer: string;
    /**
     * Array of zone response objects.
     */
    responses: Response[];
    /**
     * Serial number of the mobile robot.
     */
    serialNumber: string;
    /**
     * Timestamp (ISO 8601, UTC); YYYY-MM-DDTHH:mm:ss.fffZ (e.g., '2017-04-15T11:40:03.123Z').
     */
    timestamp: string;
    /**
     * Version of the protocol [Major].[Minor].[Patch]
     */
    version: string;
    [property: string]: any;
}
export interface Response {
    /**
     * Enum {'GRANTED','QUEUED','REVOKED','REJECTED'}. 'GRANTED': fleet control grants request.
     * 'REVOKED': fleet control revokes previously granted request. 'REJECTED': fleet control
     * rejects a request. 'QUEUED': Acknowledge the mobile robot's request to the fleet control,
     * but no permission is given yet. Request was added to some sort of a queue.
     */
    grantType: GrantType;
    /**
     * Timestamp (ISO 8601, UTC); YYYY-MM-DDTHH:mm:ss.fffZ (e.g., '2017-04-15T11:40:03.123Z').
     */
    leaseExpiry?: string;
    /**
     * Unique per mobile robot identifier within all active requests.
     */
    requestId: string;
    [property: string]: any;
}
/**
 * Enum {'GRANTED','QUEUED','REVOKED','REJECTED'}. 'GRANTED': fleet control grants request.
 * 'REVOKED': fleet control revokes previously granted request. 'REJECTED': fleet control
 * rejects a request. 'QUEUED': Acknowledge the mobile robot's request to the fleet control,
 * but no permission is given yet. Request was added to some sort of a queue.
 */
export declare enum GrantType {
    Granted = "GRANTED",
    Queued = "QUEUED",
    Rejected = "REJECTED",
    Revoked = "REVOKED"
}
/**
 * State of the mobile robot.
 */
export interface State {
    /**
     * Array of the current actions and the actions which are yet to be finished. This may
     * include actions from previous nodes that are still in progress
     * When an action is completed, an updated state message is published with actionStatus set
     * to finished and if applicable with the corresponding resultDescriptor. The actionStates
     * are kept until a new order is received.
     */
    actionStates: ActionState[];
    /**
     * Used by line guided vehicles to indicate the distance it has been driving past the
     * lastNodeId. Distance is in meters.
     */
    distanceSinceLastNode?: number;
    /**
     * True: indicates that the mobile robot is driving and/or rotating. Other movements of the
     * mobile robot (e.g., lift movements) are not included here.
     * False: indicates that the mobile robot is neither driving nor rotating
     */
    driving: boolean;
    /**
     * Array of edgeRequest objects that are currently active on the mobile robot. Empty array
     * if no edge requests are active.
     */
    edgeRequests?: EdgeRequest[];
    /**
     * Array of edgeState-Objects, that need to be traversed for fulfilling the order, empty
     * list if idle.
     */
    edgeStates: EdgeState[];
    /**
     * Array of error-objects. All active errors of the mobile robot should be in the list. An
     * empty array indicates that the mobile robot has no active errors.
     */
    errors: Error[];
    /**
     * headerId of the message. The headerId is defined per topic and incremented by 1 with each
     * sent (but not necessarily received) message.
     */
    headerId: number;
    /**
     * Array of info-objects. An empty array indicates, that the mobile robot has no
     * information. This should only be used for visualization or debugging – it must not be
     * used for logic in fleet control.
     */
    information?: Info[];
    /**
     * Array of all instant action states that the mobile robot received. Empty array if the
     * mobile robot has not received any instant actions. Instant actions are kept in the state
     * until restart or action clearInstantActions is executed.
     */
    instantActionStates: ActionState[];
    intermediatePath?: IntermediatePath;
    /**
     * Node ID of last reached node or, if mobile robot is currently on a node, current node
     * (e.g., "node7"). Empty string ("") if no lastNodeId is available.
     */
    lastNodeId: string;
    /**
     * sequenceId of the last reached node or, if the mobile robot is currently on a node,
     * sequenceId of current node. 0 if no lastNodeSequenceId is available.
     */
    lastNodeSequenceId: number;
    /**
     * Loads, that are currently handled by the mobile robot. Optional: If mobile robot cannot
     * determine load state, leave the array out of the state. If the mobile robot can determine
     * the load state, but the array is empty, the mobile robot is considered unloaded.
     */
    loads?: Load[];
    /**
     * Manufacturer of the mobile robot
     */
    manufacturer: string;
    /**
     * Array of map-objects that are currently stored on the mobile robot.
     */
    maps?: Map[];
    mobileRobotPosition?: MobileRobotPosition;
    /**
     * True: mobile robot is almost at the end of the base and will reduce speed if no new base
     * is transmitted. Trigger for fleet control to send new base
     * False: no base update required.
     */
    newBaseRequest?: boolean;
    /**
     * Array of nodeState-Objects, that need to be traversed for fulfilling the order. Empty
     * list if idle.
     */
    nodeStates: NodeState[];
    /**
     * Current operating mode of the mobile robot.
     */
    operatingMode: OperatingMode;
    /**
     * Unique order identification of the current order or the previous finished order. The
     * orderId is kept until a new order is received. Empty string ("") if no previous orderId
     * is available.
     */
    orderId: string;
    /**
     * Order Update Identification to identify that an order update has been accepted by the
     * mobile robot. 0 if no previous orderUpdateId is available.
     */
    orderUpdateId: number;
    /**
     * True: mobile robot is currently in a paused state, either because of the push of a
     * physical button on the mobile robot or because of an instantAction. The mobile robot can
     * resume the order.
     * False: The mobile robot is currently not in a paused state.
     */
    paused?: boolean;
    plannedPath?: PlannedPath;
    powerSupply: PowerSupply;
    safetyState: SafetyState;
    /**
     * Serial number of the mobile robot.
     */
    serialNumber: string;
    /**
     * Timestamp in ISO8601 format (YYYY-MM-DDTHH:mm:ss.fffZ).
     */
    timestamp: string;
    /**
     * The mobile robot's velocity in mobile robot coordinates
     */
    velocity?: StateVelocity;
    /**
     * Version of the protocol [Major].[Minor].[Patch]
     */
    version: string;
    /**
     * Array of all zone actions that are in an end state or are currently running; sharing
     * upcoming actions is optional. Zone action states are kept in the state message until
     * restart or action clearZoneActions is executed.
     */
    zoneActionStates?: ActionState[];
    /**
     * Array of zoneRequest objects that are currently active on the mobile robot. Empty array
     * if no zone requests are active.
     */
    zoneRequests?: ZoneRequest[];
    /**
     * Array of zoneSet objects that are currently stored on the mobile robot.
     */
    zoneSets?: ZoneSetElement[];
    [property: string]: any;
}
export interface ActionState {
    /**
     * A user-defined, human-readable name or descriptor.
     */
    actionDescriptor?: string;
    /**
     * Unique actionId
     */
    actionId: string;
    /**
     * Description of the result, e.g., the result of a RFID-read. Errors will be transmitted in
     * errors.
     */
    actionResult?: string;
    /**
     * WAITING: waiting for the trigger (passing the mode, entering the edge); INITIALIZING:
     * Action was triggered, preparatory measures are initiated; RUNNING: The action is running;
     * RETRIABLE: Actions that failed, but can be retried; PAUSED: paused by instantAction or
     * external trigger; FINISHED: The action is finished; FAILED: action could not be performed.
     */
    actionStatus: ActionStatus;
    /**
     * actionType of the action. Optional: Only for informational or visualization purposes.
     * Order knows the type.
     */
    actionType?: string;
    [property: string]: any;
}
/**
 * WAITING: waiting for the trigger (passing the mode, entering the edge); INITIALIZING:
 * Action was t