import { int16_t, int32_t, uint8_t, uint16_t, uint32_t, uint64_t, float } from './types';
import { MavLinkPacketRegistry, MavLinkPacketField, MavLinkData } from './mavlink';
import { LandingTargetType, MavLinkCommandRegistry, MavParamType, MavProtocolCapability, ParamAck } from './common';
/**
 * WiFi wireless security protocols.
 */
export declare enum WifiNetworkSecurity {
    /**
     * Undefined or unknown security protocol.
     */
    'UNDEFINED' = 0,
    /**
     * Open network, no security.
     */
    'OPEN' = 1,
    /**
     * WEP.
     */
    'WEP' = 2,
    /**
     * WPA1.
     */
    'WPA1' = 3,
    /**
     * WPA2.
     */
    'WPA2' = 4,
    /**
     * WPA3.
     */
    'WPA3' = 5
}
/**
 * Airspeed sensor flags
 */
export declare enum AirspeedSensorFlags {
    /**
     * Airspeed sensor is unhealthy
     */
    'UNHEALTHY' = 0,
    /**
     * True if the data from this sensor is being actively used by the flight controller for guidance,
     * navigation or control.
     */
    'USING' = 1
}
/**
 * Possible transport layers to set and get parameters via mavlink during a parameter transaction.
 */
export declare enum ParamTransactionTransport {
    /**
     * Transaction over param transport.
     */
    'PARAM' = 0,
    /**
     * Transaction over param_ext transport.
     */
    'PARAM_EXT' = 1
}
/**
 * Possible parameter transaction actions.
 */
export declare enum ParamTransactionAction {
    /**
     * Commit the current parameter transaction.
     */
    'START' = 0,
    /**
     * Commit the current parameter transaction.
     */
    'COMMIT' = 1,
    /**
     * Cancel the current parameter transaction.
     */
    'CANCEL' = 2
}
/**
 * Standard modes with a well understood meaning across flight stacks and vehicle types. For example,
 * most flight stack have the concept of a "return" or "RTL" mode that takes a vehicle to safety, even
 * though the precise mechanics of this mode may differ. Modes may be set using
 * MAV_CMD_DO_SET_STANDARD_MODE.
 */
export declare enum MavStandardMode {
    /**
     * Non standard mode. This may be used when reporting the mode if the current flight mode is not a
     * standard mode.
     */
    'NON_STANDARD' = 0,
    /**
     * Position mode (manual). Position-controlled and stabilized manual mode. When sticks are released
     * vehicles return to their level-flight orientation and hold both position and altitude against wind
     * and external forces. This mode can only be set by vehicles that can hold a fixed position.
     * Multicopter (MC) vehicles actively brake and hold both position and altitude against wind and
     * external forces. Hybrid MC/FW ("VTOL") vehicles first transition to multicopter mode (if needed) but
     * otherwise behave in the same way as MC vehicles. Fixed-wing (FW) vehicles must not support this
     * mode. Other vehicle types must not support this mode (this may be revisited through the PR process).
     *
     */
    'POSITION_HOLD' = 1,
    /**
     * Orbit (manual). Position-controlled and stabilized manual mode. The vehicle circles around a fixed
     * setpoint in the horizontal plane at a particular radius, altitude, and direction. Flight stacks may
     * further allow manual control over the setpoint position, radius, direction, speed, and/or altitude
     * of the circle, but this is not mandated. Flight stacks may support the
     * [MAV_CMD_DO_ORBIT](https://mavlink.io/en/messages/common.html#MAV_CMD_DO_ORBIT) for changing the
     * orbit parameters. MC and FW vehicles may support this mode. Hybrid MC/FW ("VTOL") vehicles may
     * support this mode in MC/FW or both modes; if the mode is not supported by the current configuration
     * the vehicle should transition to the supported configuration. Other vehicle types must not support
     * this mode (this may be revisited through the PR process).
     */
    'ORBIT' = 2,
    /**
     * Cruise mode (manual). Position-controlled and stabilized manual mode. When sticks are released
     * vehicles return to their level-flight orientation and hold their original track against wind and
     * external forces. Fixed-wing (FW) vehicles level orientation and maintain current track and altitude
     * against wind and external forces. Hybrid MC/FW ("VTOL") vehicles first transition to FW mode (if
     * needed) but otherwise behave in the same way as MC vehicles. Multicopter (MC) vehicles must not
     * support this mode. Other vehicle types must not support this mode (this may be revisited through the
     * PR process).
     */
    'CRUISE' = 3,
    /**
     * Altitude hold (manual). Altitude-controlled and stabilized manual mode. When sticks are released
     * vehicles return to their level-flight orientation and hold their altitude. MC vehicles continue with
     * existing momentum and may move with wind (or other external forces). FW vehicles continue with
     * current heading, but may be moved off-track by wind. Hybrid MC/FW ("VTOL") vehicles behave according
     * to their current configuration/mode (FW or MC). Other vehicle types must not support this mode (this
     * may be revisited through the PR process).
     */
    'ALTITUDE_HOLD' = 4,
    /**
     * Return home mode (auto). Automatic mode that returns vehicle to home via a safe flight path. It may
     * also automatically land the vehicle (i.e. RTL). The precise flight path and landing behaviour depend
     * on vehicle configuration and type.
     */
    'RETURN_HOME' = 5,
    /**
     * Safe recovery mode (auto). Automatic mode that takes vehicle to a predefined safe location via a
     * safe flight path (rally point or mission defined landing) . It may also automatically land the
     * vehicle. The precise return location, flight path, and landing behaviour depend on vehicle
     * configuration and type.
     */
    'SAFE_RECOVERY' = 6,
    /**
     * Mission mode (automatic). Automatic mode that executes MAVLink missions. Missions are executed from
     * the current waypoint as soon as the mode is enabled.
     */
    'MISSION' = 7,
    /**
     * Land mode (auto). Automatic mode that lands the vehicle at the current location. The precise landing
     * behaviour depends on vehicle configuration and type.
     */
    'LAND' = 8,
    /**
     * Takeoff mode (auto). Automatic takeoff mode. The precise takeoff behaviour depends on vehicle
     * configuration and type.
     */
    'TAKEOFF' = 9
}
/**
 * Mode properties.
 */
export declare enum MavModeProperty {
    /**
     * If set, this mode is an advanced mode. For example a rate-controlled manual mode might be advanced,
     * whereas a position-controlled manual mode is not. A GCS can optionally use this flag to configure
     * the UI for its intended users.
     */
    'ADVANCED' = 1,
    /**
     * If set, this mode should not be added to the list of selectable modes. The mode might still be
     * selected by the FC directly (for example as part of a failsafe).
     */
    'NOT_USER_SELECTABLE' = 2
}
/**
 * Battery status flags for fault, health and state indication.
 */
export declare enum MavBatteryStatusFlags {
    /**
     * The battery is not ready to use (fly). Set if the battery has faults or other conditions that make
     * it unsafe to fly with. Note: It will be the logical OR of other status bits (chosen by the
     * manufacturer/integrator).
     */
    'NOT_READY_TO_USE' = 1,
    /**
     * Battery is charging.
     */
    'CHARGING' = 2,
    /**
     * Battery is cell balancing (during charging). Not ready to use
     * (MAV_BATTERY_STATUS_FLAGS_NOT_READY_TO_USE may be set).
     */
    'CELL_BALANCING' = 4,
    /**
     * Battery cells are not balanced. Not ready to use.
     */
    'FAULT_CELL_IMBALANCE' = 8,
    /**
     * Battery is auto discharging (towards storage level). Not ready to use
     * (MAV_BATTERY_STATUS_FLAGS_NOT_READY_TO_USE would be set).
     */
    'AUTO_DISCHARGING' = 16,
    /**
     * Battery requires service (not safe to fly). This is set at vendor discretion. It is likely to be set
     * for most faults, and may also be set according to a maintenance schedule (such as age, or number of
     * recharge cycles, etc.).
     */
    'REQUIRES_SERVICE' = 32,
    /**
     * Battery is faulty and cannot be repaired (not safe to fly). This is set at vendor discretion. The
     * battery should be disposed of safely.
     */
    'BAD_BATTERY' = 64,
    /**
     * Automatic battery protection monitoring is enabled. When enabled, the system will monitor for
     * certain kinds of faults, such as cells being over-voltage. If a fault is triggered then and
     * protections are enabled then a safety fault (MAV_BATTERY_STATUS_FLAGS_FAULT_PROTECTION_SYSTEM) will
     * be set and power from the battery will be stopped. Note that battery protection monitoring should
     * only be enabled when the vehicle is landed. Once the vehicle is armed, or starts moving, the
     * protections should be disabled to prevent false positives from disabling the output.
     */
    'PROTECTIONS_ENABLED' = 128,
    /**
     * The battery fault protection system had detected a fault and cut all power from the battery. This
     * will only trigger if MAV_BATTERY_STATUS_FLAGS_PROTECTIONS_ENABLED is set. Other faults like
     * MAV_BATTERY_STATUS_FLAGS_FAULT_OVER_VOLT may also be set, indicating the cause of the protection
     * fault.
     */
    'FAULT_PROTECTION_SYSTEM' = 256,
    /**
     * One or more cells are above their maximum voltage rating.
     */
    'FAULT_OVER_VOLT' = 512,
    /**
     * One or more cells are below their minimum voltage rating. A battery that had deep-discharged might
     * be irrepairably damaged, and set both MAV_BATTERY_STATUS_FLAGS_FAULT_UNDER_VOLT and
     * MAV_BATTERY_STATUS_FLAGS_BAD_BATTERY.
     */
    'FAULT_UNDER_VOLT' = 1024,
    /**
     * Over-temperature fault.
     */
    'FAULT_OVER_TEMPERATURE' = 2048,
    /**
     * Under-temperature fault.
     */
    'FAULT_UNDER_TEMPERATURE' = 4096,
    /**
     * Over-current fault.
     */
    'FAULT_OVER_CURRENT' = 8192,
    /**
     * Short circuit event detected. The battery may or may not be safe to use (check other flags).
     */
    'FAULT_SHORT_CIRCUIT' = 16384,
    /**
     * Voltage not compatible with power rail voltage (batteries on same power rail should have similar
     * voltage).
     */
    'FAULT_INCOMPATIBLE_VOLTAGE' = 32768,
    /**
     * Battery firmware is not compatible with current autopilot firmware.
     */
    'FAULT_INCOMPATIBLE_FIRMWARE' = 65536,
    /**
     * Battery is not compatible due to cell configuration (e.g. 5s1p when vehicle requires 6s).
     */
    'FAULT_INCOMPATIBLE_CELLS_CONFIGURATION' = 131072,
    /**
     * Battery capacity_consumed and capacity_remaining values are relative to a full battery (they sum to
     * the total capacity of the battery). This flag would be set for a smart battery that can accurately
     * determine its remaining charge across vehicle reboots and discharge/recharge cycles. If unset the
     * capacity_consumed indicates the consumption since vehicle power-on, as measured using a power
     * monitor. The capacity_remaining, if provided, indicates the estimated remaining capacity on the
     * assumption that the battery was full on vehicle boot. If unset a GCS is recommended to advise that
     * users fully charge the battery on power on.
     */
    'CAPACITY_RELATIVE_TO_FULL' = 262144,
    /**
     * Reserved (not used). If set, this will indicate that an additional status field exists for higher
     * status values.
     */
    'EXTENDED' = 4294967295
}
/**
 * Commands to be executed by the MAV. They can be executed on user request, or as part of a mission
 * script. If the action is used in a mission, the parameter mapping to the waypoint/mission message is
 * as follows: Param 1, Param 2, Param 3, Param 4, X: Param 5, Y:Param 6, Z:Param 7. This command list
 * is similar what ARINC 424 is for commercial aircraft: A data format how to interpret
 * waypoint/mission data. NaN and INT32_MAX may be used in float/integer params (respectively) to
 * indicate optional/default values (e.g. to use the component's current yaw or latitude rather than a
 * specific value). See https://mavlink.io/en/guide/xml_schema.html#MAV_CMD for information about the
 * structure of the MAV_CMD entries
 */
export declare enum MavCmd {
    /**
     * Fly a figure eight path as defined by the parameters. Set parameters to NaN/INT32_MAX (as
     * appropriate) to use system-default values. The command is intended for fixed wing vehicles (and VTOL
     * hybrids flying in fixed-wing mode), allowing POI tracking for gimbals that don't support infinite
     * rotation. This command only defines the flight path. Speed should be set independently (use e.g.
     * MAV_CMD_DO_CHANGE_SPEED). Yaw and other degrees of freedom are not specified, and will be
     * flight-stack specific (on vehicles where they can be controlled independent of the heading).
     *
     * @note has location and is destination
     *
     * @param1 Major Radius[m] Major axis radius of the figure eight. Positive: orbit the north circle clockwise. Negative: orbit the north circle counter-clockwise.
          NaN: The radius will be set to 2.5 times the minor radius and direction is clockwise.
          Must be greater or equal to two times the minor radius for feasible values.
     * @param2 Minor Radius[m] Minor axis radius of the figure eight. Defines the radius of the two circles that make up the figure. Negative value has no effect.
          NaN: The radius will be set to the default loiter radius.
     * @param4 Orientation[rad] Orientation of the figure eight major axis with respect to true north (range: [-pi,pi]). NaN: use default orientation aligned to true north.
     * @param5 Latitude/X Center point latitude/X coordinate according to MAV_FRAME. If no MAV_FRAME specified, MAV_FRAME_GLOBAL is assumed.
          INT32_MAX or NaN: Use current vehicle position, or current center if already loitering.
     * @param6 Longitude/Y Center point longitude/Y coordinate according to MAV_FRAME. If no MAV_FRAME specified, MAV_FRAME_GLOBAL is assumed.
          INT32_MAX or NaN: Use current vehicle position, or current center if already loitering.
     * @param7 Altitude/Z Center point altitude MSL/Z coordinate according to MAV_FRAME. If no MAV_FRAME specified, MAV_FRAME_GLOBAL is assumed.
          INT32_MAX or NaN: Use current vehicle altitude.
     */
    'DO_FIGURE_EIGHT' = 35,
    /**
     * Request to start or end a parameter transaction. Multiple kinds of transport layers can be used to
     * exchange parameters in the transaction (param, param_ext and mavftp). The command response can
     * either be a success/failure or an in progress in case the receiving side takes some time to apply
     * the parameters.
     * @param1 Action Action to be performed (start, commit, cancel, etc.)
     * @param2 Transport Possible transport layers to set and get parameters via mavlink during a parameter transaction.
     * @param3 Transaction ID Identifier for a specific transaction.
     */
    'PARAM_TRANSACTION' = 900,
    /**
     * Request a target system to start an upgrade of one (or all) of its components. For example, the
     * command might be sent to a companion computer to cause it to upgrade a connected flight controller.
     * The system doing the upgrade will report progress using the normal command protocol sequence for a
     * long running operation. Command protocol information: https://mavlink.io/en/services/command.html.
     * @param1 Component ID Component id of the component to be upgraded. If set to 0, all components should be upgraded.
     * @param2 Reboot (min: 0, max: 1, increment: 1) 0: Do not reboot component after the action is executed, 1: Reboot component after the action is executed.
     * @param3 Reserved
     * @param4 Reserved
     * @param5 Reserved
     * @param6 Reserved
     * @param7 WIP: upgrade progress report rate (can be used for more granular control).
     */
    'DO_UPGRADE' = 247,
    /**
     * Define start of a group of mission items. When control reaches this command a GROUP_START message is
     * emitted. The end of a group is marked using MAV_CMD_GROUP_END with the same group id. Group ids are
     * expected, but not required, to iterate sequentially. Groups can be nested.
     * @param1 Group ID (min: 0, max: 16777216, increment: 1) Mission-unique group id.
            Group id is limited because only 24 bit integer can be stored in 32 bit float.
     */
    'GROUP_START' = 301,
    /**
     * Define end of a group of mission items. When control reaches this command a GROUP_END message is
     * emitted. The start of the group is marked is marked using MAV_CMD_GROUP_START with the same group
     * id. Group ids are expected, but not required, to iterate sequentially. Groups can be nested.
     * @param1 Group ID (min: 0, max: 16777216, increment: 1) Mission-unique group id.
            Group id is limited because only 24 bit integer can be stored in 32 bit float.
     */
    'GROUP_END' = 302,
    /**
     * Enable the specified standard MAVLink mode. If the mode is not supported the vehicle should ACK with
     * MAV_RESULT_FAILED.
     * @param1 Standard Mode The mode to set.
     */
    'DO_SET_STANDARD_MODE' = 262,
    /**
     * Allows setting an AT S command of an SiK radio.
     * @param1 Radio instance The radio instance, one-based, 0 for all.
     * @param2 Index The Sx index, e.g. 3 for S3 which is NETID.
     * @param3 Value The value to set it to, e.g. default 25 for NETID
     */
    'SET_AT_S_PARAM' = 550
}
/**
 * These flags indicate the sensor reporting capabilities for TARGET_ABSOLUTE.
 */
export declare enum TargetAbsoluteSensorCapabilityFlags {
    'POSITION' = 1,
    'VELOCITY' = 2,
    'ACCELERATION' = 4,
    'ATTITUDE' = 8,
    'RATES' = 16
}
/**
 * The frame of a target observation from an onboard sensor.
 */
export declare enum TargetObsFrame {
    /**
     * NED local tangent frame (x: North, y: East, z: Down) with origin fixed relative to earth.
     */
    'LOCAL_NED' = 0,
    /**
     * FRD local frame aligned to the vehicle's attitude (x: Forward, y: Right, z: Down) with an origin
     * that travels with vehicle.
     */
    'BODY_FRD' = 1,
    /**
     * NED local tangent frame (x: North, y: East, z: Down) with an origin that travels with vehicle.
     */
    'LOCAL_OFFSET_NED' = 2,
    /**
     * Other sensor frame for target observations neither in local NED nor in body FRD.
     */
    'OTHER' = 3
}
/**
 * Response from a PARAM_SET message when it is used in a transaction.
 */
export declare class ParamAckTransaction extends MavLinkData {
    static MSG_ID: number;
    static MSG_NAME: string;
    static PAYLOAD_LENGTH: number;
    static MAGIC_NUMBER: number;
    static FIELDS: MavLinkPacketField[];
    constructor();
    /**
     * Id of system that sent PARAM_SET message.
     */
    targetSystem: uint8_t;
    /**
     * Id of system that sent PARAM_SET message.
     */
    targetComponent: uint8_t;
    /**
     * Parameter id, terminated by NULL if the length is less than 16 human-readable chars and WITHOUT null
     * termination (NULL) byte if the length is exactly 16 chars - applications have to provide 16+1 bytes
     * storage if the ID is stored as string
     */
    paramId: string;
    /**
     * Parameter value (new value if PARAM_ACCEPTED, current value otherwise)
     */
    paramValue: float;
    /**
     * Parameter type.
     */
    paramType: MavParamType;
    /**
     * Result code.
     */
    paramResult: ParamAck;
}
/**
 * Airspeed information from a sensor.
 */
export declare class Airspeed extends MavLinkData {
    static MSG_ID: number;
    static MSG_NAME: string;
    static PAYLOAD_LENGTH: number;
    static MAGIC_NUMBER: number;
    static FIELDS: MavLinkPacketField[];
    constructor();
    /**
     * Sensor ID.
     */
    id: uint8_t;
    /**
     * Calibrated airspeed (CAS).
     * Units: m/s
     */
    airspeed: float;
    /**
     * Temperature. INT16_MAX for value unknown/not supplied.
     * Units: cdegC
     */
    temperature: int16_t;
    /**
     * Raw differential pressure. NaN for value unknown/not supplied.
     * Units: hPa
     */
    rawPress: float;
    /**
     * Airspeed sensor flags.
     */
    flags: AirspeedSensorFlags;
}
/**
 * Detected WiFi network status information. This message is sent per each WiFi network detected in
 * range with known SSID and general status parameters.
 */
export declare class WifiNetworkInfo extends MavLinkData {
    static MSG_ID: number;
    static MSG_NAME: string;
    static PAYLOAD_LENGTH: number;
    static MAGIC_NUMBER: number;
    static FIELDS: MavLinkPacketField[];
    constructor();
    /**
     * Name of Wi-Fi network (SSID).
     */
    ssid: string;
    /**
     * WiFi network operating channel ID. Set to 0 if unknown or unidentified.
     */
    channelId: uint8_t;
    /**
     * WiFi network signal quality.
     * Units: %
     */
    signalQuality: uint8_t;
    /**
     * WiFi network data rate. Set to UINT16_MAX if data_rate information is not supplied.
     * Units: MiB/s
     */
    dataRate: uint16_t;
    /**
     * WiFi network security type.
     */
    security: WifiNetworkSecurity;
}
/**
 * Battery dynamic information. This should be streamed (nominally at 1Hz). Static/invariant battery
 * information is sent in SMART_BATTERY_INFO. Note that smart batteries should set the
 * MAV_BATTERY_STATUS_FLAGS_CAPACITY_RELATIVE_TO_FULL bit to indicate that supplied capacity values are
 * relative to a battery that is known to be full. Power monitors would not set this bit, indicating
 * that capacity_consumed is relative to drone power-on, and that other values are estimated based on
 * the assumption that the battery was full on power-on.
 */
export declare class BatteryStatusV2 extends MavLinkData {
    static MSG_ID: number;
    static MSG_NAME: string;
    static PAYLOAD_LENGTH: number;
    static MAGIC_NUMBER: number;
    static FIELDS: MavLinkPacketField[];
    constructor();
    /**
     * Battery ID
     */
    id: uint8_t;
    /**
     * Temperature of the whole battery pack (not internal electronics). INT16_MAX field not provided.
     * Units: cdegC
     */
    temperature: int16_t;
    /**
     * Battery voltage (total). NaN: field not provided.
     * Units: V
     */
    voltage: float;
    /**
     * Battery current (through all cells/loads). Positive value when discharging and negative if charging.
     * NaN: field not provided.
     * Units: A
     */
    current: float;
    /**
     * Consumed charge. NaN: field not provided. This is either the consumption since power-on or since the
     * battery was full, depending on the value of MAV_BATTERY_STATUS_FLAGS_CAPACITY_RELATIVE_TO_FULL.
     * Units: Ah
     */
    capacityConsumed: float;
    /**
     * Remaining charge (until empty). UINT32_MAX: field not provided. Note: If
     * MAV_BATTERY_STATUS_FLAGS_CAPACITY_RELATIVE_TO_FULL is unset, this value is based on the assumption
     * the battery was full when the system was powered.
     * Units: Ah
     */
    capacityRemaining: float;
    /**
     * Remaining battery energy. Values: [0-100], UINT8_MAX: field not provided.
     * Units: %
     */
    percentRemaining: uint8_t;
    /**
     * Fault, health, readiness, and other status indications.
     */
    statusFlags: MavBatteryStatusFlags;
}
/**
 * Basic component information data. Should be requested using MAV_CMD_REQUEST_MESSAGE on startup, or
 * when required.
 */
export declare class ComponentInformationBasic extends MavLinkData {
    static MSG_ID: number;
    static MSG_NAME: string;
    static PAYLOAD_LENGTH: number;
    static MAGIC_NUMBER: number;
    static FIELDS: MavLinkPacketField[];
    constructor();
    /**
     * Timestamp (time since system boot).
     * Units: ms
     */
    timeBootMs: uint32_t;
    /**
     * Component capability flags
     */
    capabilities: MavProtocolCapability;
    /**
     * Name of the component vendor. Needs to be zero terminated. The field is optional and can be
     * empty/all zeros.
     */
    vendorName: string;
    /**
     * Name of the component model. Needs to be zero terminated. The field is optional and can be empty/all
     * zeros.
     */
    modelName: string;
    /**
     * Software version. The recommended format is SEMVER: 'major.minor.patch' (any format may be used).
     * The field must be zero terminated if it has a value. The field is optional and can be empty/all
     * zeros.
     */
    softwareVersion: string;
    /**
     * Hardware version. The recommended format is SEMVER: 'major.minor.patch' (any format may be used).
     * The field must be zero terminated if it has a value. The field is optional and can be empty/all
     * zeros.
     */
    hardwareVersion: string;
    /**
     * Hardware serial number. The field must be zero terminated if it has a value. The field is optional
     * and can be empty/all zeros.
     */
    serialNumber: string;
}
/**
 * Emitted during mission execution when control reaches MAV_CMD_GROUP_START.
 */
export declare class GroupStart extends MavLinkData {
    static MSG_ID: number;
    static MSG_NAME: string;
    static PAYLOAD_LENGTH: number;
    static MAGIC_NUMBER: number;
    static FIELDS: MavLinkPacketField[];
    constructor();
    /**
     * Mission-unique group id (from MAV_CMD_GROUP_START).
     */
    groupId: uint32_t;
    /**
     * CRC32 checksum of current plan for MAV_MISSION_TYPE_ALL. As defined in MISSION_CHECKSUM message.
     */
    missionChecksum: uint32_t;
    /**
     * Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format
     * (since 1.1.1970 or since system boot) by checking for the magnitude of the number.
     * Units: us
     */
    timeUsec: uint64_t;
}
/**
 * Emitted during mission execution when control reaches MAV_CMD_GROUP_END.
 */
export declare class GroupEnd extends MavLinkData {
    static MSG_ID: number;
    static MSG_NAME: string;
    static PAYLOAD_LENGTH: number;
    static MAGIC_NUMBER: number;
    static FIELDS: MavLinkPacketField[];
    constructor();
    /**
     * Mission-unique group id (from MAV_CMD_GROUP_END).
     */
    groupId: uint32_t;
    /**
     * CRC32 checksum of current plan for MAV_MISSION_TYPE_ALL. As defined in MISSION_CHECKSUM message.
     */
    missionChecksum: uint32_t;
    /**
     * Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format
     * (since 1.1.1970 or since system boot) by checking for the magnitude of the number.
     * Units: us
     */
    timeUsec: uint64_t;
}
/**
 * Get information about a particular flight modes. The message can be enumerated or requested for a
 * particular mode using MAV_CMD_REQUEST_MESSAGE. Specify 0 in param2 to request that the message is
 * emitted for all available modes or the specific index for just one mode. The modes must be
 * available/settable for the current vehicle/frame type. Each modes should only be emitted once (even
 * if it is both standard and custom).
 */
export declare class AvailableModes extends MavLinkData {
    static MSG_ID: number;
    static MSG_NAME: string;
    static PAYLOAD_LENGTH: number;
    static MAGIC_NUMBER: number;
    static FIELDS: MavLinkPacketField[];
    constructor();
    /**
     * The total number of available modes for the current vehicle type.
     */
    numberModes: uint8_t;
    /**
     * The current mode index within number_modes, indexed from 1.
     */
    modeIndex: uint8_t;
    /**
     * Standard mode.
     */
    standardMode: MavStandardMode;
    /**
     * A bitfield for use for autopilot-specific flags
     */
    customMode: uint32_t;
    /**
     * Mode properties.
     */
    properties: MavModeProperty;
    /**
     * Name of custom mode, with null termination character. Should be omitted for standard modes.
     */
    modeName: string;
}
/**
 * Get the current mode. This should be emitted on any mode change, and broadcast at low rate
 * (nominally 0.5 Hz). It may be requested using MAV_CMD_REQUEST_MESSAGE.
 */
export declare class CurrentMode extends MavLinkData {
    static MSG_ID: number;
    static MSG_NAME: string;
    static PAYLOAD_LENGTH: number;
    static MAGIC_NUMBER: number;
    static FIELDS: MavLinkPacketField[];
    constructor();
    /**
     * Standard mode.
     */
    standardMode: MavStandardMode;
    /**
     * A bitfield for use for autopilot-specific flags
     */
    customMode: uint32_t;
    /**
     * The custom_mode of the mode that was last commanded by the user (for example, with
     * MAV_CMD_DO_SET_STANDARD_MODE, MAV_CMD_DO_SET_MODE or via RC). This should usually be the same as
     * custom_mode. It will be different if the vehicle is unable to enter the intended mode, or has left
     * that mode due to a failsafe condition. 0 indicates the intended custom mode is unknown/not supplied
     */
    intendedCustomMode: uint32_t;
}
/**
 * A change to the sequence number indicates that the set of AVAILABLE_MODES has changed. A receiver
 * must re-request all available modes whenever the sequence number changes. This is only emitted after
 * the first change and should then be broadcast at low rate (nominally 0.3 Hz) and on change.
 */
export declare class AvailableModesMonitor extends MavLinkData {
    static MSG_ID: number;
    static MSG_NAME: string;
    static PAYLOAD_LENGTH: number;
    static MAGIC_NUMBER: number;
    static FIELDS: MavLinkPacketField[];
    constructor();
    /**
     * Sequence number. The value iterates sequentially whenever AVAILABLE_MODES changes (e.g. support for
     * a new mode is added/removed dynamically).
     */
    seq: uint8_t;
}
/**
 * Current motion information from sensors on a target
 */
export declare class TargetAbsolute extends MavLinkData {
    static MSG_ID: number;
    static MSG_NAME: string;
    static PAYLOAD_LENGTH: number;
    static MAGIC_NUMBER: number;
    static FIELDS: MavLinkPacketField[];
    constructor();
    /**
     * Timestamp (UNIX epoch time).
     * Units: us
     */
    timestamp: uint64_t;
    /**
     * The ID of the target if multiple targets are present
     */
    id: uint8_t;
    /**
     * Bitmap to indicate the sensor's reporting capabilities
     */
    sensorCapabilities: TargetAbsoluteSensorCapabilityFlags;
    /**
     * Target's latitude (WGS84)
     * Units: degE7
     */
    lat: int32_t;
    /**
     * Target's longitude (WGS84)
     * Units: degE7
     */
    lon: int32_t;
    /**
     * Target's altitude (AMSL)
     * Units: m
     */
    alt: float;
    /**
     * Target's velocity in its body frame
     * Units: m/s
     */
    vel: float[];
    /**
     * Linear target's acceleration in its body frame
     * Units: m/s/s
     */
    acc: float[];
    /**
     * Quaternion of the target's orientation from its body frame to the vehicle's NED frame.
     */
    qTarget: float[];
    /**
     * Target's roll, pitch and yaw rates
     * Units: rad/s
     */
    rates: float[];
    /**
     * Standard deviation of horizontal (eph) and vertical (epv) position errors
     * Units: m
     */
    positionStd: float[];
    /**
     * Standard deviation of the target's velocity in its body frame
     * Units: m/s
     */
    velStd: float[];
    /**
     * Standard deviation of the target's acceleration in its body frame
     * Units: m/s/s
     */
    accStd: float[];
}
/**
 * The location of a target measured by MAV's onboard sensors.
 */
export declare class TargetRelative extends MavLinkData {
    static MSG_ID: number;
    static MSG_NAME: string;
    static PAYLOAD_LENGTH: number;
    static MAGIC_NUMBER: number;
    static FIELDS: MavLinkPacketField[];
    constructor();
    /**
     * Timestamp (UNIX epoch time)
     * Units: us
     */
    timestamp: uint64_t;
    /**
     * The ID of the target if multiple targets are present
     */
    id: uint8_t;
    /**
     * Coordinate frame used for following fields.
     */
    frame: TargetObsFrame;
    /**
     * X Position of the target in TARGET_OBS_FRAME
     * Units: m
     */
    x: float;
    /**
     * Y Position of the target in TARGET_OBS_FRAME
     * Units: m
     */
    y: float;
    /**
     * Z Position of the target in TARGET_OBS_FRAME
     * Units: m
     */
    z: float;
    /**
     * Standard deviation of the target's position in TARGET_OBS_FRAME
     * Units: m
     */
    posStd: float[];
    /**
     * Standard deviation of the target's orientation in TARGET_OBS_FRAME
     * Units: rad
     */
    yawStd: float;
    /**
     * Quaternion of the target's orientation from the target's frame to the TARGET_OBS_FRAME (w, x, y, z
     * order, zero-rotation is 1, 0, 0, 0)
     */
    qTarget: float[];
    /**
     * Quaternion of the sensor's orientation from TARGET_OBS_FRAME to vehicle-carried NED. (Ignored if set
     * to (0,0,0,0)) (w, x, y, z order, zero-rotation is 1, 0, 0, 0)
     */
    qSensor: float[];
    /**
     * Type of target
     */
    type: LandingTargetType;
}
import { CommandLong } from './common';
/**
 * Fly a figure eight path as defined by the parameters. Set parameters to NaN/INT32_MAX (as
 * appropriate) to use system-default values. The command is intended for fixed wing vehicles (and VTOL
 * hybrids flying in fixed-wing mode), allowing POI tracking for gimbals that don't support infinite
 * rotation. This command only defines the flight path. Speed should be set independently (use e.g.
 * MAV_CMD_DO_CHANGE_SPEED). Yaw and other degrees of freedom are not specified, and will be
 * flight-stack specific (on vehicles where they can be controlled independent of the heading).
 *
 * This command has location.
 * This command is destination.
 */
export declare class DoFigureEightCommand extends CommandLong {
    constructor(targetSystem?: number, targetComponent?: number);
    /**
     * Major axis radius of the figure eight. Positive: orbit the north circle clockwise. Negative: orbit
     * the north circle counter-clockwise. NaN: The radius will be set to 2.5 times the minor radius and
     * direction is clockwise. Must be greater or equal to two times the minor radius for feasible values.
     *
     * @units m
     */
    get majorRadius(): number;
    set majorRadius(value: number);
    /**
     * Minor axis radius of the figure eight. Defines the radius of the two circles that make up the
     * figure. Negative value has no effect. NaN: The radius will be set to the default loiter radius.
     *
     * @units m
     */
    get minorRadius(): number;
    set minorRadius(value: number);
    /**
     * Orientation of the figure eight major axis with respect to true north (range: [-pi,pi]). NaN: use
     * default orientation aligned to true north.
     *
     * @units rad
     */
    get orientation(): number;
    set orientation(value: number);
    /**
     * Center point latitude/X coordinate according to MAV_FRAME. If no MAV_FRAME specified,
     * MAV_FRAME_GLOBAL is assumed. INT32_MAX or NaN: Use current vehicle position, or current center if
     * already loitering.
     */
    get latitude(): number;
    set latitude(value: number);
    /**
     * Center point longitude/Y coordinate according to MAV_FRAME. If no MAV_FRAME specified,
     * MAV_FRAME_GLOBAL is assumed. INT32_MAX or NaN: Use current vehicle position, or current center if
     * already loitering.
     */
    get longitude(): number;
    set longitude(value: number);
    /**
     * Center point altitude MSL/Z coordinate according to MAV_FRAME. If no MAV_FRAME specified,
     * MAV_FRAME_GLOBAL is assumed. INT32_MAX or NaN: Use current vehicle altitude.
     */
    get altitude(): number;
    set altitude(value: number);
}
/**
 * Request to start or end a parameter transaction. Multiple kinds of transport layers can be used to
 * exchange parameters in the transaction (param, param_ext and mavftp). The command response can
 * either be a success/failure or an in progress in case the receiving side takes some time to apply
 * the parameters.
 */
export declare class ParamTransactionCommand extends CommandLong {
    constructor(targetSystem?: number, targetComponent?: number);
    /**
     * Action to be performed (start, commit, cancel, etc.)
     */
    get action(): number;
    set action(value: number);
    /**
     * Possible transport layers to set and get parameters via mavlink during a parameter transaction.
     */
    get transport(): number;
    set transport(value: number);
    /**
     * Identifier for a specific transaction.
     */
    get transactionId(): number;
    set transactionId(value: number);
}
/**
 * Request a target system to start an upgrade of one (or all) of its components. For example, the
 * command might be sent to a companion computer to cause it to upgrade a connected flight controller.
 * The system doing the upgrade will report progress using the normal command protocol sequence for a
 * long running operation. Command protocol information: https://mavlink.io/en/services/command.html.
 */
export declare class DoUpgradeCommand extends CommandLong {
    constructor(targetSystem?: number, targetComponent?: number);
    /**
     * Component id of the component to be upgraded. If set to 0, all components should be upgraded.
     */
    get componentId(): number;
    set componentId(value: number);
    /**
     * 0: Do not reboot component after the action is executed, 1: Reboot component after the action is
     * executed.
     *
     * @min: 0
     * @max: 1
     * @increment: 1
     */
    get reboot(): number;
    set reboot(value: number);
}
/**
 * Define start of a group of mission items. When control reaches this command a GROUP_START message is
 * emitted. The end of a group is marked using MAV_CMD_GROUP_END with the same group id. Group ids are
 * expected, but not required, to iterate sequentially. Groups can be nested.
 */
export declare class GroupStartCommand extends CommandLong {
    constructor(targetSystem?: number, targetComponent?: number);
    /**
     * Mission-unique group id. Group id is limited because only 24 bit integer can be stored in 32 bit
     * float.
     *
     * @min: 0
     * @max: 16777216
     * @increment: 1
     */
    get groupId(): number;
    set groupId(value: number);
}
/**
 * Define end of a group of mission items. When control reaches this command a GROUP_END message is
 * emitted. The start of the group is marked is marked using MAV_CMD_GROUP_START with the same group
 * id. Group ids are expected, but not required, to iterate sequentially. Groups can be nested.
 */
export declare class GroupEndCommand extends CommandLong {
    constructor(targetSystem?: number, targetComponent?: number);
    /**
     * Mission-unique group id. Group id is limited because only 24 bit integer can be stored in 32 bit
     * float.
     *
     * @min: 0
     * @max: 16777216
     * @increment: 1
     */
    get groupId(): number;
    set groupId(value: number);
}
/**
 * Enable the specified standard MAVLink mode. If the mode is not supported the vehicle should ACK with
 * MAV_RESULT_FAILED.
 */
export declare class DoSetStandardModeCommand extends CommandLong {
    constructor(targetSystem?: number, targetComponent?: number);
    /**
     * The mode to set.
     */
    get standardMode(): number;
    set standardMode(value: number);
}
/**
 * Allows setting an AT S command of an SiK radio.
 */
export declare class SetAtSParamCommand extends CommandLong {
    constructor(targetSystem?: number, targetComponent?: number);
    /**
     * The radio instance, one-based, 0 for all.
     */
    get radioInstance(): number;
    set radioInstance(value: number);
    /**
     * The Sx index, e.g. 3 for S3 which is NETID.
     */
    get index(): number;
    set index(value: number);
    /**
     * The value to set it to, e.g. default 25 for NETID
     */
    get value(): number;
    set value(value: number);
}
export declare const REGISTRY: MavLinkPacketRegistry;
export declare const COMMANDS: MavLinkCommandRegistry;