import { GenEnum, GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1";
import { Message } from "@bufbuild/protobuf";
declare namespace channel_pb_d_exports {
  export { Channel, ChannelSchema, ChannelSettings, ChannelSettingsSchema, Channel_Role, Channel_RoleSchema, ModuleSettings, ModuleSettingsSchema, file_meshtastic_channel };
}
/**
 * Describes the file meshtastic/channel.proto.
 */
declare const file_meshtastic_channel: GenFile;
/**
 *
 * This information can be encoded as a QRcode/url so that other users can configure
 * their radio to join the same channel.
 * A note about how channel names are shown to users: channelname-X
 * poundsymbol is a prefix used to indicate this is a channel name (idea from @professr).
 * Where X is a letter from A-Z (base 26) representing a hash of the PSK for this
 * channel - so that if the user changes anything about the channel (which does
 * force a new PSK) this letter will also change. Thus preventing user confusion if
 * two friends try to type in a channel name of "BobsChan" and then can't talk
 * because their PSKs will be different.
 * The PSK is hashed into this letter by "0x41 + [xor all bytes of the psk ] modulo 26"
 * This also allows the option of someday if people have the PSK off (zero), the
 * users COULD type in a channel name and be able to talk.
 * FIXME: Add description of multi-channel support and how primary vs secondary channels are used.
 * FIXME: explain how apps use channels for security.
 * explain how remote settings and remote gpio are managed as an example
 *
 * @generated from message meshtastic.ChannelSettings
 */
type ChannelSettings = Message<"meshtastic.ChannelSettings"> & {
  /**
   *
   * Deprecated in favor of LoraConfig.channel_num
   *
   * @generated from field: uint32 channel_num = 1 [deprecated = true];
   * @deprecated
   */
  channelNum: number;
  /**
   *
   * A simple pre-shared key for now for crypto.
   * Must be either 0 bytes (no crypto), 16 bytes (AES128), or 32 bytes (AES256).
   * A special shorthand is used for 1 byte long psks.
   * These psks should be treated as only minimally secure,
   * because they are listed in this source code.
   * Those bytes are mapped using the following scheme:
   * `0` = No crypto
   * `1` = The special "default" channel key: {0xd4, 0xf1, 0xbb, 0x3a, 0x20, 0x29, 0x07, 0x59, 0xf0, 0xbc, 0xff, 0xab, 0xcf, 0x4e, 0x69, 0x01}
   * `2` through 10 = The default channel key, except with 1 through 9 added to the last byte.
   * Shown to user as simple1 through 10
   *
   * @generated from field: bytes psk = 2;
   */
  psk: Uint8Array;
  /**
   *
   * A SHORT name that will be packed into the URL.
   * Less than 12 bytes.
   * Something for end users to call the channel
   * If this is the empty string it is assumed that this channel
   * is the special (minimally secure) "Default"channel.
   * In user interfaces it should be rendered as a local language translation of "X".
   * For channel_num hashing empty string will be treated as "X".
   * Where "X" is selected based on the English words listed above for ModemPreset
   *
   * @generated from field: string name = 3;
   */
  name: string;
  /**
   *
   * Used to construct a globally unique channel ID.
   * The full globally unique ID will be: "name.id" where ID is shown as base36.
   * Assuming that the number of meshtastic users is below 20K (true for a long time)
   * the chance of this 64 bit random number colliding with anyone else is super low.
   * And the penalty for collision is low as well, it just means that anyone trying to decrypt channel messages might need to
   * try multiple candidate channels.
   * Any time a non wire compatible change is made to a channel, this field should be regenerated.
   * There are a small number of 'special' globally known (and fairly) insecure standard channels.
   * Those channels do not have a numeric id included in the settings, but instead it is pulled from
   * a table of well known IDs.
   * (see Well Known Channels FIXME)
   *
   * @generated from field: fixed32 id = 4;
   */
  id: number;
  /**
   *
   * If true, messages on the mesh will be sent to the *public* internet by any gateway ndoe
   *
   * @generated from field: bool uplink_enabled = 5;
   */
  uplinkEnabled: boolean;
  /**
   *
   * If true, messages seen on the internet will be forwarded to the local mesh.
   *
   * @generated from field: bool downlink_enabled = 6;
   */
  downlinkEnabled: boolean;
  /**
   *
   * Per-channel module settings.
   *
   * @generated from field: meshtastic.ModuleSettings module_settings = 7;
   */
  moduleSettings?: ModuleSettings;
};
/**
 * Describes the message meshtastic.ChannelSettings.
 * Use `create(ChannelSettingsSchema)` to create a new message.
 */
declare const ChannelSettingsSchema: GenMessage<ChannelSettings>;
/**
 *
 * This message is specifically for modules to store per-channel configuration data.
 *
 * @generated from message meshtastic.ModuleSettings
 */
type ModuleSettings = Message<"meshtastic.ModuleSettings"> & {
  /**
   *
   * Bits of precision for the location sent in position packets.
   *
   * @generated from field: uint32 position_precision = 1;
   */
  positionPrecision: number;
  /**
   *
   * Controls whether or not the client / device should mute the current channel
   * Useful for noisy public channels you don't necessarily want to disable
   *
   * @generated from field: bool is_muted = 2;
   */
  isMuted: boolean;
};
/**
 * Describes the message meshtastic.ModuleSettings.
 * Use `create(ModuleSettingsSchema)` to create a new message.
 */
declare const ModuleSettingsSchema: GenMessage<ModuleSettings>;
/**
 *
 * A pair of a channel number, mode and the (sharable) settings for that channel
 *
 * @generated from message meshtastic.Channel
 */
type Channel = Message<"meshtastic.Channel"> & {
  /**
   *
   * The index of this channel in the channel table (from 0 to MAX_NUM_CHANNELS-1)
   * (Someday - not currently implemented) An index of -1 could be used to mean "set by name",
   * in which case the target node will find and set the channel by settings.name.
   *
   * @generated from field: int32 index = 1;
   */
  index: number;
  /**
   *
   * The new settings, or NULL to disable that channel
   *
   * @generated from field: meshtastic.ChannelSettings settings = 2;
   */
  settings?: ChannelSettings;
  /**
   *
   * TODO: REPLACE
   *
   * @generated from field: meshtastic.Channel.Role role = 3;
   */
  role: Channel_Role;
};
/**
 * Describes the message meshtastic.Channel.
 * Use `create(ChannelSchema)` to create a new message.
 */
declare const ChannelSchema: GenMessage<Channel>;
/**
 *
 * How this channel is being used (or not).
 * Note: this field is an enum to give us options for the future.
 * In particular, someday we might make a 'SCANNING' option.
 * SCANNING channels could have different frequencies and the radio would
 * occasionally check that freq to see if anything is being transmitted.
 * For devices that have multiple physical radios attached, we could keep multiple PRIMARY/SCANNING channels active at once to allow
 * cross band routing as needed.
 * If a device has only a single radio (the common case) only one channel can be PRIMARY at a time
 * (but any number of SECONDARY channels can't be sent received on that common frequency)
 *
 * @generated from enum meshtastic.Channel.Role
 */
declare enum Channel_Role {
  /**
   *
   * This channel is not in use right now
   *
   * @generated from enum value: DISABLED = 0;
   */
  DISABLED = 0,
  /**
   *
   * This channel is used to set the frequency for the radio - all other enabled channels must be SECONDARY
   *
   * @generated from enum value: PRIMARY = 1;
   */
  PRIMARY = 1,
  /**
   *
   * Secondary channels are only used for encryption/decryption/authentication purposes.
   * Their radio settings (freq etc) are ignored, only psk is used.
   *
   * @generated from enum value: SECONDARY = 2;
   */
  SECONDARY = 2
}
/**
 * Describes the enum meshtastic.Channel.Role.
 */
declare const Channel_RoleSchema: GenEnum<Channel_Role>;
//#endregion
//#region lib/device_ui_pb.d.ts
/**
 * @generated from message meshtastic.DeviceUIConfig
 */
type DeviceUIConfig = Message<"meshtastic.DeviceUIConfig"> & {
  /**
   *
   * A version integer used to invalidate saved files when we make incompatible changes.
   *
   * @generated from field: uint32 version = 1;
   */
  version: number;
  /**
   *
   * TFT display brightness 1..255
   *
   * @generated from field: uint32 screen_brightness = 2;
   */
  screenBrightness: number;
  /**
   *
   * Screen timeout 0..900
   *
   * @generated from field: uint32 screen_timeout = 3;
   */
  screenTimeout: number;
  /**
   *
   * Screen/Settings lock enabled
   *
   * @generated from field: bool screen_lock = 4;
   */
  screenLock: boolean;
  /**
   * @generated from field: bool settings_lock = 5;
   */
  settingsLock: boolean;
  /**
   * @generated from field: uint32 pin_code = 6;
   */
  pinCode: number;
  /**
   *
   * Color theme
   *
   * @generated from field: meshtastic.Theme theme = 7;
   */
  theme: Theme;
  /**
   *
   * Audible message, banner and ring tone
   *
   * @generated from field: bool alert_enabled = 8;
   */
  alertEnabled: boolean;
  /**
   * @generated from field: bool banner_enabled = 9;
   */
  bannerEnabled: boolean;
  /**
   * @generated from field: uint32 ring_tone_id = 10;
   */
  ringToneId: number;
  /**
   *
   * Localization
   *
   * @generated from field: meshtastic.Language language = 11;
   */
  language: Language;
  /**
   *
   * Node list filter
   *
   * @generated from field: meshtastic.NodeFilter node_filter = 12;
   */
  nodeFilter?: NodeFilter;
  /**
   *
   * Node list highlightening
   *
   * @generated from field: meshtastic.NodeHighlight node_highlight = 13;
   */
  nodeHighlight?: NodeHighlight;
  /**
   *
   * 8 integers for screen calibration data
   *
   * @generated from field: bytes calibration_data = 14;
   */
  calibrationData: Uint8Array;
  /**
   *
   * Map related data
   *
   * @generated from field: meshtastic.Map map_data = 15;
   */
  mapData?: Map;
  /**
   *
   * Compass mode
   *
   * @generated from field: meshtastic.CompassMode compass_mode = 16;
   */
  compassMode: CompassMode;
  /**
   *
   * RGB color for BaseUI
   * 0xRRGGBB format, e.g. 0xFF0000 for red
   *
   * @generated from field: uint32 screen_rgb_color = 17;
   */
  screenRgbColor: number;
  /**
   *
   * Clockface analog style
   * true for analog clockface, false for digital clockface
   *
   * @generated from field: bool is_clockface_analog = 18;
   */
  isClockfaceAnalog: boolean;
  /**
   *
   * How the GPS coordinates are formatted on the OLED screen.
   *
   * @generated from field: meshtastic.DeviceUIConfig.GpsCoordinateFormat gps_format = 19;
   */
  gpsFormat: DeviceUIConfig_GpsCoordinateFormat;
};
/**
 *
 * How the GPS coordinates are displayed on the OLED screen.
 *
 * @generated from enum meshtastic.DeviceUIConfig.GpsCoordinateFormat
 */
declare enum DeviceUIConfig_GpsCoordinateFormat {
  /**
   *
   * GPS coordinates are displayed in the normal decimal degrees format:
   * DD.DDDDDD DDD.DDDDDD
   *
   * @generated from enum value: DEC = 0;
   */
  DEC = 0,
  /**
   *
   * GPS coordinates are displayed in the degrees minutes seconds format:
   * DD°MM'SS"C DDD°MM'SS"C, where C is the compass point representing the locations quadrant
   *
   * @generated from enum value: DMS = 1;
   */
  DMS = 1,
  /**
   *
   * Universal Transverse Mercator format:
   * ZZB EEEEEE NNNNNNN, where Z is zone, B is band, E is easting, N is northing
   *
   * @generated from enum value: UTM = 2;
   */
  UTM = 2,
  /**
   *
   * Military Grid Reference System format:
   * ZZB CD EEEEE NNNNN, where Z is zone, B is band, C is the east 100k square, D is the north 100k square,
   * E is easting, N is northing
   *
   * @generated from enum value: MGRS = 3;
   */
  MGRS = 3,
  /**
   *
   * Open Location Code (aka Plus Codes).
   *
   * @generated from enum value: OLC = 4;
   */
  OLC = 4,
  /**
   *
   * Ordnance Survey Grid Reference (the National Grid System of the UK).
   * Format: AB EEEEE NNNNN, where A is the east 100k square, B is the north 100k square,
   * E is the easting, N is the northing
   *
   * @generated from enum value: OSGR = 5;
   */
  OSGR = 5,
  /**
   *
   * Maidenhead Locator System
   * Described here: https://en.wikipedia.org/wiki/Maidenhead_Locator_System
   *
   * @generated from enum value: MLS = 6;
   */
  MLS = 6
}
/**
 * @generated from message meshtastic.NodeFilter
 */
type NodeFilter = Message<"meshtastic.NodeFilter"> & {
  /**
   *
   * Filter unknown nodes
   *
   * @generated from field: bool unknown_switch = 1;
   */
  unknownSwitch: boolean;
  /**
   *
   * Filter offline nodes
   *
   * @generated from field: bool offline_switch = 2;
   */
  offlineSwitch: boolean;
  /**
   *
   * Filter nodes w/o public key
   *
   * @generated from field: bool public_key_switch = 3;
   */
  publicKeySwitch: boolean;
  /**
   *
   * Filter based on hops away
   *
   * @generated from field: int32 hops_away = 4;
   */
  hopsAway: number;
  /**
   *
   * Filter nodes w/o position
   *
   * @generated from field: bool position_switch = 5;
   */
  positionSwitch: boolean;
  /**
   *
   * Filter nodes by matching name string
   *
   * @generated from field: string node_name = 6;
   */
  nodeName: string;
  /**
   *
   * Filter based on channel
   *
   * @generated from field: int32 channel = 7;
   */
  channel: number;
};
/**
 * @generated from message meshtastic.NodeHighlight
 */
type NodeHighlight = Message<"meshtastic.NodeHighlight"> & {
  /**
   *
   * Hightlight nodes w/ active chat
   *
   * @generated from field: bool chat_switch = 1;
   */
  chatSwitch: boolean;
  /**
   *
   * Highlight nodes w/ position
   *
   * @generated from field: bool position_switch = 2;
   */
  positionSwitch: boolean;
  /**
   *
   * Highlight nodes w/ telemetry data
   *
   * @generated from field: bool telemetry_switch = 3;
   */
  telemetrySwitch: boolean;
  /**
   *
   * Highlight nodes w/ iaq data
   *
   * @generated from field: bool iaq_switch = 4;
   */
  iaqSwitch: boolean;
  /**
   *
   * Highlight nodes by matching name string
   *
   * @generated from field: string node_name = 5;
   */
  nodeName: string;
};
/**
 * @generated from message meshtastic.GeoPoint
 */
type GeoPoint = Message<"meshtastic.GeoPoint"> & {
  /**
   *
   * Zoom level
   *
   * @generated from field: int32 zoom = 1;
   */
  zoom: number;
  /**
   *
   * Coordinate: latitude
   *
   * @generated from field: int32 latitude = 2;
   */
  latitude: number;
  /**
   *
   * Coordinate: longitude
   *
   * @generated from field: int32 longitude = 3;
   */
  longitude: number;
};
/**
 * @generated from message meshtastic.Map
 */
type Map = Message<"meshtastic.Map"> & {
  /**
   *
   * Home coordinates
   *
   * @generated from field: meshtastic.GeoPoint home = 1;
   */
  home?: GeoPoint;
  /**
   *
   * Map tile style
   *
   * @generated from field: string style = 2;
   */
  style: string;
  /**
   *
   * Map scroll follows GPS
   *
   * @generated from field: bool follow_gps = 3;
   */
  followGps: boolean;
};
/**
 * @generated from enum meshtastic.CompassMode
 */
declare enum CompassMode {
  /**
   *
   * Compass with dynamic ring and heading
   *
   * @generated from enum value: DYNAMIC = 0;
   */
  DYNAMIC = 0,
  /**
   *
   * Compass with fixed ring and heading
   *
   * @generated from enum value: FIXED_RING = 1;
   */
  FIXED_RING = 1,
  /**
   *
   * Compass with heading and freeze option
   *
   * @generated from enum value: FREEZE_HEADING = 2;
   */
  FREEZE_HEADING = 2
}
/**
 * @generated from enum meshtastic.Theme
 */
declare enum Theme {
  /**
   *
   * Dark
   *
   * @generated from enum value: DARK = 0;
   */
  DARK = 0,
  /**
   *
   * Light
   *
   * @generated from enum value: LIGHT = 1;
   */
  LIGHT = 1,
  /**
   *
   * Red
   *
   * @generated from enum value: RED = 2;
   */
  RED = 2
}
/**
 *
 * Localization
 *
 * @generated from enum meshtastic.Language
 */
declare enum Language {
  /**
   *
   * English
   *
   * @generated from enum value: ENGLISH = 0;
   */
  ENGLISH = 0,
  /**
   *
   * French
   *
   * @generated from enum value: FRENCH = 1;
   */
  FRENCH = 1,
  /**
   *
   * German
   *
   * @generated from enum value: GERMAN = 2;
   */
  GERMAN = 2,
  /**
   *
   * Italian
   *
   * @generated from enum value: ITALIAN = 3;
   */
  ITALIAN = 3,
  /**
   *
   * Portuguese
   *
   * @generated from enum value: PORTUGUESE = 4;
   */
  PORTUGUESE = 4,
  /**
   *
   * Spanish
   *
   * @generated from enum value: SPANISH = 5;
   */
  SPANISH = 5,
  /**
   *
   * Swedish
   *
   * @generated from enum value: SWEDISH = 6;
   */
  SWEDISH = 6,
  /**
   *
   * Finnish
   *
   * @generated from enum value: FINNISH = 7;
   */
  FINNISH = 7,
  /**
   *
   * Polish
   *
   * @generated from enum value: POLISH = 8;
   */
  POLISH = 8,
  /**
   *
   * Turkish
   *
   * @generated from enum value: TURKISH = 9;
   */
  TURKISH = 9,
  /**
   *
   * Serbian
   *
   * @generated from enum value: SERBIAN = 10;
   */
  SERBIAN = 10,
  /**
   *
   * Russian
   *
   * @generated from enum value: RUSSIAN = 11;
   */
  RUSSIAN = 11,
  /**
   *
   * Dutch
   *
   * @generated from enum value: DUTCH = 12;
   */
  DUTCH = 12,
  /**
   *
   * Greek
   *
   * @generated from enum value: GREEK = 13;
   */
  GREEK = 13,
  /**
   *
   * Norwegian
   *
   * @generated from enum value: NORWEGIAN = 14;
   */
  NORWEGIAN = 14,
  /**
   *
   * Slovenian
   *
   * @generated from enum value: SLOVENIAN = 15;
   */
  SLOVENIAN = 15,
  /**
   *
   * Ukrainian
   *
   * @generated from enum value: UKRAINIAN = 16;
   */
  UKRAINIAN = 16,
  /**
   *
   * Bulgarian
   *
   * @generated from enum value: BULGARIAN = 17;
   */
  BULGARIAN = 17,
  /**
   *
   * Czech
   *
   * @generated from enum value: CZECH = 18;
   */
  CZECH = 18,
  /**
   *
   * Danish
   *
   * @generated from enum value: DANISH = 19;
   */
  DANISH = 19,
  /**
   *
   * Simplified Chinese (experimental)
   *
   * @generated from enum value: SIMPLIFIED_CHINESE = 30;
   */
  SIMPLIFIED_CHINESE = 30,
  /**
   *
   * Traditional Chinese (experimental)
   *
   * @generated from enum value: TRADITIONAL_CHINESE = 31;
   */
  TRADITIONAL_CHINESE = 31
}
declare namespace config_pb_d_exports {
  export { Config, ConfigSchema, Config_BluetoothConfig, Config_BluetoothConfigSchema, Config_BluetoothConfig_PairingMode, Config_BluetoothConfig_PairingModeSchema, Config_DeviceConfig, Config_DeviceConfigSchema, Config_DeviceConfig_BuzzerMode, Config_DeviceConfig_BuzzerModeSchema, Config_DeviceConfig_RebroadcastMode, Config_DeviceConfig_RebroadcastModeSchema, Config_DeviceConfig_Role, Config_DeviceConfig_RoleSchema, Config_DisplayConfig, Config_DisplayConfigSchema, Config_DisplayConfig_CompassOrientation, Config_DisplayConfig_CompassOrientationSchema, Config_DisplayConfig_DeprecatedGpsCoordinateFormat, Config_DisplayConfig_DeprecatedGpsCoordinateFormatSchema, Config_DisplayConfig_DisplayMode, Config_DisplayConfig_DisplayModeSchema, Config_DisplayConfig_DisplayUnits, Config_DisplayConfig_DisplayUnitsSchema, Config_DisplayConfig_OledType, Config_DisplayConfig_OledTypeSchema, Config_LoRaConfig, Config_LoRaConfigSchema, Config_LoRaConfig_FEM_LNA_Mode, Config_LoRaConfig_FEM_LNA_ModeSchema, Config_LoRaConfig_ModemPreset, Config_LoRaConfig_ModemPresetSchema, Config_LoRaConfig_RegionCode, Config_LoRaConfig_RegionCodeSchema, Config_NetworkConfig, Config_NetworkConfigSchema, Config_NetworkConfig_AddressMode, Config_NetworkConfig_AddressModeSchema, Config_NetworkConfig_IpV4Config, Config_NetworkConfig_IpV4ConfigSchema, Config_NetworkConfig_ProtocolFlags, Config_NetworkConfig_ProtocolFlagsSchema, Config_PositionConfig, Config_PositionConfigSchema, Config_PositionConfig_GpsMode, Config_PositionConfig_GpsModeSchema, Config_PositionConfig_PositionFlags, Config_PositionConfig_PositionFlagsSchema, Config_PowerConfig, Config_PowerConfigSchema, Config_SecurityConfig, Config_SecurityConfigSchema, Config_SecurityConfig_PacketSignaturePolicy, Config_SecurityConfig_PacketSignaturePolicySchema, Config_SessionkeyConfig, Config_SessionkeyConfigSchema, file_meshtastic_config };
}
/**
 * Describes the file meshtastic/config.proto.
 */
declare const file_meshtastic_config: GenFile;
/**
 * @generated from message meshtastic.Config
 */
type Config = Message<"meshtastic.Config"> & {
  /**
   *
   * Payload Variant
   *
   * @generated from oneof meshtastic.Config.payload_variant
   */
  payloadVariant: {
    /**
     * @generated from field: meshtastic.Config.DeviceConfig device = 1;
     */
    value: Config_DeviceConfig;
    case: "device";
  } | {
    /**
     * @generated from field: meshtastic.Config.PositionConfig position = 2;
     */
    value: Config_PositionConfig;
    case: "position";
  } | {
    /**
     * @generated from field: meshtastic.Config.PowerConfig power = 3;
     */
    value: Config_PowerConfig;
    case: "power";
  } | {
    /**
     * @generated from field: meshtastic.Config.NetworkConfig network = 4;
     */
    value: Config_NetworkConfig;
    case: "network";
  } | {
    /**
     * @generated from field: meshtastic.Config.DisplayConfig display = 5;
     */
    value: Config_DisplayConfig;
    case: "display";
  } | {
    /**
     * @generated from field: meshtastic.Config.LoRaConfig lora = 6;
     */
    value: Config_LoRaConfig;
    case: "lora";
  } | {
    /**
     * @generated from field: meshtastic.Config.BluetoothConfig bluetooth = 7;
     */
    value: Config_BluetoothConfig;
    case: "bluetooth";
  } | {
    /**
     * @generated from field: meshtastic.Config.SecurityConfig security = 8;
     */
    value: Config_SecurityConfig;
    case: "security";
  } | {
    /**
     * @generated from field: meshtastic.Config.SessionkeyConfig sessionkey = 9;
     */
    value: Config_SessionkeyConfig;
    case: "sessionkey";
  } | {
    /**
     * @generated from field: meshtastic.DeviceUIConfig device_ui = 10;
     */
    value: DeviceUIConfig;
    case: "deviceUi";
  } | {
    case: undefined;
    value?: undefined;
  };
};
/**
 * Describes the message meshtastic.Config.
 * Use `create(ConfigSchema)` to create a new message.
 */
declare const ConfigSchema: GenMessage<Config>;
/**
 *
 * Configuration
 *
 * @generated from message meshtastic.Config.DeviceConfig
 */
type Config_DeviceConfig = Message<"meshtastic.Config.DeviceConfig"> & {
  /**
   *
   * Sets the role of node
   *
   * @generated from field: meshtastic.Config.DeviceConfig.Role role = 1;
   */
  role: Config_DeviceConfig_Role;
  /**
   *
   * Disabling this will disable the SerialConsole by not initilizing the StreamAPI
   * Moved to SecurityConfig
   *
   * @generated from field: bool serial_enabled = 2 [deprecated = true];
   * @deprecated
   */
  serialEnabled: boolean;
  /**
   *
   * For boards without a hard wired button, this is the pin number that will be used
   * Boards that have more than one button can swap the function with this one. defaults to BUTTON_PIN if defined.
   *
   * @generated from field: uint32 button_gpio = 4;
   */
  buttonGpio: number;
  /**
   *
   * For boards without a PWM buzzer, this is the pin number that will be used
   * Defaults to PIN_BUZZER if defined.
   *
   * @generated from field: uint32 buzzer_gpio = 5;
   */
  buzzerGpio: number;
  /**
   *
   * Sets the role of node
   *
   * @generated from field: meshtastic.Config.DeviceConfig.RebroadcastMode rebroadcast_mode = 6;
   */
  rebroadcastMode: Config_DeviceConfig_RebroadcastMode;
  /**
   *
   * Send our nodeinfo this often
   * Defaults to 900 Seconds (15 minutes)
   *
   * @generated from field: uint32 node_info_broadcast_secs = 7;
   */
  nodeInfoBroadcastSecs: number;
  /**
   *
   * Treat double tap interrupt on supported accelerometers as a button press if set to true
   *
   * @generated from field: bool double_tap_as_button_press = 8;
   */
  doubleTapAsButtonPress: boolean;
  /**
   *
   * If true, device is considered to be "managed" by a mesh administrator
   * Clients should then limit available configuration and administrative options inside the user interface
   * Moved to SecurityConfig
   *
   * @generated from field: bool is_managed = 9 [deprecated = true];
   * @deprecated
   */
  isManaged: boolean;
  /**
   *
   * Disables the triple-press of user button to enable or disable GPS
   *
   * @generated from field: bool disable_triple_click = 10;
   */
  disableTripleClick: boolean;
  /**
   *
   * POSIX Timezone definition string from https://github.com/nayarsystems/posix_tz_db/blob/master/zones.csv.
   *
   * @generated from field: string tzdef = 11;
   */
  tzdef: string;
  /**
   *
   * If true, disable the default blinking LED (LED_PIN) behavior on the device
   *
   * @generated from field: bool led_heartbeat_disabled = 12;
   */
  ledHeartbeatDisabled: boolean;
  /**
   *
   * Controls buzzer behavior for audio feedback
   * Defaults to ENABLED
   *
   * @generated from field: meshtastic.Config.DeviceConfig.BuzzerMode buzzer_mode = 13;
   */
  buzzerMode: Config_DeviceConfig_BuzzerMode;
};
/**
 * Describes the message meshtastic.Config.DeviceConfig.
 * Use `create(Config_DeviceConfigSchema)` to create a new message.
 */
declare const Config_DeviceConfigSchema: GenMessage<Config_DeviceConfig>;
/**
 *
 * Defines the device's role on the Mesh network
 *
 * @generated from enum meshtastic.Config.DeviceConfig.Role
 */
declare enum Config_DeviceConfig_Role {
  /**
   *
   * Description: App connected or stand alone messaging device.
   * Technical Details: Default Role
   *
   * @generated from enum value: CLIENT = 0;
   */
  CLIENT = 0,
  /**
   *
   *  Description: Device that does not forward packets from other devices.
   *
   * @generated from enum value: CLIENT_MUTE = 1;
   */
  CLIENT_MUTE = 1,
  /**
   *
   * Description: Infrastructure node for extending network coverage by relaying messages. Visible in Nodes list.
   * Technical Details: Mesh packets will prefer to be routed over this node. This node will not be used by client apps.
   *   The wifi radio and the oled screen will be put to sleep.
   *   This mode may still potentially have higher power usage due to it's preference in message rebroadcasting on the mesh.
   *
   * @generated from enum value: ROUTER = 2;
   */
  ROUTER = 2,
  /**
   * @generated from enum value: ROUTER_CLIENT = 3 [deprecated = true];
   * @deprecated
   */
  ROUTER_CLIENT = 3,
  /**
   *
   * Description: Infrastructure node for extending network coverage by relaying messages with minimal overhead. Not visible in Nodes list.
   * Technical Details: Mesh packets will simply be rebroadcasted over this node. Nodes configured with this role will not originate NodeInfo, Position, Telemetry
   *   or any other packet type. They will simply rebroadcast any mesh packets on the same frequency, channel num, spread factor, and coding rate.
   * Deprecated in v2.7.11 because it creates "holes" in the mesh rebroadcast chain.
   *
   * @generated from enum value: REPEATER = 4 [deprecated = true];
   * @deprecated
   */
  REPEATER = 4,
  /**
   *
   * Description: Broadcasts GPS position packets as priority.
   * Technical Details: Position Mesh packets will be prioritized higher and sent more frequently by default.
   *   When used in conjunction with power.is_power_saving = true, nodes will wake up,
   *   send position, and then sleep for position.position_broadcast_secs seconds.
   *
   * @generated from enum value: TRACKER = 5;
   */
  TRACKER = 5,
  /**
   *
   * Description: Broadcasts telemetry packets as priority.
   * Technical Details: Telemetry Mesh packets will be prioritized higher and sent more frequently by default.
   *   When used in conjunction with power.is_power_saving = true, nodes will wake up,
   *   send environment telemetry, and then sleep for telemetry.environment_update_interval seconds.
   *
   * @generated from enum value: SENSOR = 6;
   */
  SENSOR = 6,
  /**
   *
   * Description: Optimized for ATAK system communication and reduces routine broadcasts.
   * Technical Details: Used for nodes dedicated for connection to an ATAK EUD.
   *    Turns off many of the routine broadcasts to favor CoT packet stream
   *    from the Meshtastic ATAK plugin -> IMeshService -> Node
   *
   * @generated from enum value: TAK = 7;
   */
  TAK = 7,
  /**
   *
   * Description: Device that only broadcasts as needed for stealth or power savings.
   * Technical Details: Used for nodes that "only speak when spoken to"
   *    Turns all of the routine broadcasts but allows for ad-hoc communication
   *    Still rebroadcasts, but with local only rebroadcast mode (known meshes only)
   *    Can be used for clandestine operation or to dramatically reduce airtime / power consumption
   *
   * @generated from enum value: CLIENT_HIDDEN = 8;
   */
  CLIENT_HIDDEN = 8,
  /**
   *
   * Description: Broadcasts location as message to default channel regularly for to assist with device recovery.
   * Technical Details: Used to automatically send a text message to the mesh
   *    with the current position of the device on a frequent interval:
   *    "I'm lost! Position: lat / long"
   *
   * @generated from enum value: LOST_AND_FOUND = 9;
   */
  LOST_AND_FOUND = 9,
  /**
   *
   * Description: Enables automatic TAK PLI broadcasts and reduces routine broadcasts.
   * Technical Details: Turns off many of the routine broadcasts to favor ATAK CoT packet stream
   *    and automatic TAK PLI (position location information) broadcasts.
   *    Uses position module configuration to determine TAK PLI broadcast interval.
   *
   * @generated from enum value: TAK_TRACKER = 10;
   */
  TAK_TRACKER = 10,
  /**
   *
   * Description: Will always rebroadcast packets, but will do so after all other modes.
   * Technical Details: Used for router nodes that are intended to provide additional coverage
   *    in areas not already covered by other routers, or to bridge around problematic terrain,
   *    but should not be given priority over other routers in order to avoid unnecessaraily
   *    consuming hops.
   *
   * @generated from enum value: ROUTER_LATE = 11;
   */
  ROUTER_LATE = 11,
  /**
   *
   * Description: Treats packets from or to favorited nodes as ROUTER_LATE, and all other packets as CLIENT.
   * Technical Details: Used for stronger attic/roof nodes to distribute messages more widely
   *    from weaker, indoor, or less-well-positioned nodes. Recommended for users with multiple nodes
   *    where one CLIENT_BASE acts as a more powerful base station, such as an attic/roof node.
   *
   * @generated from enum value: CLIENT_BASE = 12;
   */
  CLIENT_BASE = 12
}
/**
 * Describes the enum meshtastic.Config.DeviceConfig.Role.
 */
declare const Config_DeviceConfig_RoleSchema: GenEnum<Config_DeviceConfig_Role>;
/**
 *
 * Defines the device's behavior for how messages are rebroadcast
 *
 * @generated from enum meshtastic.Config.DeviceConfig.RebroadcastMode
 */
declare enum Config_DeviceConfig_RebroadcastMode {
  /**
   *
   * Default behavior.
   * Rebroadcast any observed message, if it was on our private channel or from another mesh with the same lora params.
   *
   * @generated from enum value: ALL = 0;
   */
  ALL = 0,
  /**
   *
   * Same as behavior as ALL but skips packet decoding and simply rebroadcasts them.
   * Only available in Repeater role. Setting this on any other roles will result in ALL behavior.
   *
   * @generated from enum value: ALL_SKIP_DECODING = 1;
   */
  ALL_SKIP_DECODING = 1,
  /**
   *
   * Ignores observed messages from foreign meshes that are open or those which it cannot decrypt.
   * Only rebroadcasts message on the nodes local primary / secondary channels.
   *
   * @generated from enum value: LOCAL_ONLY = 2;
   */
  LOCAL_ONLY = 2,
  /**
   *
   * Ignores observed messages from foreign meshes like LOCAL_ONLY,
   * but takes it step further by also ignoring messages from nodenums not in the node's known list (NodeDB)
   *
   * @generated from enum value: KNOWN_ONLY = 3;
   */
  KNOWN_ONLY = 3,
  /**
   *
   * Only permitted for SENSOR, TRACKER and TAK_TRACKER roles, this will inhibit all rebroadcasts, not unlike CLIENT_MUTE role.
   *
   * @generated from enum value: NONE = 4;
   */
  NONE = 4,
  /**
   *
   * Ignores packets from non-standard portnums such as: TAK, RangeTest, PaxCounter, etc.
   * Only rebroadcasts packets with standard portnums: NodeInfo, Text, Position, Telemetry, and Routing.
   *
   * @generated from enum value: CORE_PORTNUMS_ONLY = 5;
   */
  CORE_PORTNUMS_ONLY = 5
}
/**
 * Describes the enum meshtastic.Config.DeviceConfig.RebroadcastMode.
 */
declare const Config_DeviceConfig_RebroadcastModeSchema: GenEnum<Config_DeviceConfig_RebroadcastMode>;
/**
 *
 * Defines buzzer behavior for audio feedback
 *
 * @generated from enum meshtastic.Config.DeviceConfig.BuzzerMode
 */
declare enum Config_DeviceConfig_BuzzerMode {
  /**
   *
   * Default behavior.
   * Buzzer is enabled for all audio feedback including button presses and alerts.
   *
   * @generated from enum value: ALL_ENABLED = 0;
   */
  ALL_ENABLED = 0,
  /**
   *
   * Disabled.
   * All buzzer audio feedback is disabled.
   *
   * @generated from enum value: DISABLED = 1;
   */
  DISABLED = 1,
  /**
   *
   * Notifications Only.
   * Buzzer is enabled only for notifications and alerts, but not for button presses.
   * External notification config determines the specifics of the notification behavior.
   *
   * @generated from enum value: NOTIFICATIONS_ONLY = 2;
   */
  NOTIFICATIONS_ONLY = 2,
  /**
   *
   * Non-notification system buzzer tones only.
   * Buzzer is enabled only for non-notification tones such as button presses, startup, shutdown, but not for alerts.
   *
   * @generated from enum value: SYSTEM_ONLY = 3;
   */
  SYSTEM_ONLY = 3,
  /**
   *
   * Direct Message notifications only.
   * Buzzer is enabled only for direct messages and alerts, but not for button presses.
   * External notification config determines the specifics of the notification behavior.
   *
   * @generated from enum value: DIRECT_MSG_ONLY = 4;
   */
  DIRECT_MSG_ONLY = 4
}
/**
 * Describes the enum meshtastic.Config.DeviceConfig.BuzzerMode.
 */
declare const Config_DeviceConfig_BuzzerModeSchema: GenEnum<Config_DeviceConfig_BuzzerMode>;
/**
 *
 * Position Config
 *
 * @generated from message meshtastic.Config.PositionConfig
 */
type Config_PositionConfig = Message<"meshtastic.Config.PositionConfig"> & {
  /**
   *
   * We should send our position this often (but only if it has changed significantly)
   * Defaults to 15 minutes
   *
   * @generated from field: uint32 position_broadcast_secs = 1;
   */
  positionBroadcastSecs: number;
  /**
   *
   * Adaptive position braoadcast, which is now the default.
   *
   * @generated from field: bool position_broadcast_smart_enabled = 2;
   */
  positionBroadcastSmartEnabled: boolean;
  /**
   *
   * If set, this node is at a fixed position.
   * We will generate GPS position updates at the regular interval, but use whatever the last lat/lon/alt we have for the node.
   * The lat/lon/alt can be set by an internal GPS or with the help of the app.
   *
   * @generated from field: bool fixed_position = 3;
   */
  fixedPosition: boolean;
  /**
   *
   * Is GPS enabled for this node?
   *
   * @generated from field: bool gps_enabled = 4 [deprecated = true];
   * @deprecated
   */
  gpsEnabled: boolean;
  /**
   *
   * How often should we try to get GPS position (in seconds)
   * or zero for the default of once every 30 seconds
   * or a very large value (maxint) to update only once at boot.
   *
   * @generated from field: uint32 gps_update_interval = 5;
   */
  gpsUpdateInterval: number;
  /**
   *
   * Deprecated in favor of using smart / regular broadcast intervals as implicit attempt time
   *
   * @generated from field: uint32 gps_attempt_time = 6 [deprecated = true];
   * @deprecated
   */
  gpsAttemptTime: number;
  /**
   *
   * Bit field of boolean configuration options for POSITION messages
   * (bitwise OR of PositionFlags)
   *
   * @generated from field: uint32 position_flags = 7;
   */
  positionFlags: number;
  /**
   *
   * (Re)define GPS_RX_PIN for your board.
   *
   * @generated from field: uint32 rx_gpio = 8;
   */
  rxGpio: number;
  /**
   *
   * (Re)define GPS_TX_PIN for your board.
   *
   * @generated from field: uint32 tx_gpio = 9;
   */
  txGpio: number;
  /**
   *
   * The minimum distance in meters traveled (since the last send) before we can send a position to the mesh if position_broadcast_smart_enabled
   *
   * @generated from field: uint32 broadcast_smart_minimum_distance = 10;
   */
  broadcastSmartMinimumDistance: number;
  /**
   *
   * The minimum number of seconds (since the last send) before we can send a position to the mesh if position_broadcast_smart_enabled
   *
   * @generated from field: uint32 broadcast_smart_minimum_interval_secs = 11;
   */
  broadcastSmartMinimumIntervalSecs: number;
  /**
   *
   * (Re)define PIN_GPS_EN for your board.
   *
   * @generated from field: uint32 gps_en_gpio = 12;
   */
  gpsEnGpio: number;
  /**
   *
   * Set where GPS is enabled, disabled, or not present
   *
   * @generated from field: meshtastic.Config.PositionConfig.GpsMode gps_mode = 13;
   */
  gpsMode: Config_PositionConfig_GpsMode;
};
/**
 * Describes the message meshtastic.Config.PositionConfig.
 * Use `create(Config_PositionConfigSchema)` to create a new message.
 */
declare const Config_PositionConfigSchema: GenMessage<Config_PositionConfig>;
/**
 *
 * Bit field of boolean configuration options, indicating which optional
 * fields to include when assembling POSITION messages.
 * Longitude, latitude, altitude, speed, heading, and DOP
 * are always included (also time if GPS-synced)
 * NOTE: the more fields are included, the larger the message will be -
 *   leading to longer airtime and a higher risk of packet loss
 *
 * @generated from enum meshtastic.Config.PositionConfig.PositionFlags
 */
declare enum Config_PositionConfig_PositionFlags {
  /**
   *
   * Required for compilation
   *
   * @generated from enum value: UNSET = 0;
   */
  UNSET = 0,
  /**
   *
   * Include an altitude value (if available)
   *
   * @generated from enum value: ALTITUDE = 1;
   */
  ALTITUDE = 1,
  /**
   *
   * Altitude value is MSL
   *
   * @generated from enum value: ALTITUDE_MSL = 2;
   */
  ALTITUDE_MSL = 2,
  /**
   *
   * Include geoidal separation
   *
   * @generated from enum value: GEOIDAL_SEPARATION = 4;
   */
  GEOIDAL_SEPARATION = 4,
  /**
   *
   * Include the DOP value ; PDOP used by default, see below
   *
   * @generated from enum value: DOP = 8;
   */
  DOP = 8,
  /**
   *
   * If POS_DOP set, send separate HDOP / VDOP values instead of PDOP
   *
   * @generated from enum value: HVDOP = 16;
   */
  HVDOP = 16,
  /**
   *
   * Include number of "satellites in view"
   *
   * @generated from enum value: SATINVIEW = 32;
   */
  SATINVIEW = 32,
  /**
   *
   * Include a sequence number incremented per packet
   *
   * @generated from enum value: SEQ_NO = 64;
   */
  SEQ_NO = 64,
  /**
   *
   * Include positional timestamp (from GPS solution)
   *
   * @generated from enum value: TIMESTAMP = 128;
   */
  TIMESTAMP = 128,
  /**
   *
   * Include positional heading
   * Intended for use with vehicle not walking speeds
   * walking speeds are likely to be error prone like the compass
   *
   * @generated from enum value: HEADING = 256;
   */
  HEADING = 256,
  /**
   *
   * Include positional speed
   * Intended for use with vehicle not walking speeds
   * walking speeds are likely to be error prone like the compass
   *
   * @generated from enum value: SPEED = 512;
   */
  SPEED = 512
}
/**
 * Describes the enum meshtastic.Config.PositionConfig.PositionFlags.
 */
declare const Config_PositionConfig_PositionFlagsSchema: GenEnum<Config_PositionConfig_PositionFlags>;
/**
 * @generated from enum meshtastic.Config.PositionConfig.GpsMode
 */
declare enum Config_PositionConfig_GpsMode {
  /**
   *
   * GPS is present but disabled
   *
   * @generated from enum value: DISABLED = 0;
   */
  DISABLED = 0,
  /**
   *
   * GPS is present and enabled
   *
   * @generated from enum value: ENABLED = 1;
   */
  ENABLED = 1,
  /**
   *
   * GPS is not present on the device
   *
   * @generated from enum value: NOT_PRESENT = 2;
   */
  NOT_PRESENT = 2
}
/**
 * Describes the enum meshtastic.Config.PositionConfig.GpsMode.
 */
declare const Config_PositionConfig_GpsModeSchema: GenEnum<Config_PositionConfig_GpsMode>;
/**
 *
 * Power Config\
 * See [Power Config](/docs/settings/config/power) for additional power config details.
 *
 * @generated from message meshtastic.Config.PowerConfig
 */
type Config_PowerConfig = Message<"meshtastic.Config.PowerConfig"> & {
  /**
   *
   * Description: Will sleep everything as much as possible, for the tracker and sensor role this will also include the lora radio.
   * Don't use this setting if you want to use your device with the phone apps or are using a device without a user button.
   * Technical Details: Works for ESP32 devices and NRF52 devices in the Sensor or Tracker roles
   *
   * @generated from field: bool is_power_saving = 1;
   */
  isPowerSaving: boolean;
  /**
   *
   *  Description: If non-zero, the device will fully power off this many seconds after external power is removed.
   *
   * @generated from field: uint32 on_battery_shutdown_after_secs = 2;
   */
  onBatteryShutdownAfterSecs: number;
  /**
   *
   * Ratio of voltage divider for battery pin eg. 3.20 (R1=100k, R2=220k)
   * Overrides the ADC_MULTIPLIER defined in variant for battery voltage calculation.
   * https://meshtastic.org/docs/configuration/radio/power/#adc-multiplier-override
   * Should be set to floating point value between 2 and 6
   *
   * @generated from field: float adc_multiplier_override = 3;
   */
  adcMultiplierOverride: number;
  /**
   *
   *  Description: The number of seconds for to wait before turning off BLE in No Bluetooth states
   *  Technical Details: ESP32 Only 0 for default of 1 minute
   *
   * @generated from field: uint32 wait_bluetooth_secs = 4;
   */
  waitBluetoothSecs: number;
  /**
   *
   * Super Deep Sleep Seconds
   * While in Light Sleep if mesh_sds_timeout_secs is exceeded we will lower into super deep sleep
   * for this value (default 1 year) or a button press
   * 0 for default of one year
   *
   * @generated from field: uint32 sds_secs = 6;
   */
  sdsSecs: number;
  /**
   *
   * Description: In light sleep the CPU is suspended, LoRa radio is on, BLE is off an GPS is on
   * Technical Details: ESP32 Only 0 for default of 300
   *
   * @generated from field: uint32 ls_secs = 7;
   */
  lsSecs: number;
  /**
   *
   * Description: While in light sleep when we receive packets on the LoRa radio we will wake and handle them and stay awake in no BLE mode for this value
   * Technical Details: ESP32 Only 0 for default of 10 seconds
   *
   * @generated from field: uint32 min_wake_secs = 8;
   */
  minWakeSecs: number;
  /**
   *
   * I2C address of INA_2XX to use for reading device battery voltage
   *
   * @generated from field: uint32 device_battery_ina_address = 9;
   */
  deviceBatteryInaAddress: number;
  /**
   *
   * If non-zero, we want powermon log outputs.  With the particular (bitfield) sources enabled.
   * Note: we picked an ID of 32 so that lower more efficient IDs can be used for more frequently used options.
   *
   * @generated from field: uint64 powermon_enables = 32;
   */
  powermonEnables: bigint;
};
/**
 * Describes the message meshtastic.Config.PowerConfig.
 * Use `create(Config_PowerConfigSchema)` to create a new message.
 */
declare const Config_PowerConfigSchema: GenMessage<Config_PowerConfig>;
/**
 *
 * Network Config
 *
 * @generated from message meshtastic.Config.NetworkConfig
 */
type Config_NetworkConfig = Message<"meshtastic.Config.NetworkConfig"> & {
  /**
   *
   * Enable WiFi (disables Bluetooth)
   *
   * @generated from field: bool wifi_enabled = 1;
   */
  wifiEnabled: boolean;
  /**
   *
   * If set, this node will try to join the specified wifi network and
   * acquire an address via DHCP
   *
   * @generated from field: string wifi_ssid = 3;
   */
  wifiSsid: string;
  /**
   *
   * If set, will be use to authenticate to the named wifi
   *
   * @generated from field: string wifi_psk = 4;
   */
  wifiPsk: string;
  /**
   *
   * NTP server to use if WiFi is conneced, defaults to `meshtastic.pool.ntp.org`
   *
   * @generated from field: string ntp_server = 5;
   */
  ntpServer: string;
  /**
   *
   * Enable Ethernet
   *
   * @generated from field: bool eth_enabled = 6;
   */
  ethEnabled: boolean;
  /**
   *
   * acquire an address via DHCP or assign static
   *
   * @generated from field: meshtastic.Config.NetworkConfig.AddressMode address_mode = 7;
   */
  addressMode: Config_NetworkConfig_AddressMode;
  /**
   *
   * struct to keep static address
   *
   * @generated from field: meshtastic.Config.NetworkConfig.IpV4Config ipv4_config = 8;
   */
  ipv4Config?: Config_NetworkConfig_IpV4Config;
  /**
   *
   * rsyslog Server and Port
   *
   * @generated from field: string rsyslog_server = 9;
   */
  rsyslogServer: string;
  /**
   *
   * Flags for enabling/disabling network protocols
   *
   * @generated from field: uint32 enabled_protocols = 10;
   */
  enabledProtocols: number;
  /**
   *
   * Enable/Disable ipv6 support
   *
   * @generated from field: bool ipv6_enabled = 11;
   */
  ipv6Enabled: boolean;
};
/**
 * Describes the message meshtastic.Config.NetworkConfig.
 * Use `create(Config_NetworkConfigSchema)` to create a new message.
 */
declare const Config_NetworkConfigSchema: GenMessage<Config_NetworkConfig>;
/**
 * @generated from message meshtastic.Config.NetworkConfig.IpV4Config
 */
type Config_NetworkConfig_IpV4Config = Message<"meshtastic.Config.NetworkConfig.IpV4Config"> & {
  /**
   *
   * Static IP address
   *
   * @generated from field: fixed32 ip = 1;
   */
  ip: number;
  /**
   *
   * Static gateway address
   *
   * @generated from field: fixed32 gateway = 2;
   */
  gateway: number;
  /**
   *
   * Static subnet mask
   *
   * @generated from field: fixed32 subnet = 3;
   */
  subnet: number;
  /**
   *
   * Static DNS server address
   *
   * @generated from field: fixed32 dns = 4;
   */
  dns: number;
};
/**
 * Describes the message meshtastic.Config.NetworkConfig.IpV4Config.
 * Use `create(Config_NetworkConfig_IpV4ConfigSchema)` to create a new message.
 */
declare const Config_NetworkConfig_IpV4ConfigSchema: GenMessage<Config_NetworkConfig_IpV4Config>;
/**
 * @generated from enum meshtastic.Config.NetworkConfig.AddressMode
 */
declare enum Config_NetworkConfig_AddressMode {
  /**
   *
   * obtain ip address via DHCP
   *
   * @generated from enum value: DHCP = 0;
   */
  DHCP = 0,
  /**
   *
   * use static ip address
   *
   * @generated from enum value: STATIC = 1;
   */
  STATIC = 1
}
/**
 * Describes the enum meshtastic.Config.NetworkConfig.AddressMode.
 */
declare const Config_NetworkConfig_AddressModeSchema: GenEnum<Config_NetworkConfig_AddressMode>;
/**
 *
 * Available flags auxiliary network protocols
 *
 * @generated from enum meshtastic.Config.NetworkConfig.ProtocolFlags
 */
declare enum Config_NetworkConfig_ProtocolFlags {
  /**
   *
   * Do not broadcast packets over any network protocol
   *
   * @generated from enum value: NO_BROADCAST = 0;
   */
  NO_BROADCAST = 0,
  /**
   *
   * Enable broadcasting packets via UDP over the local network
   *
   * @generated from enum value: UDP_BROADCAST = 1;
   */
  UDP_BROADCAST = 1
}
/**
 * Describes the enum meshtastic.Config.NetworkConfig.ProtocolFlags.
 */
declare const Config_NetworkConfig_ProtocolFlagsSchema: GenEnum<Config_NetworkConfig_ProtocolFlags>;
/**
 *
 * Display Config
 *
 * @generated from message meshtastic.Config.DisplayConfig
 */
type Config_DisplayConfig = Message<"meshtastic.Config.DisplayConfig"> & {
  /**
   *
   * Number of seconds the screen stays on after pressing the user button or receiving a message
   * 0 for default of one minute MAXUINT for always on
   *
   * @generated from field: uint32 screen_on_secs = 1;
   */
  screenOnSecs: number;
  /**
   *
   * Deprecated in 2.7.4: Unused
   * How the GPS coordinates are formatted on the OLED screen.
   *
   * @generated from field: meshtastic.Config.DisplayConfig.DeprecatedGpsCoordinateFormat gps_format = 2 [deprecated = true];
   * @deprecated
   */
  gpsFormat: Config_DisplayConfig_DeprecatedGpsCoordinateFormat;
  /**
   *
   * Automatically toggles to the next page on the screen like a carousel, based the specified interval in seconds.
   * Potentially useful for devices without user buttons.
   *
   * @generated from field: uint32 auto_screen_carousel_secs = 3;
   */
  autoScreenCarouselSecs: number;
  /**
   *
   * If this is set, the displayed compass will always point north. if unset, the old behaviour
   * (top of display is heading direction) is used.
   *
   * @generated from field: bool compass_north_top = 4 [deprecated = true];
   * @deprecated
   */
  compassNorthTop: boolean;
  /**
   *
   * Flip screen vertically, for cases that mount the screen upside down
   *
   * @generated from field: bool flip_screen = 5;
   */
  flipScreen: boolean;
  /**
   *
   * Perferred display units
   *
   * @generated from field: meshtastic.Config.DisplayConfig.DisplayUnits units = 6;
   */
  units: Config_DisplayConfig_DisplayUnits;
  /**
   *
   * Override auto-detect in screen
   *
   * @generated from field: meshtastic.Config.DisplayConfig.OledType oled = 7;
   */
  oled: Config_DisplayConfig_OledType;
  /**
   *
   * Display Mode
   *
   * @generated from field: meshtastic.Config.DisplayConfig.DisplayMode displaymode = 8;
   */
  displaymode: Config_DisplayConfig_DisplayMode;
  /**
   *
   * Print first line in pseudo-bold? FALSE is original style, TRUE is bold
   *
   * @generated from field: bool heading_bold = 9;
   */
  headingBold: boolean;
  /**
   *
   * Should we wake the screen up on accelerometer detected motion or tap
   *
   * @generated from field: bool wake_on_tap_or_motion = 10;
   */
  wakeOnTapOrMotion: boolean;
  /**
   *
   * Indicates how to rotate or invert the compass output to accurate display on the display.
   *
   * @generated from field: meshtastic.Config.DisplayConfig.CompassOrientation compass_orientation = 11;
   */
  compassOrientation: Config_DisplayConfig_CompassOrientation;
  /**
   *
   * If false (default), the device will display the time in 24-hour format on screen.
   * If true, the device will display the time in 12-hour format on screen.
   *
   * @generated from field: bool use_12h_clock = 12;
   */
  use12hClock: boolean;
  /**
   *
   * If false (default), the device will use short names for various display screens.
   * If true, node names will show in long format
   *
   * @generated from field: bool use_long_node_name = 13;
   */
  useLongNodeName: boolean;
  /**
   *
   * If true, the device will display message bubbles on screen.
   *
   * @generated from field: bool enable_message_bubbles = 14;
   */
  enableMessageBubbles: boolean;
};
/**
 * Describes the message meshtastic.Config.DisplayConfig.
 * Use `create(Config_DisplayConfigSchema)` to create a new message.
 */
declare const Config_DisplayConfigSchema: GenMessage<Config_DisplayConfig>;
/**
 *
 * Deprecated in 2.7.4: Unused
 *
 * @generated from enum meshtastic.Config.DisplayConfig.DeprecatedGpsCoordinateFormat
 */
declare enum Config_DisplayConfig_DeprecatedGpsCoordinateFormat {
  /**
   * @generated from enum value: UNUSED = 0;
   */
  UNUSED = 0
}
/**
 * Describes the enum meshtastic.Config.DisplayConfig.DeprecatedGpsCoordinateFormat.
 */
declare const Config_DisplayConfig_DeprecatedGpsCoordinateFormatSchema: GenEnum<Config_DisplayConfig_DeprecatedGpsCoordinateFormat>;
/**
 *
 * Unit display preference
 *
 * @generated from enum meshtastic.Config.DisplayConfig.DisplayUnits
 */
declare enum Config_DisplayConfig_DisplayUnits {
  /**
   *
   * Metric (Default)
   *
   * @generated from enum value: METRIC = 0;
   */
  METRIC = 0,
  /**
   *
   * Imperial
   *
   * @generated from enum value: IMPERIAL = 1;
   */
  IMPERIAL = 1
}
/**
 * Describes the enum meshtastic.Config.DisplayConfig.DisplayUnits.
 */
declare const Config_DisplayConfig_DisplayUnitsSchema: GenEnum<Config_DisplayConfig_DisplayUnits>;
/**
 *
 * Override OLED outo detect with this if it fails.
 *
 * @generated from enum meshtastic.Config.DisplayConfig.OledType
 */
declare enum Config_DisplayConfig_OledType {
  /**
   *
   * Default / Autodetect
   *
   * @generated from enum value: OLED_AUTO = 0;
   */
  OLED_AUTO = 0,
  /**
   *
   * Default / Autodetect
   *
   * @generated from enum value: OLED_SSD1306 = 1;
   */
  OLED_SSD1306 = 1,
  /**
   *
   * Default / Autodetect
   *
   * @generated from enum value: OLED_SH1106 = 2;
   */
  OLED_SH1106 = 2,
  /**
   *
   * Can not be auto detected but set by proto. Used for 128x64 screens
   *
   * @generated from enum value: OLED_SH1107 = 3;
   */
  OLED_SH1107 = 3,
  /**
   *
   * Can not be auto detected but set by proto. Used for 128x128 screens
   *
   * @generated from enum value: OLED_SH1107_128_128 = 4;
   */
  OLED_SH1107_128_128 = 4,
  /**
   *
   * Can not be auto detected but set by proto. Used for 64x128 rotated screens
   *
   * @generated from enum value: OLED_SH1107_ROTATED = 5;
   */
  OLED_SH1107_ROTATED = 5
}
/**
 * Describes the enum meshtastic.Config.DisplayConfig.OledType.
 */
declare const Config_DisplayConfig_OledTypeSchema: GenEnum<Config_DisplayConfig_OledType>;
/**
 * @generated from enum meshtastic.Config.DisplayConfig.DisplayMode
 */
declare enum Config_DisplayConfig_DisplayMode {
  /**
   *
   * Default. The old style for the 128x64 OLED screen
   *
   * @generated from enum value: DEFAULT = 0;
   */
  DEFAULT = 0,
  /**
   *
   * Rearrange display elements to cater for bicolor OLED displays
   *
   * @generated from enum value: TWOCOLOR = 1;
   */
  TWOCOLOR = 1,
  /**
   *
   * Same as TwoColor, but with inverted top bar. Not so good for Epaper displays
   *
   * @generated from enum value: INVERTED = 2;
   */
  INVERTED = 2,
  /**
   *
   * TFT Full Color Displays (not implemented yet)
   *
   * @generated from enum value: COLOR = 3;
   */
  COLOR = 3
}
/**
 * Describes the enum meshtastic.Config.DisplayConfig.DisplayMode.
 */
declare const Config_DisplayConfig_DisplayModeSchema: GenEnum<Config_DisplayConfig_DisplayMode>;
/**
 * @generated from enum meshtastic.Config.DisplayConfig.CompassOrientation
 */
declare enum Config_DisplayConfig_CompassOrientation {
  /**
   *
   * The compass and the display are in the same orientation.
   *
   * @generated from enum value: DEGREES_0 = 0;
   */
  DEGREES_0 = 0,
  /**
   *
   * Rotate the compass by 90 degrees.
   *
   * @generated from enum value: DEGREES_90 = 1;
   */
  DEGREES_90 = 1,
  /**
   *
   * Rotate the compass by 180 degrees.
   *
   * @generated from enum value: DEGREES_180 = 2;
   */
  DEGREES_180 = 2,
  /**
   *
   * Rotate the compass by 270 degrees.
   *
   * @generated from enum value: DEGREES_270 = 3;
   */
  DEGREES_270 = 3,
  /**
   *
   * Don't rotate the compass, but invert the result.
   *
   * @generated from enum value: DEGREES_0_INVERTED = 4;
   */
  DEGREES_0_INVERTED = 4,
  /**
   *
   * Rotate the compass by 90 degrees and invert.
   *
   * @generated from enum value: DEGREES_90_INVERTED = 5;
   */
  DEGREES_90_INVERTED = 5,
  /**
   *
   * Rotate the compass by 180 degrees and invert.
   *
   * @generated from enum value: DEGREES_180_INVERTED = 6;
   */
  DEGREES_180_INVERTED = 6,
  /**
   *
   * Rotate the compass by 270 degrees and invert.
   *
   * @generated from enum value: DEGREES_270_INVERTED = 7;
   */
  DEGREES_270_INVERTED = 7
}
/**
 * Describes the enum meshtastic.Config.DisplayConfig.CompassOrientation.
 */
declare const Config_DisplayConfig_CompassOrientationSchema: GenEnum<Config_DisplayConfig_CompassOrientation>;
/**
 *
 * Lora Config
 *
 * @generated from message meshtastic.Config.LoRaConfig
 */
type Config_LoRaConfig = Message<"meshtastic.Config.LoRaConfig"> & {
  /**
   *
   * When enabled, the `modem_preset` fields will be adhered to, else the `bandwidth`/`spread_factor`/`coding_rate`
   * will be taked from their respective manually defined fields
   *
   * @generated from field: bool use_preset = 1;
   */
  usePreset: boolean;
  /**
   *
   * Either modem_config or bandwidth/spreading/coding will be specified - NOT BOTH.
   * As a heuristic: If bandwidth is specified, do not use modem_config.
   * Because protobufs take ZERO space when the value is zero this works out nicely.
   * This value is replaced by bandwidth/spread_factor/coding_rate.
   * If you'd like to experiment with other options add them to MeshRadio.cpp in the device code.
   *
   * @generated from field: meshtastic.Config.LoRaConfig.ModemPreset modem_preset = 2;
   */
  modemPreset: Config_LoRaConfig_ModemPreset;
  /**
   *
   * Bandwidth in MHz
   * Certain bandwidth numbers are 'special' and will be converted to the
   * appropriate floating point value: 31 -> 31.25MHz
   *
   * @generated from field: uint32 bandwidth = 3;
   */
  bandwidth: number;
  /**
   *
   * A number from 7 to 12.
   * Indicates number of chirps per symbol as 1<<spread_factor.
   *
   * @generated from field: uint32 spread_factor = 4;
   */
  spreadFactor: number;
  /**
   *
   * The denominator of the coding rate.
   * ie for 4/5, the value is 5. 4/8 the value is 8.
   *
   * @generated from field: uint32 coding_rate = 5;
   */
  codingRate: number;
  /**
   *
   * This parameter is for advanced users with advanced test equipment, we do not recommend most users use it.
   * A frequency offset that is added to to the calculated band center frequency.
   * Used to correct for crystal calibration errors.
   *
   * @generated from field: float frequency_offset = 6;
   */
  frequencyOffset: number;
  /**
   *
   * The region code for the radio (US, CN, EU433, etc...)
   *
   * @generated from field: meshtastic.Config.LoRaConfig.RegionCode region = 7;
   */
  region: Config_LoRaConfig_RegionCode;
  /**
   *
   * Maximum number of hops. This can't be greater than 7.
   * Default of 3
   * Attempting to set a value > 7 results in the default
   *
   * @generated from field: uint32 hop_limit = 8;
   */
  hopLimit: number;
  /**
   *
   * Disable TX from the LoRa radio. Useful for hot-swapping antennas and other tests.
   * Defaults to false
   *
   * @generated from field: bool tx_enabled = 9;
   */
  txEnabled: boolean;
  /**
   *
   * If zero, then use default max legal continuous power (ie. something that won't
   * burn out the radio hardware)
   * In most cases you should use zero here.
   * Units are in dBm.
   *
   * @generated from field: int32 tx_power = 10;
   */
  txPower: number;
  /**
   *
   * This controls the actual hardware frequency the radio transmits on.
   * Most users should never need to be exposed to this field/concept.
   * A channel number between 1 and NUM_CHANNELS (whatever the max is in the current region).
   * If ZERO then the rule is "use the old channel name hash based
   * algorithm to derive the channel number")
   * If using the hash algorithm the channel number will be: hash(channel_name) %
   * NUM_CHANNELS (Where num channels depends on the regulatory region).
   *
   * @generated from field: uint32 channel_num = 11;
   */
  channelNum: number;
  /**
   *
   * If true, duty cycle limits will be exceeded and thus you're possibly not following
   * the local regulations if you're not a HAM.
   * Has no effect if the duty cycle of the used region is 100%.
   *
   * @generated from field: bool override_duty_cycle = 12;
   */
  overrideDutyCycle: boolean;
  /**
   *
   * If true, sets RX boosted gain mode on SX126X based radios
   *
   * @generated from field: bool sx126x_rx_boosted_gain = 13;
   */
  sx126xRxBoostedGain: boolean;
  /**
   *
   * This parameter is for advanced users and licensed HAM radio operators.
   * Ignore Channel Calculation and use this frequency instead. The frequency_offset
   * will still be applied. This will allow you to use out-of-band frequencies.
   * Please respect your local laws and regulations. If you are a HAM, make sure you
   * enable HAM mode and turn off encryption.
   *
   * @generated from field: float override_frequency = 14;
   */
  overrideFrequency: number;
  /**
   *
   * If true, disable the build-in PA FAN using pin define in RF95_FAN_EN.
   *
   * @generated from field: bool pa_fan_disabled = 15;
   */
  paFanDisabled: boolean;
  /**
   *
   * For testing it is useful sometimes to force a node to never listen to
   * particular other nodes (simulating radio out of range). All nodenums listed
   * in ignore_incoming will have packets they send dropped on receive (by router.cpp)
   *
   * @generated from field: repeated uint32 ignore_incoming = 103;
   */
  ignoreIncoming: number[];
  /**
   *
   * If true, the device will not process any packets received via LoRa that passed via MQTT anywhere on the path towards it.
   *
   * @generated from field: bool ignore_mqtt = 104;
   */
  ignoreMqtt: boolean;
  /**
   *
   * Sets the ok_to_mqtt bit on outgoing packets
   *
   * @generated from field: bool config_ok_to_mqtt = 105;
   */
  configOkToMqtt: boolean;
  /**
   *
   * Set where LORA FEM is enabled, disabled, or not present
   *
   * @generated from field: meshtastic.Config.LoRaConfig.FEM_LNA_Mode fem_lna_mode = 106;
   */
  femLnaMode: Config_LoRaConfig_FEM_LNA_Mode;
  /**
   *
   * Don't use radiolib to initialize the radio, instead listen for a serialHal connection
   *
   * @generated from field: bool serial_hal_only = 107;
   */
  serialHalOnly: boolean;
};
/**
 * Describes the message meshtastic.Config.LoRaConfig.
 * Use `create(Config_LoRaConfigSchema)` to create a new message.
 */
declare const Config_LoRaConfigSchema: GenMessage<Config_LoRaConfig>;
/**
 * @generated from enum meshtastic.Config.LoRaConfig.RegionCode
 */
declare enum Config_LoRaConfig_RegionCode {
  /**
   *
   * Region is not set
   *
   * @generated from enum value: UNSET = 0;
   */
  UNSET = 0,
  /**
   *
   * United States
   *
   * @generated from enum value: US = 1;
   */
  US = 1,
  /**
   *
   * European Union 433mhz
   *
   * @generated from enum value: EU_433 = 2;
   */
  EU_433 = 2,
  /**
   *
   * European Union 868mhz
   *
   * @generated from enum value: EU_868 = 3;
   */
  EU_868 = 3,
  /**
   *
   * China
   *
   * @generated from enum value: CN = 4;
   */
  CN = 4,
  /**
   *
   * Japan
   *
   * @generated from enum value: JP = 5;
   */
  JP = 5,
  /**
   *
   * Australia / New Zealand
   *
   * @generated from enum value: ANZ = 6;
   */
  ANZ = 6,
  /**
   *
   * Korea
   *
   * @generated from enum value: KR = 7;
   */
  KR = 7,
  /**
   *
   * Taiwan
   *
   * @generated from enum value: TW = 8;
   */
  TW = 8,
  /**
   *
   * Russia
   *
   * @generated from enum value: RU = 9;
   */
  RU = 9,
  /**
   *
   * India
   *
   * @generated from enum value: IN = 10;
   */
  IN = 10,
  /**
   *
   * New Zealand 865mhz
   *
   * @generated from enum value: NZ_865 = 11;
   */
  NZ_865 = 11,
  /**
   *
   * Thailand
   *
   * @generated from enum value: TH = 12;
   */
  TH = 12,
  /**
   *
   * WLAN Band
   *
   * @generated from enum value: LORA_24 = 13;
   */
  LORA_24 = 13,
  /**
   *
   * Ukraine 433mhz
   *
   * @generated from enum value: UA_433 = 14;
   */
  UA_433 = 14,
  /**
   *
   * Ukraine 868mhz
   *
   * @generated from enum value: UA_868 = 15 [deprecated = true];
   * @deprecated
   */
  UA_868 = 15,
  /**
   *
   * Malaysia 433mhz
   *
   * @generated from enum value: MY_433 = 16;
   */
  MY_433 = 16,
  /**
   *
   * Malaysia 919mhz
   *
   * @generated from enum value: MY_919 = 17;
   */
  MY_919 = 17,
  /**
   *
   * Singapore 923mhz
   *
   * @generated from enum value: SG_923 = 18;
   */
  SG_923 = 18,
  /**
   *
   * Philippines 433mhz
   *
   * @generated from enum value: PH_433 = 19;
   */
  PH_433 = 19,
  /**
   *
   * Philippines 868mhz
   *
   * @generated from enum value: PH_868 = 20;
   */
  PH_868 = 20,
  /**
   *
   * Philippines 915mhz
   *
   * @generated from enum value: PH_915 = 21;
   */
  PH_915 = 21,
  /**
   *
   * Australia / New Zealand 433MHz
   *
   * @generated from enum value: ANZ_433 = 22;
   */
  ANZ_433 = 22,
  /**
   *
   * Kazakhstan 433MHz
   *
   * @generated from enum value: KZ_433 = 23;
   */
  KZ_433 = 23,
  /**
   *
   * Kazakhstan 863MHz
   *
   * @generated from enum value: KZ_863 = 24;
   */
  KZ_863 = 24,
  /**
   *
   * Nepal 865MHz
   *
   * @generated from enum value: NP_865 = 25;
   */
  NP_865 = 25,
  /**
   *
   * Brazil 902MHz
   *
   * @generated from enum value: BR_902 = 26;
   */
  BR_902 = 26,
  /**
   *
   * ITU Region 1 Amateur Radio 2m band (144-146 MHz)
   *
   * @generated from enum value: ITU1_2M = 27;
   */
  ITU1_2M = 27,
  /**
   *
   * ITU Region 2 Amateur Radio 2m band (144-148 MHz)
   *
   * @generated from enum value: ITU2_2M = 28;
   */
  ITU2_2M = 28,
  /**
   *
   * EU 866MHz band (Band no. 47b of 2006/771/EC and subsequent amendments) for Non-specific short-range devices (SRD)
   *
   * @generated from enum value: EU_866 = 29;
   */
  EU_866 = 29,
  /**
   *
   * EU 874MHz and 917MHz bands (Band no. 1 and 4 of 2022/172/EC and subsequent amendments) for Non-specific short-range devices (SRD)
   *
   * @generated from enum value: EU_874 = 30;
   */
  EU_874 = 30,
  /**
   * @generated from enum value: EU_917 = 31;
   */
  EU_917 = 31,
  /**
   *
   * EU 868MHz band, with narrow presets
   *
   * @generated from enum value: EU_N_868 = 32;
   */
  EU_N_868 = 32,
  /**
   *
   * ITU Region 3 Amateur Radio 2m band (144-148 MHz)
   *
   * @generated from enum value: ITU3_2M = 33;
   */
  ITU3_2M = 33,
  /**
   *
   * ITU Region 1 Amateur Radio 70cm band (430-440 MHz)
   *
   * @generated from enum value: ITU1_70CM = 34;
   */
  ITU1_70CM = 34,
  /**
   *
   * ITU Region 2 Amateur Radio 70cm band (420-450 MHz)
   * Note: Some countries do not allocate 420-430 MHz or 440-450 MHz.
   * Check local law!
   *
   * @generated from enum value: ITU2_70CM = 35;
   */
  ITU2_70CM = 35,
  /**
   *
   * ITU Region 3 Amateur Radio 70cm band (430-450 MHz)
   * Note: Some countries do not allocate 440-450 MHz. Check local law!
   *
   * @generated from enum value: ITU3_70CM = 36;
   */
  ITU3_70CM = 36,
  /**
   *
   * ITU Region 2 Amateur Radio 1.25m '125cm' band (220-225 MHz)
   * Note: Some countries do not allocate 220-222 MHz (Ex: USA/Canada).
   * Check local law!
   *
   * @generated from enum value: ITU2_125CM = 37;
   */
  ITU2_125CM = 37
}
/**
 * Describes the enum meshtastic.Config.LoRaConfig.RegionCode.
 */
declare const Config_LoRaConfig_RegionCodeSchema: GenEnum<Config_LoRaConfig_RegionCode>;
/**
 *
 * Standard predefined channel settings
 * Note: these mappings must match ModemPreset Choice in the device code.
 *
 * @generated from enum meshtastic.Config.LoRaConfig.ModemPreset
 */
declare enum Config_LoRaConfig_ModemPreset {
  /**
   *
   * Long Range - Fast
   *
   * @generated from enum value: LONG_FAST = 0;
   */
  LONG_FAST = 0,
  /**
   *
   * Long Range - Slow
   * Deprecated in 2.7: Unpopular slow preset.
   *
   * @generated from enum value: LONG_SLOW = 1 [deprecated = true];
   * @deprecated
   */
  LONG_SLOW = 1,
  /**
   *
   * Very Long Range - Slow
   * Deprecated in 2.5: Works only with txco and is unusably slow
   *
   * @generated from enum value: VERY_LONG_SLOW = 2 [deprecated = true];
   * @deprecated
   */
  VERY_LONG_SLOW = 2,
  /**
   *
   * Medium Range - Slow
   *
   * @generated from enum value: MEDIUM_SLOW = 3;
   */
  MEDIUM_SLOW = 3,
  /**
   *
   * Medium Range - Fast
   *
   * @generated from enum value: MEDIUM_FAST = 4;
   */
  MEDIUM_FAST = 4,
  /**
   *
   * Short Range - Slow
   *
   * @generated from enum value: SHORT_SLOW = 5;
   */
  SHORT_SLOW = 5,
  /**
   *
   * Short Range - Fast
   *
   * @generated from enum value: SHORT_FAST = 6;
   */
  SHORT_FAST = 6,
  /**
   *
   * Long Range - Moderately Fast
   *
   * @generated from enum value: LONG_MODERATE = 7;
   */
  LONG_MODERATE = 7,
  /**
   *
   * Short Range - Turbo
   * This is the fastest preset and the only one with 500kHz bandwidth.
   * It is not legal to use in all regions due to this wider bandwidth.
   *
   * @generated from enum value: SHORT_TURBO = 8;
   */
  SHORT_TURBO = 8,
  /**
   *
   * Long Range - Turbo
   * This preset performs similarly to LongFast, but with 500Khz bandwidth.
   *
   * @generated from enum value: LONG_TURBO = 9;
   */
  LONG_TURBO = 9,
  /**
   *
   * Lite Fast
   * Medium range preset optimized for EU 866MHz SRD band with 125kHz bandwidth.
   * Comparable link budget to MEDIUM_FAST but compliant with Band no. 47b of 2006/771/EC.
   *
   * @generated from enum value: LITE_FAST = 10;
   */
  LITE_FAST = 10,
  /**
   *
   * Lite Slow
   * Medium-to-moderate range preset optimized for EU 866MHz SRD band with 125kHz bandwidth.
   * Comparable link budget to LONG_FAST but compliant with Band no. 47b of 2006/771/EC.
   *
   * @generated from enum value: LITE_SLOW = 11;
   */
  LITE_SLOW = 11,
  /**
   *
   * Narrow Fast
   * Medium-to-moderate range preset optimized for EU 868MHz band with 62.5kHz bandwidth.
   * Comparable link budget to SHORT_SLOW, but with half the data rate.
   * Intended to avoid interference with other devices.
   *
   * @generated from enum value: NARROW_FAST = 12;
   */
  NARROW_FAST = 12,
  /**
   *
   * Narrow Slow
   * Moderate range preset optimized for EU 868MHz band with 62.5kHz bandwidth.
   * Comparable link budget and data rate to LONG_FAST.
   *
   * @generated from enum value: NARROW_SLOW = 13;
   */
  NARROW_SLOW = 13,
  /**
   *
   * Tiny Fast
   * Preset optimized for compliance with Amateur Radio restrictions with 20kHz bandwidth.
   * Many regions limit data transmission bandwidth in lower amateur bands (2 Meter).
   * Note: TCXO with tight tolerances (±5 ppm or better) is *absolutely required* at these narrow bandwidths.
   * Only compatible with SX127x and SX126x chipsets.
   * Comparable link budget and data rate to LONG_FAST.
   *
   * @generated from enum value: TINY_FAST = 14;
   */
  TINY_FAST = 14,
  /**
   *
   * Tiny Slow
   * Preset optimized for compliance with Amateur Radio restrictions with 20kHz bandwidth.
   * Many regions limit data transmission bandwidth in lower amateur bands (2 Meter).
   * Note: TCXO with tight tolerances (±5 ppm or better) is *absolutely required* at these narrow bandwidths.
   * Only compatible with SX127x and SX126x chipsets.
   * Comparable link budget and data rate to LONG_MODERATE.
   *
   * @generated from enum value: TINY_SLOW = 15;
   */
  TINY_SLOW = 15,
  /**
   *
   * Medium Range - Turbo
   * This preset performs similarly to MEDIUM_FAST, but with 500kHz bandwidth.
   * It is not legal to use in all regions due to this wider bandwidth.
   *
   * @generated from enum value: MEDIUM_TURBO = 16;
   */
  MEDIUM_TURBO = 16
}
/**
 * Describes the enum meshtastic.Config.LoRaConfig.ModemPreset.
 */
declare const Config_LoRaConfig_ModemPresetSchema: GenEnum<Config_LoRaConfig_ModemPreset>;
/**
 * @generated from enum meshtastic.Config.LoRaConfig.FEM_LNA_Mode
 */
declare enum Config_LoRaConfig_FEM_LNA_Mode {
  /**
   *
   * FEM_LNA is present but disabled
   *
   * @generated from enum value: DISABLED = 0;
   */
  DISABLED = 0,
  /**
   *
   * FEM_LNA is present and enabled
   *
   * @generated from enum value: ENABLED = 1;
   */
  ENABLED = 1,
  /**
   *
   * FEM_LNA is not present on the device
   *
   * @generated from enum value: NOT_PRESENT = 2;
   */
  NOT_PRESENT = 2
}
/**
 * Describes the enum meshtastic.Config.LoRaConfig.FEM_LNA_Mode.
 */
declare const Config_LoRaConfig_FEM_LNA_ModeSchema: GenEnum<Config_LoRaConfig_FEM_LNA_Mode>;
/**
 * @generated from message meshtastic.Config.BluetoothConfig
 */
type Config_BluetoothConfig = Message<"meshtastic.Config.BluetoothConfig"> & {
  /**
   *
   * Enable Bluetooth on the device
   *
   * @generated from field: bool enabled = 1;
   */
  enabled: boolean;
  /**
   *
   * Determines the pairing strategy for the device
   *
   * @generated from field: meshtastic.Config.BluetoothConfig.PairingMode mode = 2;
   */
  mode: Config_BluetoothConfig_PairingMode;
  /**
   *
   * Specified PIN for PairingMode.FixedPin
   *
   * @generated from field: uint32 fixed_pin = 3;
   */
  fixedPin: number;
};
/**
 * Describes the message meshtastic.Config.BluetoothConfig.
 * Use `create(Config_BluetoothConfigSchema)` to create a new message.
 */
declare const Config_BluetoothConfigSchema: GenMessage<Config_BluetoothConfig>;
/**
 * @generated from enum meshtastic.Config.BluetoothConfig.PairingMode
 */
declare enum Config_BluetoothConfig_PairingMode {
  /**
   *
   * Device generates a random PIN that will be shown on the screen of the device for pairing
   *
   * @generated from enum value: RANDOM_PIN = 0;
   */
  RANDOM_PIN = 0,
  /**
   *
   * Device requires a specified fixed PIN for pairing
   *
   * @generated from enum value: FIXED_PIN = 1;
   */
  FIXED_PIN = 1,
  /**
   *
   * Device requires no PIN for pairing
   *
   * @generated from enum value: NO_PIN = 2;
   */
  NO_PIN = 2
}
/**
 * Describes the enum meshtastic.Config.BluetoothConfig.PairingMode.
 */
declare const Config_BluetoothConfig_PairingModeSchema: GenEnum<Config_BluetoothConfig_PairingMode>;
/**
 * @generated from message meshtastic.Config.SecurityConfig
 */
type Config_SecurityConfig = Message<"meshtastic.Config.SecurityConfig"> & {
  /**
   *
   * The public key of the user's device.
   * Sent out to other nodes on the mesh to allow them to compute a shared secret key.
   *
   * @generated from field: bytes public_key = 1;
   */
  publicKey: Uint8Array;
  /**
   *
   * The private key of the device.
   * Used to create a shared key with a remote device.
   *
   * @generated from field: bytes private_key = 2;
   */
  privateKey: Uint8Array;
  /**
   *
   * The public key authorized to send admin messages to this node.
   *
   * @generated from field: repeated bytes admin_key = 3;
   */
  adminKey: Uint8Array[];
  /**
   *
   * If true, device is considered to be "managed" by a mesh administrator via admin messages
   * Device is managed by a mesh administrator.
   *
   * @generated from field: bool is_managed = 4;
   */
  isManaged: boolean;
  /**
   *
   * Serial Console over the Stream API."
   *
   * @generated from field: bool serial_enabled = 5;
   */
  serialEnabled: boolean;
  /**
   *
   * By default we turn off logging as soon as an API client connects (to keep shared serial link quiet).
   * Output live debug logging over serial or bluetooth is set to true.
   *
   * @generated from field: bool debug_log_api_enabled = 6;
   */
  debugLogApiEnabled: boolean;
  /**
   *
   * Allow incoming device control over the insecure legacy admin channel.
   *
   * @generated from field: bool admin_channel_enabled = 8;
   */
  adminChannelEnabled: boolean;
  /**
   *
   * Determines the packet signature policy applied to remotely received mesh packets.
   *
   * @generated from field: meshtastic.Config.SecurityConfig.PacketSignaturePolicy packet_signature_policy = 9;
   */
  packetSignaturePolicy: Config_SecurityConfig_PacketSignaturePolicy;
};
/**
 * Describes the message meshtastic.Config.SecurityConfig.
 * Use `create(Config_SecurityConfigSchema)` to create a new message.
 */
declare const Config_SecurityConfigSchema: GenMessage<Config_SecurityConfig>;
/**
 *
 * Controls how the device authenticates remotely received mesh packets.
 *
 * @generated from enum meshtastic.Config.SecurityConfig.PacketSignaturePolicy
 */
declare enum Config_SecurityConfig_PacketSignaturePolicy {
  /**
   *
   * Accept unsigned packets for maximum compatibility while still rejecting malformed or invalid signatures.
   * This is the default to avoid legacy nodes dropping signed packets during rebroadcast.
   *
   * @generated from enum value: PACKET_SIGNATURE_POLICY_COMPATIBLE = 0;
   */
  COMPATIBLE = 0,
  /**
   *
   * Prefer authenticated packets while retaining compatibility with unsigned packets from nodes not known to sign.
   * Rejects unsigned, signable broadcasts from nodes that have previously signed.
   *
   * @generated from enum value: PACKET_SIGNATURE_POLICY_BALANCED = 1;
   */
  BALANCED = 1,
  /**
   *
   * Accept only packets authenticated by a verified XEdDSA signature or successful PKI decryption.
   * Unsigned, malformed, invalid, or unverifiable packets are ignored.
   *
   * @generated from enum value: PACKET_SIGNATURE_POLICY_STRICT = 2;
   */
  STRICT = 2
}
/**
 * Describes the enum meshtastic.Config.SecurityConfig.PacketSignaturePolicy.
 */
declare const Config_SecurityConfig_PacketSignaturePolicySchema: GenEnum<Config_SecurityConfig_PacketSignaturePolicy>;
/**
 *
 * Blank config request, strictly for getting the session key
 *
 * @generated from message meshtastic.Config.SessionkeyConfig
 */
type Config_SessionkeyConfig = Message<"meshtastic.Config.SessionkeyConfig"> & {};
/**
 * Describes the message meshtastic.Config.SessionkeyConfig.
 * Use `create(Config_SessionkeyConfigSchema)` to create a new message.
 */
declare const Config_SessionkeyConfigSchema: GenMessage<Config_SessionkeyConfig>;
declare namespace connection_status_pb_d_exports {
  export { BluetoothConnectionStatus, BluetoothConnectionStatusSchema, DeviceConnectionStatus, DeviceConnectionStatusSchema, EthernetConnectionStatus, EthernetConnectionStatusSchema, NetworkConnectionStatus, NetworkConnectionStatusSchema, SerialConnectionStatus, SerialConnectionStatusSchema, WifiConnectionStatus, WifiConnectionStatusSchema, file_meshtastic_connection_status };
}
/**
 * Describes the file meshtastic/connection_status.proto.
 */
declare const file_meshtastic_connection_status: GenFile;
/**
 * @generated from message meshtastic.DeviceConnectionStatus
 */
type DeviceConnectionStatus = Message<"meshtastic.DeviceConnectionStatus"> & {
  /**
   *
   * WiFi Status
   *
   * @generated from field: optional meshtastic.WifiConnectionStatus wifi = 1;
   */
  wifi?: WifiConnectionStatus;
  /**
   *
   * WiFi Status
   *
   * @generated from field: optional meshtastic.EthernetConnectionStatus ethernet = 2;
   */
  ethernet?: EthernetConnectionStatus;
  /**
   *
   * Bluetooth Status
   *
   * @generated from field: optional meshtastic.BluetoothConnectionStatus bluetooth = 3;
   */
  bluetooth?: BluetoothConnectionStatus;
  /**
   *
   * Serial Status
   *
   * @generated from field: optional meshtastic.SerialConnectionStatus serial = 4;
   */
  serial?: SerialConnectionStatus;
};
/**
 * Describes the message meshtastic.DeviceConnectionStatus.
 * Use `create(DeviceConnectionStatusSchema)` to create a new message.
 */
declare const DeviceConnectionStatusSchema: GenMessage<DeviceConnectionStatus>;
/**
 *
 * WiFi connection status
 *
 * @generated from message meshtastic.WifiConnectionStatus
 */
type WifiConnectionStatus = Message<"meshtastic.WifiConnectionStatus"> & {
  /**
   *
   * Connection status
   *
   * @generated from field: meshtastic.NetworkConnectionStatus status = 1;
   */
  status?: NetworkConnectionStatus;
  /**
   *
   * WiFi access point SSID
   *
   * @generated from field: string ssid = 2;
   */
  ssid: string;
  /**
   *
   * RSSI of wireless connection
   *
   * @generated from field: int32 rssi = 3;
   */
  rssi: number;
};
/**
 * Describes the message meshtastic.WifiConnectionStatus.
 * Use `create(WifiConnectionStatusSchema)` to create a new message.
 */
declare const WifiConnectionStatusSchema: GenMessage<WifiConnectionStatus>;
/**
 *
 * Ethernet connection status
 *
 * @generated from message meshtastic.EthernetConnectionStatus
 */
type EthernetConnectionStatus = Message<"meshtastic.EthernetConnectionStatus"> & {
  /**
   *
   * Connection status
   *
   * @generated from field: meshtastic.NetworkConnectionStatus status = 1;
   */
  status?: NetworkConnectionStatus;
};
/**
 * Describes the message meshtastic.EthernetConnectionStatus.
 * Use `create(EthernetConnectionStatusSchema)` to create a new message.
 */
declare const EthernetConnectionStatusSchema: GenMessage<EthernetConnectionStatus>;
/**
 *
 * Ethernet or WiFi connection status
 *
 * @generated from message meshtastic.NetworkConnectionStatus
 */
type NetworkConnectionStatus = Message<"meshtastic.NetworkConnectionStatus"> & {
  /**
   *
   * IP address of device
   *
   * @generated from field: fixed32 ip_address = 1;
   */
  ipAddress: number;
  /**
   *
   * Whether the device has an active connection or not
   *
   * @generated from field: bool is_connected = 2;
   */
  isConnected: boolean;
  /**
   *
   * Whether the device has an active connection to an MQTT broker or not
   *
   * @generated from field: bool is_mqtt_connected = 3;
   */
  isMqttConnected: boolean;
  /**
   *
   * Whether the device is actively remote syslogging or not
   *
   * @generated from field: bool is_syslog_connected = 4;
   */
  isSyslogConnected: boolean;
};
/**
 * Describes the message meshtastic.NetworkConnectionStatus.
 * Use `create(NetworkConnectionStatusSchema)` to create a new message.
 */
declare const NetworkConnectionStatusSchema: GenMessage<NetworkConnectionStatus>;
/**
 *
 * Bluetooth connection status
 *
 * @generated from message meshtastic.BluetoothConnectionStatus
 */
type BluetoothConnectionStatus = Message<"meshtastic.BluetoothConnectionStatus"> & {
  /**
   *
   * The pairing PIN for bluetooth
   *
   * @generated from field: uint32 pin = 1;
   */
  pin: number;
  /**
   *
   * RSSI of bluetooth connection
   *
   * @generated from field: int32 rssi = 2;
   */
  rssi: number;
  /**
   *
   * Whether the device has an active connection or not
   *
   * @generated from field: bool is_connected = 3;
   */
  isConnected: boolean;
};
/**
 * Describes the message meshtastic.BluetoothConnectionStatus.
 * Use `create(BluetoothConnectionStatusSchema)` to create a new message.
 */
declare const BluetoothConnectionStatusSchema: GenMessage<BluetoothConnectionStatus>;
/**
 *
 * Serial connection status
 *
 * @generated from message meshtastic.SerialConnectionStatus
 */
type SerialConnectionStatus = Message<"meshtastic.SerialConnectionStatus"> & {
  /**
   *
   * Serial baud rate
   *
   * @generated from field: uint32 baud = 1;
   */
  baud: number;
  /**
   *
   * Whether the device has an active connection or not
   *
   * @generated from field: bool is_connected = 2;
   */
  isConnected: boolean;
};
/**
 * Describes the message meshtastic.SerialConnectionStatus.
 * Use `create(SerialConnectionStatusSchema)` to create a new message.
 */
declare const SerialConnectionStatusSchema: GenMessage<SerialConnectionStatus>;
declare namespace atak_pb_d_exports {
  export { AircraftTrack, AircraftTrackSchema, CasevacReport, CasevacReportSchema, CasevacReport_HlzMarking, CasevacReport_HlzMarkingSchema, CasevacReport_Precedence, CasevacReport_PrecedenceSchema, CasevacReport_Security, CasevacReport_SecuritySchema, Contact, ContactSchema, CotGeoPoint, CotGeoPointSchema, CotHow, CotHowSchema, CotType, CotTypeSchema, DrawnShape, DrawnShapeSchema, DrawnShape_Kind, DrawnShape_KindSchema, DrawnShape_StyleMode, DrawnShape_StyleModeSchema, EmergencyAlert, EmergencyAlertSchema, EmergencyAlert_Type, EmergencyAlert_TypeSchema, GeoChat, GeoChatSchema, GeoChat_ReceiptType, GeoChat_ReceiptTypeSchema, GeoPointSource, GeoPointSourceSchema, Group, GroupSchema, Marker, MarkerSchema, Marker_Kind, Marker_KindSchema, Marti, MartiSchema, MemberRole, MemberRoleSchema, PLI, PLISchema, RangeAndBearing, RangeAndBearingSchema, Route, RouteSchema, Route_Direction, Route_DirectionSchema, Route_Link, Route_LinkSchema, Route_Method, Route_MethodSchema, SensorFov, SensorFovSchema, SensorFov_SensorType, SensorFov_SensorTypeSchema, Status, StatusSchema, TAKEnvironment, TAKEnvironmentSchema, TAKPacket, TAKPacketSchema, TAKPacketV2, TAKPacketV2Schema, TakTalkMessage, TakTalkMessageSchema, TakTalkRoomData, TakTalkRoomDataSchema, TaskRequest, TaskRequestSchema, TaskRequest_Priority, TaskRequest_PrioritySchema, TaskRequest_Status, TaskRequest_StatusSchema, Team, TeamSchema, ZMistEntry, ZMistEntrySchema, file_meshtastic_atak };
}
/**
 * Describes the file meshtastic/atak.proto.
 */
declare const file_meshtastic_atak: GenFile;
/**
 *
 * Packets for the official ATAK Plugin
 *
 * @generated from message meshtastic.TAKPacket
 */
type TAKPacket = Message<"meshtastic.TAKPacket"> & {
  /**
   *
   * Are the payloads strings compressed for LoRA transport?
   *
   * @generated from field: bool is_compressed = 1;
   */
  isCompressed: boolean;
  /**
   *
   * The contact / callsign for ATAK user
   *
   * @generated from field: meshtastic.Contact contact = 2;
   */
  contact?: Contact;
  /**
   *
   * The group for ATAK user
   *
   * @generated from field: meshtastic.Group group = 3;
   */
  group?: Group;
  /**
   *
   * The status of the ATAK EUD
   *
   * @generated from field: meshtastic.Status status = 4;
   */
  status?: Status;
  /**
   *
   * The payload of the packet
   *
   * @generated from oneof meshtastic.TAKPacket.payload_variant
   */
  payloadVariant: {
    /**
     *
     * TAK position report
     *
     * @generated from field: meshtastic.PLI pli = 5;
     */
    value: PLI;
    case: "pli";
  } | {
    /**
     *
     * ATAK GeoChat message
     *
     * @generated from field: meshtastic.GeoChat chat = 6;
     */
    value: GeoChat;
    case: "chat";
  } | {
    /**
     *
     * Generic CoT detail XML
     * May be compressed / truncated by the sender (EUD)
     *
     * @generated from field: bytes detail = 7;
     */
    value: Uint8Array;
    case: "detail";
  } | {
    case: undefined;
    value?: undefined;
  };
};
/**
 * Describes the message meshtastic.TAKPacket.
 * Use `create(TAKPacketSchema)` to create a new message.
 */
declare const TAKPacketSchema: GenMessage<TAKPacket>;
/**
 *
 * ATAK GeoChat message
 *
 * @generated from message meshtastic.GeoChat
 */
type GeoChat = Message<"meshtastic.GeoChat"> & {
  /**
   *
   * The text message. Empty for receipts.
   *
   * @generated from field: string message = 1;
   */
  message: string;
  /**
   *
   * Uid recipient of the message
   *
   * @generated from field: optional string to = 2;
   */
  to?: string;
  /**
   *
   * Callsign of the recipient for the message
   *
   * @generated from field: optional string to_callsign = 3;
   */
  toCallsign?: string;
  /**
   *
   * UID of the chat message this event is acknowledging. Empty for a
   * normal chat message; set for delivered / read receipts. Paired with
   * receipt_type so receivers can match the ack back to the original
   * outbound GeoChat by its event uid.
   *
   * @generated from field: string receipt_for_uid = 4;
   */
  receiptForUid: string;
  /**
   *
   * Receipt kind discriminator. See ReceiptType doc. Default ReceiptType_None
   * means this is a regular chat message, not a receipt.
   *
   * @generated from field: meshtastic.GeoChat.ReceiptType receipt_type = 5;
   */
  receiptType: GeoChat_ReceiptType;
  /**
   *
   * BCP-47-ish language tag or human-readable name (e.g. "en", "English")
   * that the originator's TAKTALK plugin recorded for the message.
   *
   * @generated from field: optional string lang = 6;
   */
  lang?: string;
  /**
   *
   * TAKTALK chatroom UUID (e.g. "30b2755c-c547-44ef-a0cc-cdbd8a15616f") that
   * the receiver's TAKTALK plugin uses to thread the message under the
   * right room. Resolved to a friendly name via TakTalkRoomData broadcasts.
   *
   * @generated from field: optional string room_id = 7;
   */
  roomId?: string;
  /**
   *
   * TAKTALK voice profile pointer. Often empty in practice (the empty
   * marker `<voice_profile_id/>` still signals TAKTALK origination), so
   * receivers should treat empty-but-present as the equivalent of the
   * marker rather than a missing field.
   *
   * @generated from field: optional string voice_profile_id = 8;
   */
  voiceProfileId?: string;
};
/**
 * Describes the message meshtastic.GeoChat.
 * Use `create(GeoChatSchema)` to create a new message.
 */
declare const GeoChatSchema: GenMessage<GeoChat>;
/**
 *
 * Receipt discriminator. Set alongside cot_type_id = b-t-f-d (delivered)
 * or b-t-f-r (read). ReceiptType_None is the default for a normal chat
 * message (cot_type_id = b-t-f).
 *
 * Receivers can detect a receipt by checking receipt_type != ReceiptType_None
 * without re-parsing the envelope cot_type_id.
 *
 * @generated from enum meshtastic.GeoChat.ReceiptType
 */
declare enum GeoChat_ReceiptType {
  /**
   * normal chat message
   *
   * @generated from enum value: ReceiptType_None = 0;
   */
  ReceiptType_None = 0,
  /**
   * b-t-f-d delivered receipt
   *
   * @generated from enum value: ReceiptType_Delivered = 1;
   */
  ReceiptType_Delivered = 1,
  /**
   * b-t-f-r read receipt
   *
   * @generated from enum value: ReceiptType_Read = 2;
   */
  ReceiptType_Read = 2
}
/**
 * Describes the enum meshtastic.GeoChat.ReceiptType.
 */
declare const GeoChat_ReceiptTypeSchema: GenEnum<GeoChat_ReceiptType>;
/**
 *
 * ATAK Group
 * <__group role='Team Member' name='Cyan'/>
 *
 * @generated from message meshtastic.Group
 */
type Group = Message<"meshtastic.Group"> & {
  /**
   *
   * Role of the group member
   *
   * @generated from field: meshtastic.MemberRole role = 1;
   */
  role: MemberRole;
  /**
   *
   * Team (color)
   * Default Cyan
   *
   * @generated from field: meshtastic.Team team = 2;
   */
  team: Team;
};
/**
 * Describes the message meshtastic.Group.
 * Use `create(GroupSchema)` to create a new message.
 */
declare const GroupSchema: GenMessage<Group>;
/**
 *
 * ATAK EUD Status
 * <status battery='100' />
 *
 * @generated from message meshtastic.Status
 */
type Status = Message<"meshtastic.Status"> & {
  /**
   *
   * Battery level
   *
   * @generated from field: uint32 battery = 1;
   */
  battery: number;
};
/**
 * Describes the message meshtastic.Status.
 * Use `create(StatusSchema)` to create a new message.
 */
declare const StatusSchema: GenMessage<Status>;
/**
 *
 * ATAK Contact
 * <contact endpoint='0.0.0.0:4242:tcp' phone='+12345678' callsign='FALKE'/>
 *
 * @generated from message meshtastic.Contact
 */
type Contact = Message<"meshtastic.Contact"> & {
  /**
   *
   * Callsign
   *
   * @generated from field: string callsign = 1;
   */
  callsign: string;
  /**
   *
   * Device callsign
   *
   *
   * IP address of endpoint in integer form (0.0.0.0 default)
   *
   * @generated from field: string device_callsign = 2;
   */
  deviceCallsign: string;
};
/**
 * Describes the message meshtastic.Contact.
 * Use `create(ContactSchema)` to create a new message.
 */
declare const ContactSchema: GenMessage<Contact>;
/**
 *
 * Position Location Information from ATAK
 *
 * @generated from message meshtastic.PLI
 */
type PLI = Message<"meshtastic.PLI"> & {
  /**
   *
   * The new preferred location encoding, multiply by 1e-7 to get degrees
   * in floating point
   *
   * @generated from field: sfixed32 latitude_i = 1;
   */
  latitudeI: number;
  /**
   *
   * The new preferred location encoding, multiply by 1e-7 to get degrees
   * in floating point
   *
   * @generated from field: sfixed32 longitude_i = 2;
   */
  longitudeI: number;
  /**
   *
   * Altitude (ATAK prefers HAE)
   *
   * @generated from field: int32 altitude = 3;
   */
  altitude: number;
  /**
   *
   * Speed
   *
   * @generated from field: uint32 speed = 4;
   */
  speed: number;
  /**
   *
   * Course in degrees
   *
   * @generated from field: uint32 course = 5;
   */
  course: number;
};
/**
 * Describes the message meshtastic.PLI.
 * Use `create(PLISchema)` to create a new message.
 */
declare const PLISchema: GenMessage<PLI>;
/**
 *
 * Aircraft track information from ADS-B or military air tracking.
 * Covers the majority of observed real-world CoT traffic.
 *
 * @generated from message meshtastic.AircraftTrack
 */
type AircraftTrack = Message<"meshtastic.AircraftTrack"> & {
  /**
   *
   * ICAO hex identifier (e.g. "AD237C")
   *
   * @generated from field: string icao = 1;
   */
  icao: string;
  /**
   *
   * Aircraft registration (e.g. "N946AK")
   *
   * @generated from field: string registration = 2;
   */
  registration: string;
  /**
   *
   * Flight number/callsign (e.g. "ASA864")
   *
   * @generated from field: string flight = 3;
   */
  flight: string;
  /**
   *
   * ICAO aircraft type designator (e.g. "B39M")
   *
   * @generated from field: string aircraft_type = 4;
   */
  aircraftType: string;
  /**
   *
   * Transponder squawk code (0-7777 octal)
   *
   * @generated from field: uint32 squawk = 5;
   */
  squawk: number;
  /**
   *
   * ADS-B emitter category (e.g. "A3")
   *
   * @generated from field: string category = 6;
   */
  category: string;
  /**
   *
   * Received signal strength * 10 (e.g. -194 for -19.4 dBm)
   *
   * @generated from field: sint32 rssi_x10 = 7;
   */
  rssiX10: number;
  /**
   *
   * Whether receiver has GPS fix
   *
   * @generated from field: bool gps = 8;
   */
  gps: boolean;
  /**
   *
   * CoT host ID for source attribution
   *
   * @generated from field: string cot_host_id = 9;
   */
  cotHostId: string;
};
/**
 * Describes the message meshtastic.AircraftTrack.
 * Use `create(AircraftTrackSchema)` to create a new message.
 */
declare const AircraftTrackSchema: GenMessage<AircraftTrack>;
/**
 *
 * Compact geographic vertex used by repeated vertex lists in TAK geometry
 * payloads. Named with a `Cot` prefix to avoid a namespace collision with
 * `meshtastic.GeoPoint` in `device_ui.proto`, which is an unrelated zoom/
 * latitude/longitude type used by the on-device map UI.
 *
 * Encoded as a signed DELTA from TAKPacketV2.latitude_i / longitude_i (the
 * enclosing event's anchor point). The absolute coordinate is recovered by
 * the receiver as `event.latitude_i + vertex.lat_delta_i` (and likewise for
 * longitude).
 *
 * Why deltas: a 32-vertex telestration with vertices clustered within a few
 * hundred meters of the anchor has per-vertex deltas in the ±10^4 range.
 * Under sint32+zigzag those encode as 2 bytes each (tag+varint), versus the
 * 4 bytes that sfixed32 would always require. At 32 vertices that is ~128
 * bytes of savings — the difference between fitting under the LoRa MTU or
 * not. Absolute coordinates (values ~10^9) would cost sint32 varint 5 bytes
 * per field, which is why TAKPacketV2's top-level latitude_i / longitude_i
 * stay sfixed32 — only small values win with sint32.
 *
 * @generated from message meshtastic.CotGeoPoint
 */
type CotGeoPoint = Message<"meshtastic.CotGeoPoint"> & {
  /**
   *
   * Latitude delta from TAKPacketV2.latitude_i, in 1e-7 degree units.
   * Add to the enclosing event's latitude_i to recover the absolute latitude.
   *
   * @generated from field: sint32 lat_delta_i = 1;
   */
  latDeltaI: number;
  /**
   *
   * Longitude delta from TAKPacketV2.longitude_i, in 1e-7 degree units.
   *
   * @generated from field: sint32 lon_delta_i = 2;
   */
  lonDeltaI: number;
};
/**
 * Describes the message meshtastic.CotGeoPoint.
 * Use `create(CotGeoPointSchema)` to create a new message.
 */
declare const CotGeoPointSchema: GenMessage<CotGeoPoint>;
/**
 *
 * User-drawn tactical graphic: circle, rectangle, polygon, polyline, freehand
 * telestration, ranging circle, or bullseye.
 *
 * Covers CoT types u-d-c-c, u-d-r, u-d-f, u-d-f-m, u-d-p, u-r-b-c-c,
 * u-r-b-bullseye. The shape's anchor position is carried on
 * TAKPacketV2.latitude_i/longitude_i; polyline/polygon vertices are in the
 * `vertices` repeated field as `CotGeoPoint` deltas from that anchor.
 *
 * Colors use the Team enum as a 14-color palette (see color encoding below)
 * with a fixed32 exact-ARGB fallback for custom user-picked colors that
 * don't map to a palette entry.
 *
 * @generated from message meshtastic.DrawnShape
 */
type DrawnShape = Message<"meshtastic.DrawnShape"> & {
  /**
   *
   * Shape kind (circle, rectangle, freeform, etc.)
   *
   * @generated from field: meshtastic.DrawnShape.Kind kind = 1;
   */
  kind: DrawnShape_Kind;
  /**
   *
   * Explicit stroke/fill/both discriminator. See StyleMode doc.
   *
   * @generated from field: meshtastic.DrawnShape.StyleMode style = 2;
   */
  style: DrawnShape_StyleMode;
  /**
   *
   * Ellipse major radius in centimeters. 0 for non-ellipse kinds.
   *
   * @generated from field: uint32 major_cm = 3;
   */
  majorCm: number;
  /**
   *
   * Ellipse minor radius in centimeters. 0 for non-ellipse kinds.
   *
   * @generated from field: uint32 minor_cm = 4;
   */
  minorCm: number;
  /**
   *
   * Ellipse rotation angle in degrees. Valid values are 0..360 inclusive;
   * 0 and 360 are equivalent rotations. In proto3, an unset uint32 reads
   * as 0, so senders should emit 0 when the angle is unspecified.
   *
   * @generated from field: uint32 angle_deg = 5;
   */
  angleDeg: number;
  /**
   *
   * Stroke color as a named palette entry from the Team enum. If
   * Unspecifed_Color, the exact ARGB is carried in stroke_argb.
   * Valid only when style is StrokeOnly or StrokeAndFill.
   *
   * @generated from field: meshtastic.Team stroke_color = 6;
   */
  strokeColor: Team;
  /**
   *
   * Stroke color as an exact 32-bit ARGB bit pattern. Always populated
   * on the wire; readers MUST use this value when stroke_color ==
   * Unspecifed_Color and MAY use it to recover the exact original bytes
   * even when a palette entry is set.
   *
   * @generated from field: fixed32 stroke_argb = 7;
   */
  strokeArgb: number;
  /**
   *
   * Stroke weight in tenths of a unit (e.g. 30 = 3.0). Typical ATAK
   * range 10..60.
   *
   * @generated from field: uint32 stroke_weight_x10 = 8;
   */
  strokeWeightX10: number;
  /**
   *
   * Fill color as a named palette entry. See stroke_color docs.
   * Valid only when style is FillOnly or StrokeAndFill.
   *
   * @generated from field: meshtastic.Team fill_color = 9;
   */
  fillColor: Team;
  /**
   *
   * Fill color exact ARGB fallback. See stroke_argb docs.
   *
   * @generated from field: fixed32 fill_argb = 10;
   */
  fillArgb: number;
  /**
   *
   * Whether labels are rendered on this shape.
   *
   * @generated from field: bool labels_on = 11;
   */
  labelsOn: boolean;
  /**
   * @generated from field: repeated sint32 vertex_lat_deltas = 18;
   */
  vertexLatDeltas: number[];
  /**
   * @generated from field: repeated sint32 vertex_lon_deltas = 19;
   */
  vertexLonDeltas: number[];
  /**
   *
   * True if the sender truncated the vertex columns to fit the pool.
   *
   * --- Bullseye-only fields. All ignored unless kind == Kind_Bullseye. ---
   *
   * @generated from field: bool truncated = 13;
   */
  truncated: boolean;
  /**
   *
   * Bullseye distance in meters * 10 (e.g. 3285 = 328.5 m). 0 = unset.
   *
   * @generated from field: uint32 bullseye_distance_dm = 14;
   */
  bullseyeDistanceDm: number;
  /**
   *
   * Bullseye bearing reference: 0 unset, 1 Magnetic, 2 True, 3 Grid.
   *
   * @generated from field: uint32 bullseye_bearing_ref = 15;
   */
  bullseyeBearingRef: number;
  /**
   *
   * Bullseye attribute bit flags:
   *   bit 0: rangeRingVisible
   *   bit 1: hasRangeRings
   *   bit 2: edgeToCenter
   *   bit 3: mils
   *
   * @generated from field: uint32 bullseye_flags = 16;
   */
  bullseyeFlags: number;
  /**
   *
   * Bullseye reference UID (anchor marker). Empty = anchor is self.
   *
   * @generated from field: string bullseye_uid_ref = 17;
   */
  bullseyeUidRef: string;
};
/**
 * Describes the message meshtastic.DrawnShape.
 * Use `create(DrawnShapeSchema)` to create a new message.
 */
declare const DrawnShapeSchema: GenMessage<DrawnShape>;
/**
 *
 * Shape kind discriminator. Drives receiver rendering and also controls
 * which optional fields below are meaningful.
 *
 * @generated from enum meshtastic.DrawnShape.Kind
 */
declare enum DrawnShape_Kind {
  /**
   *
   * Unspecified (do not use on the wire)
   *
   * @generated from enum value: Kind_Unspecified = 0;
   */
  Unspecified = 0,
  /**
   *
   * u-d-c-c: User-drawn circle (uses major/minor/angle, anchor = event point)
   *
   * @generated from enum value: Kind_Circle = 1;
   */
  Circle = 1,
  /**
   *
   * u-d-r: User-drawn rectangle (uses vertices = 4 corners)
   *
   * @generated from enum value: Kind_Rectangle = 2;
   */
  Rectangle = 2,
  /**
   *
   * u-d-f: User-drawn polyline (uses vertices, not closed)
   *
   * @generated from enum value: Kind_Freeform = 3;
   */
  Freeform = 3,
  /**
   *
   * u-d-f-m: Freehand telestration / annotation (uses vertices, may be truncated)
   *
   * @generated from enum value: Kind_Telestration = 4;
   */
  Telestration = 4,
  /**
   *
   * u-d-p: Closed polygon (uses vertices, implicitly closed)
   *
   * @generated from enum value: Kind_Polygon = 5;
   */
  Polygon = 5,
  /**
   *
   * u-r-b-c-c: Ranging circle (major/minor/angle, stroke + optional fill)
   *
   * @generated from enum value: Kind_RangingCircle = 6;
   */
  RangingCircle = 6,
  /**
   *
   * u-r-b-bullseye: Bullseye ring with range rings and bearing reference
   *
   * @generated from enum value: Kind_Bullseye = 7;
   */
  Bullseye = 7,
  /**
   *
   * u-d-c-e: Ellipse with distinct major/minor axes (same storage as
   * Kind_Circle — uses major_cm/minor_cm/angle_deg — but receivers
   * render it as a non-circular ellipse rather than a round circle).
   *
   * @generated from enum value: Kind_Ellipse = 8;
   */
  Ellipse = 8,
  /**
   *
   * u-d-v: 2D vehicle outline drawn on the map. Vertices carry the
   * outline polygon; receivers draw it as a filled polygon.
   *
   * @generated from enum value: Kind_Vehicle2D = 9;
   */
  Vehicle2D = 9,
  /**
   *
   * u-d-v-m: 3D vehicle model reference. Same vertex polygon as
   * Kind_Vehicle2D; receivers that support 3D rendering extrude it.
   *
   * @generated from enum value: Kind_Vehicle3D = 10;
   */
  Vehicle3D = 10
}
/**
 * Describes the enum meshtastic.DrawnShape.Kind.
 */
declare const DrawnShape_KindSchema: GenEnum<DrawnShape_Kind>;
/**
 *
 * Explicit stroke/fill/both discriminator.
 *
 * ATAK's source XML distinguishes "stroke-only polyline" from "closed shape
 * with both stroke and fill" by the presence of the <fillColor> element.
 * Both states can hash to all-zero color fields, so we carry the signal
 * explicitly. Parser sets this from (sawStrokeColor, sawFillColor) at the
 * end of parse; builder uses it to decide which of <strokeColor> /
 * <fillColor> to emit in the reconstructed XML.
 *
 * @generated from enum meshtastic.DrawnShape.StyleMode
 */
declare enum DrawnShape_StyleMode {
  /**
   *
   * Unspecified — receiver infers from which color fields are non-zero.
   *
   * @generated from enum value: StyleMode_Unspecified = 0;
   */
  StyleMode_Unspecified = 0,
  /**
   *
   * Stroke only. No <fillColor> in the source XML. Used for polylines,
   * ranging lines, bullseye rings.
   *
   * @generated from enum value: StyleMode_StrokeOnly = 1;
   */
  StyleMode_StrokeOnly = 1,
  /**
   *
   * Fill only. No <strokeColor> in the source XML. Rare but valid in
   * ATAK (solid region with no outline).
   *
   * @generated from enum value: StyleMode_FillOnly = 2;
   */
  StyleMode_FillOnly = 2,
  /**
   *
   * Both stroke and fill present. Closed shapes: circle, rectangle,
   * polygon, ranging circle.
   *
   * @generated from enum value: StyleMode_StrokeAndFill = 3;
   */
  StyleMode_StrokeAndFill = 3
}
/**
 * Describes the enum meshtastic.DrawnShape.StyleMode.
 */
declare const DrawnShape_StyleModeSchema: GenEnum<DrawnShape_StyleMode>;
/**
 *
 * Fixed point of interest: spot marker, waypoint, checkpoint, 2525 symbol,
 * or custom icon.
 *
 * Covers CoT types b-m-p-s-m, b-m-p-w, b-m-p-c, b-m-p-s-p-i, b-m-p-s-p-loc,
 * plus a-u-G / a-f-G / a-h-G / a-n-G with iconset paths. The marker position
 * is carried on TAKPacketV2.latitude_i/longitude_i; fields below carry only
 * the marker-specific metadata.
 *
 * @generated from message meshtastic.Marker
 */
type Marker = Message<"meshtastic.Marker"> & {
  /**
   *
   * Marker kind
   *
   * @generated from field: meshtastic.Marker.Kind kind = 1;
   */
  kind: Marker_Kind;
  /**
   *
   * Marker color as a named palette entry. If Unspecifed_Color, the exact
   * ARGB is in color_argb.
   *
   * @generated from field: meshtastic.Team color = 2;
   */
  color: Team;
  /**
   *
   * Marker color exact ARGB bit pattern. Always populated on the wire.
   *
   * @generated from field: fixed32 color_argb = 3;
   */
  colorArgb: number;
  /**
   *
   * Status readiness flag (ATAK <status readiness="true"/>).
   *
   * @generated from field: bool readiness = 4;
   */
  readiness: boolean;
  /**
   *
   * Parent link UID (ATAK <link uid=... relation="p-p"/>). Empty = no parent.
   * For spot/waypoint markers this is typically the producing TAK user's UID.
   *
   * @generated from field: string parent_uid = 5;
   */
  parentUid: string;
  /**
   *
   * Parent CoT type (e.g. "a-f-G-U-C"). Usually the parent TAK user's type.
   *
   * @generated from field: string parent_type = 6;
   */
  parentType: string;
  /**
   *
   * Parent callsign (e.g. "HOPE").
   *
   * @generated from field: string parent_callsign = 7;
   */
  parentCallsign: string;
  /**
   *
   * Iconset path stored verbatim. ATAK emits three flavors:
   *   Kind_Symbol2525    -> "COT_MAPPING_2525B/<cot-type-prefix>/<cot-type>"
   *   Kind_SpotMap       -> "COT_MAPPING_SPOTMAP/<cot-type>/<argb>"
   *   Kind_CustomIcon    -> "<UUID>/<GroupName>/<filename>.png"
   * Stored end-to-end without prefix stripping; the ~19 bytes saved by
   * stripping well-known prefixes are not worth the builder-side bug
   * surface, and the dict compresses the repetition effectively.
   *
   * @generated from field: string iconset = 8;
   */
  iconset: string;
};
/**
 * Describes the message meshtastic.Marker.
 * Use `create(MarkerSchema)` to create a new message.
 */
declare const MarkerSchema: GenMessage<Marker>;
/**
 *
 * Marker kind. Used to pick sensible receiver defaults when the CoT type
 * alone is ambiguous (e.g. a-u-G could be a 2525 symbol or a custom icon
 * depending on the iconset path).
 *
 * @generated from enum meshtastic.Marker.Kind
 */
declare enum Marker_Kind {
  /**
   *
   * Unspecified — fall back to TAKPacketV2.cot_type_id
   *
   * @generated from enum value: Kind_Unspecified = 0;
   */
  Unspecified = 0,
  /**
   *
   * b-m-p-s-m: Spot map marker
   *
   * @generated from enum value: Kind_Spot = 1;
   */
  Spot = 1,
  /**
   *
   * b-m-p-w: Route waypoint
   *
   * @generated from enum value: Kind_Waypoint = 2;
   */
  Waypoint = 2,
  /**
   *
   * b-m-p-c: Checkpoint
   *
   * @generated from enum value: Kind_Checkpoint = 3;
   */
  Checkpoint = 3,
  /**
   *
   * b-m-p-s-p-i / b-m-p-s-p-loc: Self-position marker
   *
   * @generated from enum value: Kind_SelfPosition = 4;
   */
  SelfPosition = 4,
  /**
   *
   * 2525B/C military symbol (iconsetpath = COT_MAPPING_2525B/...)
   *
   * @generated from enum value: Kind_Symbol2525 = 5;
   */
  Symbol2525 = 5,
  /**
   *
   * COT_MAPPING_SPOTMAP icon (e.g. colored dot)
   *
   * @generated from enum value: Kind_SpotMap = 6;
   */
  SpotMap = 6,
  /**
   *
   * Custom icon set (UUID/GroupName/filename.png)
   *
   * @generated from enum value: Kind_CustomIcon = 7;
   */
  CustomIcon = 7,
  /**
   *
   * b-m-p-w-GOTO: Go To / bloodhound navigation waypoint.
   *
   * @generated from enum value: Kind_GoToPoint = 8;
   */
  GoToPoint = 8,
  /**
   *
   * b-m-p-c-ip: Initial point (mission planning control point).
   *
   * @generated from enum value: Kind_InitialPoint = 9;
   */
  InitialPoint = 9,
  /**
   *
   * b-m-p-c-cp: Contact point (mission planning control point).
   *
   * @generated from enum value: Kind_ContactPoint = 10;
   */
  ContactPoint = 10,
  /**
   *
   * b-m-p-s-p-op: Observation post.
   *
   * @generated from enum value: Kind_ObservationPost = 11;
   */
  ObservationPost = 11,
  /**
   *
   * b-i-x-i: Quick Pic geotagged image marker. iconset carries the
   * image reference (local filename or remote URL); the image itself
   * does not ride on the LoRa wire.
   *
   * @generated from enum value: Kind_ImageMarker = 12;
   */
  ImageMarker = 12
}
/**
 * Describes the enum meshtastic.Marker.Kind.
 */
declare const Marker_KindSchema: GenEnum<Marker_Kind>;
/**
 *
 * Range and bearing measurement line from the event anchor to a target point.
 *
 * Covers CoT type u-rb-a. The anchor position is on
 * TAKPacketV2.latitude_i/longitude_i; the target endpoint is carried as a
 * CotGeoPoint — same delta-from-anchor encoding used by DrawnShape.vertices
 * so a self-anchored RAB (common case) encodes in zero bytes.
 *
 * @generated from message meshtastic.RangeAndBearing
 */
type RangeAndBearing = Message<"meshtastic.RangeAndBearing"> & {
  /**
   *
   * Target/anchor endpoint (delta-encoded from TAKPacketV2.latitude_i/longitude_i).
   *
   * @generated from field: meshtastic.CotGeoPoint anchor = 1;
   */
  anchor?: CotGeoPoint;
  /**
   *
   * Anchor UID (from <link uid="anchor-1"/>). Empty = free-standing.
   *
   * @generated from field: string anchor_uid = 2;
   */
  anchorUid: string;
  /**
   *
   * Range in centimeters (value * 100). Range 0..4294 km.
   *
   * @generated from field: uint32 range_cm = 3;
   */
  rangeCm: number;
  /**
   *
   * Bearing in degrees * 100 (0..36000).
   *
   * @generated from field: uint32 bearing_cdeg = 4;
   */
  bearingCdeg: number;
  /**
   *
   * Stroke color as a Team palette entry. See DrawnShape.stroke_color doc.
   *
   * @generated from field: meshtastic.Team stroke_color = 5;
   */
  strokeColor: Team;
  /**
   *
   * Stroke color exact ARGB fallback.
   *
   * @generated from field: fixed32 stroke_argb = 6;
   */
  strokeArgb: number;
  /**
   *
   * Stroke weight * 10 (e.g. 30 = 3.0).
   *
   * @generated from field: uint32 stroke_weight_x10 = 7;
   */
  strokeWeightX10: number;
};
/**
 * Describes the message meshtastic.RangeAndBearing.
 * Use `create(RangeAndBearingSchema)` to create a new message.
 */
declare const RangeAndBearingSchema: GenMessage<RangeAndBearing>;
/**
 *
 * Named route consisting of ordered waypoints and control points.
 *
 * Covers CoT type b-m-r. The first waypoint's position is on
 * TAKPacketV2.latitude_i/longitude_i; subsequent waypoints and checkpoints
 * are in `links`. Link count is capped at 16 by the nanopb pool; senders
 * MUST truncate longer routes and set `truncated = true`.
 *
 * @generated from message meshtastic.Route
 */
type Route = Message<"meshtastic.Route"> & {
  /**
   *
   * Travel method
   *
   * @generated from field: meshtastic.Route.Method method = 1;
   */
  method: Route_Method;
  /**
   *
   * Direction (infil/exfil)
   *
   * @generated from field: meshtastic.Route.Direction direction = 2;
   */
  direction: Route_Direction;
  /**
   *
   * Waypoint name prefix (e.g. "CP").
   *
   * @generated from field: string prefix = 3;
   */
  prefix: string;
  /**
   *
   * Stroke weight * 10 (e.g. 30 = 3.0). 0 = default.
   *
   * @generated from field: uint32 stroke_weight_x10 = 4;
   */
  strokeWeightX10: number;
  /**
   *
   * Ordered list of route control points. Capped at 16.
   *
   * @generated from field: repeated meshtastic.Route.Link links = 5;
   */
  links: Route_Link[];
  /**
   *
   * True if the sender truncated `links` to fit the pool.
   *
   * @generated from field: bool truncated = 6;
   */
  truncated: boolean;
};
/**
 * Describes the message meshtastic.Route.
 * Use `create(RouteSchema)` to create a new message.
 */
declare const RouteSchema: GenMessage<Route>;
/**
 *
 * Route waypoint or control point. Each link corresponds to one ATAK
 * <link type=... point=...> entry inside the b-m-r event.
 *
 * @generated from message meshtastic.Route.Link
 */
type Route_Link = Message<"meshtastic.Route.Link"> & {
  /**
   *
   * Waypoint position (delta-encoded from TAKPacketV2.latitude_i/longitude_i).
   *
   * @generated from field: meshtastic.CotGeoPoint point = 1;
   */
  point?: CotGeoPoint;
  /**
   *
   * Optional UID (empty = receiver derives).
   *
   * @generated from field: string uid = 2;
   */
  uid: string;
  /**
   *
   * Optional display callsign (e.g. "CP1"). Empty for unnamed control points.
   *
   * @generated from field: string callsign = 3;
   */
  callsign: string;
  /**
   *
   * Link role: 0 = waypoint (b-m-p-w), 1 = checkpoint (b-m-p-c).
   *
   * @generated from field: uint32 link_type = 4;
   */
  linkType: number;
};
/**
 * Describes the message meshtastic.Route.Link.
 * Use `create(Route_LinkSchema)` to create a new message.
 */
declare const Route_LinkSchema: GenMessage<Route_Link>;
/**
 *
 * Travel method for the route.
 *
 * @generated from enum meshtastic.Route.Method
 */
declare enum Route_Method {
  /**
   *
   * Unspecified / unknown
   *
   * @generated from enum value: Method_Unspecified = 0;
   */
  Unspecified = 0,
  /**
   *
   * Driving / vehicle
   *
   * @generated from enum value: Method_Driving = 1;
   */
  Driving = 1,
  /**
   *
   * Walking / foot
   *
   * @generated from enum value: Method_Walking = 2;
   */
  Walking = 2,
  /**
   *
   * Flying
   *
   * @generated from enum value: Method_Flying = 3;
   */
  Flying = 3,
  /**
   *
   * Swimming (individual)
   *
   * @generated from enum value: Method_Swimming = 4;
   */
  Swimming = 4,
  /**
   *
   * Watercraft (boat)
   *
   * @generated from enum value: Method_Watercraft = 5;
   */
  Watercraft = 5
}
/**
 * Describes the enum meshtastic.Route.Method.
 */
declare const Route_MethodSchema: GenEnum<Route_Method>;
/**
 *
 * Route direction (infil = ingress, exfil = egress).
 *
 * @generated from enum meshtastic.Route.Direction
 */
declare enum Route_Direction {
  /**
   *
   * Unspecified
   *
   * @generated from enum value: Direction_Unspecified = 0;
   */
  Unspecified = 0,
  /**
   *
   * Infiltration (ingress)
   *
   * @generated from enum value: Direction_Infil = 1;
   */
  Infil = 1,
  /**
   *
   * Exfiltration (egress)
   *
   * @generated from enum value: Direction_Exfil = 2;
   */
  Exfil = 2
}
/**
 * Describes the enum meshtastic.Route.Direction.
 */
declare const Route_DirectionSchema: GenEnum<Route_Direction>;
/**
 *
 * 9-line MEDEVAC request (CoT type b-r-f-h-c).
 *
 * Mirrors the ATAK MedLine tool's <_medevac_> detail element. Every field
 * is optional (proto3 default); senders omit lines they don't have. The
 * envelope (TAKPacketV2.uid, cot_type_id=b-r-f-h-c, latitude_i/longitude_i,
 * altitude, callsign) carries Line 1 (location) and Line 2 (callsign).
 *
 * All numeric fields are tight varints so a complete 9-line request fits
 * in well under 100 bytes of proto on the wire.
 *
 * @generated from message meshtastic.CasevacReport
 */
type CasevacReport = Message<"meshtastic.CasevacReport"> & {
  /**
   *
   * Line 3: precedence / urgency.
   *
   * @generated from field: meshtastic.CasevacReport.Precedence precedence = 1;
   */
  precedence: CasevacReport_Precedence;
  /**
   *
   * Line 4: special equipment required, as a bitfield.
   *   bit 0: none
   *   bit 1: hoist
   *   bit 2: extraction equipment
   *   bit 3: ventilator
   *   bit 4: blood
   *
   * @generated from field: uint32 equipment_flags = 2;
   */
  equipmentFlags: number;
  /**
   *
   * Line 5: number of litter (stretcher-bound) patients.
   *
   * @generated from field: uint32 litter_patients = 3;
   */
  litterPatients: number;
  /**
   *
   * Line 5: number of ambulatory (walking-wounded) patients.
   *
   * @generated from field: uint32 ambulatory_patients = 4;
   */
  ambulatoryPatients: number;
  /**
   *
   * Line 6: security situation at the PZ.
   *
   * @generated from field: meshtastic.CasevacReport.Security security = 5;
   */
  security: CasevacReport_Security;
  /**
   *
   * Line 7: HLZ marking method.
   *
   * @generated from field: meshtastic.CasevacReport.HlzMarking hlz_marking = 6;
   */
  hlzMarking: CasevacReport_HlzMarking;
  /**
   *
   * Line 7 supplementary: short free-text describing the zone marker
   * (e.g. "Green smoke", "VS-17 panel west"). Capped tight in options.
   *
   * @generated from field: string zone_marker = 7;
   */
  zoneMarker: string;
  /**
   * --- Line 8: patient nationality counts ---
   *
   * @generated from field: uint32 us_military = 8;
   */
  usMilitary: number;
  /**
   * @generated from field: uint32 us_civilian = 9;
   */
  usCivilian: number;
  /**
   * @generated from field: uint32 non_us_military = 10;
   */
  nonUsMilitary: number;
  /**
   * @generated from field: uint32 non_us_civilian = 11;
   */
  nonUsCivilian: number;
  /**
   * enemy prisoner of war
   *
   * @generated from field: uint32 epw = 12;
   */
  epw: number;
  /**
   * @generated from field: uint32 child = 13;
   */
  child: number;
  /**
   *
   * Line 9: terrain and obstacles at the PZ, as a bitfield.
   *   bit 0: slope
   *   bit 1: rough
   *   bit 2: loose
   *   bit 3: trees
   *   bit 4: wires
   *   bit 5: other
   *
   * @generated from field: uint32 terrain_flags = 14;
   */
  terrainFlags: number;
  /**
   *
   * Line 2: radio frequency / callsign metadata (e.g. "38.90 Mhz" or
   * "Victor 6"). Capped tight in options.
   *
   * @generated from field: string frequency = 15;
   */
  frequency: string;
  /**
   *
   * Short title / MEDEVAC identifier (e.g. "EAGLE.15.181230"). Usually the
   * same as the envelope callsign but ATAK sometimes carries a distinct
   * ops-number here.
   *
   * @generated from field: string title = 16;
   */
  title: string;
  /**
   *
   * Primary medline free-text — the single most clinically important line
   * on a MEDLINE form (e.g. "2 urgent litter patients, smoke on approach").
   * MUST be preserved under MTU pressure as long as any casevac is sent.
   *
   * @generated from field: string medline_remarks = 17;
   */
  medlineRemarks: string;
  /**
   *
   * Line 3 (newer ATAK format): patient counts by precedence level.
   * Coexists with the enum-style `precedence` field (tag 1) — older ATAK
   * emits a single enum, newer ATAK emits these counts, and both can be
   * set simultaneously. Senders populate whichever style(s) the source
   * XML had; receivers prefer counts when non-zero.
   *
   * @generated from field: uint32 urgent_count = 18;
   */
  urgentCount: number;
  /**
   * @generated from field: uint32 urgent_surgical_count = 19;
   */
  urgentSurgicalCount: number;
  /**
   * @generated from field: uint32 priority_count = 20;
   */
  priorityCount: number;
  /**
   * @generated from field: uint32 routine_count = 21;
   */
  routineCount: number;
  /**
   * @generated from field: uint32 convenience_count = 22;
   */
  convenienceCount: number;
  /**
   *
   * Line 4 supplementary: free-text description of non-standard equipment
   * (e.g. "Blood warmer"). Pairs with the `equipment_flags` bitfield.
   *
   * @generated from field: string equipment_detail = 23;
   */
  equipmentDetail: string;
  /**
   *
   * Line 1 override: MGRS grid when distinct from the event anchor point
   * (e.g. "34T CQ 12345 67890"). Event lat/lon/hae still carries the
   * numeric location; this field preserves the exact MGRS string the
   * medic entered.
   *
   * @generated from field: string zone_protected_coord = 24;
   */
  zoneProtectedCoord: string;
  /**
   *
   * Line 9 supplementary: slope direction (e.g. "N", "NE", "SSW") when
   * `terrain_flags` bit 0 (slope) is set.
   *
   * @generated from field: string terrain_slope_dir = 25;
   */
  terrainSlopeDir: string;
  /**
   *
   * Line 9 supplementary: free-text description of "other" terrain hazards
   * (e.g. "Loose debris on west edge") when `terrain_flags` bit 5 (other)
   * is set. Tier-2 strippable under MTU pressure.
   *
   * @generated from field: string terrain_other_detail = 26;
   */
  terrainOtherDetail: string;
  /**
   *
   * Line 7 supplementary: how the zone is being marked right now
   * (e.g. "Orange smoke", "VS-17 panel"). Complements the structured
   * `hlz_marking` enum with a specific human-readable description.
   *
   * @generated from field: string marked_by = 27;
   */
  markedBy: string;
  /**
   *
   * Nearby obstacles on the approach (e.g. "Power lines north of HLZ").
   *
   * @generated from field: string obstacles = 28;
   */
  obstacles: string;
  /**
   *
   * Wind direction and speed (e.g. "270 at 12 kts").
   *
   * @generated from field: string winds_are_from = 29;
   */
  windsAreFrom: string;
  /**
   *
   * Friendly forces posture near the pickup zone
   * (e.g. "Squad east of HLZ").
   *
   * @generated from field: string friendlies = 30;
   */
  friendlies: string;
  /**
   *
   * Known or suspected enemy positions near the pickup zone
   * (e.g. "Possible enemy on south ridge").
   *
   * @generated from field: string enemy = 31;
   */
  enemy: string;
  /**
   *
   * Free-text description of the HLZ itself
   * (e.g. "Primary HLZ is soccer field").
   *
   * @generated from field: string hlz_remarks = 32;
   */
  hlzRemarks: string;
  /**
   *
   * Per-patient clinical records. Each entry is one patient's ZMIST card
   * (Zap number / Mechanism / Injuries / Signs / Treatment). Repeatable —
   * a mass-casualty event can carry 1-6 entries in practice, limited by
   * the 237 B LoRa MTU.
   *
   * @generated from field: repeated meshtastic.ZMistEntry zmist = 33;
   */
  zmist: ZMistEntry[];
};
/**
 * Describes the message meshtastic.CasevacReport.
 * Use `create(CasevacReportSchema)` to create a new message.
 */
declare const CasevacReportSchema: GenMessage<CasevacReport>;
/**
 *
 * Line 3: precedence / urgency.
 *
 * @generated from enum meshtastic.CasevacReport.Precedence
 */
declare enum CasevacReport_Precedence {
  /**
   * @generated from enum value: Precedence_Unspecified = 0;
   */
  Unspecified = 0,
  /**
   * A - immediate, life-threatening
   *
   * @generated from enum value: Precedence_Urgent = 1;
   */
  Urgent = 1,
  /**
   * B - needs surgery
   *
   * @generated from enum value: Precedence_UrgentSurgical = 2;
   */
  UrgentSurgical = 2,
  /**
   * C - within 4 hours
   *
   * @generated from enum value: Precedence_Priority = 3;
   */
  Priority = 3,
  /**
   * D - within 24 hours
   *
   * @generated from enum value: Precedence_Routine = 4;
   */
  Routine = 4,
  /**
   * E - convenience
   *
   * @generated from enum value: Precedence_Convenience = 5;
   */
  Convenience = 5
}
/**
 * Describes the enum meshtastic.CasevacReport.Precedence.
 */
declare const CasevacReport_PrecedenceSchema: GenEnum<CasevacReport_Precedence>;
/**
 *
 * Line 7: HLZ marking method.
 *
 * @generated from enum meshtastic.CasevacReport.HlzMarking
 */
declare enum CasevacReport_HlzMarking {
  /**
   * @generated from enum value: HlzMarking_Unspecified = 0;
   */
  HlzMarking_Unspecified = 0,
  /**
   * @generated from enum value: HlzMarking_Panels = 1;
   */
  HlzMarking_Panels = 1,
  /**
   * @generated from enum value: HlzMarking_PyroSignal = 2;
   */
  HlzMarking_PyroSignal = 2,
  /**
   * @generated from enum value: HlzMarking_Smoke = 3;
   */
  HlzMarking_Smoke = 3,
  /**
   * @generated from enum value: HlzMarking_None = 4;
   */
  HlzMarking_None = 4,
  /**
   * @generated from enum value: HlzMarking_Other = 5;
   */
  HlzMarking_Other = 5
}
/**
 * Describes the enum meshtastic.CasevacReport.HlzMarking.
 */
declare const CasevacReport_HlzMarkingSchema: GenEnum<CasevacReport_HlzMarking>;
/**
 *
 * Line 6: security situation at the pickup zone.
 *
 * @generated from enum meshtastic.CasevacReport.Security
 */
declare enum CasevacReport_Security {
  /**
   * @generated from enum value: Security_Unspecified = 0;
   */
  Unspecified = 0,
  /**
   * N - no enemy activity
   *
   * @generated from enum value: Security_NoEnemy = 1;
   */
  NoEnemy = 1,
  /**
   * P - possible enemy
   *
   * @generated from enum value: Security_PossibleEnemy = 2;
   */
  PossibleEnemy = 2,
  /**
   * E - enemy, approach with caution
   *
   * @generated from enum value: Security_EnemyInArea = 3;
   */
  EnemyInArea = 3,
  /**
   * X - armed escort required
   *
   * @generated from enum value: Security_EnemyInArmedContact = 4;
   */
  EnemyInArmedContact = 4
}
/**
 * Describes the enum meshtastic.CasevacReport.Security.
 */
declare const CasevacReport_SecuritySchema: GenEnum<CasevacReport_Security>;
/**
 *
 * Per-patient clinical summary record — one entry per patient in a CASEVAC.
 * Maps directly to ATAK's <zMist> child element inside <zMistsMap>.
 * All fields are optional free-text; senders populate what they have.
 *
 * @generated from message meshtastic.ZMistEntry
 */
type ZMistEntry = Message<"meshtastic.ZMistEntry"> & {
  /**
   *
   * Patient identifier / sequence label (e.g. "ZMIST-1", "ZMIST-2").
   *
   * @generated from field: string title = 1;
   */
  title: string;
  /**
   *
   * Zap number — unique patient tracking ID (often a terse code like
   * "Gunshot" or a serial).
   *
   * @generated from field: string z = 2;
   */
  z: string;
  /**
   *
   * Mechanism of injury (e.g. "Penetrating trauma", "Blast injury").
   *
   * @generated from field: string m = 3;
   */
  m: string;
  /**
   *
   * Injuries observed (e.g. "Left thigh", "Concussion").
   *
   * @generated from field: string i = 4;
   */
  i: string;
  /**
   *
   * Signs / vital stats (e.g. "Stable", "Priority", "BP 110/70").
   *
   * @generated from field: string s = 5;
   */
  s: string;
  /**
   *
   * Treatment given (e.g. "Tourniquet 1810Z", "O2 administered").
   *
   * @generated from field: string t = 6;
   */
  t: string;
};
/**
 * Describes the message meshtastic.ZMistEntry.
 * Use `create(ZMistEntrySchema)` to create a new message.
 */
declare const ZMistEntrySchema: GenMessage<ZMistEntry>;
/**
 *
 * Emergency alert / 911 beacon (CoT types b-a-o-tbl, b-a-o-pan, b-a-o-opn,
 * b-a-o-can, b-a-o-c, b-a-g).
 *
 * Small, high-priority structured record. The CoT type string is still set
 * on cot_type_id so receivers that ignore payload_variant can still display
 * the alert from the enum alone; the typed fields let modern receivers show
 * the authoring unit and handle cancel-referencing without XML parsing.
 *
 * @generated from message meshtastic.EmergencyAlert
 */
type EmergencyAlert = Message<"meshtastic.EmergencyAlert"> & {
  /**
   *
   * Alert discriminator.
   *
   * @generated from field: meshtastic.EmergencyAlert.Type type = 1;
   */
  type: EmergencyAlert_Type;
  /**
   *
   * UID of the unit that raised the alert. Often the same as
   * TAKPacketV2.uid but can be a parent device uid when a tracker raises
   * an alert on behalf of a dismount.
   *
   * @generated from field: string authoring_uid = 2;
   */
  authoringUid: string;
  /**
   *
   * For Type_Cancel: the uid of the alert being cancelled. Empty for
   * non-cancel alert types.
   *
   * @generated from field: string cancel_reference_uid = 3;
   */
  cancelReferenceUid: string;
};
/**
 * Describes the message meshtastic.EmergencyAlert.
 * Use `create(EmergencyAlertSchema)` to create a new message.
 */
declare const EmergencyAlertSchema: GenMessage<EmergencyAlert>;
/**
 * @generated from enum meshtastic.EmergencyAlert.Type
 */
declare enum EmergencyAlert_Type {
  /**
   * @generated from enum value: Type_Unspecified = 0;
   */
  Unspecified = 0,
  /**
   * b-a-o-tbl
   *
   * @generated from enum value: Type_Alert911 = 1;
   */
  Alert911 = 1,
  /**
   * b-a-o-pan
   *
   * @generated from enum value: Type_RingTheBell = 2;
   */
  RingTheBell = 2,
  /**
   * b-a-o-opn
   *
   * @generated from enum value: Type_InContact = 3;
   */
  InContact = 3,
  /**
   * b-a-g
   *
   * @generated from enum value: Type_GeoFenceBreached = 4;
   */
  GeoFenceBreached = 4,
  /**
   * b-a-o-c
   *
   * @generated from enum value: Type_Custom = 5;
   */
  Custom = 5,
  /**
   * b-a-o-can
   *
   * @generated from enum value: Type_Cancel = 6;
   */
  Cancel = 6
}
/**
 * Describes the enum meshtastic.EmergencyAlert.Type.
 */
declare const EmergencyAlert_TypeSchema: GenEnum<EmergencyAlert_Type>;
/**
 *
 * Task / engage request (CoT type t-s).
 *
 * Mirrors ATAK's TaskCotReceiver / CotTaskBuilder workflow. The envelope
 * carries the task's originating uid (implicit requester), position, and
 * creation time; the fields below carry structured metadata the raw-detail
 * fallback currently loses.
 *
 * Fields are deliberately lean — this variant is closer to the MTU ceiling
 * than the others, so every string is capped in options.
 *
 * @generated from message meshtastic.TaskRequest
 */
type TaskRequest = Message<"meshtastic.TaskRequest"> & {
  /**
   *
   * Short tag for the task category (e.g. "engage", "observe", "recon",
   * "rescue"). Free text on the wire so ATAK-specific task taxonomies
   * don't need proto coordination; capped tight in options.
   *
   * @generated from field: string task_type = 1;
   */
  taskType: string;
  /**
   *
   * UID of the target / map item being tasked.
   *
   * @generated from field: string target_uid = 2;
   */
  targetUid: string;
  /**
   *
   * UID of the assigned unit. Empty = unassigned / broadcast task.
   *
   * @generated from field: string assignee_uid = 3;
   */
  assigneeUid: string;
  /**
   * @generated from field: meshtastic.TaskRequest.Priority priority = 4;
   */
  priority: TaskRequest_Priority;
  /**
   * @generated from field: meshtastic.TaskRequest.Status status = 5;
   */
  status: TaskRequest_Status;
  /**
   *
   * Optional short note (reason, constraints, grid reference). Capped
   * tight in options to keep the worst-case under the LoRa MTU.
   *
   * @generated from field: string note = 6;
   */
  note: string;
};
/**
 * Describes the message meshtastic.TaskRequest.
 * Use `create(TaskRequestSchema)` to create a new message.
 */
declare const TaskRequestSchema: GenMessage<TaskRequest>;
/**
 * @generated from enum meshtastic.TaskRequest.Priority
 */
declare enum TaskRequest_Priority {
  /**
   * @generated from enum value: Priority_Unspecified = 0;
   */
  Unspecified = 0,
  /**
   * @generated from enum value: Priority_Low = 1;
   */
  Low = 1,
  /**
   * @generated from enum value: Priority_Normal = 2;
   */
  Normal = 2,
  /**
   * @generated from enum value: Priority_High = 3;
   */
  High = 3,
  /**
   * @generated from enum value: Priority_Critical = 4;
   */
  Critical = 4
}
/**
 * Describes the enum meshtastic.TaskRequest.Priority.
 */
declare const TaskRequest_PrioritySchema: GenEnum<TaskRequest_Priority>;
/**
 * @generated from enum meshtastic.TaskRequest.Status
 */
declare enum TaskRequest_Status {
  /**
   * @generated from enum value: Status_Unspecified = 0;
   */
  Unspecified = 0,
  /**
   * assigned, not yet acknowledged
   *
   * @generated from enum value: Status_Pending = 1;
   */
  Pending = 1,
  /**
   * assignee has seen it
   *
   * @generated from enum value: Status_Acknowledged = 2;
   */
  Acknowledged = 2,
  /**
   * assignee is working it
   *
   * @generated from enum value: Status_InProgress = 3;
   */
  InProgress = 3,
  /**
   * task done
   *
   * @generated from enum value: Status_Completed = 4;
   */
  Completed = 4,
  /**
   * cancelled before completion
   *
   * @generated from enum value: Status_Cancelled = 5;
   */
  Cancelled = 5
}
/**
 * Describes the enum meshtastic.TaskRequest.Status.
 */
declare const TaskRequest_StatusSchema: GenEnum<TaskRequest_Status>;
/**
 *
 * Weather annotation from <environment> CoT detail element.
 *
 * Attaches to any TAKPacketV2 regardless of payload_variant — an Aircraft,
 * PLI, or Marker can all carry observed conditions at the emitting station.
 * ATAK-CIV ships an XSD for <environment> but no dedicated handler, so the
 * element round-trips through the generic detail pipeline; this message
 * promotes it to a first-class structured field.
 *
 * Target wire cost: ~6-8 bytes compressed with a fully populated instance.
 *
 * Named `TAKEnvironment` (not just `Environment`) because the bare name
 * collides with `SwiftUI.Environment` — every SwiftUI view in a consuming
 * iOS app uses the `@Environment` property wrapper, and importing the
 * generated proto module would make `Environment` ambiguous in every one
 * of those files. The `TAK` prefix matches the convention used by the
 * outer `TAKPacketV2` wrapper and is unambiguous across all target
 * languages (Swift, Kotlin, Python, TypeScript, C#).
 *
 * @generated from message meshtastic.TAKEnvironment
 */
type TAKEnvironment = Message<"meshtastic.TAKEnvironment"> & {
  /**
   *
   * Temperature in deci-degrees Celsius. 225 = 22.5°C.
   * Range covers -50°C to +50°C (-500 to +500) which spans every realistic
   * outdoor TAK deployment. sint32 because negative temps are common in
   * cold-weather ops.
   *
   * @generated from field: sint32 temperature_c_x10 = 1;
   */
  temperatureCX10: number;
  /**
   *
   * Wind direction in whole degrees, 0-359. "Direction FROM" per
   * meteorological convention (matches CoT / ATAK).
   *
   * @generated from field: uint32 wind_direction_deg = 2;
   */
  windDirectionDeg: number;
  /**
   *
   * Wind speed in cm/s. Matches the unit of TAKPacketV2.speed for
   * consistency. 1200 = 12.00 m/s = ~27 mph.
   *
   * @generated from field: uint32 wind_speed_cm_s = 3;
   */
  windSpeedCmS: number;
};
/**
 * Describes the message meshtastic.TAKEnvironment.
 * Use `create(TAKEnvironmentSchema)` to create a new message.
 */
declare const TAKEnvironmentSchema: GenMessage<TAKEnvironment>;
/**
 *
 * Sensor field-of-view cone from <sensor> CoT detail element.
 *
 * Encodes the 8 geometry attributes that ATAK-CIV's SensorDetailHandler
 * reads from the wire; drops the 9 visual-styling attributes that are
 * receiver-side render hints (fovAlpha, fovRed/Green/Blue, strokeColor,
 * strokeWeight, displayMagneticReference, hideFov, fovLabels, rangeLines).
 * The receiving ATAK client restores those from its own defaults, same as
 * every other CoT carried over Meshtastic today.
 *
 * Attaches to any TAKPacketV2 — a PLI with a sensor on the operator's head,
 * an Aircraft with a FLIR turret, a Marker dropped on a UAV.
 * Target wire cost: ~7-14 bytes compressed (dominated by model string).
 *
 * @generated from message meshtastic.SensorFov
 */
type SensorFov = Message<"meshtastic.SensorFov"> & {
  /**
   * @generated from field: meshtastic.SensorFov.SensorType type = 1;
   */
  type: SensorFov_SensorType;
  /**
   *
   * Azimuth in whole degrees, 0-359. "Pointing direction" of the cone axis,
   * measured clockwise from true north. Whole degrees match ATAK-CIV's
   * SensorDetailHandler default (270°) and save varint bytes over centi-deg.
   *
   * @generated from field: uint32 azimuth_deg = 2;
   */
  azimuthDeg: number;
  /**
   *
   * Maximum range of the cone in meters.
   * Optional — if unset, receivers should use the ATAK-CIV default of 100m.
   *
   * @generated from field: optional uint32 range_m = 3;
   */
  rangeM?: number;
  /**
   *
   * Horizontal field of view in whole degrees (cone's angular width).
   * ATAK-CIV default is 45°.
   *
   * @generated from field: uint32 fov_horizontal_deg = 4;
   */
  fovHorizontalDeg: number;
  /**
   *
   * Vertical field of view in whole degrees. ATAK-CIV default is 45°.
   * Optional — a value of 0 means "not set / use horizontal FOV".
   *
   * @generated from field: uint32 fov_vertical_deg = 5;
   */
  fovVerticalDeg: number;
  /**
   *
   * Elevation angle in whole degrees. Positive = up, negative = down.
   * Range -90 to +90. sint32 for varint efficiency on small negatives.
   *
   * @generated from field: sint32 elevation_deg = 6;
   */
  elevationDeg: number;
  /**
   *
   * Roll (camera tilt) in whole degrees, -180 to +180.
   * Optional — use 0 if the sensor doesn't track roll.
   *
   * @generated from field: sint32 roll_deg = 7;
   */
  rollDeg: number;
  /**
   *
   * Free-form device model identifier, e.g. "FLIR-Boson-640", "SEEK".
   * Optional — empty string means "unknown model" (ATAK-CIV default).
   *
   * @generated from field: string model = 8;
   */
  model: string;
};
/**
 * Describes the message meshtastic.SensorFov.
 * Use `create(SensorFovSchema)` to create a new message.
 */
declare const SensorFovSchema: GenMessage<SensorFov>;
/**
 *
 * Coarse sensor category, inferred from `model` on parse when the source
 * XML doesn't label it. Receivers that render differently per sensor
 * class (thermal overlay vs daylight cone) use this.
 *
 * @generated from enum meshtastic.SensorFov.SensorType
 */
declare enum SensorFov_SensorType {
  /**
   * @generated from enum value: SensorType_Unspecified = 0;
   */
  SensorType_Unspecified = 0,
  /**
   * daylight / general optical
   *
   * @generated from enum value: SensorType_Camera = 1;
   */
  SensorType_Camera = 1,
  /**
   * FLIR, thermal imager
   *
   * @generated from enum value: SensorType_Thermal = 2;
   */
  SensorType_Thermal = 2,
  /**
   * rangefinder, LRF, designator
   *
   * @generated from enum value: SensorType_Laser = 3;
   */
  SensorType_Laser = 3,
  /**
   * night vision goggles
   *
   * @generated from enum value: SensorType_Nvg = 4;
   */
  SensorType_Nvg = 4,
  /**
   * radio/radar direction-finding
   *
   * @generated from enum value: SensorType_Rf = 5;
   */
  SensorType_Rf = 5,
  /**
   * @generated from enum value: SensorType_Other = 6;
   */
  SensorType_Other = 6
}
/**
 * Describes the enum meshtastic.SensorFov.SensorType.
 */
declare const SensorFov_SensorTypeSchema: GenEnum<SensorFov_SensorType>;
/**
 *
 * TAKTALK chat message payload (CoT type m-t-t).
 *
 * TAKTALK is an ATAK plugin for voice + text team messaging. The voice
 * audio stream goes over UDP/RTP and is NOT carried by the mesh — only
 * the text envelope (this message) is. `from_voice` marks messages sent
 * via push-to-talk speech-to-text so receivers can render a mic icon
 * next to the text.
 *
 * Wire shape inside <event type="m-t-t">/<detail>:
 *   <callsign>...</callsign>        - mapped to TAKPacketV2.callsign
 *   <lang>English</lang>            - lang
 *   <text>...</text>                - text
 *   <chatroom-id>1</chatroom-id>    - chatroom_id
 *   <voice/>                        - presence sets from_voice = true
 *
 * @generated from message meshtastic.TakTalkMessage
 */
type TakTalkMessage = Message<"meshtastic.TakTalkMessage"> & {
  /**
   *
   * The text body of the TAKTALK message (speech-to-text transcript when
   * from_voice = true, typed message otherwise).
   *
   * @generated from field: string text = 1;
   */
  text: string;
  /**
   *
   * TAKTALK chatroom identifier. May be a short id like "1" for the
   * default room or a UUID like "30b2755c-c547-44ef-a0cc-cdbd8a15616f"
   * for custom rooms (resolved by TakTalkRoomData broadcasts).
   * Empty = broadcast room.
   *
   * @generated from field: string chatroom_id = 2;
   */
  chatroomId: string;
  /**
   *
   * BCP-47-ish language tag or human-readable name (e.g. "en", "English").
   * Empty = unspecified.
   *
   * @generated from field: string lang = 3;
   */
  lang: string;
  /**
   *
   * True when the source CoT carried a <voice/> marker, i.e. the message
   * originated as push-to-talk speech-to-text. Lets receivers show a mic
   * icon. Proto3 only encodes when true so empty payload cost is 0 bytes.
   *
   * @generated from field: bool from_voice = 4;
   */
  fromVoice: boolean;
};
/**
 * Describes the message meshtastic.TakTalkMessage.
 * Use `create(TakTalkMessageSchema)` to create a new message.
 */
declare const TakTalkMessageSchema: GenMessage<TakTalkMessage>;
/**
 *
 * TAKTALK room/membership broadcast (CoT type y-).
 *
 * Announces a TAKTALK chatroom's friendly name and roster so peers can
 * resolve room UUIDs (used in TakTalkMessage.chatroom_id and
 * GeoChat.room_id) to a display name and participant list. Not a chat
 * message itself — these events are emitted by TAKTALK when rooms are
 * created or memberships change.
 *
 * @generated from message meshtastic.TakTalkRoomData
 */
type TakTalkRoomData = Message<"meshtastic.TakTalkRoomData"> & {
  /**
   *
   * Callsign of the device broadcasting the room state (typically the
   * room owner / latest writer).
   *
   * DEPRECATED in v0.3.2: always equals TAKPacketV2.callsign, so the wire
   * byte was redundant. Builders stop emitting this field in v0.3.2;
   * parsers still read it for one release so v0.3.1-encoded packets decode
   * cleanly. To be removed entirely in v0.4.x.
   *
   * @generated from field: string sender_callsign = 1 [deprecated = true];
   * @deprecated
   */
  senderCallsign: string;
  /**
   *
   * Room UUID, matches TakTalkMessage.chatroom_id / GeoChat.room_id on
   * messages routed into this room.
   *
   * @generated from field: string room_id = 2;
   */
  roomId: string;
  /**
   *
   * Friendly display name for the room (e.g. "test", "Alpha Team").
   *
   * @generated from field: string room_name = 3;
   */
  roomName: string;
  /**
   *
   * Member callsigns. Wire-encoded as repeated strings; the underlying
   * CoT carries them as a single <chatroom-participants>A,B,C</> element
   * which parsers split / builders join on ','.
   *
   * @generated from field: repeated string participants = 4;
   */
  participants: string[];
};
/**
 * Describes the message meshtastic.TakTalkRoomData.
 * Use `create(TakTalkRoomDataSchema)` to create a new message.
 */
declare const TakTalkRoomDataSchema: GenMessage<TakTalkRoomData>;
/**
 *
 * ATAK directed-routing recipient list (CoT <marti><dest callsign='X'/>…</marti>).
 *
 * Present when an event is addressed to specific TAK users rather than the
 * broadcast group. TAKTALK gates voice TTS on this element matching the
 * receiver's callsign; directed b-t-f chats use it for the same purpose. A
 * missing <marti> means "broadcast to all peers", which is the default for
 * PLI, alerts, drawings, and most situational-awareness events.
 *
 * Carried as repeated strings (not indexes into a per-packet table) because
 * the typical event has 1-2 destinations and table overhead would erase the
 * savings. Receivers that need the original XML element rebuild it from
 * dest_callsign on emit.
 *
 * @generated from message meshtastic.Marti
 */
type Marti = Message<"meshtastic.Marti"> & {
  /**
   *
   * Recipient callsigns. Order is preserved end-to-end so receivers can show
   * primary-vs-cc distinction the same way ATAK does.
   *
   * If dest_callsign is [TAKPacketV2.callsign] (self-addressed, unusual but
   * legal — e.g. ATAK echoing back to its own room), the builder still emits
   * the element so loopback shapes round-trip cleanly.
   *
   * @generated from field: repeated string dest_callsign = 1;
   */
  destCallsign: string[];
};
/**
 * Describes the message meshtastic.Marti.
 * Use `create(MartiSchema)` to create a new message.
 */
declare const MartiSchema: GenMessage<Marti>;
/**
 *
 * ATAK v2 packet with expanded CoT field support and zstd dictionary compression.
 * Sent on ATAK_PLUGIN_V2 port. The wire payload is:
 *   [1 byte flags][zstd-compressed TAKPacketV2 protobuf]
 * Flags byte: bits 0-5 = dictionary ID, bits 6-7 = reserved.
 *
 * @generated from message meshtastic.TAKPacketV2
 */
type TAKPacketV2 = Message<"meshtastic.TAKPacketV2"> & {
  /**
   *
   * Well-known CoT event type enum.
   * Use CotType_Other with cot_type_str for unknown types.
   *
   * @generated from field: meshtastic.CotType cot_type_id = 1;
   */
  cotTypeId: CotType;
  /**
   *
   * How the coordinates were generated
   *
   * @generated from field: meshtastic.CotHow how = 2;
   */
  how: CotHow;
  /**
   *
   * Callsign
   *
   * @generated from field: string callsign = 3;
   */
  callsign: string;
  /**
   *
   * Team color assignment
   *
   * @generated from field: meshtastic.Team team = 4;
   */
  team: Team;
  /**
   *
   * Role of the group member
   *
   * @generated from field: meshtastic.MemberRole role = 5;
   */
  role: MemberRole;
  /**
   *
   * Latitude, multiply by 1e-7 to get degrees in floating point
   *
   * @generated from field: sfixed32 latitude_i = 6;
   */
  latitudeI: number;
  /**
   *
   * Longitude, multiply by 1e-7 to get degrees in floating point
   *
   * @generated from field: sfixed32 longitude_i = 7;
   */
  longitudeI: number;
  /**
   *
   * Altitude in meters (HAE). ATAK's "no altitude" sentinel is hae=9999999.0.
   *
   * NOTE: an earlier v0.4.0 attempt made this `optional` to omit the 9999999
   * sentinel from the wire, but measurement showed it was net-negative: the
   * zstd dictionary already compresses the literal 9999999 to ~nothing, while
   * proto3 `optional` forces a genuine 0 m HAE (common on routes/drawings that
   * carry hae="0.0" or omit hae → parsed as 0) to encode explicitly (+2 bytes),
   * which REGRESSED the worst-case route fixture. Kept as a plain field.
   *
   * @generated from field: sint32 altitude = 8;
   */
  altitude: number;
  /**
   *
   * Speed in cm/s
   *
   * @generated from field: uint32 speed = 9;
   */
  speed: number;
  /**
   *
   * Course in degrees * 100 (0-36000)
   *
   * @generated from field: uint32 course = 10;
   */
  course: number;
  /**
   *
   * Battery level 0-100
   *
   * @generated from field: uint32 battery = 11;
   */
  battery: number;
  /**
   *
   * Geopoint source
   *
   * @generated from field: meshtastic.GeoPointSource geo_src = 12;
   */
  geoSrc: GeoPointSource;
  /**
   *
   * Altitude source
   *
   * @generated from field: meshtastic.GeoPointSource alt_src = 13;
   */
  altSrc: GeoPointSource;
  /**
   *
   * Device UID (UUID string or device ID like "ANDROID-xxxx")
   *
   * @generated from field: string uid = 14;
   */
  uid: string;
  /**
   *
   * Device callsign
   *
   * @generated from field: string device_callsign = 15;
   */
  deviceCallsign: string;
  /**
   *
   * Stale time as seconds offset from event time
   *
   * @generated from field: uint32 stale_seconds = 16;
   */
  staleSeconds: number;
  /**
   *
   * TAK client version string
   *
   * @generated from field: string tak_version = 17;
   */
  takVersion: string;
  /**
   *
   * TAK device model
   *
   * @generated from field: string tak_device = 18;
   */
  takDevice: string;
  /**
   *
   * TAK platform (ATAK-CIV, WebTAK, etc.)
   *
   * @generated from field: string tak_platform = 19;
   */
  takPlatform: string;
  /**
   *
   * TAK OS version
   *
   * @generated from field: string tak_os = 20;
   */
  takOs: string;
  /**
   *
   * Connection endpoint
   *
   * @generated from field: string endpoint = 21;
   */
  endpoint: string;
  /**
   *
   * Phone number
   *
   * @generated from field: string phone = 22;
   */
  phone: string;
  /**
   *
   * CoT event type string, only populated when cot_type_id is CotType_Other
   *
   * @generated from field: string cot_type_str = 23;
   */
  cotTypeStr: string;
  /**
   *
   * Optional remarks / free-text annotation from the <remarks> element.
   * Populated for non-GeoChat payload types (shapes, markers, routes, etc.)
   * when the original CoT event carried non-empty remarks text.
   * GeoChat messages carry their text in GeoChat.message instead.
   * Empty string (proto3 default) means no remarks were present.
   *
   * @generated from field: string remarks = 24;
   */
  remarks: string;
  /**
   *
   * Observed weather conditions (temperature, wind). From <environment>.
   * Type is `TAKEnvironment`, not `Environment`, to avoid colliding with
   * SwiftUI's `@Environment` property wrapper in iOS consumers.
   *
   * @generated from field: optional meshtastic.TAKEnvironment environment = 25;
   */
  environment?: TAKEnvironment;
  /**
   *
   * Sensor field-of-view cone (camera, FLIR, laser, etc.). From <sensor>.
   *
   * @generated from field: optional meshtastic.SensorFov sensor_fov = 26;
   */
  sensorFov?: SensorFov;
  /**
   *
   * Directed-routing recipient list (CoT <marti><dest callsign='X'/>…</marti>).
   * Empty / unset = broadcast to all peers (the default for situational-awareness
   * events). Populated for TAKTALK m-t-t, directed b-t-f DMs, and any other CoT
   * shape that ATAK addresses to specific recipients. TAKTALK gates voice TTS
   * playback on this element matching the receiver's callsign, so dropping it
   * silently breaks voice messaging end-to-end.
   *
   * See Marti.
   *
   * @generated from field: optional meshtastic.Marti marti = 29;
   */
  marti?: Marti;
  /**
   *
   * The payload of the packet
   *
   * Tag 30 was `bool pli` — a PLI carries no fields beyond the common
   * envelope (position is in latitude_i/longitude_i), so the boolean was
   * pure overhead (~3 wire bytes on every position beacon, the highest-
   * frequency packet). PLI is now the IMPLICIT payload: a packet with NO
   * payload_variant set decodes as a position report. Tag 30 is reserved at
   * the message level (proto3 forbids `reserved` inside a oneof).
   *
   * @generated from oneof meshtastic.TAKPacketV2.payload_variant
   */
  payloadVariant: {
    /**
     *
     * ATAK GeoChat message
     *
     * @generated from field: meshtastic.GeoChat chat = 31;
     */
    value: GeoChat;
    case: "chat";
  } | {
    /**
     *
     * Aircraft track data (ADS-B, military air)
     *
     * @generated from field: meshtastic.AircraftTrack aircraft = 32;
     */
    value: AircraftTrack;
    case: "aircraft";
  } | {
    /**
     *
     * Generic CoT detail XML for unmapped types. Kept as a fallback for CoT
     * types not yet promoted to a typed variant; drawings, markers, ranging
     * tools, and routes have dedicated variants below and should not land here.
     *
     * @generated from field: bytes raw_detail = 33;
     */
    value: Uint8Array;
    case: "rawDetail";
  } | {
    /**
     *
     * User-drawn tactical graphic: circle, rectangle, polygon, polyline,
     * telestration, ranging circle, or bullseye. See DrawnShape.
     *
     * @generated from field: meshtastic.DrawnShape shape = 34;
     */
    value: DrawnShape;
    case: "shape";
  } | {
    /**
     *
     * Fixed point of interest: spot marker, waypoint, checkpoint, 2525
     * symbol, or custom icon. See Marker.
     *
     * @generated from field: meshtastic.Marker marker = 35;
     */
    value: Marker;
    case: "marker";
  } | {
    /**
     *
     * Range and bearing measurement line. See RangeAndBearing.
     *
     * @generated from field: meshtastic.RangeAndBearing rab = 36;
     */
    value: RangeAndBearing;
    case: "rab";
  } | {
    /**
     *
     * Named route with ordered waypoints and control points. See Route.
     *
     * @generated from field: meshtastic.Route route = 37;
     */
    value: Route;
    case: "route";
  } | {
    /**
     *
     * 9-line MEDEVAC request. See CasevacReport.
     *
     * @generated from field: meshtastic.CasevacReport casevac = 38;
     */
    value: CasevacReport;
    case: "casevac";
  } | {
    /**
     *
     * Emergency beacon / 911 alert. See EmergencyAlert.
     *
     * @generated from field: meshtastic.EmergencyAlert emergency = 39;
     */
    value: EmergencyAlert;
    case: "emergency";
  } | {
    /**
     *
     * Task / engage request. See TaskRequest.
     *
     * @generated from field: meshtastic.TaskRequest task = 40;
     */
    value: TaskRequest;
    case: "task";
  } | {
    /**
     *
     * TAKTALK chat message (CoT type m-t-t). See TakTalkMessage.
     * Voice audio itself rides UDP/RTP outside the mesh; this carries the
     * text envelope plus a from_voice marker for receiver UX.
     *
     * @generated from field: meshtastic.TakTalkMessage taktalk = 41;
     */
    value: TakTalkMessage;
    case: "taktalk";
  } | {
    /**
     *
     * TAKTALK room/membership broadcast (CoT type y-). See TakTalkRoomData.
     * Resolves room UUIDs (used in TakTalkMessage.chatroom_id and
     * GeoChat.room_id) to display name + roster on receivers.
     *
     * @generated from field: meshtastic.TakTalkRoomData taktalk_room = 42;
     */
    value: TakTalkRoomData;
    case: "taktalkRoom";
  } | {
    case: undefined;
    value?: undefined;
  };
};
/**
 * Describes the message meshtastic.TAKPacketV2.
 * Use `create(TAKPacketV2Schema)` to create a new message.
 */
declare const TAKPacketV2Schema: GenMessage<TAKPacketV2>;
/**
 * @generated from enum meshtastic.Team
 */
declare enum Team {
  /**
   *
   * Unspecifed
   *
   * @generated from enum value: Unspecifed_Color = 0;
   */
  Unspecifed_Color = 0,
  /**
   *
   * White
   *
   * @generated from enum value: White = 1;
   */
  White = 1,
  /**
   *
   * Yellow
   *
   * @generated from enum value: Yellow = 2;
   */
  Yellow = 2,
  /**
   *
   * Orange
   *
   * @generated from enum value: Orange = 3;
   */
  Orange = 3,
  /**
   *
   * Magenta
   *
   * @generated from enum value: Magenta = 4;
   */
  Magenta = 4,
  /**
   *
   * Red
   *
   * @generated from enum value: Red = 5;
   */
  Red = 5,
  /**
   *
   * Maroon
   *
   * @generated from enum value: Maroon = 6;
   */
  Maroon = 6,
  /**
   *
   * Purple
   *
   * @generated from enum value: Purple = 7;
   */
  Purple = 7,
  /**
   *
   * Dark Blue
   *
   * @generated from enum value: Dark_Blue = 8;
   */
  Dark_Blue = 8,
  /**
   *
   * Blue
   *
   * @generated from enum value: Blue = 9;
   */
  Blue = 9,
  /**
   *
   * Cyan
   *
   * @generated from enum value: Cyan = 10;
   */
  Cyan = 10,
  /**
   *
   * Teal
   *
   * @generated from enum value: Teal = 11;
   */
  Teal = 11,
  /**
   *
   * Green
   *
   * @generated from enum value: Green = 12;
   */
  Green = 12,
  /**
   *
   * Dark Green
   *
   * @generated from enum value: Dark_Green = 13;
   */
  Dark_Green = 13,
  /**
   *
   * Brown
   *
   * @generated from enum value: Brown = 14;
   */
  Brown = 14
}
/**
 * Describes the enum meshtastic.Team.
 */
declare const TeamSchema: GenEnum<Team>;
/**
 *
 * Role of the group member
 *
 * @generated from enum meshtastic.MemberRole
 */
declare enum MemberRole {
  /**
   *
   * Unspecifed
   *
   * @generated from enum value: Unspecifed = 0;
   */
  Unspecifed = 0,
  /**
   *
   * Team Member
   *
   * @generated from enum value: TeamMember = 1;
   */
  TeamMember = 1,
  /**
   *
   * Team Lead
   *
   * @generated from enum value: TeamLead = 2;
   */
  TeamLead = 2,
  /**
   *
   * Headquarters
   *
   * @generated from enum value: HQ = 3;
   */
  HQ = 3,
  /**
   *
   * Airsoft enthusiast
   *
   * @generated from enum value: Sniper = 4;
   */
  Sniper = 4,
  /**
   *
   * Medic
   *
   * @generated from enum value: Medic = 5;
   */
  Medic = 5,
  /**
   *
   * ForwardObserver
   *
   * @generated from enum value: ForwardObserver = 6;
   */
  ForwardObserver = 6,
  /**
   *
   * Radio Telephone Operator
   *
   * @generated from enum value: RTO = 7;
   */
  RTO = 7,
  /**
   *
   * Doggo
   *
   * @generated from enum value: K9 = 8;
   */
  K9 = 8
}
/**
 * Describes the enum meshtastic.MemberRole.
 */
declare const MemberRoleSchema: GenEnum<MemberRole>;
/**
 *
 * CoT how field values.
 * Represents how the coordinates were generated.
 *
 * @generated from enum meshtastic.CotHow
 */
declare enum CotHow {
  /**
   *
   * Unspecified
   *
   * @generated from enum value: CotHow_Unspecified = 0;
   */
  CotHow_Unspecified = 0,
  /**
   *
   * Human entered
   *
   * @generated from enum value: CotHow_h_e = 1;
   */
  CotHow_h_e = 1,
  /**
   *
   * Machine generated
   *
   * @generated from enum value: CotHow_m_g = 2;
   */
  CotHow_m_g = 2,
  /**
   *
   * Human GPS/INS derived
   *
   * @generated from enum value: CotHow_h_g_i_g_o = 3;
   */
  CotHow_h_g_i_g_o = 3,
  /**
   *
   * Machine relayed (imported from another system/gateway)
   *
   * @generated from enum value: CotHow_m_r = 4;
   */
  CotHow_m_r = 4,
  /**
   *
   * Machine fused (corroborated from multiple sources)
   *
   * @generated from enum value: CotHow_m_f = 5;
   */
  CotHow_m_f = 5,
  /**
   *
   * Machine predicted
   *
   * @generated from enum value: CotHow_m_p = 6;
   */
  CotHow_m_p = 6,
  /**
   *
   * Machine simulated
   *
   * @generated from enum value: CotHow_m_s = 7;
   */
  CotHow_m_s = 7
}
/**
 * Describes the enum meshtastic.CotHow.
 */
declare const CotHowSchema: GenEnum<CotHow>;
/**
 *
 * Well-known CoT event types.
 * When the type is known, use the enum value for efficient encoding.
 * For unknown types, set cot_type_id to CotType_Other and populate cot_type_str.
 *
 * @generated from enum meshtastic.CotType
 */
declare enum CotType {
  /**
   *
   * Unknown or unmapped type, use cot_type_str
   *
   * @generated from enum value: CotType_Other = 0;
   */
  CotType_Other = 0,
  /**
   *
   * a-f-G-U-C: Friendly ground unit combat
   *
   * @generated from enum value: CotType_a_f_G_U_C = 1;
   */
  CotType_a_f_G_U_C = 1,
  /**
   *
   * a-f-G-U-C-I: Friendly ground unit combat infantry
   *
   * @generated from enum value: CotType_a_f_G_U_C_I = 2;
   */
  CotType_a_f_G_U_C_I = 2,
  /**
   *
   * a-n-A-C-F: Neutral aircraft civilian fixed-wing
   *
   * @generated from enum value: CotType_a_n_A_C_F = 3;
   */
  CotType_a_n_A_C_F = 3,
  /**
   *
   * a-n-A-C-H: Neutral aircraft civilian helicopter
   *
   * @generated from enum value: CotType_a_n_A_C_H = 4;
   */
  CotType_a_n_A_C_H = 4,
  /**
   *
   * a-n-A-C: Neutral aircraft civilian
   *
   * @generated from enum value: CotType_a_n_A_C = 5;
   */
  CotType_a_n_A_C = 5,
  /**
   *
   * a-f-A-M-H: Friendly aircraft military helicopter
   *
   * @generated from enum value: CotType_a_f_A_M_H = 6;
   */
  CotType_a_f_A_M_H = 6,
  /**
   *
   * a-f-A-M: Friendly aircraft military
   *
   * @generated from enum value: CotType_a_f_A_M = 7;
   */
  CotType_a_f_A_M = 7,
  /**
   *
   * a-f-A-M-F-F: Friendly aircraft military fixed-wing fighter
   *
   * @generated from enum value: CotType_a_f_A_M_F_F = 8;
   */
  CotType_a_f_A_M_F_F = 8,
  /**
   *
   * a-f-A-M-H-A: Friendly aircraft military helicopter attack
   *
   * @generated from enum value: CotType_a_f_A_M_H_A = 9;
   */
  CotType_a_f_A_M_H_A = 9,
  /**
   *
   * a-f-A-M-H-U-M: Friendly aircraft military helicopter utility medium
   *
   * @generated from enum value: CotType_a_f_A_M_H_U_M = 10;
   */
  CotType_a_f_A_M_H_U_M = 10,
  /**
   *
   * a-h-A-M-F-F: Hostile aircraft military fixed-wing fighter
   *
   * @generated from enum value: CotType_a_h_A_M_F_F = 11;
   */
  CotType_a_h_A_M_F_F = 11,
  /**
   *
   * a-h-A-M-H-A: Hostile aircraft military helicopter attack
   *
   * @generated from enum value: CotType_a_h_A_M_H_A = 12;
   */
  CotType_a_h_A_M_H_A = 12,
  /**
   *
   * a-u-A-C: Unknown aircraft civilian
   *
   * @generated from enum value: CotType_a_u_A_C = 13;
   */
  CotType_a_u_A_C = 13,
  /**
   *
   * t-x-d-d: Tasking delete/disconnect
   *
   * @generated from enum value: CotType_t_x_d_d = 14;
   */
  CotType_t_x_d_d = 14,
  /**
   *
   * a-f-G-E-S-E: Friendly ground equipment sensor
   *
   * @generated from enum value: CotType_a_f_G_E_S_E = 15;
   */
  CotType_a_f_G_E_S_E = 15,
  /**
   *
   * a-f-G-E-V-C: Friendly ground equipment vehicle
   *
   * @generated from enum value: CotType_a_f_G_E_V_C = 16;
   */
  CotType_a_f_G_E_V_C = 16,
  /**
   *
   * a-f-S: Friendly sea
   *
   * @generated from enum value: CotType_a_f_S = 17;
   */
  CotType_a_f_S = 17,
  /**
   *
   * a-f-A-M-F: Friendly aircraft military fixed-wing
   *
   * @generated from enum value: CotType_a_f_A_M_F = 18;
   */
  CotType_a_f_A_M_F = 18,
  /**
   *
   * a-f-A-M-F-C-H: Friendly aircraft military fixed-wing cargo heavy
   *
   * @generated from enum value: CotType_a_f_A_M_F_C_H = 19;
   */
  CotType_a_f_A_M_F_C_H = 19,
  /**
   *
   * a-f-A-M-F-U-L: Friendly aircraft military fixed-wing utility light
   *
   * @generated from enum value: CotType_a_f_A_M_F_U_L = 20;
   */
  CotType_a_f_A_M_F_U_L = 20,
  /**
   *
   * a-f-A-M-F-L: Friendly aircraft military fixed-wing liaison
   *
   * @generated from enum value: CotType_a_f_A_M_F_L = 21;
   */
  CotType_a_f_A_M_F_L = 21,
  /**
   *
   * a-f-A-M-F-P: Friendly aircraft military fixed-wing patrol
   *
   * @generated from enum value: CotType_a_f_A_M_F_P = 22;
   */
  CotType_a_f_A_M_F_P = 22,
  /**
   *
   * a-f-A-C-H: Friendly aircraft civilian helicopter
   *
   * @generated from enum value: CotType_a_f_A_C_H = 23;
   */
  CotType_a_f_A_C_H = 23,
  /**
   *
   * a-n-A-M-F-Q: Neutral aircraft military fixed-wing drone
   *
   * @generated from enum value: CotType_a_n_A_M_F_Q = 24;
   */
  CotType_a_n_A_M_F_Q = 24,
  /**
   *
   * b-t-f: GeoChat message
   *
   * @generated from enum value: CotType_b_t_f = 25;
   */
  CotType_b_t_f = 25,
  /**
   *
   * b-r-f-h-c: CASEVAC/MEDEVAC report
   *
   * @generated from enum value: CotType_b_r_f_h_c = 26;
   */
  CotType_b_r_f_h_c = 26,
  /**
   *
   * b-a-o-pan: Ring the bell / alert all
   *
   * @generated from enum value: CotType_b_a_o_pan = 27;
   */
  CotType_b_a_o_pan = 27,
  /**
   *
   * b-a-o-opn: Troops in contact
   *
   * @generated from enum value: CotType_b_a_o_opn = 28;
   */
  CotType_b_a_o_opn = 28,
  /**
   *
   * b-a-o-can: Cancel alert
   *
   * @generated from enum value: CotType_b_a_o_can = 29;
   */
  CotType_b_a_o_can = 29,
  /**
   *
   * b-a-o-tbl: 911 alert
   *
   * @generated from enum value: CotType_b_a_o_tbl = 30;
   */
  CotType_b_a_o_tbl = 30,
  /**
   *
   * b-a-g: Geofence breach alert
   *
   * @generated from enum value: CotType_b_a_g = 31;
   */
  CotType_b_a_g = 31,
  /**
   *
   * a-f-G: Friendly ground (generic)
   *
   * @generated from enum value: CotType_a_f_G = 32;
   */
  CotType_a_f_G = 32,
  /**
   *
   * a-f-G-U: Friendly ground unit (generic)
   *
   * @generated from enum value: CotType_a_f_G_U = 33;
   */
  CotType_a_f_G_U = 33,
  /**
   *
   * a-h-G: Hostile ground (generic)
   *
   * @generated from enum value: CotType_a_h_G = 34;
   */
  CotType_a_h_G = 34,
  /**
   *
   * a-u-G: Unknown ground (generic)
   *
   * @generated from enum value: CotType_a_u_G = 35;
   */
  CotType_a_u_G = 35,
  /**
   *
   * a-n-G: Neutral ground (generic)
   *
   * @generated from enum value: CotType_a_n_G = 36;
   */
  CotType_a_n_G = 36,
  /**
   *
   * b-m-r: Route
   *
   * @generated from enum value: CotType_b_m_r = 37;
   */
  CotType_b_m_r = 37,
  /**
   *
   * b-m-p-w: Route waypoint
   *
   * @generated from enum value: CotType_b_m_p_w = 38;
   */
  CotType_b_m_p_w = 38,
  /**
   *
   * b-m-p-s-p-i: Self-position marker
   *
   * @generated from enum value: CotType_b_m_p_s_p_i = 39;
   */
  CotType_b_m_p_s_p_i = 39,
  /**
   *
   * u-d-f: Freeform shape (line/polygon)
   *
   * @generated from enum value: CotType_u_d_f = 40;
   */
  CotType_u_d_f = 40,
  /**
   *
   * u-d-r: Rectangle
   *
   * @generated from enum value: CotType_u_d_r = 41;
   */
  CotType_u_d_r = 41,
  /**
   *
   * u-d-c-c: Circle
   *
   * @generated from enum value: CotType_u_d_c_c = 42;
   */
  CotType_u_d_c_c = 42,
  /**
   *
   * u-rb-a: Range/bearing line
   *
   * @generated from enum value: CotType_u_rb_a = 43;
   */
  CotType_u_rb_a = 43,
  /**
   *
   * a-h-A: Hostile aircraft (generic)
   *
   * @generated from enum value: CotType_a_h_A = 44;
   */
  CotType_a_h_A = 44,
  /**
   *
   * a-u-A: Unknown aircraft (generic)
   *
   * @generated from enum value: CotType_a_u_A = 45;
   */
  CotType_a_u_A = 45,
  /**
   *
   * a-f-A-M-H-Q: Friendly aircraft military helicopter observation
   *
   * @generated from enum value: CotType_a_f_A_M_H_Q = 46;
   */
  CotType_a_f_A_M_H_Q = 46,
  /**
   *
   * a-f-A-C-F: Friendly aircraft civilian fixed-wing
   *
   * @generated from enum value: CotType_a_f_A_C_F = 47;
   */
  CotType_a_f_A_C_F = 47,
  /**
   *
   * a-f-A-C: Friendly aircraft civilian (generic)
   *
   * @generated from enum value: CotType_a_f_A_C = 48;
   */
  CotType_a_f_A_C = 48,
  /**
   *
   * a-f-A-C-L: Friendly aircraft civilian lighter-than-air
   *
   * @generated from enum value: CotType_a_f_A_C_L = 49;
   */
  CotType_a_f_A_C_L = 49,
  /**
   *
   * a-f-A: Friendly aircraft (generic)
   *
   * @generated from enum value: CotType_a_f_A = 50;
   */
  CotType_a_f_A = 50,
  /**
   *
   * a-f-A-M-H-C: Friendly aircraft military helicopter cargo
   *
   * @generated from enum value: CotType_a_f_A_M_H_C = 51;
   */
  CotType_a_f_A_M_H_C = 51,
  /**
   *
   * a-n-A-M-F-F: Neutral aircraft military fixed-wing fighter
   *
   * @generated from enum value: CotType_a_n_A_M_F_F = 52;
   */
  CotType_a_n_A_M_F_F = 52,
  /**
   *
   * a-u-A-C-F: Unknown aircraft civilian fixed-wing
   *
   * @generated from enum value: CotType_a_u_A_C_F = 53;
   */
  CotType_a_u_A_C_F = 53,
  /**
   *
   * a-f-G-U-C-F-T-A: Friendly ground unit combat forces theater aviation
   *
   * @generated from enum value: CotType_a_f_G_U_C_F_T_A = 54;
   */
  CotType_a_f_G_U_C_F_T_A = 54,
  /**
   *
   * a-f-G-U-C-V-S: Friendly ground unit combat vehicle support
   *
   * @generated from enum value: CotType_a_f_G_U_C_V_S = 55;
   */
  CotType_a_f_G_U_C_V_S = 55,
  /**
   *
   * a-f-G-U-C-R-X: Friendly ground unit combat reconnaissance exploitation
   *
   * @generated from enum value: CotType_a_f_G_U_C_R_X = 56;
   */
  CotType_a_f_G_U_C_R_X = 56,
  /**
   *
   * a-f-G-U-C-I-Z: Friendly ground unit combat infantry mechanized
   *
   * @generated from enum value: CotType_a_f_G_U_C_I_Z = 57;
   */
  CotType_a_f_G_U_C_I_Z = 57,
  /**
   *
   * a-f-G-U-C-E-C-W: Friendly ground unit combat engineer construction wheeled
   *
   * @generated from enum value: CotType_a_f_G_U_C_E_C_W = 58;
   */
  CotType_a_f_G_U_C_E_C_W = 58,
  /**
   *
   * a-f-G-U-C-I-L: Friendly ground unit combat infantry light
   *
   * @generated from enum value: CotType_a_f_G_U_C_I_L = 59;
   */
  CotType_a_f_G_U_C_I_L = 59,
  /**
   *
   * a-f-G-U-C-R-O: Friendly ground unit combat reconnaissance other
   *
   * @generated from enum value: CotType_a_f_G_U_C_R_O = 60;
   */
  CotType_a_f_G_U_C_R_O = 60,
  /**
   *
   * a-f-G-U-C-R-V: Friendly ground unit combat reconnaissance cavalry
   *
   * @generated from enum value: CotType_a_f_G_U_C_R_V = 61;
   */
  CotType_a_f_G_U_C_R_V = 61,
  /**
   *
   * a-f-G-U-H: Friendly ground unit headquarters
   *
   * @generated from enum value: CotType_a_f_G_U_H = 62;
   */
  CotType_a_f_G_U_H = 62,
  /**
   *
   * a-f-G-U-U-M-S-E: Friendly ground unit support medical surgical evacuation
   *
   * @generated from enum value: CotType_a_f_G_U_U_M_S_E = 63;
   */
  CotType_a_f_G_U_U_M_S_E = 63,
  /**
   *
   * a-f-G-U-S-M-C: Friendly ground unit support maintenance collection
   *
   * @generated from enum value: CotType_a_f_G_U_S_M_C = 64;
   */
  CotType_a_f_G_U_S_M_C = 64,
  /**
   *
   * a-f-G-E-S: Friendly ground equipment sensor (generic)
   *
   * @generated from enum value: CotType_a_f_G_E_S = 65;
   */
  CotType_a_f_G_E_S = 65,
  /**
   *
   * a-f-G-E: Friendly ground equipment (generic)
   *
   * @generated from enum value: CotType_a_f_G_E = 66;
   */
  CotType_a_f_G_E = 66,
  /**
   *
   * a-f-G-E-V-C-U: Friendly ground equipment vehicle utility
   *
   * @generated from enum value: CotType_a_f_G_E_V_C_U = 67;
   */
  CotType_a_f_G_E_V_C_U = 67,
  /**
   *
   * a-f-G-E-V-C-ps: Friendly ground equipment vehicle public safety
   *
   * @generated from enum value: CotType_a_f_G_E_V_C_ps = 68;
   */
  CotType_a_f_G_E_V_C_ps = 68,
  /**
   *
   * a-u-G-E-V: Unknown ground equipment vehicle
   *
   * @generated from enum value: CotType_a_u_G_E_V = 69;
   */
  CotType_a_u_G_E_V = 69,
  /**
   *
   * a-f-S-N-N-R: Friendly sea surface non-naval rescue
   *
   * @generated from enum value: CotType_a_f_S_N_N_R = 70;
   */
  CotType_a_f_S_N_N_R = 70,
  /**
   *
   * a-f-F-B: Friendly force boundary
   *
   * @generated from enum value: CotType_a_f_F_B = 71;
   */
  CotType_a_f_F_B = 71,
  /**
   *
   * b-m-p-s-p-loc: Self-position location marker
   *
   * @generated from enum value: CotType_b_m_p_s_p_loc = 72;
   */
  CotType_b_m_p_s_p_loc = 72,
  /**
   *
   * b-i-v: Imagery/video
   *
   * @generated from enum value: CotType_b_i_v = 73;
   */
  CotType_b_i_v = 73,
  /**
   *
   * b-f-t-r: File transfer request
   *
   * @generated from enum value: CotType_b_f_t_r = 74;
   */
  CotType_b_f_t_r = 74,
  /**
   *
   * b-f-t-a: File transfer acknowledgment
   *
   * @generated from enum value: CotType_b_f_t_a = 75;
   */
  CotType_b_f_t_a = 75,
  /**
   *
   * u-d-f-m: Freehand telestration / annotation. Anchor at event point,
   * geometry carried via DrawnShape.vertices. May be truncated to
   * MAX_VERTICES by the sender.
   *
   * @generated from enum value: CotType_u_d_f_m = 76;
   */
  CotType_u_d_f_m = 76,
  /**
   *
   * u-d-p: Closed polygon. Geometry carried via DrawnShape.vertices,
   * implicitly closed (receiver duplicates first vertex as needed).
   *
   * @generated from enum value: CotType_u_d_p = 77;
   */
  CotType_u_d_p = 77,
  /**
   *
   * b-m-p-s-m: Spot map marker (colored dot at a point of interest).
   *
   * @generated from enum value: CotType_b_m_p_s_m = 78;
   */
  CotType_b_m_p_s_m = 78,
  /**
   *
   * b-m-p-c: Checkpoint (intermediate route control point).
   *
   * @generated from enum value: CotType_b_m_p_c = 79;
   */
  CotType_b_m_p_c = 79,
  /**
   *
   * u-r-b-c-c: Ranging circle (range rings centered on the event point).
   *
   * @generated from enum value: CotType_u_r_b_c_c = 80;
   */
  CotType_u_r_b_c_c = 80,
  /**
   *
   * u-r-b-bullseye: Bullseye with configurable range rings and bearing
   * reference (magnetic / true / grid).
   *
   * @generated from enum value: CotType_u_r_b_bullseye = 81;
   */
  CotType_u_r_b_bullseye = 81,
  /**
   *
   * a-f-G-E-V-A: Friendly armored vehicle, user-selectable self PLI.
   *
   * @generated from enum value: CotType_a_f_G_E_V_A = 82;
   */
  CotType_a_f_G_E_V_A = 82,
  /**
   *
   * a-n-A: Neutral aircraft (friendly/hostile/unknown already present).
   *
   * @generated from enum value: CotType_a_n_A = 83;
   */
  CotType_a_n_A = 83,
  /**
   * --- 2525 quick-drop: artillery (4) ----------------------------------
   *
   * @generated from enum value: CotType_a_u_G_U_C_F = 84;
   */
  CotType_a_u_G_U_C_F = 84,
  /**
   * @generated from enum value: CotType_a_n_G_U_C_F = 85;
   */
  CotType_a_n_G_U_C_F = 85,
  /**
   * @generated from enum value: CotType_a_h_G_U_C_F = 86;
   */
  CotType_a_h_G_U_C_F = 86,
  /**
   * @generated from enum value: CotType_a_f_G_U_C_F = 87;
   */
  CotType_a_f_G_U_C_F = 87,
  /**
   * --- 2525 quick-drop: building (4) -----------------------------------
   *
   * @generated from enum value: CotType_a_u_G_I = 88;
   */
  CotType_a_u_G_I = 88,
  /**
   * @generated from enum value: CotType_a_n_G_I = 89;
   */
  CotType_a_n_G_I = 89,
  /**
   * @generated from enum value: CotType_a_h_G_I = 90;
   */
  CotType_a_h_G_I = 90,
  /**
   * @generated from enum value: CotType_a_f_G_I = 91;
   */
  CotType_a_f_G_I = 91,
  /**
   * --- 2525 quick-drop: mine (4) ---------------------------------------
   *
   * @generated from enum value: CotType_a_u_G_E_X_M = 92;
   */
  CotType_a_u_G_E_X_M = 92,
  /**
   * @generated from enum value: CotType_a_n_G_E_X_M = 93;
   */
  CotType_a_n_G_E_X_M = 93,
  /**
   * @generated from enum value: CotType_a_h_G_E_X_M = 94;
   */
  CotType_a_h_G_E_X_M = 94,
  /**
   * @generated from enum value: CotType_a_f_G_E_X_M = 95;
   */
  CotType_a_f_G_E_X_M = 95,
  /**
   * --- 2525 quick-drop: ship (3; a-f-S already at 17) ------------------
   *
   * @generated from enum value: CotType_a_u_S = 96;
   */
  CotType_a_u_S = 96,
  /**
   * @generated from enum value: CotType_a_n_S = 97;
   */
  CotType_a_n_S = 97,
  /**
   * @generated from enum value: CotType_a_h_S = 98;
   */
  CotType_a_h_S = 98,
  /**
   * --- 2525 quick-drop: sniper (4) -------------------------------------
   *
   * @generated from enum value: CotType_a_u_G_U_C_I_d = 99;
   */
  CotType_a_u_G_U_C_I_d = 99,
  /**
   * @generated from enum value: CotType_a_n_G_U_C_I_d = 100;
   */
  CotType_a_n_G_U_C_I_d = 100,
  /**
   * @generated from enum value: CotType_a_h_G_U_C_I_d = 101;
   */
  CotType_a_h_G_U_C_I_d = 101,
  /**
   * @generated from enum value: CotType_a_f_G_U_C_I_d = 102;
   */
  CotType_a_f_G_U_C_I_d = 102,
  /**
   * --- 2525 quick-drop: tank (4) ---------------------------------------
   *
   * @generated from enum value: CotType_a_u_G_E_V_A_T = 103;
   */
  CotType_a_u_G_E_V_A_T = 103,
  /**
   * @generated from enum value: CotType_a_n_G_E_V_A_T = 104;
   */
  CotType_a_n_G_E_V_A_T = 104,
  /**
   * @generated from enum value: CotType_a_h_G_E_V_A_T = 105;
   */
  CotType_a_h_G_E_V_A_T = 105,
  /**
   * @generated from enum value: CotType_a_f_G_E_V_A_T = 106;
   */
  CotType_a_f_G_E_V_A_T = 106,
  /**
   * --- 2525 quick-drop: troops (3; a-f-G-U-C-I already at 2) -----------
   *
   * @generated from enum value: CotType_a_u_G_U_C_I = 107;
   */
  CotType_a_u_G_U_C_I = 107,
  /**
   * @generated from enum value: CotType_a_n_G_U_C_I = 108;
   */
  CotType_a_n_G_U_C_I = 108,
  /**
   * @generated from enum value: CotType_a_h_G_U_C_I = 109;
   */
  CotType_a_h_G_U_C_I = 109,
  /**
   * --- 2525 quick-drop: generic vehicle (3; a-u-G-E-V already at 69) ---
   *
   * @generated from enum value: CotType_a_n_G_E_V = 110;
   */
  CotType_a_n_G_E_V = 110,
  /**
   * @generated from enum value: CotType_a_h_G_E_V = 111;
   */
  CotType_a_h_G_E_V = 111,
  /**
   * @generated from enum value: CotType_a_f_G_E_V = 112;
   */
  CotType_a_f_G_E_V = 112,
  /**
   *
   * b-m-p-w-GOTO: Go To / bloodhound navigation target.
   *
   * @generated from enum value: CotType_b_m_p_w_GOTO = 113;
   */
  CotType_b_m_p_w_GOTO = 113,
  /**
   *
   * b-m-p-c-ip: Initial point (mission planning).
   *
   * @generated from enum value: CotType_b_m_p_c_ip = 114;
   */
  CotType_b_m_p_c_ip = 114,
  /**
   *
   * b-m-p-c-cp: Contact point (mission planning).
   *
   * @generated from enum value: CotType_b_m_p_c_cp = 115;
   */
  CotType_b_m_p_c_cp = 115,
  /**
   *
   * b-m-p-s-p-op: Observation post.
   *
   * @generated from enum value: CotType_b_m_p_s_p_op = 116;
   */
  CotType_b_m_p_s_p_op = 116,
  /**
   *
   * u-d-v: 2D vehicle outline drawn on the map.
   *
   * @generated from enum value: CotType_u_d_v = 117;
   */
  CotType_u_d_v = 117,
  /**
   *
   * u-d-v-m: 3D vehicle model reference.
   *
   * @generated from enum value: CotType_u_d_v_m = 118;
   */
  CotType_u_d_v_m = 118,
  /**
   *
   * u-d-c-e: Non-circular ellipse (circle with distinct major/minor axes).
   *
   * @generated from enum value: CotType_u_d_c_e = 119;
   */
  CotType_u_d_c_e = 119,
  /**
   *
   * b-i-x-i: Quick Pic geotagged image marker. The image itself does not
   * ride on LoRa; this event references the image via iconset metadata.
   *
   * @generated from enum value: CotType_b_i_x_i = 120;
   */
  CotType_b_i_x_i = 120,
  /**
   *
   * b-t-f-d: GeoChat delivered receipt. Carried on the existing `chat`
   * payload_variant via GeoChat.receipt_for_uid + receipt_type.
   *
   * @generated from enum value: CotType_b_t_f_d = 121;
   */
  CotType_b_t_f_d = 121,
  /**
   *
   * b-t-f-r: GeoChat read receipt. Same wire slot as b-t-f-d.
   *
   * @generated from enum value: CotType_b_t_f_r = 122;
   */
  CotType_b_t_f_r = 122,
  /**
   *
   * b-a-o-c: Custom / generic emergency beacon.
   *
   * @generated from enum value: CotType_b_a_o_c = 123;
   */
  CotType_b_a_o_c = 123,
  /**
   *
   * t-s: Task / engage request. Structured payload carried via the new
   * TaskRequest typed variant.
   *
   * @generated from enum value: CotType_t_s = 124;
   */
  CotType_t_s = 124,
  /**
   *
   * m-t-t: TAKTALK voice/text chat message. Payload carried via the
   * TakTalkMessage typed variant (text, chatroom_id, lang, from_voice).
   *
   * @generated from enum value: CotType_m_t_t = 125;
   */
  CotType_m_t_t = 125,
  /**
   *
   * y-: TAKTALK room/membership broadcast. Payload carried via the
   * TakTalkRoomData typed variant (sender_callsign, room_id, room_name,
   * participants). The CoT type literally has a trailing dash and no
   * second atom — not a typo.
   *
   * @generated from enum value: CotType_y = 126;
   */
  CotType_y = 126
}
/**
 * Describes the enum meshtastic.CotType.
 */
declare const CotTypeSchema: GenEnum<CotType>;
/**
 *
 * Geopoint and altitude source
 *
 * @generated from enum meshtastic.GeoPointSource
 */
declare enum GeoPointSource {
  /**
   *
   * Unspecified
   *
   * @generated from enum value: GeoPointSource_Unspecified = 0;
   */
  GeoPointSource_Unspecified = 0,
  /**
   *
   * GPS derived
   *
   * @generated from enum value: GeoPointSource_GPS = 1;
   */
  GeoPointSource_GPS = 1,
  /**
   *
   * User entered
   *
   * @generated from enum value: GeoPointSource_USER = 2;
   */
  GeoPointSource_USER = 2,
  /**
   *
   * Network/external
   *
   * @generated from enum value: GeoPointSource_NETWORK = 3;
   */
  GeoPointSource_NETWORK = 3
}
/**
 * Describes the enum meshtastic.GeoPointSource.
 */
declare const GeoPointSourceSchema: GenEnum<GeoPointSource>;
declare namespace module_config_pb_d_exports {
  export { ModuleConfig, ModuleConfigSchema, ModuleConfig_AmbientLightingConfig, ModuleConfig_AmbientLightingConfigSchema, ModuleConfig_AudioConfig, ModuleConfig_AudioConfigSchema, ModuleConfig_AudioConfig_Audio_Baud, ModuleConfig_AudioConfig_Audio_BaudSchema, ModuleConfig_CannedMessageConfig, ModuleConfig_CannedMessageConfigSchema, ModuleConfig_CannedMessageConfig_InputEventChar, ModuleConfig_CannedMessageConfig_InputEventCharSchema, ModuleConfig_DetectionSensorConfig, ModuleConfig_DetectionSensorConfigSchema, ModuleConfig_DetectionSensorConfig_TriggerType, ModuleConfig_DetectionSensorConfig_TriggerTypeSchema, ModuleConfig_ExternalNotificationConfig, ModuleConfig_ExternalNotificationConfigSchema, ModuleConfig_MQTTConfig, ModuleConfig_MQTTConfigSchema, ModuleConfig_MapReportSettings, ModuleConfig_MapReportSettingsSchema, ModuleConfig_MeshBeaconConfig, ModuleConfig_MeshBeaconConfigSchema, ModuleConfig_MeshBeaconConfig_BroadcastTarget, ModuleConfig_MeshBeaconConfig_BroadcastTargetSchema, ModuleConfig_MeshBeaconConfig_Flags, ModuleConfig_MeshBeaconConfig_FlagsSchema, ModuleConfig_NeighborInfoConfig, ModuleConfig_NeighborInfoConfigSchema, ModuleConfig_PaxcounterConfig, ModuleConfig_PaxcounterConfigSchema, ModuleConfig_RangeTestConfig, ModuleConfig_RangeTestConfigSchema, ModuleConfig_RemoteHardwareConfig, ModuleConfig_RemoteHardwareConfigSchema, ModuleConfig_SerialConfig, ModuleConfig_SerialConfigSchema, ModuleConfig_SerialConfig_Serial_Baud, ModuleConfig_SerialConfig_Serial_BaudSchema, ModuleConfig_SerialConfig_Serial_Mode, ModuleConfig_SerialConfig_Serial_ModeSchema, ModuleConfig_StatusMessageConfig, ModuleConfig_StatusMessageConfigSchema, ModuleConfig_StoreForwardConfig, ModuleConfig_StoreForwardConfigSchema, ModuleConfig_TAKConfig, ModuleConfig_TAKConfigSchema, ModuleConfig_TelemetryConfig, ModuleConfig_TelemetryConfigSchema, ModuleConfig_TrafficManagementConfig, ModuleConfig_TrafficManagementConfigSchema, RemoteHardwarePin, RemoteHardwarePinSchema, RemoteHardwarePinType, RemoteHardwarePinTypeSchema, file_meshtastic_module_config };
}
/**
 * Describes the file meshtastic/module_config.proto.
 */
declare const file_meshtastic_module_config: GenFile;
/**
 *
 * Module Config
 *
 * @generated from message meshtastic.ModuleConfig
 */
type ModuleConfig = Message<"meshtastic.ModuleConfig"> & {
  /**
   *
   * TODO: REPLACE
   *
   * @generated from oneof meshtastic.ModuleConfig.payload_variant
   */
  payloadVariant: {
    /**
     *
     * TODO: REPLACE
     *
     * @generated from field: meshtastic.ModuleConfig.MQTTConfig mqtt = 1;
     */
    value: ModuleConfig_MQTTConfig;
    case: "mqtt";
  } | {
    /**
     *
     * TODO: REPLACE
     *
     * @generated from field: meshtastic.ModuleConfig.SerialConfig serial = 2;
     */
    value: ModuleConfig_SerialConfig;
    case: "serial";
  } | {
    /**
     *
     * TODO: REPLACE
     *
     * @generated from field: meshtastic.ModuleConfig.ExternalNotificationConfig external_notification = 3;
     */
    value: ModuleConfig_ExternalNotificationConfig;
    case: "externalNotification";
  } | {
    /**
     *
     * TODO: REPLACE
     *
     * @generated from field: meshtastic.ModuleConfig.StoreForwardConfig store_forward = 4;
     */
    value: ModuleConfig_StoreForwardConfig;
    case: "storeForward";
  } | {
    /**
     *
     * TODO: REPLACE
     *
     * @generated from field: meshtastic.ModuleConfig.RangeTestConfig range_test = 5;
     */
    value: ModuleConfig_RangeTestConfig;
    case: "rangeTest";
  } | {
    /**
     *
     * TODO: REPLACE
     *
     * @generated from field: meshtastic.ModuleConfig.TelemetryConfig telemetry = 6;
     */
    value: ModuleConfig_TelemetryConfig;
    case: "telemetry";
  } | {
    /**
     *
     * TODO: REPLACE
     *
     * @generated from field: meshtastic.ModuleConfig.CannedMessageConfig canned_message = 7;
     */
    value: ModuleConfig_CannedMessageConfig;
    case: "cannedMessage";
  } | {
    /**
     *
     * TODO: REPLACE
     *
     * @generated from field: meshtastic.ModuleConfig.AudioConfig audio = 8;
     */
    value: ModuleConfig_AudioConfig;
    case: "audio";
  } | {
    /**
     *
     * TODO: REPLACE
     *
     * @generated from field: meshtastic.ModuleConfig.RemoteHardwareConfig remote_hardware = 9;
     */
    value: ModuleConfig_RemoteHardwareConfig;
    case: "remoteHardware";
  } | {
    /**
     *
     * TODO: REPLACE
     *
     * @generated from field: meshtastic.ModuleConfig.NeighborInfoConfig neighbor_info = 10;
     */
    value: ModuleConfig_NeighborInfoConfig;
    case: "neighborInfo";
  } | {
    /**
     *
     * TODO: REPLACE
     *
     * @generated from field: meshtastic.ModuleConfig.AmbientLightingConfig ambient_lighting = 11;
     */
    value: ModuleConfig_AmbientLightingConfig;
    case: "ambientLighting";
  } | {
    /**
     *
     * TODO: REPLACE
     *
     * @generated from field: meshtastic.ModuleConfig.DetectionSensorConfig detection_sensor = 12;
     */
    value: ModuleConfig_DetectionSensorConfig;
    case: "detectionSensor";
  } | {
    /**
     *
     * TODO: REPLACE
     *
     * @generated from field: meshtastic.ModuleConfig.PaxcounterConfig paxcounter = 13;
     */
    value: ModuleConfig_PaxcounterConfig;
    case: "paxcounter";
  } | {
    /**
     *
     * TODO: REPLACE
     *
     * @generated from field: meshtastic.ModuleConfig.StatusMessageConfig statusmessage = 14;
     */
    value: ModuleConfig_StatusMessageConfig;
    case: "statusmessage";
  } | {
    /**
     *
     * Traffic management module config for mesh network optimization
     *
     * @generated from field: meshtastic.ModuleConfig.TrafficManagementConfig traffic_management = 15;
     */
    value: ModuleConfig_TrafficManagementConfig;
    case: "trafficManagement";
  } | {
    /**
     *
     * TAK team/role configuration for TAK_TRACKER
     *
     * @generated from field: meshtastic.ModuleConfig.TAKConfig tak = 16;
     */
    value: ModuleConfig_TAKConfig;
    case: "tak";
  } | {
    /**
     *
     * MeshBeacon module config
     *
     * @generated from field: meshtastic.ModuleConfig.MeshBeaconConfig mesh_beacon = 17;
     */
    value: ModuleConfig_MeshBeaconConfig;
    case: "meshBeacon";
  } | {
    case: undefined;
    value?: undefined;
  };
};
/**
 * Describes the message meshtastic.ModuleConfig.
 * Use `create(ModuleConfigSchema)` to create a new message.
 */
declare const ModuleConfigSchema: GenMessage<ModuleConfig>;
/**
 *
 * MQTT Client Config
 *
 * @generated from message meshtastic.ModuleConfig.MQTTConfig
 */
type ModuleConfig_MQTTConfig = Message<"meshtastic.ModuleConfig.MQTTConfig"> & {
  /**
   *
   * If a meshtastic node is able to reach the internet it will normally attempt to gateway any channels that are marked as
   * is_uplink_enabled or is_downlink_enabled.
   *
   * @generated from field: bool enabled = 1;
   */
  enabled: boolean;
  /**
   *
   * The server to use for our MQTT global message gateway feature.
   * If not set, the default server will be used
   *
   * @generated from field: string address = 2;
   */
  address: string;
  /**
   *
   * MQTT username to use (most useful for a custom MQTT server).
   * If using a custom server, this will be honoured even if empty.
   * If using the default server, this will only be honoured if set, otherwise the device will use the default username
   *
   * @generated from field: string username = 3;
   */
  username: string;
  /**
   *
   * MQTT password to use (most useful for a custom MQTT server).
   * If using a custom server, this will be honoured even if empty.
   * If using the default server, this will only be honoured if set, otherwise the device will use the default password
   *
   * @generated from field: string password = 4;
   */
  password: string;
  /**
   *
   * Whether to send encrypted or decrypted packets to MQTT.
   * This parameter is only honoured if you also set server
   * (the default official mqtt.meshtastic.org server can handle encrypted packets)
   * Decrypted packets may be useful for external systems that want to consume meshtastic packets
   *
   * @generated from field: bool encryption_enabled = 5;
   */
  encryptionEnabled: boolean;
  /**
   *
   * Deprecated: JSON packet support on MQTT was removed, and this field is ignored.
   *
   * @generated from field: bool json_enabled = 6 [deprecated = true];
   * @deprecated
   */
  jsonEnabled: boolean;
  /**
   *
   * If true, we attempt to establish a secure connection using TLS
   *
   * @generated from field: bool tls_enabled = 7;
   */
  tlsEnabled: boolean;
  /**
   *
   * The root topic to use for MQTT messages. Default is "msh".
   * This is useful if you want to use a single MQTT server for multiple meshtastic networks and separate them via ACLs
   *
   * @generated from field: string root = 8;
   */
  root: string;
  /**
   *
   * If true, we can use the connected phone / client to proxy messages to MQTT instead of a direct connection
   *
   * @generated from field: bool proxy_to_client_enabled = 9;
   */
  proxyToClientEnabled: boolean;
  /**
   *
   * If true, we will periodically report unencrypted information about our node to a map via MQTT
   *
   * @generated from field: bool map_reporting_enabled = 10;
   */
  mapReportingEnabled: boolean;
  /**
   *
   * Settings for reporting information about our node to a map via MQTT
   *
   * @generated from field: meshtastic.ModuleConfig.MapReportSettings map_report_settings = 11;
   */
  mapReportSettings?: ModuleConfig_MapReportSettings;
};
/**
 * Describes the message meshtastic.ModuleConfig.MQTTConfig.
 * Use `create(ModuleConfig_MQTTConfigSchema)` to create a new message.
 */
declare const ModuleConfig_MQTTConfigSchema: GenMessage<ModuleConfig_MQTTConfig>;
/**
 *
 * Settings for reporting unencrypted information about our node to a map via MQTT
 *
 * @generated from message meshtastic.ModuleConfig.MapReportSettings
 */
type ModuleConfig_MapReportSettings = Message<"meshtastic.ModuleConfig.MapReportSettings"> & {
  /**
   *
   * How often we should report our info to the map (in seconds)
   *
   * @generated from field: uint32 publish_interval_secs = 1;
   */
  publishIntervalSecs: number;
  /**
   *
   * Bits of precision for the location sent (default of 32 is full precision).
   *
   * @generated from field: uint32 position_precision = 2;
   */
  positionPrecision: number;
  /**
   *
   * Whether we have opted-in to report our location to the map
   *
   * @generated from field: bool should_report_location = 3;
   */
  shouldReportLocation: boolean;
};
/**
 * Describes the message meshtastic.ModuleConfig.MapReportSettings.
 * Use `create(ModuleConfig_MapReportSettingsSchema)` to create a new message.
 */
declare const ModuleConfig_MapReportSettingsSchema: GenMessage<ModuleConfig_MapReportSettings>;
/**
 *
 * RemoteHardwareModule Config
 *
 * @generated from message meshtastic.ModuleConfig.RemoteHardwareConfig
 */
type ModuleConfig_RemoteHardwareConfig = Message<"meshtastic.ModuleConfig.RemoteHardwareConfig"> & {
  /**
   *
   * Whether the Module is enabled
   *
   * @generated from field: bool enabled = 1;
   */
  enabled: boolean;
  /**
   *
   * Whether the Module allows consumers to read / write to pins not defined in available_pins
   *
   * @generated from field: bool allow_undefined_pin_access = 2;
   */
  allowUndefinedPinAccess: boolean;
  /**
   *
   * Exposes the available pins to the mesh for reading and writing
   *
   * @generated from field: repeated meshtastic.RemoteHardwarePin available_pins = 3;
   */
  availablePins: RemoteHardwarePin[];
};
/**
 * Describes the message meshtastic.ModuleConfig.RemoteHardwareConfig.
 * Use `create(ModuleConfig_RemoteHardwareConfigSchema)` to create a new message.
 */
declare const ModuleConfig_RemoteHardwareConfigSchema: GenMessage<ModuleConfig_RemoteHardwareConfig>;
/**
 *
 * NeighborInfoModule Config
 *
 * @generated from message meshtastic.ModuleConfig.NeighborInfoConfig
 */
type ModuleConfig_NeighborInfoConfig = Message<"meshtastic.ModuleConfig.NeighborInfoConfig"> & {
  /**
   *
   * Whether the Module is enabled
   *
   * @generated from field: bool enabled = 1;
   */
  enabled: boolean;
  /**
   *
   * Interval in seconds of how often we should try to send our
   * Neighbor Info (minimum is 14400, i.e., 4 hours)
   *
   * @generated from field: uint32 update_interval = 2;
   */
  updateInterval: number;
  /**
   *
   * Whether in addition to sending it to MQTT and the PhoneAPI, our NeighborInfo should be transmitted over LoRa.
   * Note that this is not available on a channel with default key and name.
   *
   * @generated from field: bool transmit_over_lora = 3;
   */
  transmitOverLora: boolean;
};
/**
 * Describes the message meshtastic.ModuleConfig.NeighborInfoConfig.
 * Use `create(ModuleConfig_NeighborInfoConfigSchema)` to create a new message.
 */
declare const ModuleConfig_NeighborInfoConfigSchema: GenMessage<ModuleConfig_NeighborInfoConfig>;
/**
 *
 * Detection Sensor Module Config
 *
 * @generated from message meshtastic.ModuleConfig.DetectionSensorConfig
 */
type ModuleConfig_DetectionSensorConfig = Message<"meshtastic.ModuleConfig.DetectionSensorConfig"> & {
  /**
   *
   * Whether the Module is enabled
   *
   * @generated from field: bool enabled = 1;
   */
  enabled: boolean;
  /**
   *
   * Interval in seconds of how often we can send a message to the mesh when a
   * trigger event is detected
   *
   * @generated from field: uint32 minimum_broadcast_secs = 2;
   */
  minimumBroadcastSecs: number;
  /**
   *
   * Interval in seconds of how often we should send a message to the mesh
   * with the current state regardless of trigger events When set to 0, only
   * trigger events will be broadcasted Works as a sort of status heartbeat
   * for peace of mind
   *
   * @generated from field: uint32 state_broadcast_secs = 3;
   */
  stateBroadcastSecs: number;
  /**
   *
   * Send ASCII bell with alert message
   * Useful for triggering ext. notification on bell
   *
   * @generated from field: bool send_bell = 4;
   */
  sendBell: boolean;
  /**
   *
   * Friendly name used to format message sent to mesh
   * Example: A name "Motion" would result in a message "Motion detected"
   * Maximum length of 20 characters
   *
   * @generated from field: string name = 5;
   */
  name: string;
  /**
   *
   * GPIO pin to monitor for state changes
   *
   * @generated from field: uint32 monitor_pin = 6;
   */
  monitorPin: number;
  /**
   *
   * The type of trigger event to be used
   *
   * @generated from field: meshtastic.ModuleConfig.DetectionSensorConfig.TriggerType detection_trigger_type = 7;
   */
  detectionTriggerType: ModuleConfig_DetectionSensorConfig_TriggerType;
  /**
   *
   * Whether or not use INPUT_PULLUP mode for GPIO pin
   * Only applicable if the board uses pull-up resistors on the pin
   *
   * @generated from field: bool use_pullup = 8;
   */
  usePullup: boolean;
};
/**
 * Describes the message meshtastic.ModuleConfig.DetectionSensorConfig.
 * Use `create(ModuleConfig_DetectionSensorConfigSchema)` to create a new message.
 */
declare const ModuleConfig_DetectionSensorConfigSchema: GenMessage<ModuleConfig_DetectionSensorConfig>;
/**
 * @generated from enum meshtastic.ModuleConfig.DetectionSensorConfig.TriggerType
 */
declare enum ModuleConfig_DetectionSensorConfig_TriggerType {
  /**
   * Event is triggered if pin is low
   *
   * @generated from enum value: LOGIC_LOW = 0;
   */
  LOGIC_LOW = 0,
  /**
   * Event is triggered if pin is high
   *
   * @generated from enum value: LOGIC_HIGH = 1;
   */
  LOGIC_HIGH = 1,
  /**
   * Event is triggered when pin goes high to low
   *
   * @generated from enum value: FALLING_EDGE = 2;
   */
  FALLING_EDGE = 2,
  /**
   * Event is triggered when pin goes low to high
   *
   * @generated from enum value: RISING_EDGE = 3;
   */
  RISING_EDGE = 3,
  /**
   * Event is triggered on every pin state change, low is considered to be
   * "active"
   *
   * @generated from enum value: EITHER_EDGE_ACTIVE_LOW = 4;
   */
  EITHER_EDGE_ACTIVE_LOW = 4,
  /**
   * Event is triggered on every pin state change, high is considered to be
   * "active"
   *
   * @generated from enum value: EITHER_EDGE_ACTIVE_HIGH = 5;
   */
  EITHER_EDGE_ACTIVE_HIGH = 5
}
/**
 * Describes the enum meshtastic.ModuleConfig.DetectionSensorConfig.TriggerType.
 */
declare const ModuleConfig_DetectionSensorConfig_TriggerTypeSchema: GenEnum<ModuleConfig_DetectionSensorConfig_TriggerType>;
/**
 *
 * Audio Config for codec2 voice
 *
 * @generated from message meshtastic.ModuleConfig.AudioConfig
 */
type ModuleConfig_AudioConfig = Message<"meshtastic.ModuleConfig.AudioConfig"> & {
  /**
   *
   * Whether Audio is enabled
   *
   * @generated from field: bool codec2_enabled = 1;
   */
  codec2Enabled: boolean;
  /**
   *
   * PTT Pin
   *
   * @generated from field: uint32 ptt_pin = 2;
   */
  pttPin: number;
  /**
   *
   * The audio sample rate to use for codec2
   *
   * @generated from field: meshtastic.ModuleConfig.AudioConfig.Audio_Baud bitrate = 3;
   */
  bitrate: ModuleConfig_AudioConfig_Audio_Baud;
  /**
   *
   * I2S Word Select
   *
   * @generated from field: uint32 i2s_ws = 4;
   */
  i2sWs: number;
  /**
   *
   * I2S Data IN
   *
   * @generated from field: uint32 i2s_sd = 5;
   */
  i2sSd: number;
  /**
   *
   * I2S Data OUT
   *
   * @generated from field: uint32 i2s_din = 6;
   */
  i2sDin: number;
  /**
   *
   * I2S Clock
   *
   * @generated from field: uint32 i2s_sck = 7;
   */
  i2sSck: number;
};
/**
 * Describes the message meshtastic.ModuleConfig.AudioConfig.
 * Use `create(ModuleConfig_AudioConfigSchema)` to create a new message.
 */
declare const ModuleConfig_AudioConfigSchema: GenMessage<ModuleConfig_AudioConfig>;
/**
 *
 * Baudrate for codec2 voice
 *
 * @generated from enum meshtastic.ModuleConfig.AudioConfig.Audio_Baud
 */
declare enum ModuleConfig_AudioConfig_Audio_Baud {
  /**
   * @generated from enum value: CODEC2_DEFAULT = 0;
   */
  CODEC2_DEFAULT = 0,
  /**
   * @generated from enum value: CODEC2_3200 = 1;
   */
  CODEC2_3200 = 1,
  /**
   * @generated from enum value: CODEC2_2400 = 2;
   */
  CODEC2_2400 = 2,
  /**
   * @generated from enum value: CODEC2_1600 = 3;
   */
  CODEC2_1600 = 3,
  /**
   * @generated from enum value: CODEC2_1400 = 4;
   */
  CODEC2_1400 = 4,
  /**
   * @generated from enum value: CODEC2_1300 = 5;
   */
  CODEC2_1300 = 5,
  /**
   * @generated from enum value: CODEC2_1200 = 6;
   */
  CODEC2_1200 = 6,
  /**
   * @generated from enum value: CODEC2_700 = 7;
   */
  CODEC2_700 = 7,
  /**
   * @generated from enum value: CODEC2_700B = 8;
   */
  CODEC2_700B = 8
}
/**
 * Describes the enum meshtastic.ModuleConfig.AudioConfig.Audio_Baud.
 */
declare const ModuleConfig_AudioConfig_Audio_BaudSchema: GenEnum<ModuleConfig_AudioConfig_Audio_Baud>;
/**
 *
 * Config for the Paxcounter Module
 *
 * @generated from message meshtastic.ModuleConfig.PaxcounterConfig
 */
type ModuleConfig_PaxcounterConfig = Message<"meshtastic.ModuleConfig.PaxcounterConfig"> & {
  /**
   *
   * Enable the Paxcounter Module
   *
   * @generated from field: bool enabled = 1;
   */
  enabled: boolean;
  /**
   * @generated from field: uint32 paxcounter_update_interval = 2;
   */
  paxcounterUpdateInterval: number;
  /**
   *
   * WiFi RSSI threshold. Defaults to -80
   *
   * @generated from field: int32 wifi_threshold = 3;
   */
  wifiThreshold: number;
  /**
   *
   * BLE RSSI threshold. Defaults to -80
   *
   * @generated from field: int32 ble_threshold = 4;
   */
  bleThreshold: number;
};
/**
 * Describes the message meshtastic.ModuleConfig.PaxcounterConfig.
 * Use `create(ModuleConfig_PaxcounterConfigSchema)` to create a new message.
 */
declare const ModuleConfig_PaxcounterConfigSchema: GenMessage<ModuleConfig_PaxcounterConfig>;
/**
 *
 * Config for the Traffic Management module.
 * Provides packet inspection and traffic shaping to help reduce channel utilization
 *
 * @generated from message meshtastic.ModuleConfig.TrafficManagementConfig
 */
type ModuleConfig_TrafficManagementConfig = Message<"meshtastic.ModuleConfig.TrafficManagementConfig"> & {
  /**
   *
   * Minimum interval in seconds between position updates from the same node.
   * A non-zero value implicitly enables the suppression window; 0 disables it.
   *
   * @generated from field: uint32 position_min_interval_secs = 4;
   */
  positionMinIntervalSecs: number;
  /**
   *
   * Maximum hop distance from the requestor at which direct NodeInfo responses
   * are served from the local cache. A non-zero value implicitly enables direct
   * response; 0 disables it.
   *
   * @generated from field: uint32 nodeinfo_direct_response_max_hops = 6;
   */
  nodeinfoDirectResponseMaxHops: number;
  /**
   *
   * Time window in seconds for per-node rate limiting.
   * A non-zero value implicitly enables rate limiting; 0 disables it.
   *
   * @generated from field: uint32 rate_limit_window_secs = 8;
   */
  rateLimitWindowSecs: number;
  /**
   *
   * Maximum packets allowed per node within the rate limit window.
   * A non-zero value implicitly enables rate limiting; 0 disables it.
   *
   * @generated from field: uint32 rate_limit_max_packets = 9;
   */
  rateLimitMaxPackets: number;
  /**
   *
   * Maximum unknown/undecryptable packets per rate window before the source
   * is dropped. A non-zero value implicitly enables unknown-packet filtering;
   * 0 disables it.
   *
   * @generated from field: uint32 unknown_packet_threshold = 11;
   */
  unknownPacketThreshold: number;
};
/**
 * Describes the message meshtastic.ModuleConfig.TrafficManagementConfig.
 * Use `create(ModuleConfig_TrafficManagementConfigSchema)` to create a new message.
 */
declare const ModuleConfig_TrafficManagementConfigSchema: GenMessage<ModuleConfig_TrafficManagementConfig>;
/**
 *
 * Serial Config
 *
 * @generated from message meshtastic.ModuleConfig.SerialConfig
 */
type ModuleConfig_SerialConfig = Message<"meshtastic.ModuleConfig.SerialConfig"> & {
  /**
   *
   * Preferences for the SerialModule
   *
   * @generated from field: bool enabled = 1;
   */
  enabled: boolean;
  /**
   *
   * TODO: REPLACE
   *
   * @generated from field: bool echo = 2;
   */
  echo: boolean;
  /**
   *
   * RX pin (should match Arduino gpio pin number)
   *
   * @generated from field: uint32 rxd = 3;
   */
  rxd: number;
  /**
   *
   * TX pin (should match Arduino gpio pin number)
   *
   * @generated from field: uint32 txd = 4;
   */
  txd: number;
  /**
   *
   * Serial baud rate
   *
   * @generated from field: meshtastic.ModuleConfig.SerialConfig.Serial_Baud baud = 5;
   */
  baud: ModuleConfig_SerialConfig_Serial_Baud;
  /**
   *
   * TODO: REPLACE
   *
   * @generated from field: uint32 timeout = 6;
   */
  timeout: number;
  /**
   *
   * Mode for serial module operation
   *
   * @generated from field: meshtastic.ModuleConfig.SerialConfig.Serial_Mode mode = 7;
   */
  mode: ModuleConfig_SerialConfig_Serial_Mode;
  /**
   *
   * Overrides the platform's defacto Serial port instance to use with Serial module config settings
   * This is currently only usable in output modes like NMEA / CalTopo and may behave strangely or not work at all in other modes
   * Existing logging over the Serial Console will still be present
   *
   * @generated from field: bool override_console_serial_port = 8;
   */
  overrideConsoleSerialPort: boolean;
};
/**
 * Describes the message meshtastic.ModuleConfig.SerialConfig.
 * Use `create(ModuleConfig_SerialConfigSchema)` to create a new message.
 */
declare const ModuleConfig_SerialConfigSchema: GenMessage<ModuleConfig_SerialConfig>;
/**
 *
 * TODO: REPLACE
 *
 * @generated from enum meshtastic.ModuleConfig.SerialConfig.Serial_Baud
 */
declare enum ModuleConfig_SerialConfig_Serial_Baud {
  /**
   * @generated from enum value: BAUD_DEFAULT = 0;
   */
  BAUD_DEFAULT = 0,
  /**
   * @generated from enum value: BAUD_110 = 1;
   */
  BAUD_110 = 1,
  /**
   * @generated from enum value: BAUD_300 = 2;
   */
  BAUD_300 = 2,
  /**
   * @generated from enum value: BAUD_600 = 3;
   */
  BAUD_600 = 3,
  /**
   * @generated from enum value: BAUD_1200 = 4;
   */
  BAUD_1200 = 4,
  /**
   * @generated from enum value: BAUD_2400 = 5;
   */
  BAUD_2400 = 5,
  /**
   * @generated from enum value: BAUD_4800 = 6;
   */
  BAUD_4800 = 6,
  /**
   * @generated from enum value: BAUD_9600 = 7;
   */
  BAUD_9600 = 7,
  /**
   * @generated from enum value: BAUD_19200 = 8;
   */
  BAUD_19200 = 8,
  /**
   * @generated from enum value: BAUD_38400 = 9;
   */
  BAUD_38400 = 9,
  /**
   * @generated from enum value: BAUD_57600 = 10;
   */
  BAUD_57600 = 10,
  /**
   * @generated from enum value: BAUD_115200 = 11;
   */
  BAUD_115200 = 11,
  /**
   * @generated from enum value: BAUD_230400 = 12;
   */
  BAUD_230400 = 12,
  /**
   * @generated from enum value: BAUD_460800 = 13;
   */
  BAUD_460800 = 13,
  /**
   * @generated from enum value: BAUD_576000 = 14;
   */
  BAUD_576000 = 14,
  /**
   * @generated from enum value: BAUD_921600 = 15;
   */
  BAUD_921600 = 15
}
/**
 * Describes the enum meshtastic.ModuleConfig.SerialConfig.Serial_Baud.
 */
declare const ModuleConfig_SerialConfig_Serial_BaudSchema: GenEnum<ModuleConfig_SerialConfig_Serial_Baud>;
/**
 *
 * TODO: REPLACE
 *
 * @generated from enum meshtastic.ModuleConfig.SerialConfig.Serial_Mode
 */
declare enum ModuleConfig_SerialConfig_Serial_Mode {
  /**
   * @generated from enum value: DEFAULT = 0;
   */
  DEFAULT = 0,
  /**
   * @generated from enum value: SIMPLE = 1;
   */
  SIMPLE = 1,
  /**
   * @generated from enum value: PROTO = 2;
   */
  PROTO = 2,
  /**
   * @generated from enum value: TEXTMSG = 3;
   */
  TEXTMSG = 3,
  /**
   * @generated from enum value: NMEA = 4;
   */
  NMEA = 4,
  /**
   * NMEA messages specifically tailored for CalTopo
   *
   * @generated from enum value: CALTOPO = 5;
   */
  CALTOPO = 5,
  /**
   * Ecowitt WS85 weather station
   *
   * @generated from enum value: WS85 = 6;
   */
  WS85 = 6,
  /**
   * VE.Direct is a serial protocol used by Victron Energy products
   * https://beta.ivc.no/wiki/index.php/Victron_VE_Direct_DIY_Cable
   *
   * @generated from enum value: VE_DIRECT = 7;
   */
  VE_DIRECT = 7,
  /**
   * Used to configure and view some parameters of MeshSolar.
   * https://heltec.org/project/meshsolar/
   *
   * @generated from enum value: MS_CONFIG = 8;
   */
  MS_CONFIG = 8,
  /**
   * Logs mesh traffic to the serial pins, ideal for logging via openLog or similar.
   *
   * includes other packets
   *
   * @generated from enum value: LOG = 9;
   */
  LOG = 9,
  /**
   * only text (channel & DM)
   *
   * @generated from enum value: LOGTEXT = 10;
   */
  LOGTEXT = 10
}
/**
 * Describes the enum meshtastic.ModuleConfig.SerialConfig.Serial_Mode.
 */
declare const ModuleConfig_SerialConfig_Serial_ModeSchema: GenEnum<ModuleConfig_SerialConfig_Serial_Mode>;
/**
 *
 * External Notifications Config
 *
 * @generated from message meshtastic.ModuleConfig.ExternalNotificationConfig
 */
type ModuleConfig_ExternalNotificationConfig = Message<"meshtastic.ModuleConfig.ExternalNotificationConfig"> & {
  /**
   *
   * Enable the ExternalNotificationModule
   *
   * @generated from field: bool enabled = 1;
   */
  enabled: boolean;
  /**
   *
   * When using in On/Off mode, keep the output on for this many
   * milliseconds. Default 1000ms (1 second).
   *
   * @generated from field: uint32 output_ms = 2;
   */
  outputMs: number;
  /**
   *
   * Define the output pin GPIO setting Defaults to
   * EXT_NOTIFY_OUT if set for the board.
   * In standalone devices this pin should drive the LED to match the UI.
   *
   * @generated from field: uint32 output = 3;
   */
  output: number;
  /**
   *
   * Optional: Define a secondary output pin for a vibra motor
   * This is used in standalone devices to match the UI.
   *
   * @generated from field: uint32 output_vibra = 8;
   */
  outputVibra: number;
  /**
   *
   * Optional: Define a tertiary output pin for an active buzzer
   * This is used in standalone devices to to match the UI.
   *
   * @generated from field: uint32 output_buzzer = 9;
   */
  outputBuzzer: number;
  /**
   *
   * IF this is true, the 'output' Pin will be pulled active high, false
   * means active low.
   *
   * @generated from field: bool active = 4;
   */
  active: boolean;
  /**
   *
   * True: Alert when a text message arrives (output)
   *
   * @generated from field: bool alert_message = 5;
   */
  alertMessage: boolean;
  /**
   *
   * True: Alert when a text message arrives (output_vibra)
   *
   * @generated from field: bool alert_message_vibra = 10;
   */
  alertMessageVibra: boolean;
  /**
   *
   * True: Alert when a text message arrives (output_buzzer)
   *
   * @generated from field: bool alert_message_buzzer = 11;
   */
  alertMessageBuzzer: boolean;
  /**
   *
   * True: Alert when the bell character is received (output)
   *
   * @generated from field: bool alert_bell = 6;
   */
  alertBell: boolean;
  /**
   *
   * True: Alert when the bell character is received (output_vibra)
   *
   * @generated from field: bool alert_bell_vibra = 12;
   */
  alertBellVibra: boolean;
  /**
   *
   * True: Alert when the bell character is received (output_buzzer)
   *
   * @generated from field: bool alert_bell_buzzer = 13;
   */
  alertBellBuzzer: boolean;
  /**
   *
   * use a PWM output instead of a simple on/off output. This will ignore
   * the 'output', 'output_ms' and 'active' settings and use the
   * device.buzzer_gpio instead.
   *
   * @generated from field: bool use_pwm = 7;
   */
  usePwm: boolean;
  /**
   *
   * The notification will toggle with 'output_ms' for this time of seconds.
   * Default is 0 which means don't repeat at all. 60 would mean blink
   * and/or beep for 60 seconds
   *
   * @generated from field: uint32 nag_timeout = 14;
   */
  nagTimeout: number;
  /**
   *
   * When true, enables devices with native I2S audio output to use the RTTTL over speaker like a buzzer
   * T-Watch S3 and T-Deck for example have this capability
   *
   * @generated from field: bool use_i2s_as_buzzer = 15;
   */
  useI2sAsBuzzer: boolean;
};
/**
 * Describes the message meshtastic.ModuleConfig.ExternalNotificationConfig.
 * Use `create(ModuleConfig_ExternalNotificationConfigSchema)` to create a new message.
 */
declare const ModuleConfig_ExternalNotificationConfigSchema: GenMessage<ModuleConfig_ExternalNotificationConfig>;
/**
 *
 * Store and Forward Module Config
 *
 * @generated from message meshtastic.ModuleConfig.StoreForwardConfig
 */
type ModuleConfig_StoreForwardConfig = Message<"meshtastic.ModuleConfig.StoreForwardConfig"> & {
  /**
   *
   * Enable the Store and Forward Module
   *
   * @generated from field: bool enabled = 1;
   */
  enabled: boolean;
  /**
   *
   * TODO: REPLACE
   *
   * @generated from field: bool heartbeat = 2;
   */
  heartbeat: boolean;
  /**
   *
   * TODO: REPLACE
   *
   * @generated from field: uint32 records = 3;
   */
  records: number;
  /**
   *
   * TODO: REPLACE
   *
   * @generated from field: uint32 history_return_max = 4;
   */
  historyReturnMax: number;
  /**
   *
   * TODO: REPLACE
   *
   * @generated from field: uint32 history_return_window = 5;
   */
  historyReturnWindow: number;
  /**
   *
   * Set to true to let this node act as a server that stores received messages and resends them upon request.
   *
   * @generated from field: bool is_server = 6;
   */
  isServer: boolean;
};
/**
 * Describes the message meshtastic.ModuleConfig.StoreForwardConfig.
 * Use `create(ModuleConfig_StoreForwardConfigSchema)` to create a new message.
 */
declare const ModuleConfig_StoreForwardConfigSchema: GenMessage<ModuleConfig_StoreForwardConfig>;
/**
 *
 * Preferences for the RangeTestModule
 *
 * @generated from message meshtastic.ModuleConfig.RangeTestConfig
 */
type ModuleConfig_RangeTestConfig = Message<"meshtastic.ModuleConfig.RangeTestConfig"> & {
  /**
   *
   * Enable the Range Test Module
   *
   * @generated from field: bool enabled = 1;
   */
  enabled: boolean;
  /**
   *
   * Send out range test messages from this node
   *
   * @generated from field: uint32 sender = 2;
   */
  sender: number;
  /**
   *
   * Bool value indicating that this node should save a RangeTest.csv file.
   * ESP32 Only
   *
   * @generated from field: bool save = 3;
   */
  save: boolean;
  /**
   *
   * Bool indicating that the node should cleanup / destroy it's RangeTest.csv file.
   * ESP32 Only
   *
   * @generated from field: bool clear_on_reboot = 4;
   */
  clearOnReboot: boolean;
};
/**
 * Describes the message meshtastic.ModuleConfig.RangeTestConfig.
 * Use `create(ModuleConfig_RangeTestConfigSchema)` to create a new message.
 */
declare const ModuleConfig_RangeTestConfigSchema: GenMessage<ModuleConfig_RangeTestConfig>;
/**
 *
 * Configuration for both device and environment metrics
 *
 * @generated from message meshtastic.ModuleConfig.TelemetryConfig
 */
type ModuleConfig_TelemetryConfig = Message<"meshtastic.ModuleConfig.TelemetryConfig"> & {
  /**
   *
   * Interval in seconds of how often we should try to send our
   * device metrics to the mesh
   *
   * @generated from field: uint32 device_update_interval = 1;
   */
  deviceUpdateInterval: number;
  /**
   * @generated from field: uint32 environment_update_interval = 2;
   */
  environmentUpdateInterval: number;
  /**
   *
   * Preferences for the Telemetry Module (Environment)
   * Enable/Disable the telemetry measurement module measurement collection
   *
   * @generated from field: bool environment_measurement_enabled = 3;
   */
  environmentMeasurementEnabled: boolean;
  /**
   *
   * Enable/Disable the telemetry measurement module on-device display
   *
   * @generated from field: bool environment_screen_enabled = 4;
   */
  environmentScreenEnabled: boolean;
  /**
   *
   * We'll always read the sensor in Celsius, but sometimes we might want to
   * display the results in Fahrenheit as a "user preference".
   *
   * @generated from field: bool environment_display_fahrenheit = 5;
   */
  environmentDisplayFahrenheit: boolean;
  /**
   *
   * Enable/Disable the air quality metrics
   *
   * @generated from field: bool air_quality_enabled = 6;
   */
  airQualityEnabled: boolean;
  /**
   *
   * Interval in seconds of how often we should try to send our
   * air quality metrics to the mesh
   *
   * @generated from field: uint32 air_quality_interval = 7;
   */
  airQualityInterval: number;
  /**
   *
   * Enable/disable Power metrics
   *
   * @generated from field: bool power_measurement_enabled = 8;
   */
  powerMeasurementEnabled: boolean;
  /**
   *
   * Interval in seconds of how often we should try to send our
   * power metrics to the mesh
   *
   * @generated from field: uint32 power_update_interval = 9;
   */
  powerUpdateInterval: number;
  /**
   *
   * Enable/Disable the power measurement module on-device display
   *
   * @generated from field: bool power_screen_enabled = 10;
   */
  powerScreenEnabled: boolean;
  /**
   *
   * Preferences for the (Health) Telemetry Module
   * Enable/Disable the telemetry measurement module measurement collection
   *
   * @generated from field: bool health_measurement_enabled = 11;
   */
  healthMeasurementEnabled: boolean;
  /**
   *
   * Interval in seconds of how often we should try to send our
   * health metrics to the mesh
   *
   * @generated from field: uint32 health_update_interval = 12;
   */
  healthUpdateInterval: number;
  /**
   *
   * Enable/Disable the health telemetry module on-device display
   *
   * @generated from field: bool health_screen_enabled = 13;
   */
  healthScreenEnabled: boolean;
  /**
   *
   * Enable/Disable the device telemetry module to send metrics to the mesh
   * Note: We will still send telemtry to the connected phone / client every minute over the API
   *
   * @generated from field: bool device_telemetry_enabled = 14;
   */
  deviceTelemetryEnabled: boolean;
  /**
   *
   * Enable/Disable the air quality telemetry measurement module on-device display
   *
   * @generated from field: bool air_quality_screen_enabled = 15;
   */
  airQualityScreenEnabled: boolean;
};
/**
 * Describes the message meshtastic.ModuleConfig.TelemetryConfig.
 * Use `create(ModuleConfig_TelemetryConfigSchema)` to create a new message.
 */
declare const ModuleConfig_TelemetryConfigSchema: GenMessage<ModuleConfig_TelemetryConfig>;
/**
 *
 * Canned Messages Module Config
 *
 * @generated from message meshtastic.ModuleConfig.CannedMessageConfig
 */
type ModuleConfig_CannedMessageConfig = Message<"meshtastic.ModuleConfig.CannedMessageConfig"> & {
  /**
   *
   * Enable the rotary encoder #1. This is a 'dumb' encoder sending pulses on both A and B pins while rotating.
   *
   * @generated from field: bool rotary1_enabled = 1;
   */
  rotary1Enabled: boolean;
  /**
   *
   * GPIO pin for rotary encoder A port.
   *
   * @generated from field: uint32 inputbroker_pin_a = 2;
   */
  inputbrokerPinA: number;
  /**
   *
   * GPIO pin for rotary encoder B port.
   *
   * @generated from field: uint32 inputbroker_pin_b = 3;
   */
  inputbrokerPinB: number;
  /**
   *
   * GPIO pin for rotary encoder Press port.
   *
   * @generated from field: uint32 inputbroker_pin_press = 4;
   */
  inputbrokerPinPress: number;
  /**
   *
   * Generate input event on CW of this kind.
   *
   * @generated from field: meshtastic.ModuleConfig.CannedMessageConfig.InputEventChar inputbroker_event_cw = 5;
   */
  inputbrokerEventCw: ModuleConfig_CannedMessageConfig_InputEventChar;
  /**
   *
   * Generate input event on CCW of this kind.
   *
   * @generated from field: meshtastic.ModuleConfig.CannedMessageConfig.InputEventChar inputbroker_event_ccw = 6;
   */
  inputbrokerEventCcw: ModuleConfig_CannedMessageConfig_InputEventChar;
  /**
   *
   * Generate input event on Press of this kind.
   *
   * @generated from field: meshtastic.ModuleConfig.CannedMessageConfig.InputEventChar inputbroker_event_press = 7;
   */
  inputbrokerEventPress: ModuleConfig_CannedMessageConfig_InputEventChar;
  /**
   *
   * Enable the Up/Down/Select input device. Can be RAK rotary encoder or 3 buttons. Uses the a/b/press definitions from inputbroker.
   *
   * @generated from field: bool updown1_enabled = 8;
   */
  updown1Enabled: boolean;
  /**
   *
   * Enable/disable CannedMessageModule.
   *
   * @generated from field: bool enabled = 9 [deprecated = true];
   * @deprecated
   */
  enabled: boolean;
  /**
   *
   * Input event origin accepted by the canned message module.
   * Can be e.g. "rotEnc1", "upDownEnc1", "scanAndSelect", "cardkb", "serialkb", or keyword "_any"
   *
   * @generated from field: string allow_input_source = 10 [deprecated = true];
   * @deprecated
   */
  allowInputSource: string;
  /**
   *
   * CannedMessageModule also sends a bell character with the messages.
   * ExternalNotificationModule can benefit from this feature.
   *
   * @generated from field: bool send_bell = 11;
   */
  sendBell: boolean;
};
/**
 * Describes the message meshtastic.ModuleConfig.CannedMessageConfig.
 * Use `create(ModuleConfig_CannedMessageConfigSchema)` to create a new message.
 */
declare const ModuleConfig_CannedMessageConfigSchema: GenMessage<ModuleConfig_CannedMessageConfig>;
/**
 *
 * TODO: REPLACE
 *
 * @generated from enum meshtastic.ModuleConfig.CannedMessageConfig.InputEventChar
 */
declare enum ModuleConfig_CannedMessageConfig_InputEventChar {
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: NONE = 0;
   */
  NONE = 0,
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: UP = 17;
   */
  UP = 17,
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: DOWN = 18;
   */
  DOWN = 18,
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: LEFT = 19;
   */
  LEFT = 19,
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: RIGHT = 20;
   */
  RIGHT = 20,
  /**
   *
   * '\n'
   *
   * @generated from enum value: SELECT = 10;
   */
  SELECT = 10,
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: BACK = 27;
   */
  BACK = 27,
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: CANCEL = 24;
   */
  CANCEL = 24
}
/**
 * Describes the enum meshtastic.ModuleConfig.CannedMessageConfig.InputEventChar.
 */
declare const ModuleConfig_CannedMessageConfig_InputEventCharSchema: GenEnum<ModuleConfig_CannedMessageConfig_InputEventChar>;
/**
 *
 * Ambient Lighting Module - Settings for control of onboard LEDs to allow users to adjust the brightness levels and respective color levels.
 * Initially created for the RAK14001 RGB LED module.
 *
 * @generated from message meshtastic.ModuleConfig.AmbientLightingConfig
 */
type ModuleConfig_AmbientLightingConfig = Message<"meshtastic.ModuleConfig.AmbientLightingConfig"> & {
  /**
   *
   * Sets LED to on or off.
   *
   * @generated from field: bool led_state = 1;
   */
  ledState: boolean;
  /**
   *
   * Sets the current for the LED output. Default is 10.
   *
   * @generated from field: uint32 current = 2;
   */
  current: number;
  /**
   *
   * Sets the red LED level. Values are 0-255.
   *
   * @generated from field: uint32 red = 3;
   */
  red: number;
  /**
   *
   * Sets the green LED level. Values are 0-255.
   *
   * @generated from field: uint32 green = 4;
   */
  green: number;
  /**
   *
   * Sets the blue LED level. Values are 0-255.
   *
   * @generated from field: uint32 blue = 5;
   */
  blue: number;
};
/**
 * Describes the message meshtastic.ModuleConfig.AmbientLightingConfig.
 * Use `create(ModuleConfig_AmbientLightingConfigSchema)` to create a new message.
 */
declare const ModuleConfig_AmbientLightingConfigSchema: GenMessage<ModuleConfig_AmbientLightingConfig>;
/**
 *
 * StatusMessage config - Allows setting a status message for a node to periodically rebroadcast
 *
 * @generated from message meshtastic.ModuleConfig.StatusMessageConfig
 */
type ModuleConfig_StatusMessageConfig = Message<"meshtastic.ModuleConfig.StatusMessageConfig"> & {
  /**
   *
   * The actual status string
   *
   * @generated from field: string node_status = 1;
   */
  nodeStatus: string;
};
/**
 * Describes the message meshtastic.ModuleConfig.StatusMessageConfig.
 * Use `create(ModuleConfig_StatusMessageConfigSchema)` to create a new message.
 */
declare const ModuleConfig_StatusMessageConfigSchema: GenMessage<ModuleConfig_StatusMessageConfig>;
/**
 *
 * MeshBeacon module config
 *
 * @generated from message meshtastic.ModuleConfig.MeshBeaconConfig
 */
type ModuleConfig_MeshBeaconConfig = Message<"meshtastic.ModuleConfig.MeshBeaconConfig"> & {
  /**
   *
   * Bitwise-OR of Flags values (listen / broadcast / legacy-split toggles).
   *
   * @generated from field: uint32 flags = 1;
   */
  flags: number;
  /**
   *
   * Message to include in each beacon broadcast. Max 100 bytes enforced by firmware.
   *
   * @generated from field: string broadcast_message = 4;
   */
  broadcastMessage: string;
  /**
   *
   * Optional channel (name + PSK) to advertise in the MeshBeacon offer_channel field.
   *
   * @generated from field: meshtastic.ChannelSettings broadcast_offer_channel = 5;
   */
  broadcastOfferChannel?: ChannelSettings;
  /**
   *
   * Optional region to advertise in the MeshBeacon offer_region field.
   *
   * @generated from field: meshtastic.Config.LoRaConfig.RegionCode broadcast_offer_region = 6;
   */
  broadcastOfferRegion: Config_LoRaConfig_RegionCode;
  /**
   *
   * Optional modem preset to advertise in the MeshBeacon offer_preset field.
   *
   * @generated from field: optional meshtastic.Config.LoRaConfig.ModemPreset broadcast_offer_preset = 7;
   */
  broadcastOfferPreset?: Config_LoRaConfig_ModemPreset;
  /**
   *
   * How often to broadcast, in seconds. Min 3600 (1 h), default 3600.
   *
   * @generated from field: uint32 broadcast_interval_secs = 11;
   */
  broadcastIntervalSecs: number;
  /**
   *
   * Broadcast destination list.
   * The broadcaster sends one beacon copy per distinct destination, in sequence, temporarily
   * switching the radio to that entry's preset/region/channel for each.
   * When empty, a single beacon is sent on the node's running preset and region over the
   * primary channel.
   * Entries that resolve to the same effective preset, region and channel are deduplicated, so
   * a duplicate entry does not produce a second transmission.
   *
   * @generated from field: repeated meshtastic.ModuleConfig.MeshBeaconConfig.BroadcastTarget broadcast_targets = 13;
   */
  broadcastTargets: ModuleConfig_MeshBeaconConfig_BroadcastTarget[];
};
/**
 * Describes the message meshtastic.ModuleConfig.MeshBeaconConfig.
 * Use `create(ModuleConfig_MeshBeaconConfigSchema)` to create a new message.
 */
declare const ModuleConfig_MeshBeaconConfigSchema: GenMessage<ModuleConfig_MeshBeaconConfig>;
/**
 *
 * One entry in the broadcast destination list.
 * Each entry names one set of radio settings to send a beacon copy on.
 *
 * @generated from message meshtastic.ModuleConfig.MeshBeaconConfig.BroadcastTarget
 */
type ModuleConfig_MeshBeaconConfig_BroadcastTarget = Message<"meshtastic.ModuleConfig.MeshBeaconConfig.BroadcastTarget"> & {
  /**
   *
   * Modem preset to use for this target.
   * Falls back to the running config preset if unset.
   *
   * @generated from field: optional meshtastic.Config.LoRaConfig.ModemPreset preset = 1;
   */
  preset?: Config_LoRaConfig_ModemPreset;
  /**
   *
   * Region to use for this target. UNSET means use the running config region.
   *
   * @generated from field: meshtastic.Config.LoRaConfig.RegionCode region = 2;
   */
  region: Config_LoRaConfig_RegionCode;
  /**
   *
   * Index into the device's channel table (0..MAX_NUM_CHANNELS-1) of the channel to
   * transmit this target's beacon on. The referenced channel must already be configured
   * on the node (its key is needed to encrypt). If unset, the default channel for the
   * preset is used.
   *
   * @generated from field: optional uint32 channel_index = 4;
   */
  channelIndex?: number;
};
/**
 * Describes the message meshtastic.ModuleConfig.MeshBeaconConfig.BroadcastTarget.
 * Use `create(ModuleConfig_MeshBeaconConfig_BroadcastTargetSchema)` to create a new message.
 */
declare const ModuleConfig_MeshBeaconConfig_BroadcastTargetSchema: GenMessage<ModuleConfig_MeshBeaconConfig_BroadcastTarget>;
/**
 *
 * Boolean options for the beacon module, packed into the `flags` bitfield below.
 * OR the FLAG_* values together; a flag is on when its bit is set.
 *
 * @generated from enum meshtastic.ModuleConfig.MeshBeaconConfig.Flags
 */
declare enum ModuleConfig_MeshBeaconConfig_Flags {
  /**
   *
   * No options enabled.
   *
   * @generated from enum value: FLAG_NONE = 0;
   */
  FLAG_NONE = 0,
  /**
   *
   * Enable receiving MESH_BEACON_APP packets from other nodes.
   * The text portion is delivered to the local message inbox.
   * Offered channel/preset are stored for the client app to act on.
   *
   * @generated from enum value: FLAG_LISTEN_ENABLED = 1;
   */
  FLAG_LISTEN_ENABLED = 1,
  /**
   *
   * Enable periodically broadcasting MESH_BEACON_APP packets from this node.
   *
   * @generated from enum value: FLAG_BROADCAST_ENABLED = 2;
   */
  FLAG_BROADCAST_ENABLED = 2,
  /**
   *
   * When both text and offer content are present, split the beacon into a separate
   * MESH_BEACON_APP (offer only) and TEXT_MESSAGE_APP (text only) packet, so firmware
   * that only decodes TEXT_MESSAGE_APP still receives the human-readable text.
   *
   * @generated from enum value: FLAG_LEGACY_SPLIT = 4;
   */
  FLAG_LEGACY_SPLIT = 4
}
/**
 * Describes the enum meshtastic.ModuleConfig.MeshBeaconConfig.Flags.
 */
declare const ModuleConfig_MeshBeaconConfig_FlagsSchema: GenEnum<ModuleConfig_MeshBeaconConfig_Flags>;
/**
 *
 * TAK team/role configuration
 *
 * @generated from message meshtastic.ModuleConfig.TAKConfig
 */
type ModuleConfig_TAKConfig = Message<"meshtastic.ModuleConfig.TAKConfig"> & {
  /**
   *
   * Team color.
   * Default Unspecifed_Color -> firmware uses Cyan
   *
   * @generated from field: meshtastic.Team team = 1;
   */
  team: Team;
  /**
   *
   * Member role.
   * Default Unspecifed -> firmware uses TeamMember
   *
   * @generated from field: meshtastic.MemberRole role = 2;
   */
  role: MemberRole;
};
/**
 * Describes the message meshtastic.ModuleConfig.TAKConfig.
 * Use `create(ModuleConfig_TAKConfigSchema)` to create a new message.
 */
declare const ModuleConfig_TAKConfigSchema: GenMessage<ModuleConfig_TAKConfig>;
/**
 *
 * A GPIO pin definition for remote hardware module
 *
 * @generated from message meshtastic.RemoteHardwarePin
 */
type RemoteHardwarePin = Message<"meshtastic.RemoteHardwarePin"> & {
  /**
   *
   * GPIO Pin number (must match Arduino)
   *
   * @generated from field: uint32 gpio_pin = 1;
   */
  gpioPin: number;
  /**
   *
   * Name for the GPIO pin (i.e. Front gate, mailbox, etc)
   *
   * @generated from field: string name = 2;
   */
  name: string;
  /**
   *
   * Type of GPIO access available to consumers on the mesh
   *
   * @generated from field: meshtastic.RemoteHardwarePinType type = 3;
   */
  type: RemoteHardwarePinType;
};
/**
 * Describes the message meshtastic.RemoteHardwarePin.
 * Use `create(RemoteHardwarePinSchema)` to create a new message.
 */
declare const RemoteHardwarePinSchema: GenMessage<RemoteHardwarePin>;
/**
 * @generated from enum meshtastic.RemoteHardwarePinType
 */
declare enum RemoteHardwarePinType {
  /**
   *
   * Unset/unused
   *
   * @generated from enum value: UNKNOWN = 0;
   */
  UNKNOWN = 0,
  /**
   *
   * GPIO pin can be read (if it is high / low)
   *
   * @generated from enum value: DIGITAL_READ = 1;
   */
  DIGITAL_READ = 1,
  /**
   *
   * GPIO pin can be written to (high / low)
   *
   * @generated from enum value: DIGITAL_WRITE = 2;
   */
  DIGITAL_WRITE = 2
}
/**
 * Describes the enum meshtastic.RemoteHardwarePinType.
 */
declare const RemoteHardwarePinTypeSchema: GenEnum<RemoteHardwarePinType>;
declare namespace portnums_pb_d_exports {
  export { PortNum, PortNumSchema, file_meshtastic_portnums };
}
/**
 * Describes the file meshtastic/portnums.proto.
 */
declare const file_meshtastic_portnums: GenFile;
/**
 *
 * For any new 'apps' that run on the device or via sister apps on phones/PCs they should pick and use a
 * unique 'portnum' for their application.
 * If you are making a new app using meshtastic, please send in a pull request to add your 'portnum' to this
 * master table.
 * PortNums should be assigned in the following range:
 * 0-63   Core Meshtastic use, do not use for third party apps
 * 64-127 Registered 3rd party apps, send in a pull request that adds a new entry to portnums.proto to  register your application
 * 256-511 Use one of these portnums for your private applications that you don't want to register publically
 * All other values are reserved.
 * Note: This was formerly a Type enum named 'typ' with the same id #
 * We have change to this 'portnum' based scheme for specifying app handlers for particular payloads.
 * This change is backwards compatible by treating the legacy OPAQUE/CLEAR_TEXT values identically.
 *
 * @generated from enum meshtastic.PortNum
 */
declare enum PortNum {
  /**
   *
   * Deprecated: do not use in new code (formerly called OPAQUE)
   * A message sent from a device outside of the mesh, in a form the mesh does not understand
   * NOTE: This must be 0, because it is documented in IMeshService.aidl to be so
   * ENCODING: binary undefined
   *
   * @generated from enum value: UNKNOWN_APP = 0;
   */
  UNKNOWN_APP = 0,
  /**
   *
   * A simple UTF-8 text message, which even the little micros in the mesh
   * can understand and show on their screen eventually in some circumstances
   * even signal might send messages in this form (see below)
   * ENCODING: UTF-8 Plaintext (?)
   *
   * @generated from enum value: TEXT_MESSAGE_APP = 1;
   */
  TEXT_MESSAGE_APP = 1,
  /**
   *
   * Reserved for built-in GPIO/example app.
   * See remote_hardware.proto/HardwareMessage for details on the message sent/received to this port number
   * ENCODING: Protobuf
   *
   * @generated from enum value: REMOTE_HARDWARE_APP = 2;
   */
  REMOTE_HARDWARE_APP = 2,
  /**
   *
   * The built-in position messaging app.
   * Payload is a Position message.
   * ENCODING: Protobuf
   *
   * @generated from enum value: POSITION_APP = 3;
   */
  POSITION_APP = 3,
  /**
   *
   * The built-in user info app.
   * Payload is a User message.
   * ENCODING: Protobuf
   *
   * @generated from enum value: NODEINFO_APP = 4;
   */
  NODEINFO_APP = 4,
  /**
   *
   * Protocol control packets for mesh protocol use.
   * Payload is a Routing message.
   * ENCODING: Protobuf
   *
   * @generated from enum value: ROUTING_APP = 5;
   */
  ROUTING_APP = 5,
  /**
   *
   * Admin control packets.
   * Payload is a AdminMessage message.
   * ENCODING: Protobuf
   *
   * @generated from enum value: ADMIN_APP = 6;
   */
  ADMIN_APP = 6,
  /**
   *
   * Compressed TEXT_MESSAGE payloads.
   * ENCODING: UTF-8 Plaintext (?) with Unishox2 Compression
   * NOTE: The Device Firmware converts a TEXT_MESSAGE_APP to TEXT_MESSAGE_COMPRESSED_APP if the compressed
   * payload is shorter. There's no need for app developers to do this themselves. Also the firmware will decompress
   * any incoming TEXT_MESSAGE_COMPRESSED_APP payload and convert to TEXT_MESSAGE_APP.
   *
   * @generated from enum value: TEXT_MESSAGE_COMPRESSED_APP = 7;
   */
  TEXT_MESSAGE_COMPRESSED_APP = 7,
  /**
   *
   * Waypoint payloads.
   * Payload is a Waypoint message.
   * ENCODING: Protobuf
   *
   * @generated from enum value: WAYPOINT_APP = 8;
   */
  WAYPOINT_APP = 8,
  /**
   *
   * Audio Payloads.
   * Encapsulated codec2 packets. On 2.4 GHZ Bandwidths only for now
   * ENCODING: codec2 audio frames
   * NOTE: audio frames contain a 3 byte header (0xc0 0xde 0xc2) and a one byte marker for the decompressed bitrate.
   * This marker comes from the 'moduleConfig.audio.bitrate' enum minus one.
   *
   * @generated from enum value: AUDIO_APP = 9;
   */
  AUDIO_APP = 9,
  /**
   *
   * Same as Text Message but originating from Detection Sensor Module.
   * NOTE: This portnum traffic is not sent to the public MQTT starting at firmware version 2.2.9
   *
   * @generated from enum value: DETECTION_SENSOR_APP = 10;
   */
  DETECTION_SENSOR_APP = 10,
  /**
   *
   * Same as Text Message but used for critical alerts.
   *
   * @generated from enum value: ALERT_APP = 11;
   */
  ALERT_APP = 11,
  /**
   *
   * Module/port for handling key verification requests.
   *
   * @generated from enum value: KEY_VERIFICATION_APP = 12;
   */
  KEY_VERIFICATION_APP = 12,
  /**
   *
   * Module/port for handling primitive remote shell access.
   *
   * @generated from enum value: REMOTE_SHELL_APP = 13;
   */
  REMOTE_SHELL_APP = 13,
  /**
   *
   * Provides a 'ping' service that replies to any packet it receives.
   * Also serves as a small example module.
   * ENCODING: ASCII Plaintext
   *
   * @generated from enum value: REPLY_APP = 32;
   */
  REPLY_APP = 32,
  /**
   *
   * Used for the python IP tunnel feature
   * ENCODING: IP Packet. Handled by the python API, firmware ignores this one and pases on.
   *
   * @generated from enum value: IP_TUNNEL_APP = 33;
   */
  IP_TUNNEL_APP = 33,
  /**
   *
   * Paxcounter lib included in the firmware
   * ENCODING: protobuf
   *
   * @generated from enum value: PAXCOUNTER_APP = 34;
   */
  PAXCOUNTER_APP = 34,
  /**
   *
   * Store and Forward++ module included in the firmware
   * ENCODING: protobuf
   * This module is specifically for Native Linux nodes, and provides a Git-style
   * chain of messages.
   *
   * @generated from enum value: STORE_FORWARD_PLUSPLUS_APP = 35;
   */
  STORE_FORWARD_PLUSPLUS_APP = 35,
  /**
   *
   * Node Status module
   * ENCODING: protobuf
   * This module allows setting an extra string of status for a node.
   * Broadcasts on change and on a timer, possibly once a day.
   *
   * @generated from enum value: NODE_STATUS_APP = 36;
   */
  NODE_STATUS_APP = 36,
  /**
   *
   * Beacon module broadcast packets.
   * ENCODING: protobuf
   * Periodically broadcast by nodes in beacon mode; received by nodes with MeshBeaconConfig.FLAG_LISTEN_ENABLED.
   * Carries a text message plus optional channel/preset offers for client apps.
   *
   * @generated from enum value: MESH_BEACON_APP = 37;
   */
  MESH_BEACON_APP = 37,
  /**
   *
   * Provides a hardware serial interface to send and receive from the Meshtastic network.
   * Connect to the RX/TX pins of a device with 38400 8N1. Packets received from the Meshtastic
   * network is forwarded to the RX pin while sending a packet to TX will go out to the Mesh network.
   * Maximum packet size of 240 bytes.
   * Module is disabled by default can be turned on by setting SERIAL_MODULE_ENABLED = 1 in SerialPlugh.cpp.
   * ENCODING: binary undefined
   *
   * @generated from enum value: SERIAL_APP = 64;
   */
  SERIAL_APP = 64,
  /**
   *
   * STORE_FORWARD_APP (Work in Progress)
   * Maintained by Jm Casler (MC Hamster) : jm@casler.org
   * ENCODING: Protobuf
   *
   * @generated from enum value: STORE_FORWARD_APP = 65;
   */
  STORE_FORWARD_APP = 65,
  /**
   *
   * Optional port for messages for the range test module.
   * ENCODING: ASCII Plaintext
   * NOTE: This portnum traffic is not sent to the public MQTT starting at firmware version 2.2.9
   *
   * @generated from enum value: RANGE_TEST_APP = 66;
   */
  RANGE_TEST_APP = 66,
  /**
   *
   * Provides a format to send and receive telemetry data from the Meshtastic network.
   * Maintained by Charles Crossan (crossan007) : crossan007@gmail.com
   * ENCODING: Protobuf
   *
   * @generated from enum value: TELEMETRY_APP = 67;
   */
  TELEMETRY_APP = 67,
  /**
   *
   * Experimental tools for estimating node position without a GPS
   * Maintained by Github user a-f-G-U-C (a Meshtastic contributor)
   * Project files at https://github.com/a-f-G-U-C/Meshtastic-ZPS
   * ENCODING: arrays of int64 fields
   *
   * @generated from enum value: ZPS_APP = 68;
   */
  ZPS_APP = 68,
  /**
   *
   * Used to let multiple instances of Linux native applications communicate
   * as if they did using their LoRa chip.
   * Maintained by GitHub user GUVWAF.
   * Project files at https://github.com/GUVWAF/Meshtasticator
   * ENCODING: Protobuf (?)
   *
   * @generated from enum value: SIMULATOR_APP = 69;
   */
  SIMULATOR_APP = 69,
  /**
   *
   * Provides a traceroute functionality to show the route a packet towards
   * a certain destination would take on the mesh. Contains a RouteDiscovery message as payload.
   * ENCODING: Protobuf
   *
   * @generated from enum value: TRACEROUTE_APP = 70;
   */
  TRACEROUTE_APP = 70,
  /**
   *
   * Aggregates edge info for the network by sending out a list of each node's neighbors
   * ENCODING: Protobuf
   *
   * @generated from enum value: NEIGHBORINFO_APP = 71;
   */
  NEIGHBORINFO_APP = 71,
  /**
   *
   * ATAK Plugin
   * Portnum for payloads from the official Meshtastic ATAK plugin
   *
   * @generated from enum value: ATAK_PLUGIN = 72;
   */
  ATAK_PLUGIN = 72,
  /**
   *
   * Provides unencrypted information about a node for consumption by a map via MQTT
   *
   * @generated from enum value: MAP_REPORT_APP = 73;
   */
  MAP_REPORT_APP = 73,
  /**
   *
   * PowerStress based monitoring support (for automated power consumption testing)
   *
   * @generated from enum value: POWERSTRESS_APP = 74;
   */
  POWERSTRESS_APP = 74,
  /**
   *
   * LoraWAN Payload Transport
   * ENCODING: compact binary LoRaWAN uplink (10-byte RF metadata + PHY payload) - see LoRaWANBridgeModule
   *
   * @generated from enum value: LORAWAN_BRIDGE = 75;
   */
  LORAWAN_BRIDGE = 75,
  /**
   *
   * Reticulum Network Stack Tunnel App
   * ENCODING: Fragmented RNS Packet. Handled by Meshtastic RNS interface
   *
   * @generated from enum value: RETICULUM_TUNNEL_APP = 76;
   */
  RETICULUM_TUNNEL_APP = 76,
  /**
   *
   * App for transporting Cayenne Low Power Payload, popular for LoRaWAN sensor nodes. Offers ability to send
   * arbitrary telemetry over meshtastic that is not covered by telemetry.proto
   * ENCODING: CayenneLLP
   *
   * @generated from enum value: CAYENNE_APP = 77;
   */
  CAYENNE_APP = 77,
  /**
   *
   * ATAK Plugin V2
   * Portnum for payloads from the official Meshtastic ATAK plugin using
   * TAKPacketV2 with zstd dictionary compression.
   *
   * @generated from enum value: ATAK_PLUGIN_V2 = 78;
   */
  ATAK_PLUGIN_V2 = 78,
  /**
   * signed firmware updates over lora.
   *
   * ENCODING: binary (ota-common transport frames)
   *
   * @generated from enum value: LORA_OTA_APP = 79;
   */
  LORA_OTA_APP = 79,
  /**
   *
   * GroupAlarm integration
   * Used for transporting GroupAlarm-related messages between Meshtastic nodes
   * and companion applications/services.
   *
   * @generated from enum value: GROUPALARM_APP = 112;
   */
  GROUPALARM_APP = 112,
  /**
   *
   * Private applications should use portnums >= 256.
   * To simplify initial development and testing you can use "PRIVATE_APP"
   * in your code without needing to rebuild protobuf files (via [regen-protos.sh](https://github.com/meshtastic/firmware/blob/master/bin/regen-protos.sh))
   *
   * @generated from enum value: PRIVATE_APP = 256;
   */
  PRIVATE_APP = 256,
  /**
   *
   * ATAK Forwarder Module https://github.com/paulmandal/atak-forwarder
   * ENCODING: libcotshrink
   *
   * @generated from enum value: ATAK_FORWARDER = 257;
   */
  ATAK_FORWARDER = 257,
  /**
   *
   * Currently we limit port nums to no higher than this value
   *
   * @generated from enum value: MAX = 511;
   */
  MAX = 511
}
/**
 * Describes the enum meshtastic.PortNum.
 */
declare const PortNumSchema: GenEnum<PortNum>;
declare namespace telemetry_pb_d_exports {
  export { AS3935Config, AS3935ConfigSchema, AirQualityMetrics, AirQualityMetricsSchema, DeviceMetrics, DeviceMetricsSchema, EnvironmentMetrics, EnvironmentMetricsSchema, HealthMetrics, HealthMetricsSchema, HostMetrics, HostMetricsSchema, LocalStats, LocalStatsSchema, Nau7802Config, Nau7802ConfigSchema, PowerMetrics, PowerMetricsSchema, SEN5XState, SEN5XStateSchema, SEN6XState, SEN6XStateSchema, Telemetry, TelemetrySchema, TelemetrySensorType, TelemetrySensorTypeSchema, TrafficManagementStats, TrafficManagementStatsSchema, file_meshtastic_telemetry };
}
/**
 * Describes the file meshtastic/telemetry.proto.
 */
declare const file_meshtastic_telemetry: GenFile;
/**
 *
 * Key native device metrics such as battery level
 *
 * @generated from message meshtastic.DeviceMetrics
 */
type DeviceMetrics = Message<"meshtastic.DeviceMetrics"> & {
  /**
   *
   * 0-100 (>100 means powered)
   *
   * @generated from field: optional uint32 battery_level = 1;
   */
  batteryLevel?: number;
  /**
   *
   * Voltage measured
   *
   * @generated from field: optional float voltage = 2;
   */
  voltage?: number;
  /**
   *
   * Utilization for the current channel, including well formed TX, RX and malformed RX (aka noise).
   *
   * @generated from field: optional float channel_utilization = 3;
   */
  channelUtilization?: number;
  /**
   *
   * Percent of airtime for transmission used within the last hour.
   *
   * @generated from field: optional float air_util_tx = 4;
   */
  airUtilTx?: number;
  /**
   *
   * How long the device has been running since the last reboot (in seconds)
   *
   * @generated from field: optional uint32 uptime_seconds = 5;
   */
  uptimeSeconds?: number;
};
/**
 * Describes the message meshtastic.DeviceMetrics.
 * Use `create(DeviceMetricsSchema)` to create a new message.
 */
declare const DeviceMetricsSchema: GenMessage<DeviceMetrics>;
/**
 *
 * Weather station or other environmental metrics
 *
 * @generated from message meshtastic.EnvironmentMetrics
 */
type EnvironmentMetrics = Message<"meshtastic.EnvironmentMetrics"> & {
  /**
   *
   * Temperature measured
   *
   * @generated from field: optional float temperature = 1;
   */
  temperature?: number;
  /**
   *
   * Relative humidity percent measured
   *
   * @generated from field: optional float relative_humidity = 2;
   */
  relativeHumidity?: number;
  /**
   *
   * Barometric pressure in hPA measured
   *
   * @generated from field: optional float barometric_pressure = 3;
   */
  barometricPressure?: number;
  /**
   *
   * Gas resistance in MOhm measured
   *
   * @generated from field: optional float gas_resistance = 4;
   */
  gasResistance?: number;
  /**
   *
   * Voltage measured (To be depreciated in favor of PowerMetrics in Meshtastic 3.x)
   *
   * @generated from field: optional float voltage = 5;
   */
  voltage?: number;
  /**
   *
   * Current measured (To be depreciated in favor of PowerMetrics in Meshtastic 3.x)
   *
   * @generated from field: optional float current = 6;
   */
  current?: number;
  /**
   *
   * relative scale IAQ value as measured by Bosch BME680 . value 0-500.
   * Belongs to Air Quality but is not particle but VOC measurement. Other VOC values can also be put in here.
   *
   * @generated from field: optional uint32 iaq = 7;
   */
  iaq?: number;
  /**
   *
   * RCWL9620 Doppler Radar Distance Sensor, used for water level detection. Float value in mm.
   *
   * @generated from field: optional float distance = 8;
   */
  distance?: number;
  /**
   *
   * VEML7700 high accuracy ambient light(Lux) digital 16-bit resolution sensor.
   *
   * @generated from field: optional float lux = 9;
   */
  lux?: number;
  /**
   *
   * VEML7700 high accuracy white light(irradiance) not calibrated digital 16-bit resolution sensor.
   *
   * @generated from field: optional float white_lux = 10;
   */
  whiteLux?: number;
  /**
   *
   * Infrared lux
   *
   * @generated from field: optional float ir_lux = 11;
   */
  irLux?: number;
  /**
   *
   * Ultraviolet lux
   *
   * @generated from field: optional float uv_lux = 12;
   */
  uvLux?: number;
  /**
   *
   * Wind direction in degrees
   * 0 degrees = North, 90 = East, etc...
   *
   * @generated from field: optional uint32 wind_direction = 13;
   */
  windDirection?: number;
  /**
   *
   * Wind speed in m/s
   *
   * @generated from field: optional float wind_speed = 14;
   */
  windSpeed?: number;
  /**
   *
   * Weight in KG
   *
   * @generated from field: optional float weight = 15;
   */
  weight?: number;
  /**
   *
   * Wind gust in m/s
   *
   * @generated from field: optional float wind_gust = 16;
   */
  windGust?: number;
  /**
   *
   * Wind lull in m/s
   *
   * @generated from field: optional float wind_lull = 17;
   */
  windLull?: number;
  /**
   *
   * Radiation in µR/h
   *
   * @generated from field: optional float radiation = 18;
   */
  radiation?: number;
  /**
   *
   * Rainfall in the last hour in mm
   *
   * @generated from field: optional float rainfall_1h = 19;
   */
  rainfall1h?: number;
  /**
   *
   * Rainfall in the last 24 hours in mm
   *
   * @generated from field: optional float rainfall_24h = 20;
   */
  rainfall24h?: number;
  /**
   *
   * Soil moisture measured (% 1-100)
   *
   * @generated from field: optional uint32 soil_moisture = 21;
   */
  soilMoisture?: number;
  /**
   *
   * Soil temperature measured (*C)
   *
   * @generated from field: optional float soil_temperature = 22;
   */
  soilTemperature?: number;
  /**
   *
   * Never implemented, but Voltage may be mis-interpreted by old clients as temperature
   *
   * @generated from field: repeated float one_wire_temperature = 23 [deprecated = true];
   * @deprecated
   */
  oneWireTemperature: number[];
  /**
   *
   * Multi-channel ADC Voltage Channel 0 (V)
   *
   * @generated from field: optional float adc_voltage_ch0 = 24;
   */
  adcVoltageCh0?: number;
  /**
   *
   * Multi-channel ADC Voltage Channel 1 (V)
   *
   * @generated from field: optional float adc_voltage_ch1 = 25;
   */
  adcVoltageCh1?: number;
  /**
   *
   * Multi-channel ADC Voltage Channel 2 (V)
   *
   * @generated from field: optional float adc_voltage_ch2 = 26;
   */
  adcVoltageCh2?: number;
  /**
   *
   * Multi-channel ADC Voltage Channel 3 (V)
   *
   * @generated from field: optional float adc_voltage_ch3 = 27;
   */
  adcVoltageCh3?: number;
  /**
   *
   * Multi-channel ADC Voltage Channel 4 (V)
   *
   * @generated from field: optional float adc_voltage_ch4 = 28;
   */
  adcVoltageCh4?: number;
  /**
   *
   * Multi-channel ADC Voltage Channel 5 (V)
   *
   * @generated from field: optional float adc_voltage_ch5 = 29;
   */
  adcVoltageCh5?: number;
  /**
   *
   * Multi-channel ADC Voltage Channel 6 (V)
   *
   * @generated from field: optional float adc_voltage_ch6 = 30;
   */
  adcVoltageCh6?: number;
  /**
   *
   * Multi-channel ADC Voltage Channel 7 (V)
   *
   * @generated from field: optional float adc_voltage_ch7 = 31;
   */
  adcVoltageCh7?: number;
  /**
   *
   * Multi-channel One-Wire Temperature Channel 0 (*C)
   *
   * @generated from field: optional float one_wire_temperature_ch0 = 32;
   */
  oneWireTemperatureCh0?: number;
  /**
   *
   * Multi-channel One-Wire Temperature Channel 1 (*C)
   *
   * @generated from field: optional float one_wire_temperature_ch1 = 33;
   */
  oneWireTemperatureCh1?: number;
  /**
   *
   * Multi-channel One-Wire Temperature Channel 2 (*C)
   *
   * @generated from field: optional float one_wire_temperature_ch2 = 34;
   */
  oneWireTemperatureCh2?: number;
  /**
   *
   * Multi-channel One-Wire Temperature Channel 3 (*C)
   *
   * @generated from field: optional float one_wire_temperature_ch3 = 35;
   */
  oneWireTemperatureCh3?: number;
  /**
   *
   * Multi-channel One-Wire Temperature Channel 4 (*C)
   *
   * @generated from field: optional float one_wire_temperature_ch4 = 36;
   */
  oneWireTemperatureCh4?: number;
  /**
   *
   * Multi-channel One-Wire Temperature Channel 5 (*C)
   *
   * @generated from field: optional float one_wire_temperature_ch5 = 37;
   */
  oneWireTemperatureCh5?: number;
  /**
   *
   * Multi-channel One-Wire Temperature Channel 6 (*C)
   *
   * @generated from field: optional float one_wire_temperature_ch6 = 38;
   */
  oneWireTemperatureCh6?: number;
  /**
   *
   * Multi-channel One-Wire Temperature Channel 7 (*C)
   *
   * @generated from field: optional float one_wire_temperature_ch7 = 39;
   */
  oneWireTemperatureCh7?: number;
  /**
   *
   * Lightning strikes detected in the last hour
   *
   * @generated from field: optional uint32 lightning_strike_count_1h = 40;
   */
  lightningStrikeCount1h?: number;
  /**
   *
   * Estimated distance to the leading edge of the storm, in km
   *
   * @generated from field: optional float lightning_distance_km = 41;
   */
  lightningDistanceKm?: number;
};
/**
 * Describes the message meshtastic.EnvironmentMetrics.
 * Use `create(EnvironmentMetricsSchema)` to create a new message.
 */
declare const EnvironmentMetricsSchema: GenMessage<EnvironmentMetrics>;
/**
 *
 * Power Metrics (voltage / current / etc)
 *
 * @generated from message meshtastic.PowerMetrics
 */
type PowerMetrics = Message<"meshtastic.PowerMetrics"> & {
  /**
   *
   * Voltage (Ch1)
   *
   * @generated from field: optional float ch1_voltage = 1;
   */
  ch1Voltage?: number;
  /**
   *
   * Current (Ch1)
   *
   * @generated from field: optional float ch1_current = 2;
   */
  ch1Current?: number;
  /**
   *
   * Voltage (Ch2)
   *
   * @generated from field: optional float ch2_voltage = 3;
   */
  ch2Voltage?: number;
  /**
   *
   * Current (Ch2)
   *
   * @generated from field: optional float ch2_current = 4;
   */
  ch2Current?: number;
  /**
   *
   * Voltage (Ch3)
   *
   * @generated from field: optional float ch3_voltage = 5;
   */
  ch3Voltage?: number;
  /**
   *
   * Current (Ch3)
   *
   * @generated from field: optional float ch3_current = 6;
   */
  ch3Current?: number;
  /**
   *
   * Voltage (Ch4) - TODO Remove
   *
   * @generated from field: optional float ch4_voltage = 7 [deprecated = true];
   * @deprecated
   */
  ch4Voltage?: number;
  /**
   *
   * Current (Ch4) - TODO Remove
   *
   * @generated from field: optional float ch4_current = 8 [deprecated = true];
   * @deprecated
   */
  ch4Current?: number;
  /**
   *
   * Voltage (Ch5) - TODO Remove
   *
   * @generated from field: optional float ch5_voltage = 9 [deprecated = true];
   * @deprecated
   */
  ch5Voltage?: number;
  /**
   *
   * Current (Ch5) - TODO Remove
   *
   * @generated from field: optional float ch5_current = 10 [deprecated = true];
   * @deprecated
   */
  ch5Current?: number;
  /**
   *
   * Voltage (Ch6) - TODO Remove
   *
   * @generated from field: optional float ch6_voltage = 11 [deprecated = true];
   * @deprecated
   */
  ch6Voltage?: number;
  /**
   *
   * Current (Ch6) - TODO Remove
   *
   * @generated from field: optional float ch6_current = 12 [deprecated = true];
   * @deprecated
   */
  ch6Current?: number;
  /**
   *
   * Voltage (Ch7) - TODO Remove
   *
   * @generated from field: optional float ch7_voltage = 13 [deprecated = true];
   * @deprecated
   */
  ch7Voltage?: number;
  /**
   *
   * Current (Ch7) - TODO Remove
   *
   * @generated from field: optional float ch7_current = 14 [deprecated = true];
   * @deprecated
   */
  ch7Current?: number;
  /**
   *
   * Voltage (Ch8) - TODO Remove
   *
   * @generated from field: optional float ch8_voltage = 15 [deprecated = true];
   * @deprecated
   */
  ch8Voltage?: number;
  /**
   *
   * Current (Ch8) - TODO Remove
   *
   * @generated from field: optional float ch8_current = 16 [deprecated = true];
   * @deprecated
   */
  ch8Current?: number;
};
/**
 * Describes the message meshtastic.PowerMetrics.
 * Use `create(PowerMetricsSchema)` to create a new message.
 */
declare const PowerMetricsSchema: GenMessage<PowerMetrics>;
/**
 *
 * Air quality metrics
 *
 * @generated from message meshtastic.AirQualityMetrics
 */
type AirQualityMetrics = Message<"meshtastic.AirQualityMetrics"> & {
  /**
   *
   * Concentration Units Standard PM1.0 in ug/m3
   *
   * @generated from field: optional uint32 pm10_standard = 1;
   */
  pm10Standard?: number;
  /**
   *
   * Concentration Units Standard PM2.5 in ug/m3
   *
   * @generated from field: optional uint32 pm25_standard = 2;
   */
  pm25Standard?: number;
  /**
   *
   * Concentration Units Standard PM10.0 in ug/m3
   *
   * @generated from field: optional uint32 pm100_standard = 3;
   */
  pm100Standard?: number;
  /**
   *
   * Concentration Units Environmental PM1.0 in ug/m3
   *
   * @generated from field: optional uint32 pm10_environmental = 4;
   */
  pm10Environmental?: number;
  /**
   *
   * Concentration Units Environmental PM2.5 in ug/m3
   *
   * @generated from field: optional uint32 pm25_environmental = 5;
   */
  pm25Environmental?: number;
  /**
   *
   * Concentration Units Environmental PM10.0 in ug/m3
   *
   * @generated from field: optional uint32 pm100_environmental = 6;
   */
  pm100Environmental?: number;
  /**
   *
   * 0.3um Particle Count in #/0.1l
   *
   * @generated from field: optional uint32 particles_03um = 7;
   */
  particles03um?: number;
  /**
   *
   * 0.5um Particle Count in #/0.1l
   *
   * @generated from field: optional uint32 particles_05um = 8;
   */
  particles05um?: number;
  /**
   *
   * 1.0um Particle Count in #/0.1l
   *
   * @generated from field: optional uint32 particles_10um = 9;
   */
  particles10um?: number;
  /**
   *
   * 2.5um Particle Count in #/0.1l
   *
   * @generated from field: optional uint32 particles_25um = 10;
   */
  particles25um?: number;
  /**
   *
   * 5.0um Particle Count in #/0.1l
   *
   * @generated from field: optional uint32 particles_50um = 11;
   */
  particles50um?: number;
  /**
   *
   * 10.0um Particle Count in #/0.1l
   *
   * @generated from field: optional uint32 particles_100um = 12;
   */
  particles100um?: number;
  /**
   *
   * CO2 concentration in ppm
   *
   * @generated from field: optional uint32 co2 = 13;
   */
  co2?: number;
  /**
   *
   * CO2 sensor temperature in degC
   *
   * @generated from field: optional float co2_temperature = 14;
   */
  co2Temperature?: number;
  /**
   *
   * CO2 sensor relative humidity in %
   *
   * @generated from field: optional float co2_humidity = 15;
   */
  co2Humidity?: number;
  /**
   *
   * Formaldehyde sensor formaldehyde concentration in ppb
   *
   * @generated from field: optional float form_formaldehyde = 16;
   */
  formFormaldehyde?: number;
  /**
   *
   * Formaldehyde sensor relative humidity in %RH
   *
   * @generated from field: optional float form_humidity = 17;
   */
  formHumidity?: number;
  /**
   *
   * Formaldehyde sensor temperature in degrees Celsius
   *
   * @generated from field: optional float form_temperature = 18;
   */
  formTemperature?: number;
  /**
   *
   * Concentration Units Standard PM4.0 in ug/m3
   *
   * @generated from field: optional uint32 pm40_standard = 19;
   */
  pm40Standard?: number;
  /**
   *
   * 4.0um Particle Count in #/0.1l
   *
   * @generated from field: optional uint32 particles_40um = 20;
   */
  particles40um?: number;
  /**
   *
   * PM Sensor Temperature
   *
   * @generated from field: optional float pm_temperature = 21;
   */
  pmTemperature?: number;
  /**
   *
   * PM Sensor humidity
   *
   * @generated from field: optional float pm_humidity = 22;
   */
  pmHumidity?: number;
  /**
   *
   * PM Sensor VOC Index
   *
   * @generated from field: optional float pm_voc_idx = 23;
   */
  pmVocIdx?: number;
  /**
   *
   * PM Sensor NOx Index
   *
   * @generated from field: optional float pm_nox_idx = 24;
   */
  pmNoxIdx?: number;
  /**
   *
   * Typical Particle Size in um
   *
   * @generated from field: optional float particles_tps = 25;
   */
  particlesTps?: number;
  /**
   *
   * Raw PM sensor device status/error register bitmask, as defined by the sensor's own datasheet
   * (currently populated by the SEN6X family: bit 4 fan error, bit 6 RH&T error, bit 7 gas/VOC-NOx
   * error, bit 9 CO2 error (SEN66), bit 10 HCHO error, bit 11 PM error, bit 12 CO2 error (SEN63C/SEN69C),
   * bit 21 fan speed warning)
   *
   * @generated from field: optional uint32 pm_status_flags = 26;
   */
  pmStatusFlags?: number;
};
/**
 * Describes the message meshtastic.AirQualityMetrics.
 * Use `create(AirQualityMetricsSchema)` to create a new message.
 */
declare const AirQualityMetricsSchema: GenMessage<AirQualityMetrics>;
/**
 *
 * Local device mesh statistics
 *
 * @generated from message meshtastic.LocalStats
 */
type LocalStats = Message<"meshtastic.LocalStats"> & {
  /**
   *
   * How long the device has been running since the last reboot (in seconds)
   *
   * @generated from field: uint32 uptime_seconds = 1;
   */
  uptimeSeconds: number;
  /**
   *
   * Utilization for the current channel, including well formed TX, RX and malformed RX (aka noise).
   *
   * @generated from field: float channel_utilization = 2;
   */
  channelUtilization: number;
  /**
   *
   * Percent of airtime for transmission used within the last hour.
   *
   * @generated from field: float air_util_tx = 3;
   */
  airUtilTx: number;
  /**
   *
   * Number of packets sent
   *
   * @generated from field: uint32 num_packets_tx = 4;
   */
  numPacketsTx: number;
  /**
   *
   * Number of packets received (both good and bad)
   *
   * @generated from field: uint32 num_packets_rx = 5;
   */
  numPacketsRx: number;
  /**
   *
   * Number of packets received that are malformed or violate the protocol
   *
   * @generated from field: uint32 num_packets_rx_bad = 6;
   */
  numPacketsRxBad: number;
  /**
   *
   * Number of nodes online (in the past 2 hours)
   *
   * @generated from field: uint32 num_online_nodes = 7;
   */
  numOnlineNodes: number;
  /**
   *
   * Number of nodes total
   *
   * @generated from field: uint32 num_total_nodes = 8;
   */
  numTotalNodes: number;
  /**
   *
   * Number of received packets that were duplicates (due to multiple nodes relaying).
   * If this number is high, there are nodes in the mesh relaying packets when it's unnecessary, for example due to the ROUTER/REPEATER role.
   *
   * @generated from field: uint32 num_rx_dupe = 9;
   */
  numRxDupe: number;
  /**
   *
   * Number of packets we transmitted that were a relay for others (not originating from ourselves).
   *
   * @generated from field: uint32 num_tx_relay = 10;
   */
  numTxRelay: number;
  /**
   *
   * Number of times we canceled a packet to be relayed, because someone else did it before us.
   * This will always be zero for ROUTERs/REPEATERs. If this number is high, some other node(s) is/are relaying faster than you.
   *
   * @generated from field: uint32 num_tx_relay_canceled = 11;
   */
  numTxRelayCanceled: number;
  /**
   *
   * Number of bytes used in the heap
   *
   * @generated from field: uint32 heap_total_bytes = 12;
   */
  heapTotalBytes: number;
  /**
   *
   * Number of bytes free in the heap
   *
   * @generated from field: uint32 heap_free_bytes = 13;
   */
  heapFreeBytes: number;
  /**
   *
   * Number of packets that were dropped because the transmit queue was full.
   *
   * @generated from field: uint32 num_tx_dropped = 14;
   */
  numTxDropped: number;
  /**
   *
   * Noise floor value measured in dBm
   *
   * @generated from field: int32 noise_floor = 15;
   */
  noiseFloor: number;
};
/**
 * Describes the message meshtastic.LocalStats.
 * Use `create(LocalStatsSchema)` to create a new message.
 */
declare const LocalStatsSchema: GenMessage<LocalStats>;
/**
 *
 * Traffic management statistics for mesh network optimization
 *
 * @generated from message meshtastic.TrafficManagementStats
 */
type TrafficManagementStats = Message<"meshtastic.TrafficManagementStats"> & {
  /**
   *
   * Total number of packets inspected by traffic management
   *
   * @generated from field: uint32 packets_inspected = 1;
   */
  packetsInspected: number;
  /**
   *
   * Number of position packets dropped due to deduplication
   *
   * @generated from field: uint32 position_dedup_drops = 2;
   */
  positionDedupDrops: number;
  /**
   *
   * Number of NodeInfo requests answered from cache
   *
   * @generated from field: uint32 nodeinfo_cache_hits = 3;
   */
  nodeinfoCacheHits: number;
  /**
   *
   * Number of packets dropped due to rate limiting
   *
   * @generated from field: uint32 rate_limit_drops = 4;
   */
  rateLimitDrops: number;
  /**
   *
   * Number of unknown/undecryptable packets dropped
   *
   * @generated from field: uint32 unknown_packet_drops = 5;
   */
  unknownPacketDrops: number;
  /**
   *
   * Number of packets with hop_limit exhausted for local-only broadcast
   *
   * @generated from field: uint32 hop_exhausted_packets = 6;
   */
  hopExhaustedPackets: number;
  /**
   *
   * Number of times router hop preservation was applied
   *
   * @generated from field: uint32 router_hops_preserved = 7;
   */
  routerHopsPreserved: number;
};
/**
 * Describes the message meshtastic.TrafficManagementStats.
 * Use `create(TrafficManagementStatsSchema)` to create a new message.
 */
declare const TrafficManagementStatsSchema: GenMessage<TrafficManagementStats>;
/**
 *
 * Health telemetry metrics
 *
 * @generated from message meshtastic.HealthMetrics
 */
type HealthMetrics = Message<"meshtastic.HealthMetrics"> & {
  /**
   *
   * Heart rate (beats per minute)
   *
   * @generated from field: optional uint32 heart_bpm = 1;
   */
  heartBpm?: number;
  /**
   *
   * SpO2 (blood oxygen saturation) level
   *
   * @generated from field: optional uint32 spO2 = 2;
   */
  spO2?: number;
  /**
   *
   * Body temperature in degrees Celsius
   *
   * @generated from field: optional float temperature = 3;
   */
  temperature?: number;
};
/**
 * Describes the message meshtastic.HealthMetrics.
 * Use `create(HealthMetricsSchema)` to create a new message.
 */
declare const HealthMetricsSchema: GenMessage<HealthMetrics>;
/**
 *
 * Linux host metrics
 *
 * @generated from message meshtastic.HostMetrics
 */
type HostMetrics = Message<"meshtastic.HostMetrics"> & {
  /**
   *
   * Host system uptime
   *
   * @generated from field: uint32 uptime_seconds = 1;
   */
  uptimeSeconds: number;
  /**
   *
   * Host system free memory
   *
   * @generated from field: uint64 freemem_bytes = 2;
   */
  freememBytes: bigint;
  /**
   *
   * Host system disk space free for /
   *
   * @generated from field: uint64 diskfree1_bytes = 3;
   */
  diskfree1Bytes: bigint;
  /**
   *
   * Secondary system disk space free
   *
   * @generated from field: optional uint64 diskfree2_bytes = 4;
   */
  diskfree2Bytes?: bigint;
  /**
   *
   * Tertiary disk space free
   *
   * @generated from field: optional uint64 diskfree3_bytes = 5;
   */
  diskfree3Bytes?: bigint;
  /**
   *
   * Host system one minute load in 1/100ths
   *
   * @generated from field: uint32 load1 = 6;
   */
  load1: number;
  /**
   *
   * Host system five minute load  in 1/100ths
   *
   * @generated from field: uint32 load5 = 7;
   */
  load5: number;
  /**
   *
   * Host system fifteen minute load  in 1/100ths
   *
   * @generated from field: uint32 load15 = 8;
   */
  load15: number;
  /**
   *
   * Optional User-provided string for arbitrary host system information
   * that doesn't make sense as a dedicated entry.
   *
   * @generated from field: optional string user_string = 9;
   */
  userString?: string;
};
/**
 * Describes the message meshtastic.HostMetrics.
 * Use `create(HostMetricsSchema)` to create a new message.
 */
declare const HostMetricsSchema: GenMessage<HostMetrics>;
/**
 *
 * Types of Measurements the telemetry module is equipped to handle
 *
 * @generated from message meshtastic.Telemetry
 */
type Telemetry = Message<"meshtastic.Telemetry"> & {
  /**
   *
   * Seconds since 1970 - or 0 for unknown/unset
   *
   * @generated from field: fixed32 time = 1;
   */
  time: number;
  /**
   * @generated from oneof meshtastic.Telemetry.variant
   */
  variant: {
    /**
     *
     * Key native device metrics such as battery level
     *
     * @generated from field: meshtastic.DeviceMetrics device_metrics = 2;
     */
    value: DeviceMetrics;
    case: "deviceMetrics";
  } | {
    /**
     *
     * Weather station or other environmental metrics
     *
     * @generated from field: meshtastic.EnvironmentMetrics environment_metrics = 3;
     */
    value: EnvironmentMetrics;
    case: "environmentMetrics";
  } | {
    /**
     *
     * Air quality metrics
     *
     * @generated from field: meshtastic.AirQualityMetrics air_quality_metrics = 4;
     */
    value: AirQualityMetrics;
    case: "airQualityMetrics";
  } | {
    /**
     *
     * Power Metrics
     *
     * @generated from field: meshtastic.PowerMetrics power_metrics = 5;
     */
    value: PowerMetrics;
    case: "powerMetrics";
  } | {
    /**
     *
     * Local device mesh statistics
     *
     * @generated from field: meshtastic.LocalStats local_stats = 6;
     */
    value: LocalStats;
    case: "localStats";
  } | {
    /**
     *
     * Health telemetry metrics
     *
     * @generated from field: meshtastic.HealthMetrics health_metrics = 7;
     */
    value: HealthMetrics;
    case: "healthMetrics";
  } | {
    /**
     *
     * Linux host metrics
     *
     * @generated from field: meshtastic.HostMetrics host_metrics = 8;
     */
    value: HostMetrics;
    case: "hostMetrics";
  } | {
    /**
     *
     * Traffic management statistics
     *
     * @generated from field: meshtastic.TrafficManagementStats traffic_management_stats = 9;
     */
    value: TrafficManagementStats;
    case: "trafficManagementStats";
  } | {
    case: undefined;
    value?: undefined;
  };
};
/**
 * Describes the message meshtastic.Telemetry.
 * Use `create(TelemetrySchema)` to create a new message.
 */
declare const TelemetrySchema: GenMessage<Telemetry>;
/**
 *
 * NAU7802 Telemetry configuration, for saving to flash
 *
 * @generated from message meshtastic.Nau7802Config
 */
type Nau7802Config = Message<"meshtastic.Nau7802Config"> & {
  /**
   *
   * The offset setting for the NAU7802
   *
   * @generated from field: int32 zeroOffset = 1;
   */
  zeroOffset: number;
  /**
   *
   * The calibration factor for the NAU7802
   *
   * @generated from field: float calibrationFactor = 2;
   */
  calibrationFactor: number;
};
/**
 * Describes the message meshtastic.Nau7802Config.
 * Use `create(Nau7802ConfigSchema)` to create a new message.
 */
declare const Nau7802ConfigSchema: GenMessage<Nau7802Config>;
/**
 *
 * AS3935 lightning sensor configuration, for saving to flash
 *
 * @generated from message meshtastic.AS3935Config
 */
type AS3935Config = Message<"meshtastic.AS3935Config"> & {
  /**
   *
   * Antenna tuning capacitance in pF, 0 to 120 in steps of 8. The chip does not retain
   * this across power loss, so it is stored here and re-applied on every boot.
   *
   * @generated from field: uint32 tuning_cap_pf = 1;
   */
  tuningCapPf: number;
};
/**
 * Describes the message meshtastic.AS3935Config.
 * Use `create(AS3935ConfigSchema)` to create a new message.
 */
declare const AS3935ConfigSchema: GenMessage<AS3935Config>;
/**
 *
 * SEN5X State, for saving to flash (to be merged with SEN6XState)
 *
 * @generated from message meshtastic.SEN5XState
 */
type SEN5XState = Message<"meshtastic.SEN5XState"> & {
  /**
   *
   * Last cleaning time for SEN5X
   *
   * @generated from field: uint32 last_cleaning_time = 1;
   */
  lastCleaningTime: number;
  /**
   *
   * Last cleaning time for SEN5X - valid flag
   *
   * @generated from field: bool last_cleaning_valid = 2;
   */
  lastCleaningValid: boolean;
  /**
   *
   * Config flag for one-shot mode (see admin.proto)
   *
   * @generated from field: bool one_shot_mode = 3;
   */
  oneShotMode: boolean;
  /**
   *
   * Last VOC state time for SEN55
   *
   * @generated from field: optional uint32 voc_state_time = 4;
   */
  vocStateTime?: number;
  /**
   *
   * Last VOC state validity flag for SEN55
   *
   * @generated from field: optional bool voc_state_valid = 5;
   */
  vocStateValid?: boolean;
  /**
   *
   * VOC state array (8x uint8t) for SEN55
   *
   * @generated from field: optional fixed64 voc_state_array = 6;
   */
  vocStateArray?: bigint;
};
/**
 * Describes the message meshtastic.SEN5XState.
 * Use `create(SEN5XStateSchema)` to create a new message.
 */
declare const SEN5XStateSchema: GenMessage<SEN5XState>;
/**
 *
 * SEN6X State, for saving to flash
 *
 * @generated from message meshtastic.SEN6XState
 */
type SEN6XState = Message<"meshtastic.SEN6XState"> & {
  /**
   *
   * Last cleaning time for SEN6X
   *
   * @generated from field: uint32 last_cleaning_time = 1;
   */
  lastCleaningTime: number;
  /**
   *
   * Last cleaning time for SEN6X - valid flag
   *
   * @generated from field: bool last_cleaning_valid = 2;
   */
  lastCleaningValid: boolean;
  /**
   *
   * Config flag for one-shot mode (see admin.proto)
   *
   * @generated from field: bool one_shot_mode = 3;
   */
  oneShotMode: boolean;
  /**
   *
   * Last VOC state time, for models with a VOC sensor (SEN65, SEN66, SEN68, SEN69C)
   *
   * @generated from field: optional uint32 voc_state_time = 4;
   */
  vocStateTime?: number;
  /**
   *
   * Last VOC state validity flag, for models with a VOC sensor (SEN65, SEN66, SEN68, SEN69C)
   *
   * @generated from field: optional bool voc_state_valid = 5;
   */
  vocStateValid?: boolean;
  /**
   *
   * VOC state array (8x uint8t), for models with a VOC sensor (SEN65, SEN66, SEN68, SEN69C)
   *
   * @generated from field: optional fixed64 voc_state_array = 6;
   */
  vocStateArray?: bigint;
};
/**
 * Describes the message meshtastic.SEN6XState.
 * Use `create(SEN6XStateSchema)` to create a new message.
 */
declare const SEN6XStateSchema: GenMessage<SEN6XState>;
/**
 *
 * Supported I2C Sensors for telemetry in Meshtastic
 *
 * @generated from enum meshtastic.TelemetrySensorType
 */
declare enum TelemetrySensorType {
  /**
   *
   * No external telemetry sensor explicitly set
   *
   * @generated from enum value: SENSOR_UNSET = 0;
   */
  SENSOR_UNSET = 0,
  /**
   *
   * High accuracy temperature, pressure, humidity
   *
   * @generated from enum value: BME280 = 1;
   */
  BME280 = 1,
  /**
   *
   * High accuracy temperature, pressure, humidity, and air resistance
   *
   * @generated from enum value: BME680 = 2;
   */
  BME680 = 2,
  /**
   *
   * Very high accuracy temperature
   *
   * @generated from enum value: MCP9808 = 3;
   */
  MCP9808 = 3,
  /**
   *
   * Moderate accuracy current and voltage
   *
   * @generated from enum value: INA260 = 4;
   */
  INA260 = 4,
  /**
   *
   * Moderate accuracy current and voltage
   *
   * @generated from enum value: INA219 = 5;
   */
  INA219 = 5,
  /**
   *
   * High accuracy temperature and pressure
   *
   * @generated from enum value: BMP280 = 6;
   */
  BMP280 = 6,
  /**
   *
   * TODO - REMOVE High accuracy temperature and humidity
   *
   * @generated from enum value: SHTC3 = 7 [deprecated = true];
   * @deprecated
   */
  SHTC3 = 7,
  /**
   *
   * High accuracy pressure
   *
   * @generated from enum value: LPS22 = 8;
   */
  LPS22 = 8,
  /**
   *
   * 3-Axis magnetic sensor
   *
   * @generated from enum value: QMC6310 = 9;
   */
  QMC6310 = 9,
  /**
   *
   * 6-Axis inertial measurement sensor
   *
   * @generated from enum value: QMI8658 = 10;
   */
  QMI8658 = 10,
  /**
   *
   * 3-Axis magnetic sensor
   *
   * @generated from enum value: QMC5883L = 11;
   */
  QMC5883L = 11,
  /**
   *
   * TODO - REMOVE High accuracy temperature and humidity
   *
   * @generated from enum value: SHT31 = 12 [deprecated = true];
   * @deprecated
   */
  SHT31 = 12,
  /**
   *
   * PM2.5 air quality sensor
   *
   * @generated from enum value: PMSA003I = 13;
   */
  PMSA003I = 13,
  /**
   *
   * INA3221 3 Channel Voltage / Current Sensor
   *
   * @generated from enum value: INA3221 = 14;
   */
  INA3221 = 14,
  /**
   *
   * BMP085/BMP180 High accuracy temperature and pressure (older Version of BMP280)
   *
   * @generated from enum value: BMP085 = 15;
   */
  BMP085 = 15,
  /**
   *
   * RCWL-9620 Doppler Radar Distance Sensor, used for water level detection
   *
   * @generated from enum value: RCWL9620 = 16;
   */
  RCWL9620 = 16,
  /**
   *
   * TODO - REMOVE Sensirion High accuracy temperature and humidity
   *
   * @generated from enum value: SHT4X = 17 [deprecated = true];
   * @deprecated
   */
  SHT4X = 17,
  /**
   *
   * VEML7700 high accuracy ambient light(Lux) digital 16-bit resolution sensor.
   *
   * @generated from enum value: VEML7700 = 18;
   */
  VEML7700 = 18,
  /**
   *
   * MLX90632 non-contact IR temperature sensor.
   *
   * @generated from enum value: MLX90632 = 19;
   */
  MLX90632 = 19,
  /**
   *
   * TI OPT3001 Ambient Light Sensor
   *
   * @generated from enum value: OPT3001 = 20;
   */
  OPT3001 = 20,
  /**
   *
   * Lite On LTR-390UV-01 UV Light Sensor
   *
   * @generated from enum value: LTR390UV = 21;
   */
  LTR390UV = 21,
  /**
   *
   * AMS TSL25911FN RGB Light Sensor
   *
   * @generated from enum value: TSL25911FN = 22;
   */
  TSL25911FN = 22,
  /**
   *
   * AHT10 Integrated temperature and humidity sensor
   *
   * @generated from enum value: AHT10 = 23;
   */
  AHT10 = 23,
  /**
   *
   * DFRobot Lark Weather station (temperature, humidity, pressure, wind speed and direction)
   *
   * @generated from enum value: DFROBOT_LARK = 24;
   */
  DFROBOT_LARK = 24,
  /**
   *
   * NAU7802 Scale Chip or compatible
   *
   * @generated from enum value: NAU7802 = 25;
   */
  NAU7802 = 25,
  /**
   *
   * BMP3XX High accuracy temperature and pressure
   *
   * @generated from enum value: BMP3XX = 26;
   */
  BMP3XX = 26,
  /**
   *
   * ICM-20948 9-Axis digital motion processor
   *
   * @generated from enum value: ICM20948 = 27;
   */
  ICM20948 = 27,
  /**
   *
   * MAX17048 1S lipo battery sensor (voltage, state of charge, time to go)
   *
   * @generated from enum value: MAX17048 = 28;
   */
  MAX17048 = 28,
  /**
   *
   * Custom I2C sensor implementation based on https://github.com/meshtastic/i2c-sensor
   *
   * @generated from enum value: CUSTOM_SENSOR = 29;
   */
  CUSTOM_SENSOR = 29,
  /**
   *
   * MAX30102 Pulse Oximeter and Heart-Rate Sensor
   *
   * @generated from enum value: MAX30102 = 30;
   */
  MAX30102 = 30,
  /**
   *
   * MLX90614 non-contact IR temperature sensor
   *
   * @generated from enum value: MLX90614 = 31;
   */
  MLX90614 = 31,
  /**
   *
   * SCD40/SCD41 CO2, humidity, temperature sensor
   *
   * @generated from enum value: SCD4X = 32;
   */
  SCD4X = 32,
  /**
   *
   * ClimateGuard RadSens, radiation, Geiger-Muller Tube
   *
   * @generated from enum value: RADSENS = 33;
   */
  RADSENS = 33,
  /**
   *
   * High accuracy current and voltage
   *
   * @generated from enum value: INA226 = 34;
   */
  INA226 = 34,
  /**
   *
   * DFRobot Gravity tipping bucket rain gauge
   *
   * @generated from enum value: DFROBOT_RAIN = 35;
   */
  DFROBOT_RAIN = 35,
  /**
   *
   * Infineon DPS310 High accuracy pressure and temperature
   *
   * @generated from enum value: DPS310 = 36;
   */
  DPS310 = 36,
  /**
   *
   * RAKWireless RAK12035 Soil Moisture Sensor Module
   *
   * @generated from enum value: RAK12035 = 37;
   */
  RAK12035 = 37,
  /**
   *
   * MAX17261 lipo battery gauge
   *
   * @generated from enum value: MAX17261 = 38;
   */
  MAX17261 = 38,
  /**
   *
   * PCT2075 Temperature Sensor
   *
   * @generated from enum value: PCT2075 = 39;
   */
  PCT2075 = 39,
  /**
   *
   * ADS1X15 ADC
   *
   * @generated from enum value: ADS1X15 = 40;
   */
  ADS1X15 = 40,
  /**
   *
   * ADS1X15 ADC_ALT
   *
   * @generated from enum value: ADS1X15_ALT = 41;
   */
  ADS1X15_ALT = 41,
  /**
   *
   * Sensirion SFA30 Formaldehyde sensor
   *
   * @generated from enum value: SFA30 = 42;
   */
  SFA30 = 42,
  /**
   *
   * SEN5X PM SENSORS
   *
   * @generated from enum value: SEN5X = 43;
   */
  SEN5X = 43,
  /**
   *
   * TSL2561 light sensor
   *
   * @generated from enum value: TSL2561 = 44;
   */
  TSL2561 = 44,
  /**
   *
   * BH1750 light sensor
   *
   * @generated from enum value: BH1750 = 45;
   */
  BH1750 = 45,
  /**
   *
   * HDC1080 Temperature and Humidity Sensor
   *
   * @generated from enum value: HDC1080 = 46;
   */
  HDC1080 = 46,
  /**
   *
   * TODO - REMOVE STH21 Temperature and R. Humidity sensor
   *
   * @generated from enum value: SHT21 = 47 [deprecated = true];
   * @deprecated
   */
  SHT21 = 47,
  /**
   *
   * Sensirion STC31 CO2 sensor
   *
   * @generated from enum value: STC31 = 48;
   */
  STC31 = 48,
  /**
   *
   * SCD30 CO2, humidity, temperature sensor
   *
   * @generated from enum value: SCD30 = 49;
   */
  SCD30 = 49,
  /**
   *
   * SHT family of sensors for temperature and humidity
   *
   * @generated from enum value: SHTXX = 50;
   */
  SHTXX = 50,
  /**
   *
   * DS248X Bridge for one-wire temperature sensors
   *
   * @generated from enum value: DS248X = 51;
   */
  DS248X = 51,
  /**
   *
   * MMC5983MA 3-Axis Digital Magnetic Sensor
   *
   * @generated from enum value: MMC5983MA = 52;
   */
  MMC5983MA = 52,
  /**
   *
   * ICM-42607-P 6‑Axis IMU
   *
   * @generated from enum value: ICM42607P = 53;
   */
  ICM42607P = 53,
  /**
   *
   * SPA06 pressure and temperature
   *
   * @generated from enum value: SPA06 = 54;
   */
  SPA06 = 54,
  /**
   *
   * HM330X PM SENSOR
   *
   * @generated from enum value: HM330X = 55;
   */
  HM330X = 55,
  /**
   *
   * Sensirion SEN6X PM/RHT/VOC/NOx/CO2/HCHO sensor family (SEN62, SEN63C, SEN65, SEN66, SEN68, SEN69C)
   *
   * @generated from enum value: SEN6X = 56;
   */
  SEN6X = 56,
  /**
   *
   * AS3935 Franklin lightning sensor
   *
   * @generated from enum value: AS3935 = 57;
   */
  AS3935 = 57
}
/**
 * Describes the enum meshtastic.TelemetrySensorType.
 */
declare const TelemetrySensorTypeSchema: GenEnum<TelemetrySensorType>;
declare namespace xmodem_pb_d_exports {
  export { XModem, XModemSchema, XModem_Control, XModem_ControlSchema, file_meshtastic_xmodem };
}
/**
 * Describes the file meshtastic/xmodem.proto.
 */
declare const file_meshtastic_xmodem: GenFile;
/**
 * @generated from message meshtastic.XModem
 */
type XModem = Message<"meshtastic.XModem"> & {
  /**
   * @generated from field: meshtastic.XModem.Control control = 1;
   */
  control: XModem_Control;
  /**
   * @generated from field: uint32 seq = 2;
   */
  seq: number;
  /**
   * @generated from field: uint32 crc16 = 3;
   */
  crc16: number;
  /**
   * @generated from field: bytes buffer = 4;
   */
  buffer: Uint8Array;
};
/**
 * Describes the message meshtastic.XModem.
 * Use `create(XModemSchema)` to create a new message.
 */
declare const XModemSchema: GenMessage<XModem>;
/**
 * @generated from enum meshtastic.XModem.Control
 */
declare enum XModem_Control {
  /**
   * @generated from enum value: NUL = 0;
   */
  NUL = 0,
  /**
   * @generated from enum value: SOH = 1;
   */
  SOH = 1,
  /**
   * @generated from enum value: STX = 2;
   */
  STX = 2,
  /**
   * @generated from enum value: EOT = 4;
   */
  EOT = 4,
  /**
   * @generated from enum value: ACK = 6;
   */
  ACK = 6,
  /**
   * @generated from enum value: NAK = 21;
   */
  NAK = 21,
  /**
   * @generated from enum value: CAN = 24;
   */
  CAN = 24,
  /**
   * @generated from enum value: CTRLZ = 26;
   */
  CTRLZ = 26
}
/**
 * Describes the enum meshtastic.XModem.Control.
 */
declare const XModem_ControlSchema: GenEnum<XModem_Control>;
declare namespace mesh_pb_d_exports {
  export { BoundingBox, BoundingBoxSchema, ChunkedPayload, ChunkedPayloadResponse, ChunkedPayloadResponseSchema, ChunkedPayloadSchema, ClientNotification, ClientNotificationSchema, Compressed, CompressedSchema, Constants, ConstantsSchema, CriticalErrorCode, CriticalErrorCodeSchema, Data, DataSchema, DeviceMetadata, DeviceMetadataSchema, DuplicatedPublicKey, DuplicatedPublicKeySchema, ExcludedModules, ExcludedModulesSchema, FileInfo, FileInfoSchema, FirmwareEdition, FirmwareEditionSchema, FromRadio, FromRadioSchema, HardwareModel, HardwareModelSchema, Heartbeat, HeartbeatSchema, KeyVerification, KeyVerificationFinal, KeyVerificationFinalSchema, KeyVerificationNumberInform, KeyVerificationNumberInformSchema, KeyVerificationNumberRequest, KeyVerificationNumberRequestSchema, KeyVerificationSchema, LoRaPresetGroup, LoRaPresetGroupSchema, LoRaRegionPresetMap, LoRaRegionPresetMapSchema, LoRaRegionPresets, LoRaRegionPresetsSchema, LockdownStatus, LockdownStatusSchema, LockdownStatus_State, LockdownStatus_StateSchema, LogRecord, LogRecordSchema, LogRecord_Level, LogRecord_LevelSchema, LowEntropyKey, LowEntropyKeySchema, MeshPacket, MeshPacketSchema, MeshPacket_Delayed, MeshPacket_DelayedSchema, MeshPacket_Priority, MeshPacket_PrioritySchema, MeshPacket_TransportMechanism, MeshPacket_TransportMechanismSchema, MqttClientProxyMessage, MqttClientProxyMessageSchema, MyNodeInfo, MyNodeInfoSchema, Neighbor, NeighborInfo, NeighborInfoSchema, NeighborSchema, NodeInfo, NodeInfoSchema, NodeRemoteHardwarePin, NodeRemoteHardwarePinSchema, Position, PositionSchema, Position_AltSource, Position_AltSourceSchema, Position_LocSource, Position_LocSourceSchema, QueueStatus, QueueStatusSchema, RemoteShell, RemoteShellSchema, RemoteShell_OpCode, RemoteShell_OpCodeSchema, RouteDiscovery, RouteDiscoverySchema, Routing, RoutingSchema, Routing_Error, Routing_ErrorSchema, StatusMessage, StatusMessageSchema, StoreForwardPlusPlus, StoreForwardPlusPlusSchema, StoreForwardPlusPlus_SFPP_message_type, StoreForwardPlusPlus_SFPP_message_typeSchema, ToRadio, ToRadioSchema, User, UserSchema, Waypoint, WaypointSchema, file_meshtastic_mesh, resend_chunks, resend_chunksSchema };
}
/**
 * Describes the file meshtastic/mesh.proto.
 */
declare const file_meshtastic_mesh: GenFile;
/**
 *
 * A GPS Position
 *
 * @generated from message meshtastic.Position
 */
type Position = Message<"meshtastic.Position"> & {
  /**
   *
   * The new preferred location encoding, multiply by 1e-7 to get degrees
   * in floating point
   *
   * @generated from field: optional sfixed32 latitude_i = 1;
   */
  latitudeI?: number;
  /**
   *
   * TODO: REPLACE
   *
   * @generated from field: optional sfixed32 longitude_i = 2;
   */
  longitudeI?: number;
  /**
   *
   * In meters above MSL (but see issue #359)
   *
   * @generated from field: optional int32 altitude = 3;
   */
  altitude?: number;
  /**
   *
   * This is usually not sent over the mesh (to save space), but it is sent
   * from the phone so that the local device can set its time if it is sent over
   * the mesh (because there are devices on the mesh without GPS or RTC).
   * seconds since 1970
   *
   * @generated from field: fixed32 time = 4;
   */
  time: number;
  /**
   *
   * TODO: REPLACE
   *
   * @generated from field: meshtastic.Position.LocSource location_source = 5;
   */
  locationSource: Position_LocSource;
  /**
   *
   * TODO: REPLACE
   *
   * @generated from field: meshtastic.Position.AltSource altitude_source = 6;
   */
  altitudeSource: Position_AltSource;
  /**
   *
   * Positional timestamp (actual timestamp of GPS solution) in integer epoch seconds
   *
   * @generated from field: fixed32 timestamp = 7;
   */
  timestamp: number;
  /**
   *
   * Pos. timestamp milliseconds adjustment (rarely available or required)
   *
   * @generated from field: int32 timestamp_millis_adjust = 8;
   */
  timestampMillisAdjust: number;
  /**
   *
   * HAE altitude in meters - can be used instead of MSL altitude
   *
   * @generated from field: optional sint32 altitude_hae = 9;
   */
  altitudeHae?: number;
  /**
   *
   * Geoidal separation in meters
   *
   * @generated from field: optional sint32 altitude_geoidal_separation = 10;
   */
  altitudeGeoidalSeparation?: number;
  /**
   *
   * Horizontal, Vertical and Position Dilution of Precision, in 1/100 units
   * - PDOP is sufficient for most cases
   * - for higher precision scenarios, HDOP and VDOP can be used instead,
   *   in which case PDOP becomes redundant (PDOP=sqrt(HDOP^2 + VDOP^2))
   * TODO: REMOVE/INTEGRATE
   *
   * @generated from field: uint32 PDOP = 11;
   */
  PDOP: number;
  /**
   *
   * TODO: REPLACE
   *
   * @generated from field: uint32 HDOP = 12;
   */
  HDOP: number;
  /**
   *
   * TODO: REPLACE
   *
   * @generated from field: uint32 VDOP = 13;
   */
  VDOP: number;
  /**
   *
   * GPS accuracy (a hardware specific constant) in mm
   *   multiplied with DOP to calculate positional accuracy
   * Default: "'bout three meters-ish" :)
   *
   * @generated from field: uint32 gps_accuracy = 14;
   */
  gpsAccuracy: number;
  /**
   *
   * Ground speed in km/h and True North TRACK in 1/100 degrees
   * Clarification of terms:
   * - "track" is the direction of motion (measured in horizontal plane)
   * - "heading" is where the fuselage points (measured in horizontal plane)
   * - "yaw" indicates a relative rotation about the vertical axis
   * TODO: REMOVE/INTEGRATE
   *
   * @generated from field: optional uint32 ground_speed = 15;
   */
  groundSpeed?: number;
  /**
   *
   * TODO: REPLACE
   *
   * @generated from field: optional uint32 ground_track = 16;
   */
  groundTrack?: number;
  /**
   *
   * GPS fix quality (from NMEA GxGGA statement or similar)
   *
   * @generated from field: uint32 fix_quality = 17;
   */
  fixQuality: number;
  /**
   *
   * GPS fix type 2D/3D (from NMEA GxGSA statement)
   *
   * @generated from field: uint32 fix_type = 18;
   */
  fixType: number;
  /**
   *
   * GPS "Satellites in View" number
   *
   * @generated from field: uint32 sats_in_view = 19;
   */
  satsInView: number;
  /**
   *
   * Sensor ID - in case multiple positioning sensors are being used
   *
   * @generated from field: uint32 sensor_id = 20;
   */
  sensorId: number;
  /**
   *
   * Estimated/expected time (in seconds) until next update:
   * - if we update at fixed intervals of X seconds, use X
   * - if we update at dynamic intervals (based on relative movement etc),
   *   but "AT LEAST every Y seconds", use Y
   *
   * @generated from field: uint32 next_update = 21;
   */
  nextUpdate: number;
  /**
   *
   * A sequence number, incremented with each Position message to help
   *   detect lost updates if needed
   *
   * @generated from field: uint32 seq_number = 22;
   */
  seqNumber: number;
  /**
   *
   * Indicates the bits of precision set by the sending node
   *
   * @generated from field: uint32 precision_bits = 23;
   */
  precisionBits: number;
};
/**
 * Describes the message meshtastic.Position.
 * Use `create(PositionSchema)` to create a new message.
 */
declare const PositionSchema: GenMessage<Position>;
/**
 *
 * How the location was acquired: manual, onboard GPS, external (EUD) GPS
 *
 * @generated from enum meshtastic.Position.LocSource
 */
declare enum Position_LocSource {
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: LOC_UNSET = 0;
   */
  LOC_UNSET = 0,
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: LOC_MANUAL = 1;
   */
  LOC_MANUAL = 1,
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: LOC_INTERNAL = 2;
   */
  LOC_INTERNAL = 2,
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: LOC_EXTERNAL = 3;
   */
  LOC_EXTERNAL = 3
}
/**
 * Describes the enum meshtastic.Position.LocSource.
 */
declare const Position_LocSourceSchema: GenEnum<Position_LocSource>;
/**
 *
 * How the altitude was acquired: manual, GPS int/ext, etc
 * Default: same as location_source if present
 *
 * @generated from enum meshtastic.Position.AltSource
 */
declare enum Position_AltSource {
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: ALT_UNSET = 0;
   */
  ALT_UNSET = 0,
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: ALT_MANUAL = 1;
   */
  ALT_MANUAL = 1,
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: ALT_INTERNAL = 2;
   */
  ALT_INTERNAL = 2,
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: ALT_EXTERNAL = 3;
   */
  ALT_EXTERNAL = 3,
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: ALT_BAROMETRIC = 4;
   */
  ALT_BAROMETRIC = 4
}
/**
 * Describes the enum meshtastic.Position.AltSource.
 */
declare const Position_AltSourceSchema: GenEnum<Position_AltSource>;
/**
 *
 * Broadcast when a newly powered mesh node wants to find a node num it can use
 * Sent from the phone over bluetooth to set the user id for the owner of this node.
 * Also sent from nodes to each other when a new node signs on (so all clients can have this info)
 * The algorithm is as follows:
 * when a node starts up, it broadcasts their user and the normal flow is for all
 * other nodes to reply with their User as well (so the new node can build its nodedb)
 * If a node ever receives a User (not just the first broadcast) message where
 * the sender node number equals our node number, that indicates a collision has
 * occurred and the following steps should happen:
 * If the receiving node (that was already in the mesh)'s macaddr is LOWER than the
 * new User who just tried to sign in: it gets to keep its nodenum.
 * We send a broadcast message of OUR User (we use a broadcast so that the other node can
 * receive our message, considering we have the same id - it also serves to let
 * observers correct their nodedb) - this case is rare so it should be okay.
 * If any node receives a User where the macaddr is GTE than their local macaddr,
 * they have been vetoed and should pick a new random nodenum (filtering against
 * whatever it knows about the nodedb) and rebroadcast their User.
 * A few nodenums are reserved and will never be requested:
 * 0xff - broadcast
 * 0 through 3 - for future use
 *
 * @generated from message meshtastic.User
 */
type User = Message<"meshtastic.User"> & {
  /**
   *
   * A globally unique ID string for this user.
   * In the case of Signal that would mean +16504442323, for the default macaddr derived id it would be !<8 hexidecimal bytes>.
   * Note: app developers are encouraged to also use the following standard
   * node IDs "^all" (for broadcast), "^local" (for the locally connected node)
   *
   * @generated from field: string id = 1;
   */
  id: string;
  /**
   *
   * A full name for this user, i.e. "Kevin Hester"
   * Limited to 24 bytes of UTF-8: longer names are accepted from senders
   * built against the older 39-byte limit, but devices truncate them before
   * storing or rebroadcasting. Clients should enforce 24 bytes in their UI.
   *
   * @generated from field: string long_name = 2;
   */
  longName: string;
  /**
   *
   * A VERY short name, ideally two characters.
   * Suitable for a tiny OLED screen
   *
   * @generated from field: string short_name = 3;
   */
  shortName: string;
  /**
   *
   * Deprecated in Meshtastic 2.1.x
   * This is the addr of the radio.
   * Not populated by the phone, but added by the esp32 when broadcasting
   *
   * @generated from field: bytes macaddr = 4 [deprecated = true];
   * @deprecated
   */
  macaddr: Uint8Array;
  /**
   *
   * TBEAM, HELTEC, etc...
   * Starting in 1.2.11 moved to hw_model enum in the NodeInfo object.
   * Apps will still need the string here for older builds
   * (so OTA update can find the right image), but if the enum is available it will be used instead.
   *
   * @generated from field: meshtastic.HardwareModel hw_model = 5;
   */
  hwModel: HardwareModel;
  /**
   *
   * In some regions Ham radio operators have different bandwidth limitations than others.
   * If this user is a licensed operator, set this flag.
   * Also, "long_name" should be their licence number.
   *
   * @generated from field: bool is_licensed = 6;
   */
  isLicensed: boolean;
  /**
   *
   * Indicates that the user's role in the mesh
   *
   * @generated from field: meshtastic.Config.DeviceConfig.Role role = 7;
   */
  role: Config_DeviceConfig_Role;
  /**
   *
   * The public key of the user's device.
   * This is sent out to other nodes on the mesh to allow them to compute a shared secret key.
   *
   * @generated from field: bytes public_key = 8;
   */
  publicKey: Uint8Array;
  /**
   *
   * Whether or not the node can be messaged
   *
   * @generated from field: optional bool is_unmessagable = 9;
   */
  isUnmessagable?: boolean;
};
/**
 * Describes the message meshtastic.User.
 * Use `create(UserSchema)` to create a new message.
 */
declare const UserSchema: GenMessage<User>;
/**
 *
 * A message used in a traceroute
 *
 * @generated from message meshtastic.RouteDiscovery
 */
type RouteDiscovery = Message<"meshtastic.RouteDiscovery"> & {
  /**
   *
   * The list of nodenums this packet has visited so far to the destination.
   *
   * @generated from field: repeated fixed32 route = 1;
   */
  route: number[];
  /**
   *
   * The list of SNRs (in dB, scaled by 4) in the route towards the destination.
   *
   * @generated from field: repeated int32 snr_towards = 2;
   */
  snrTowards: number[];
  /**
   *
   * The list of nodenums the packet has visited on the way back from the destination.
   *
   * @generated from field: repeated fixed32 route_back = 3;
   */
  routeBack: number[];
  /**
   *
   * The list of SNRs (in dB, scaled by 4) in the route back from the destination.
   *
   * @generated from field: repeated int32 snr_back = 4;
   */
  snrBack: number[];
};
/**
 * Describes the message meshtastic.RouteDiscovery.
 * Use `create(RouteDiscoverySchema)` to create a new message.
 */
declare const RouteDiscoverySchema: GenMessage<RouteDiscovery>;
/**
 *
 * A Routing control Data packet handled by the routing module
 *
 * @generated from message meshtastic.Routing
 */
type Routing = Message<"meshtastic.Routing"> & {
  /**
   * @generated from oneof meshtastic.Routing.variant
   */
  variant: {
    /**
     *
     * A route request going from the requester
     *
     * @generated from field: meshtastic.RouteDiscovery route_request = 1;
     */
    value: RouteDiscovery;
    case: "routeRequest";
  } | {
    /**
     *
     * A route reply
     *
     * @generated from field: meshtastic.RouteDiscovery route_reply = 2;
     */
    value: RouteDiscovery;
    case: "routeReply";
  } | {
    /**
     *
     * A failure in delivering a message (usually used for routing control messages, but might be provided
     * in addition to ack.fail_id to provide details on the type of failure).
     *
     * @generated from field: meshtastic.Routing.Error error_reason = 3;
     */
    value: Routing_Error;
    case: "errorReason";
  } | {
    case: undefined;
    value?: undefined;
  };
};
/**
 * Describes the message meshtastic.Routing.
 * Use `create(RoutingSchema)` to create a new message.
 */
declare const RoutingSchema: GenMessage<Routing>;
/**
 *
 * A failure in delivering a message (usually used for routing control messages, but might be provided in addition to ack.fail_id to provide
 * details on the type of failure).
 *
 * @generated from enum meshtastic.Routing.Error
 */
declare enum Routing_Error {
  /**
   *
   * This message is not a failure
   *
   * @generated from enum value: NONE = 0;
   */
  NONE = 0,
  /**
   *
   * Our node doesn't have a route to the requested destination anymore.
   *
   * @generated from enum value: NO_ROUTE = 1;
   */
  NO_ROUTE = 1,
  /**
   *
   * We received a nak while trying to forward on your behalf
   *
   * @generated from enum value: GOT_NAK = 2;
   */
  GOT_NAK = 2,
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: TIMEOUT = 3;
   */
  TIMEOUT = 3,
  /**
   *
   * No suitable interface could be found for delivering this packet
   *
   * @generated from enum value: NO_INTERFACE = 4;
   */
  NO_INTERFACE = 4,
  /**
   *
   * We reached the max retransmission count (typically for naive flood routing)
   *
   * @generated from enum value: MAX_RETRANSMIT = 5;
   */
  MAX_RETRANSMIT = 5,
  /**
   *
   * No suitable channel was found for sending this packet (i.e. was requested channel index disabled?)
   *
   * @generated from enum value: NO_CHANNEL = 6;
   */
  NO_CHANNEL = 6,
  /**
   *
   * The packet was too big for sending (exceeds interface MTU after encoding)
   *
   * @generated from enum value: TOO_LARGE = 7;
   */
  TOO_LARGE = 7,
  /**
   *
   * The request had want_response set, the request reached the destination node, but no service on that node wants to send a response
   * (possibly due to bad channel permissions)
   *
   * @generated from enum value: NO_RESPONSE = 8;
   */
  NO_RESPONSE = 8,
  /**
   *
   * Cannot send currently because duty cycle regulations will be violated.
   *
   * @generated from enum value: DUTY_CYCLE_LIMIT = 9;
   */
  DUTY_CYCLE_LIMIT = 9,
  /**
   *
   * The application layer service on the remote node received your request, but considered your request somehow invalid
   *
   * @generated from enum value: BAD_REQUEST = 32;
   */
  BAD_REQUEST = 32,
  /**
   *
   * The application layer service on the remote node received your request, but considered your request not authorized
   * (i.e you did not send the request on the required bound channel)
   *
   * @generated from enum value: NOT_AUTHORIZED = 33;
   */
  NOT_AUTHORIZED = 33,
  /**
   *
   * The client specified a PKI transport, but the node was unable to send the packet using PKI (and did not send the message at all)
   *
   * @generated from enum value: PKI_FAILED = 34;
   */
  PKI_FAILED = 34,
  /**
   *
   * The receiving node does not have a Public Key to decode with
   *
   * @generated from enum value: PKI_UNKNOWN_PUBKEY = 35;
   */
  PKI_UNKNOWN_PUBKEY = 35,
  /**
   *
   * Admin packet otherwise checks out, but uses a bogus or expired session key
   *
   * @generated from enum value: ADMIN_BAD_SESSION_KEY = 36;
   */
  ADMIN_BAD_SESSION_KEY = 36,
  /**
   *
   * Admin packet sent using PKC, but not from a public key on the admin key list
   *
   * @generated from enum value: ADMIN_PUBLIC_KEY_UNAUTHORIZED = 37;
   */
  ADMIN_PUBLIC_KEY_UNAUTHORIZED = 37,
  /**
   *
   * Airtime fairness rate limit exceeded for a packet
   * This typically enforced per portnum and is used to prevent a single node from monopolizing airtime
   *
   * @generated from enum value: RATE_LIMIT_EXCEEDED = 38;
   */
  RATE_LIMIT_EXCEEDED = 38,
  /**
   *
   * PKI encryption failed, due to no public key for the remote node
   * This is different from PKI_UNKNOWN_PUBKEY which indicates a failure upon receiving a packet
   *
   * @generated from enum value: PKI_SEND_FAIL_PUBLIC_KEY = 39;
   */
  PKI_SEND_FAIL_PUBLIC_KEY = 39
}
/**
 * Describes the enum meshtastic.Routing.Error.
 */
declare const Routing_ErrorSchema: GenEnum<Routing_Error>;
/**
 *
 * (Formerly called SubPacket)
 * The payload portion fo a packet, this is the actual bytes that are sent
 * inside a radio packet (because from/to are broken out by the comms library)
 *
 * @generated from message meshtastic.Data
 */
type Data = Message<"meshtastic.Data"> & {
  /**
   *
   * Formerly named typ and of type Type
   *
   * @generated from field: meshtastic.PortNum portnum = 1;
   */
  portnum: PortNum;
  /**
   *
   * TODO: REPLACE
   *
   * @generated from field: bytes payload = 2;
   */
  payload: Uint8Array;
  /**
   *
   * Not normally used, but for testing a sender can request that recipient
   * responds in kind (i.e. if it received a position, it should unicast back it's position).
   * Note: that if you set this on a broadcast you will receive many replies.
   *
   * @generated from field: bool want_response = 3;
   */
  wantResponse: boolean;
  /**
   *
   * The address of the destination node.
   * This field is is filled in by the mesh radio device software, application
   * layer software should never need it.
   * RouteDiscovery messages _must_ populate this.
   * Other message types might need to if they are doing multihop routing.
   *
   * @generated from field: fixed32 dest = 4;
   */
  dest: number;
  /**
   *
   * The address of the original sender for this message.
   * This field should _only_ be populated for reliable multihop packets (to keep
   * packets small).
   *
   * @generated from field: fixed32 source = 5;
   */
  source: number;
  /**
   *
   * Only used in routing or response messages.
   * Indicates the original message ID that this message is reporting failure on. (formerly called original_id)
   *
   * @generated from field: fixed32 request_id = 6;
   */
  requestId: number;
  /**
   *
   * If set, this message is intened to be a reply to a previously sent message with the defined id.
   *
   * @generated from field: fixed32 reply_id = 7;
   */
  replyId: number;
  /**
   *
   * Defaults to false. If true, then what is in the payload should be treated as an emoji like giving
   * a message a heart or poop emoji.
   *
   * @generated from field: fixed32 emoji = 8;
   */
  emoji: number;
  /**
   *
   * Bitfield for extra flags. First use is to indicate that user approves the packet being uploaded to MQTT.
   *
   * @generated from field: optional uint32 bitfield = 9;
   */
  bitfield?: number;
  /**
   *
   * XEdDSA signature for the payload
   *
   * @generated from field: bytes xeddsa_signature = 10;
   */
  xeddsaSignature: Uint8Array;
};
/**
 * Describes the message meshtastic.Data.
 * Use `create(DataSchema)` to create a new message.
 */
declare const DataSchema: GenMessage<Data>;
/**
 *
 * The actual over-the-mesh message doing KeyVerification
 *
 * @generated from message meshtastic.KeyVerification
 */
type KeyVerification = Message<"meshtastic.KeyVerification"> & {
  /**
   *
   * random value Selected by the requesting node
   *
   * @generated from field: uint64 nonce = 1;
   */
  nonce: bigint;
  /**
   *
   * The final authoritative hash, only to be sent by NodeA at the end of the handshake
   *
   * @generated from field: bytes hash1 = 2;
   */
  hash1: Uint8Array;
  /**
   *
   * The intermediary hash (actually derived from hash1),
   * sent from NodeB to NodeA in response to the initial message.
   *
   * @generated from field: bytes hash2 = 3;
   */
  hash2: Uint8Array;
};
/**
 * Describes the message meshtastic.KeyVerification.
 * Use `create(KeyVerificationSchema)` to create a new message.
 */
declare const KeyVerificationSchema: GenMessage<KeyVerification>;
/**
 *
 * The actual over-the-mesh message doing store and forward++
 *
 * @generated from message meshtastic.StoreForwardPlusPlus
 */
type StoreForwardPlusPlus = Message<"meshtastic.StoreForwardPlusPlus"> & {
  /**
   *
   * Which message type is this
   *
   * @generated from field: meshtastic.StoreForwardPlusPlus.SFPP_message_type sfpp_message_type = 1;
   */
  sfppMessageType: StoreForwardPlusPlus_SFPP_message_type;
  /**
   *
   * The hash of the specific message
   *
   * @generated from field: bytes message_hash = 2;
   */
  messageHash: Uint8Array;
  /**
   *
   * The hash of a link on a chain
   *
   * @generated from field: bytes commit_hash = 3;
   */
  commitHash: Uint8Array;
  /**
   *
   * the root hash of a chain
   *
   * @generated from field: bytes root_hash = 4;
   */
  rootHash: Uint8Array;
  /**
   *
   * The encrypted bytes from a message
   *
   * @generated from field: bytes message = 5;
   */
  message: Uint8Array;
  /**
   *
   * Message ID of the contained message
   *
   * @generated from field: uint32 encapsulated_id = 6;
   */
  encapsulatedId: number;
  /**
   *
   * Destination of the contained message
   *
   * @generated from field: uint32 encapsulated_to = 7;
   */
  encapsulatedTo: number;
  /**
   *
   * Sender of the contained message
   *
   * @generated from field: uint32 encapsulated_from = 8;
   */
  encapsulatedFrom: number;
  /**
   *
   * The receive time of the message in question
   *
   * @generated from field: uint32 encapsulated_rxtime = 9;
   */
  encapsulatedRxtime: number;
  /**
   *
   * Used in a LINK_REQUEST to specify the message X spots back from head
   *
   * @generated from field: uint32 chain_count = 10;
   */
  chainCount: number;
};
/**
 * Describes the message meshtastic.StoreForwardPlusPlus.
 * Use `create(StoreForwardPlusPlusSchema)` to create a new message.
 */
declare const StoreForwardPlusPlusSchema: GenMessage<StoreForwardPlusPlus>;
/**
 *
 * Enum of message types
 *
 * @generated from enum meshtastic.StoreForwardPlusPlus.SFPP_message_type
 */
declare enum StoreForwardPlusPlus_SFPP_message_type {
  /**
   *
   * Send an announcement of the canonical tip of a chain
   *
   * @generated from enum value: CANON_ANNOUNCE = 0;
   */
  CANON_ANNOUNCE = 0,
  /**
   *
   * Query whether a specific link is on the chain
   *
   * @generated from enum value: CHAIN_QUERY = 1;
   */
  CHAIN_QUERY = 1,
  /**
   *
   * Request the next link in the chain
   *
   * @generated from enum value: LINK_REQUEST = 3;
   */
  LINK_REQUEST = 3,
  /**
   *
   * Provide a link to add to the chain
   *
   * @generated from enum value: LINK_PROVIDE = 4;
   */
  LINK_PROVIDE = 4,
  /**
   *
   * If we must fragment, send the first half
   *
   * @generated from enum value: LINK_PROVIDE_FIRSTHALF = 5;
   */
  LINK_PROVIDE_FIRSTHALF = 5,
  /**
   *
   * If we must fragment, send the second half
   *
   * @generated from enum value: LINK_PROVIDE_SECONDHALF = 6;
   */
  LINK_PROVIDE_SECONDHALF = 6
}
/**
 * Describes the enum meshtastic.StoreForwardPlusPlus.SFPP_message_type.
 */
declare const StoreForwardPlusPlus_SFPP_message_typeSchema: GenEnum<StoreForwardPlusPlus_SFPP_message_type>;
/**
 *
 * The actual over-the-mesh message doing RemoteShell
 *
 * @generated from message meshtastic.RemoteShell
 */
type RemoteShell = Message<"meshtastic.RemoteShell"> & {
  /**
   *
   * Structured frame operation.
   *
   * @generated from field: meshtastic.RemoteShell.OpCode op = 1;
   */
  op: RemoteShell_OpCode;
  /**
   *
   * Logical PTY session identifier.
   *
   * @generated from field: uint32 session_id = 2;
   */
  sessionId: number;
  /**
   *
   * Monotonic sequence number for this frame.
   *
   * @generated from field: uint32 seq = 3;
   */
  seq: number;
  /**
   *
   * Cumulative ack sequence number.
   *
   * @generated from field: uint32 ack_seq = 4;
   */
  ackSeq: number;
  /**
   *
   * Opaque bytes payload for INPUT/OUTPUT/ERROR and other frame bodies.
   *
   * @generated from field: bytes payload = 5;
   */
  payload: Uint8Array;
  /**
   *
   * Terminal size columns used for OPEN/RESIZE signaling.
   *
   * @generated from field: uint32 cols = 6;
   */
  cols: number;
  /**
   *
   * Terminal size rows used for OPEN/RESIZE signaling.
   *
   * @generated from field: uint32 rows = 7;
   */
  rows: number;
  /**
   *
   * Bit flags for protocol extensions.
   *
   * @generated from field: uint32 flags = 8;
   */
  flags: number;
  /**
   *
   * The last sequence number TX'd.
   *
   * @generated from field: uint32 last_tx_seq = 9;
   */
  lastTxSeq: number;
  /**
   *
   * The last sequence number RX'd.
   *
   * @generated from field: uint32 last_rx_seq = 10;
   */
  lastRxSeq: number;
};
/**
 * Describes the message meshtastic.RemoteShell.
 * Use `create(RemoteShellSchema)` to create a new message.
 */
declare const RemoteShellSchema: GenMessage<RemoteShell>;
/**
 *
 * Frame op code for PTY session control and stream transport.
 *
 * Values 1-63 are client->server requests.
 * Values 64-127 are server->client responses/events.
 *
 * @generated from enum meshtastic.RemoteShell.OpCode
 */
declare enum RemoteShell_OpCode {
  /**
   * @generated from enum value: OP_UNSET = 0;
   */
  OP_UNSET = 0,
  /**
   * Client -> server
   *
   * @generated from enum value: OPEN = 1;
   */
  OPEN = 1,
  /**
   * @generated from enum value: INPUT = 2;
   */
  INPUT = 2,
  /**
   * @generated from enum value: RESIZE = 3;
   */
  RESIZE = 3,
  /**
   * @generated from enum value: CLOSE = 4;
   */
  CLOSE = 4,
  /**
   * @generated from enum value: PING = 5;
   */
  PING = 5,
  /**
   * @generated from enum value: ACK = 6;
   */
  ACK = 6,
  /**
   * Server -> client
   *
   * @generated from enum value: OPEN_OK = 64;
   */
  OPEN_OK = 64,
  /**
   * @generated from enum value: OUTPUT = 65;
   */
  OUTPUT = 65,
  /**
   * @generated from enum value: CLOSED = 66;
   */
  CLOSED = 66,
  /**
   * @generated from enum value: ERROR = 67;
   */
  ERROR = 67,
  /**
   * @generated from enum value: PONG = 68;
   */
  PONG = 68
}
/**
 * Describes the enum meshtastic.RemoteShell.OpCode.
 */
declare const RemoteShell_OpCodeSchema: GenEnum<RemoteShell_OpCode>;
/**
 *
 * A rectangular, axis-aligned geographic bounding box.
 * Used to define a rectangular geofence region for a Waypoint.
 * Fields are ordered west, south, east, north to match the standard bounding box
 * convention used by GeoJSON and PMTiles (min longitude, min latitude, max longitude, max latitude),
 * so the box can drive an offline map extract directly.
 * All coordinates are in degrees scaled by 1e-7 (same convention as Position and Waypoint).
 *
 * @generated from message meshtastic.BoundingBox
 */
type BoundingBox = Message<"meshtastic.BoundingBox"> & {
  /**
   *
   * Western edge of the box - minimum longitude (south-west corner)
   *
   * @generated from field: sfixed32 longitude_west_i = 1;
   */
  longitudeWestI: number;
  /**
   *
   * Southern edge of the box - minimum latitude (south-west corner)
   *
   * @generated from field: sfixed32 latitude_south_i = 2;
   */
  latitudeSouthI: number;
  /**
   *
   * Eastern edge of the box - maximum longitude (north-east corner)
   *
   * @generated from field: sfixed32 longitude_east_i = 3;
   */
  longitudeEastI: number;
  /**
   *
   * Northern edge of the box - maximum latitude (north-east corner)
   *
   * @generated from field: sfixed32 latitude_north_i = 4;
   */
  latitudeNorthI: number;
};
/**
 * Describes the message meshtastic.BoundingBox.
 * Use `create(BoundingBoxSchema)` to create a new message.
 */
declare const BoundingBoxSchema: GenMessage<BoundingBox>;
/**
 *
 * Waypoint message, used to share arbitrary locations across the mesh
 *
 * @generated from message meshtastic.Waypoint
 */
type Waypoint = Message<"meshtastic.Waypoint"> & {
  /**
   *
   * Id of the waypoint
   *
   * @generated from field: uint32 id = 1;
   */
  id: number;
  /**
   *
   * latitude_i
   *
   * @generated from field: optional sfixed32 latitude_i = 2;
   */
  latitudeI?: number;
  /**
   *
   * longitude_i
   *
   * @generated from field: optional sfixed32 longitude_i = 3;
   */
  longitudeI?: number;
  /**
   *
   * Time the waypoint is to expire (epoch)
   *
   * @generated from field: uint32 expire = 4;
   */
  expire: number;
  /**
   *
   * If greater than zero, treat the value as a nodenum only allowing them to update the waypoint.
   * If zero, the waypoint is open to be edited by any member of the mesh.
   *
   * @generated from field: uint32 locked_to = 5;
   */
  lockedTo: number;
  /**
   *
   * Name of the waypoint - max 30 chars
   *
   * @generated from field: string name = 6;
   */
  name: string;
  /**
   *
   * Description of the waypoint - max 100 chars
   *
   * @generated from field: string description = 7;
   */
  description: string;
  /**
   *
   * Designator icon for the waypoint in the form of a unicode emoji
   *
   * @generated from field: fixed32 icon = 8;
   */
  icon: number;
  /**
   *
   * If greater than zero, defines a circular geofence centred on this waypoint's
   * location (latitude_i / longitude_i) with this radius in meters.
   * Zero means the waypoint has no circular geofence.
   *
   * @generated from field: uint32 geofence_radius = 9;
   */
  geofenceRadius: number;
  /**
   *
   * Optional rectangular geofence region for this waypoint.
   * May be used instead of, or in addition to, geofence_radius.
   *
   * @generated from field: optional meshtastic.BoundingBox bounding_box = 10;
   */
  boundingBox?: BoundingBox;
  /**
   *
   * If true, a notification should be raised when a tracked node enters this
   * waypoint's geofence (the circular radius and/or the bounding box).
   *
   * @generated from field: bool notify_on_enter = 11;
   */
  notifyOnEnter: boolean;
  /**
   *
   * If true, a notification should be raised when a tracked node exits this
   * waypoint's geofence (the circular radius and/or the bounding box).
   *
   * @generated from field: bool notify_on_exit = 12;
   */
  notifyOnExit: boolean;
  /**
   *
   * If true, only raise geofence enter/exit notifications for nodes that are
   * marked as favorites on the receiving device. Applies to both notify_on_enter
   * and notify_on_exit. Favorite status is resolved locally per receiver, so the
   * same waypoint alerts each node only for its own favorites.
   *
   * @generated from field: bool notify_favorites_only = 13;
   */
  notifyFavoritesOnly: boolean;
};
/**
 * Describes the message meshtastic.Waypoint.
 * Use `create(WaypointSchema)` to create a new message.
 */
declare const WaypointSchema: GenMessage<Waypoint>;
/**
 *
 * Message for node status
 *
 * @generated from message meshtastic.StatusMessage
 */
type StatusMessage = Message<"meshtastic.StatusMessage"> & {
  /**
   * @generated from field: string status = 1;
   */
  status: string;
};
/**
 * Describes the message meshtastic.StatusMessage.
 * Use `create(StatusMessageSchema)` to create a new message.
 */
declare const StatusMessageSchema: GenMessage<StatusMessage>;
/**
 *
 * This message will be proxied over the PhoneAPI for the client to deliver to the MQTT server
 *
 * @generated from message meshtastic.MqttClientProxyMessage
 */
type MqttClientProxyMessage = Message<"meshtastic.MqttClientProxyMessage"> & {
  /**
   *
   * The MQTT topic this message will be sent /received on
   *
   * @generated from field: string topic = 1;
   */
  topic: string;
  /**
   *
   * The actual service envelope payload or text for mqtt pub / sub
   *
   * @generated from oneof meshtastic.MqttClientProxyMessage.payload_variant
   */
  payloadVariant: {
    /**
     *
     * Bytes
     *
     * @generated from field: bytes data = 2;
     */
    value: Uint8Array;
    case: "data";
  } | {
    /**
     *
     * Text
     *
     * @generated from field: string text = 3;
     */
    value: string;
    case: "text";
  } | {
    case: undefined;
    value?: undefined;
  };
  /**
   *
   * Whether the message should be retained (or not)
   *
   * @generated from field: bool retained = 4;
   */
  retained: boolean;
};
/**
 * Describes the message meshtastic.MqttClientProxyMessage.
 * Use `create(MqttClientProxyMessageSchema)` to create a new message.
 */
declare const MqttClientProxyMessageSchema: GenMessage<MqttClientProxyMessage>;
/**
 *
 * A packet envelope sent/received over the mesh
 * only payload_variant is sent in the payload portion of the LORA packet.
 * The other fields are either not sent at all, or sent in the special 16 byte LORA header.
 *
 * @generated from message meshtastic.MeshPacket
 */
type MeshPacket = Message<"meshtastic.MeshPacket"> & {
  /**
   *
   * The sending node number.
   * Note: Our crypto implementation uses this field as well.
   * See [crypto](/docs/overview/encryption) for details.
   *
   * @generated from field: fixed32 from = 1;
   */
  from: number;
  /**
   *
   * The (immediate) destination for this packet
   * If the value is 4,294,967,295 (maximum value of an unsigned 32bit integer), this indicates that the packet was
   * not destined for a specific node, but for a channel as indicated by the value of `channel` below.
   * If the value is another, this indicates that the packet was destined for a specific
   * node (i.e. a kind of "Direct Message" to this node) and not broadcast on a channel.
   *
   * @generated from field: fixed32 to = 2;
   */
  to: number;
  /**
   *
   * (Usually) If set, this indicates the index in the secondary_channels table that this packet was sent/received on.
   * If unset, packet was on the primary channel.
   * A particular node might know only a subset of channels in use on the mesh.
   * Therefore channel_index is inherently a local concept and meaningless to send between nodes.
   * Very briefly, while sending and receiving deep inside the device Router code, this field instead
   * contains the 'channel hash' instead of the index.
   * This 'trick' is only used while the payload_variant is an 'encrypted'.
   *
   * @generated from field: uint32 channel = 3;
   */
  channel: number;
  /**
   * @generated from oneof meshtastic.MeshPacket.payload_variant
   */
  payloadVariant: {
    /**
     *
     * TODO: REPLACE
     *
     * @generated from field: meshtastic.Data decoded = 4;
     */
    value: Data;
    case: "decoded";
  } | {
    /**
     *
     * TODO: REPLACE
     *
     * @generated from field: bytes encrypted = 5;
     */
    value: Uint8Array;
    case: "encrypted";
  } | {
    case: undefined;
    value?: undefined;
  };
  /**
   *
   * A unique ID for this packet.
   * Always 0 for no-ack packets or non broadcast packets (and therefore take zero bytes of space).
   * Otherwise a unique ID for this packet, useful for flooding algorithms.
   * ID only needs to be unique on a _per sender_ basis, and it only
   * needs to be unique for a few minutes (long enough to last for the length of
   * any ACK or the completion of a mesh broadcast flood).
   * Note: Our crypto implementation uses this id as well.
   * See [crypto](/docs/overview/encryption) for details.
   *
   * @generated from field: fixed32 id = 6;
   */
  id: number;
  /**
   *
   * The time this message was received by the esp32 (secs since 1970).
   * Note: this field is _never_ sent on the radio link itself (to save space) Times
   * are typically not sent over the mesh, but they will be added to any Packet
   * (chain of SubPacket) sent to the phone (so the phone can know exact time of reception)
   * Explicit presence: firmware cannot always attach a trustworthy wall-clock timestamp at the
   * moment of reception - a node with no GPS and no phone connected yet has no time source at
   * all. has_rx_time disambiguates that state from a genuine (if coincidental) 1970-01-01
   * reading. A packet delivered with this field absent may still be re-timestamped once a valid
   * clock becomes available, before the phone ever sees it - "absent" is not guaranteed
   * permanent, only "not yet known at last observation".
   *
   * @generated from field: optional fixed32 rx_time = 7;
   */
  rxTime?: number;
  /**
   *
   * *Never* sent over the radio links.
   * Set during reception to indicate the SNR of this packet.
   * Used to collect statistics on current link quality.
   *
   * @generated from field: float rx_snr = 8;
   */
  rxSnr: number;
  /**
   *
   * If unset treated as zero (no forwarding, send to direct neighbor nodes only)
   * if 1, allow hopping through one node, etc...
   * For our usecase real world topologies probably have a max of about 3.
   * This field is normally placed into a few of bits in the header.
   *
   * @generated from field: uint32 hop_limit = 9;
   */
  hopLimit: number;
  /**
   *
   * This packet is being sent as a reliable message, we would prefer it to arrive at the destination.
   * We would like to receive a ack packet in response.
   * Broadcasts messages treat this flag specially: Since acks for broadcasts would
   * rapidly flood the channel, the normal ack behavior is suppressed.
   * Instead, the original sender listens to see if at least one node is rebroadcasting this packet (because naive flooding algorithm).
   * If it hears that the odds (given typical LoRa topologies) the odds are very high that every node should eventually receive the message.
   * So FloodingRouter.cpp generates an implicit ack which is delivered to the original sender.
   * If after some time we don't hear anyone rebroadcast our packet, we will timeout and retransmit, using the regular resend logic.
   * Note: This flag is normally sent in a flag bit in the header when sent over the wire
   *
   * @generated from field: bool want_ack = 10;
   */
  wantAck: boolean;
  /**
   *
   * The priority of this message for sending.
   * See MeshPacket.Priority description for more details.
   *
   * @generated from field: meshtastic.MeshPacket.Priority priority = 11;
   */
  priority: MeshPacket_Priority;
  /**
   *
   * rssi of received packet. Only sent to phone for dispay purposes.
   * Explicit presence: rssi 0 is a legitimate reading on some radios (SX126x can report exactly
   * 0 dBm; SX127x's formula can even go positive). has_rx_rssi disambiguates; a replayed packet
   * built from history should leave this field absent rather than emitting 0.
   *
   * @generated from field: optional int32 rx_rssi = 12;
   */
  rxRssi?: number;
  /**
   *
   * Describe if this message is delayed
   *
   * @generated from field: meshtastic.MeshPacket.Delayed delayed = 13 [deprecated = true];
   * @deprecated
   */
  delayed: MeshPacket_Delayed;
  /**
   *
   * Describes whether this packet passed via MQTT somewhere along the path it currently took.
   *
   * @generated from field: bool via_mqtt = 14;
   */
  viaMqtt: boolean;
  /**
   *
   * Hop limit with which the original packet started. Sent via LoRa using three bits in the unencrypted header.
   * When receiving a packet, the difference between hop_start and hop_limit gives how many hops it traveled.
   * hop_start == 0 does not necessarily mean a direct (0-hop) neighbor: firmware prior to 2.3.0
   * never populated this field, so a receiver can only trust hop_start == 0 as genuine once it has
   * decoded the packet and confirmed the sender's bitfield is present (added in 2.5.0). Until then,
   * or for a sender that never sets that bitfield, treat hop_start == 0 as unknown, not direct.
   *
   * @generated from field: uint32 hop_start = 15;
   */
  hopStart: number;
  /**
   *
   * Records the public key the packet was encrypted with, if applicable.
   *
   * @generated from field: bytes public_key = 16;
   */
  publicKey: Uint8Array;
  /**
   *
   * Indicates whether the packet was en/decrypted using PKI
   *
   * @generated from field: bool pki_encrypted = 17;
   */
  pkiEncrypted: boolean;
  /**
   *
   * Last byte of the node number of the node that should be used as the next hop in routing.
   * Set by the firmware internally, clients are not supposed to set this.
   *
   * @generated from field: uint32 next_hop = 18;
   */
  nextHop: number;
  /**
   *
   * Last byte of the node number of the node that will relay/relayed this packet.
   * Set by the firmware internally, clients are not supposed to set this.
   *
   * @generated from field: uint32 relay_node = 19;
   */
  relayNode: number;
  /**
   *
   * *Never* sent over the radio links.
   * Timestamp after which this packet may be sent.
   * Set by the firmware internally, clients are not supposed to set this.
   *
   * @generated from field: uint32 tx_after = 20;
   */
  txAfter: number;
  /**
   *
   * Indicates which transport mechanism this packet arrived over
   *
   * @generated from field: meshtastic.MeshPacket.TransportMechanism transport_mechanism = 21;
   */
  transportMechanism: MeshPacket_TransportMechanism;
  /**
   *
   * Indicates whether the packet has a valid signature
   *
   * @generated from field: bool xeddsa_signed = 22;
   */
  xeddsaSigned: boolean;
};
/**
 * Describes the message meshtastic.MeshPacket.
 * Use `create(MeshPacketSchema)` to create a new message.
 */
declare const MeshPacketSchema: GenMessage<MeshPacket>;
/**
 *
 * The priority of this message for sending.
 * Higher priorities are sent first (when managing the transmit queue).
 * This field is never sent over the air, it is only used internally inside of a local device node.
 * API clients (either on the local node or connected directly to the node)
 * can set this parameter if necessary.
 * (values must be <= 127 to keep protobuf field to one byte in size.
 * Detailed background on this field:
 * I noticed a funny side effect of lora being so slow: Usually when making
 * a protocol there isn’t much need to use message priority to change the order
 * of transmission (because interfaces are fairly fast).
 * But for lora where packets can take a few seconds each, it is very important
 * to make sure that critical packets are sent ASAP.
 * In the case of meshtastic that means we want to send protocol acks as soon as possible
 * (to prevent unneeded retransmissions), we want routing messages to be sent next,
 * then messages marked as reliable and finally 'background' packets like periodic position updates.
 * So I bit the bullet and implemented a new (internal - not sent over the air)
 * field in MeshPacket called 'priority'.
 * And the transmission queue in the router object is now a priority queue.
 *
 * @generated from enum meshtastic.MeshPacket.Priority
 */
declare enum MeshPacket_Priority {
  /**
   *
   * Treated as Priority.DEFAULT
   *
   * @generated from enum value: UNSET = 0;
   */
  UNSET = 0,
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: MIN = 1;
   */
  MIN = 1,
  /**
   *
   * Background position updates are sent with very low priority -
   * if the link is super congested they might not go out at all
   *
   * @generated from enum value: BACKGROUND = 10;
   */
  BACKGROUND = 10,
  /**
   *
   * This priority is used for most messages that don't have a priority set
   *
   * @generated from enum value: DEFAULT = 64;
   */
  DEFAULT = 64,
  /**
   *
   * If priority is unset but the message is marked as want_ack,
   * assume it is important and use a slightly higher priority
   *
   * @generated from enum value: RELIABLE = 70;
   */
  RELIABLE = 70,
  /**
   *
   * If priority is unset but the packet is a response to a request, we want it to get there relatively quickly.
   * Furthermore, responses stop relaying packets directed to a node early.
   *
   * @generated from enum value: RESPONSE = 80;
   */
  RESPONSE = 80,
  /**
   *
   * Higher priority for specific message types (portnums) to distinguish between other reliable packets.
   *
   * @generated from enum value: HIGH = 100;
   */
  HIGH = 100,
  /**
   *
   * Higher priority alert message used for critical alerts which take priority over other reliable packets.
   *
   * @generated from enum value: ALERT = 110;
   */
  ALERT = 110,
  /**
   *
   * Ack/naks are sent with very high priority to ensure that retransmission
   * stops as soon as possible
   *
   * @generated from enum value: ACK = 120;
   */
  ACK = 120,
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: MAX = 127;
   */
  MAX = 127
}
/**
 * Describes the enum meshtastic.MeshPacket.Priority.
 */
declare const MeshPacket_PrioritySchema: GenEnum<MeshPacket_Priority>;
/**
 *
 * Identify if this is a delayed packet
 *
 * @generated from enum meshtastic.MeshPacket.Delayed
 */
declare enum MeshPacket_Delayed {
  /**
   *
   * If unset, the message is being sent in real time.
   *
   * @generated from enum value: NO_DELAY = 0;
   */
  NO_DELAY = 0,
  /**
   *
   * The message is delayed and was originally a broadcast
   *
   * @generated from enum value: DELAYED_BROADCAST = 1;
   */
  DELAYED_BROADCAST = 1,
  /**
   *
   * The message is delayed and was originally a direct message
   *
   * @generated from enum value: DELAYED_DIRECT = 2;
   */
  DELAYED_DIRECT = 2
}
/**
 * Describes the enum meshtastic.MeshPacket.Delayed.
 */
declare const MeshPacket_DelayedSchema: GenEnum<MeshPacket_Delayed>;
/**
 *
 * Enum to identify which transport mechanism this packet arrived over
 *
 * @generated from enum meshtastic.MeshPacket.TransportMechanism
 */
declare enum MeshPacket_TransportMechanism {
  /**
   *
   * The default case is that the node generated a packet itself
   *
   * @generated from enum value: TRANSPORT_INTERNAL = 0;
   */
  TRANSPORT_INTERNAL = 0,
  /**
   *
   * Arrived via the primary LoRa radio
   *
   * @generated from enum value: TRANSPORT_LORA = 1;
   */
  TRANSPORT_LORA = 1,
  /**
   *
   * Arrived via a secondary LoRa radio
   *
   * @generated from enum value: TRANSPORT_LORA_ALT1 = 2;
   */
  TRANSPORT_LORA_ALT1 = 2,
  /**
   *
   * Arrived via a tertiary LoRa radio
   *
   * @generated from enum value: TRANSPORT_LORA_ALT2 = 3;
   */
  TRANSPORT_LORA_ALT2 = 3,
  /**
   *
   * Arrived via a quaternary LoRa radio
   *
   * @generated from enum value: TRANSPORT_LORA_ALT3 = 4;
   */
  TRANSPORT_LORA_ALT3 = 4,
  /**
   *
   * Arrived via an MQTT connection
   *
   * @generated from enum value: TRANSPORT_MQTT = 5;
   */
  TRANSPORT_MQTT = 5,
  /**
   *
   * Arrived via Multicast UDP
   *
   * @generated from enum value: TRANSPORT_MULTICAST_UDP = 6;
   */
  TRANSPORT_MULTICAST_UDP = 6,
  /**
   *
   * Arrived via API connection
   *
   * @generated from enum value: TRANSPORT_API = 7;
   */
  TRANSPORT_API = 7,
  /**
   *
   * Arrived via Unicast UDP
   *
   * @generated from enum value: TRANSPORT_UNICAST_UDP = 8;
   */
  TRANSPORT_UNICAST_UDP = 8
}
/**
 * Describes the enum meshtastic.MeshPacket.TransportMechanism.
 */
declare const MeshPacket_TransportMechanismSchema: GenEnum<MeshPacket_TransportMechanism>;
/**
 *
 * The bluetooth to device link:
 * Old BTLE protocol docs from TODO, merge in above and make real docs...
 * use protocol buffers, and NanoPB
 * messages from device to phone:
 * POSITION_UPDATE (..., time)
 * TEXT_RECEIVED(from, text, time)
 * OPAQUE_RECEIVED(from, payload, time) (for signal messages or other applications)
 * messages from phone to device:
 * SET_MYID(id, human readable long, human readable short) (send down the unique ID
 * string used for this node, a human readable string shown for that id, and a very
 * short human readable string suitable for oled screen) SEND_OPAQUE(dest, payload)
 * (for signal messages or other applications) SEND_TEXT(dest, text) Get all
 * nodes() (returns list of nodes, with full info, last time seen, loc, battery
 * level etc) SET_CONFIG (switches device to a new set of radio params and
 * preshared key, drops all existing nodes, force our node to rejoin this new group)
 * Full information about a node on the mesh
 *
 * @generated from message meshtastic.NodeInfo
 */
type NodeInfo = Message<"meshtastic.NodeInfo"> & {
  /**
   *
   * The node number
   *
   * @generated from field: uint32 num = 1;
   */
  num: number;
  /**
   *
   * The user info for this node
   *
   * @generated from field: meshtastic.User user = 2;
   */
  user?: User;
  /**
   *
   * This position data. Note: before 1.2.14 we would also store the last time we've heard from this node in position.time, that is no longer true.
   * Position.time now indicates the last time we received a POSITION from that node.
   *
   * @generated from field: meshtastic.Position position = 3;
   */
  position?: Position;
  /**
   *
   * Returns the Signal-to-noise ratio (SNR) of the last received message,
   * as measured by the receiver. Return SNR of the last received message in dB
   *
   * @generated from field: float snr = 4;
   */
  snr: number;
  /**
   *
   * Set to indicate the last time we received a packet from this node
   *
   * @generated from field: fixed32 last_heard = 5;
   */
  lastHeard: number;
  /**
   *
   * The latest device metrics for the node.
   *
   * @generated from field: meshtastic.DeviceMetrics device_metrics = 6;
   */
  deviceMetrics?: DeviceMetrics;
  /**
   *
   * local channel index we heard that node on. Only populated if its not the default channel.
   *
   * @generated from field: uint32 channel = 7;
   */
  channel: number;
  /**
   *
   * True if we witnessed the node over MQTT instead of LoRA transport
   *
   * @generated from field: bool via_mqtt = 8;
   */
  viaMqtt: boolean;
  /**
   *
   * Number of hops away from us this node is (0 if direct neighbor)
   *
   * @generated from field: optional uint32 hops_away = 9;
   */
  hopsAway?: number;
  /**
   *
   * True if node is in our favorites list
   * Persists between NodeDB internal clean ups
   *
   * @generated from field: bool is_favorite = 10;
   */
  isFavorite: boolean;
  /**
   *
   * True if node is in our ignored list
   * Persists between NodeDB internal clean ups
   *
   * @generated from field: bool is_ignored = 11;
   */
  isIgnored: boolean;
  /**
   *
   * True if node public key has been verified.
   * Persists between NodeDB internal clean ups
   * LSB 0 of the bitfield
   *
   * @generated from field: bool is_key_manually_verified = 12;
   */
  isKeyManuallyVerified: boolean;
  /**
   *
   * True if node has been muted
   * Persistes between NodeDB internal clean ups
   *
   * @generated from field: bool is_muted = 13;
   */
  isMuted: boolean;
  /**
   *
   * True if node is signing its packets via XEdDSA
   * Persists between NodeDB internal clean ups
   * LSB 1 of the bitfield
   *
   * @generated from field: bool has_xeddsa_signed = 14;
   */
  hasXeddsaSigned: boolean;
};
/**
 * Describes the message meshtastic.NodeInfo.
 * Use `create(NodeInfoSchema)` to create a new message.
 */
declare const NodeInfoSchema: GenMessage<NodeInfo>;
/**
 *
 * Unique local debugging info for this node
 * Note: we don't include position or the user info, because that will come in the
 * Sent to the phone in response to WantNodes.
 *
 * @generated from message meshtastic.MyNodeInfo
 */
type MyNodeInfo = Message<"meshtastic.MyNodeInfo"> & {
  /**
   *
   * Tells the phone what our node number is, default starting value is
   * lowbyte of macaddr, but it will be fixed if that is already in use
   *
   * @generated from field: uint32 my_node_num = 1;
   */
  myNodeNum: number;
  /**
   *
   * The total number of reboots this node has ever encountered
   * (well - since the last time we discarded preferences)
   *
   * @generated from field: uint32 reboot_count = 8;
   */
  rebootCount: number;
  /**
   *
   * The minimum app version that can talk to this device.
   * Phone/PC apps should compare this to their build number and if too low tell the user they must update their app
   *
   * @generated from field: uint32 min_app_version = 11;
   */
  minAppVersion: number;
  /**
   *
   * Unique hardware identifier for this device
   *
   * @generated from field: bytes device_id = 12;
   */
  deviceId: Uint8Array;
  /**
   *
   * The PlatformIO environment used to build this firmware
   *
   * @generated from field: string pio_env = 13;
   */
  pioEnv: string;
  /**
   *
   * The indicator for whether this device is running event firmware and which
   *
   * @generated from field: meshtastic.FirmwareEdition firmware_edition = 14;
   */
  firmwareEdition: FirmwareEdition;
  /**
   *
   * The number of nodes in the nodedb.
   * This is used by the phone to know how many NodeInfo packets to expect on want_config
   *
   * @generated from field: uint32 nodedb_count = 15;
   */
  nodedbCount: number;
};
/**
 * Describes the message meshtastic.MyNodeInfo.
 * Use `create(MyNodeInfoSchema)` to create a new message.
 */
declare const MyNodeInfoSchema: GenMessage<MyNodeInfo>;
/**
 *
 * Debug output from the device.
 * To minimize the size of records inside the device code, if a time/source/level is not set
 * on the message it is assumed to be a continuation of the previously sent message.
 * This allows the device code to use fixed maxlen 64 byte strings for messages,
 * and then extend as needed by emitting multiple records.
 *
 * @generated from message meshtastic.LogRecord
 */
type LogRecord = Message<"meshtastic.LogRecord"> & {
  /**
   *
   * Log levels, chosen to match python logging conventions.
   *
   * @generated from field: string message = 1;
   */
  message: string;
  /**
   *
   * Seconds since 1970 - or 0 for unknown/unset
   *
   * @generated from field: fixed32 time = 2;
   */
  time: number;
  /**
   *
   * Usually based on thread name - if known
   *
   * @generated from field: string source = 3;
   */
  source: string;
  /**
   *
   * Not yet set
   *
   * @generated from field: meshtastic.LogRecord.Level level = 4;
   */
  level: LogRecord_Level;
};
/**
 * Describes the message meshtastic.LogRecord.
 * Use `create(LogRecordSchema)` to create a new message.
 */
declare const LogRecordSchema: GenMessage<LogRecord>;
/**
 *
 * Log levels, chosen to match python logging conventions.
 *
 * @generated from enum meshtastic.LogRecord.Level
 */
declare enum LogRecord_Level {
  /**
   *
   * Log levels, chosen to match python logging conventions.
   *
   * @generated from enum value: UNSET = 0;
   */
  UNSET = 0,
  /**
   *
   * Log levels, chosen to match python logging conventions.
   *
   * @generated from enum value: CRITICAL = 50;
   */
  CRITICAL = 50,
  /**
   *
   * Log levels, chosen to match python logging conventions.
   *
   * @generated from enum value: ERROR = 40;
   */
  ERROR = 40,
  /**
   *
   * Log levels, chosen to match python logging conventions.
   *
   * @generated from enum value: WARNING = 30;
   */
  WARNING = 30,
  /**
   *
   * Log levels, chosen to match python logging conventions.
   *
   * @generated from enum value: INFO = 20;
   */
  INFO = 20,
  /**
   *
   * Log levels, chosen to match python logging conventions.
   *
   * @generated from enum value: DEBUG = 10;
   */
  DEBUG = 10,
  /**
   *
   * Log levels, chosen to match python logging conventions.
   *
   * @generated from enum value: TRACE = 5;
   */
  TRACE = 5
}
/**
 * Describes the enum meshtastic.LogRecord.Level.
 */
declare const LogRecord_LevelSchema: GenEnum<LogRecord_Level>;
/**
 * @generated from message meshtastic.QueueStatus
 */
type QueueStatus = Message<"meshtastic.QueueStatus"> & {
  /**
   * Last attempt to queue status, ErrorCode
   *
   * @generated from field: int32 res = 1;
   */
  res: number;
  /**
   * Free entries in the outgoing queue
   *
   * @generated from field: uint32 free = 2;
   */
  free: number;
  /**
   * Maximum entries in the outgoing queue
   *
   * @generated from field: uint32 maxlen = 3;
   */
  maxlen: number;
  /**
   * What was mesh packet id that generated this response?
   *
   * @generated from field: uint32 mesh_packet_id = 4;
   */
  meshPacketId: number;
};
/**
 * Describes the message meshtastic.QueueStatus.
 * Use `create(QueueStatusSchema)` to create a new message.
 */
declare const QueueStatusSchema: GenMessage<QueueStatus>;
/**
 *
 * Packets from the radio to the phone will appear on the fromRadio characteristic.
 * It will support READ and NOTIFY. When a new packet arrives the device will BLE notify?
 * It will sit in that descriptor until consumed by the phone,
 * at which point the next item in the FIFO will be populated.
 *
 * @generated from message meshtastic.FromRadio
 */
type FromRadio = Message<"meshtastic.FromRadio"> & {
  /**
   *
   * The packet id, used to allow the phone to request missing read packets from the FIFO,
   * see our bluetooth docs
   *
   * @generated from field: uint32 id = 1;
   */
  id: number;
  /**
   *
   * Log levels, chosen to match python logging conventions.
   *
   * @generated from oneof meshtastic.FromRadio.payload_variant
   */
  payloadVariant: {
    /**
     *
     * Log levels, chosen to match python logging conventions.
     *
     * @generated from field: meshtastic.MeshPacket packet = 2;
     */
    value: MeshPacket;
    case: "packet";
  } | {
    /**
     *
     * Tells the phone what our node number is, can be -1 if we've not yet joined a mesh.
     * NOTE: This ID must not change - to keep (minimal) compatibility with <1.2 version of android apps.
     *
     * @generated from field: meshtastic.MyNodeInfo my_info = 3;
     */
    value: MyNodeInfo;
    case: "myInfo";
  } | {
    /**
     *
     * One packet is sent for each node in the on radio DB
     * starts over with the first node in our DB
     *
     * @generated from field: meshtastic.NodeInfo node_info = 4;
     */
    value: NodeInfo;
    case: "nodeInfo";
  } | {
    /**
     *
     * Include a part of the config (was: RadioConfig radio)
     *
     * @generated from field: meshtastic.Config config = 5;
     */
    value: Config;
    case: "config";
  } | {
    /**
     *
     * Set to send debug console output over our protobuf stream
     *
     * @generated from field: meshtastic.LogRecord log_record = 6;
     */
    value: LogRecord;
    case: "logRecord";
  } | {
    /**
     *
     * Sent as true once the device has finished sending all of the responses to want_config
     * recipient should check if this ID matches our original request nonce, if
     * not, it means your config responses haven't started yet.
     * NOTE: This ID must not change - to keep (minimal) compatibility with <1.2 version of android apps.
     *
     * @generated from field: uint32 config_complete_id = 7;
     */
    value: number;
    case: "configCompleteId";
  } | {
    /**
     *
     * Sent to tell clients the radio has just rebooted.
     * Set to true if present.
     * Not used on all transports, currently just used for the serial console.
     * NOTE: This ID must not change - to keep (minimal) compatibility with <1.2 version of android apps.
     *
     * @generated from field: bool rebooted = 8;
     */
    value: boolean;
    case: "rebooted";
  } | {
    /**
     *
     * Include module config
     *
     * @generated from field: meshtastic.ModuleConfig moduleConfig = 9;
     */
    value: ModuleConfig;
    case: "moduleConfig";
  } | {
    /**
     *
     * One packet is sent for each channel
     *
     * @generated from field: meshtastic.Channel channel = 10;
     */
    value: Channel;
    case: "channel";
  } | {
    /**
     *
     * Queue status info
     *
     * @generated from field: meshtastic.QueueStatus queueStatus = 11;
     */
    value: QueueStatus;
    case: "queueStatus";
  } | {
    /**
     *
     * File Transfer Chunk
     *
     * @generated from field: meshtastic.XModem xmodemPacket = 12;
     */
    value: XModem;
    case: "xmodemPacket";
  } | {
    /**
     *
     * Device metadata message
     *
     * @generated from field: meshtastic.DeviceMetadata metadata = 13;
     */
    value: DeviceMetadata;
    case: "metadata";
  } | {
    /**
     *
     * MQTT Client Proxy Message (device sending to client / phone for publishing to MQTT)
     *
     * @generated from field: meshtastic.MqttClientProxyMessage mqttClientProxyMessage = 14;
     */
    value: MqttClientProxyMessage;
    case: "mqttClientProxyMessage";
  } | {
    /**
     *
     * File system manifest messages
     *
     * @generated from field: meshtastic.FileInfo fileInfo = 15;
     */
    value: FileInfo;
    case: "fileInfo";
  } | {
    /**
     *
     * Notification message to the client
     *
     * @generated from field: meshtastic.ClientNotification clientNotification = 16;
     */
    value: ClientNotification;
    case: "clientNotification";
  } | {
    /**
     *
     * Persistent data for device-ui
     *
     * @generated from field: meshtastic.DeviceUIConfig deviceuiConfig = 17;
     */
    value: DeviceUIConfig;
    case: "deviceuiConfig";
  } | {
    /**
     *
     * Lockdown state notification for hardened firmware builds.
     * Sent post-config (so unauthorized clients learn they must
     * provision/unlock) and after each LockdownAuth admin command
     * to report success or failure. Replaces the earlier scheme of
     * encoding state as magic-string prefixes inside ClientNotification.
     *
     * @generated from field: meshtastic.LockdownStatus lockdown_status = 18;
     */
    value: LockdownStatus;
    case: "lockdownStatus";
  } | {
    /**
     *
     * Map of which modem presets are legal in each LoRa region. Sent once
     * during the want_config handshake (right after `metadata`, before the
     * first `channel`) so client UIs can prevent the user from selecting an
     * illegal region+preset combination. A region that does not appear in
     * any group carries no constraint info and should not be restricted.
     *
     * @generated from field: meshtastic.LoRaRegionPresetMap region_presets = 19;
     */
    value: LoRaRegionPresetMap;
    case: "regionPresets";
  } | {
    case: undefined;
    value?: undefined;
  };
};
/**
 * Describes the message meshtastic.FromRadio.
 * Use `create(FromRadioSchema)` to create a new message.
 */
declare const FromRadioSchema: GenMessage<FromRadio>;
/**
 *
 * Lockdown state report from firmware to client (for hardened builds
 * with MESHTASTIC_LOCKDOWN). Sent immediately after config_complete_id
 * to inform a freshly-connected unauthorized client what it must do,
 * and again in response to each LockdownAuth admin command.
 *
 * @generated from message meshtastic.LockdownStatus
 */
type LockdownStatus = Message<"meshtastic.LockdownStatus"> & {
  /**
   * Current lockdown state being reported.
   *
   * @generated from field: meshtastic.LockdownStatus.State state = 1;
   */
  state: LockdownStatus_State;
  /**
   *
   * For LOCKED: machine-readable reason. Known values:
   *   "needs_auth"        — storage already unlocked, client must auth
   *   "token_missing"     — no boot token on flash
   *   "token_expired"     — boot token wall-clock TTL elapsed
   *   "token_boots_zero"  — boot token boot-count TTL exhausted
   *   "token_hmac_fail"   — token tampered or wrong device
   *   "token_dek_fail"    — token DEK decrypt failed
   *   "token_wrong_size"  — token file corrupted
   *   "token_bad_magic"   — token file corrupted
   *   "not_provisioned"   — should generally use NEEDS_PROVISION state instead
   * Other values may be added; clients should treat unknown values as
   * "locked, ask for passphrase".
   *
   * @generated from field: string lock_reason = 2;
   */
  lockReason: string;
  /**
   *
   * For UNLOCKED: remaining boots on the issued session token.
   * Decrements by 1 on each subsequent boot.
   *
   * @generated from field: uint32 boots_remaining = 3;
   */
  bootsRemaining: number;
  /**
   *
   * For UNLOCKED: wall-clock expiry of the issued session token,
   * absolute Unix-epoch seconds. 0 = no time limit.
   *
   * @generated from field: uint32 valid_until_epoch = 4;
   */
  validUntilEpoch: number;
  /**
   *
   * For UNLOCK_FAILED: seconds the client must wait before another
   * passphrase attempt will be accepted. 0 = wrong passphrase, no
   * backoff (immediate retry allowed but advisable to prompt user).
   *
   * @generated from field: uint32 backoff_seconds = 5;
   */
  backoffSeconds: number;
};
/**
 * Describes the message meshtastic.LockdownStatus.
 * Use `create(LockdownStatusSchema)` to create a new message.
 */
declare const LockdownStatusSchema: GenMessage<LockdownStatus>;
/**
 * @generated from enum meshtastic.LockdownStatus.State
 */
declare enum LockdownStatus_State {
  /**
   * Default; should not be sent.
   *
   * @generated from enum value: STATE_UNSPECIFIED = 0;
   */
  STATE_UNSPECIFIED = 0,
  /**
   *
   * No passphrase has ever been provisioned on this device.
   * Client should prompt the operator to set one.
   *
   * @generated from enum value: NEEDS_PROVISION = 1;
   */
  NEEDS_PROVISION = 1,
  /**
   *
   * Storage is locked or this client has not authenticated yet.
   * lock_reason carries a machine-readable detail string.
   * Client should present (or auto-replay) a passphrase via
   * AdminMessage.lockdown_auth.
   *
   * @generated from enum value: LOCKED = 2;
   */
  LOCKED = 2,
  /**
   *
   * Passphrase accepted; client is now authorized for this connection.
   * boots_remaining and valid_until_epoch describe the active session
   * token's TTL.
   *
   * @generated from enum value: UNLOCKED = 3;
   */
  UNLOCKED = 3,
  /**
   *
   * Passphrase rejected. backoff_seconds is non-zero when rate-limited.
   *
   * @generated from enum value: UNLOCK_FAILED = 4;
   */
  UNLOCK_FAILED = 4,
  /**
   *
   * Lockdown is supported by this firmware but not currently active
   * (no passphrase has been provisioned, or it was disabled via
   * AdminMessage.lockdown_auth.disable). The device is operating in
   * normal, non-encrypted mode. Clients render the lockdown-mode
   * toggle as OFF on receiving this. Distinct from NEEDS_PROVISION,
   * which is only used during an in-progress enable flow.
   *
   * @generated from enum value: DISABLED = 5;
   */
  DISABLED = 5
}
/**
 * Describes the enum meshtastic.LockdownStatus.State.
 */
declare const LockdownStatus_StateSchema: GenEnum<LockdownStatus_State>;
/**
 *
 * A notification message from the device to the client
 * To be used for important messages that should to be displayed to the user
 * in the form of push notifications or validation messages when saving
 * invalid configuration.
 *
 * @generated from message meshtastic.ClientNotification
 */
type ClientNotification = Message<"meshtastic.ClientNotification"> & {
  /**
   *
   * The id of the packet we're notifying in response to
   *
   * @generated from field: optional uint32 reply_id = 1;
   */
  replyId?: number;
  /**
   *
   * Seconds since 1970 - or 0 for unknown/unset
   *
   * @generated from field: fixed32 time = 2;
   */
  time: number;
  /**
   *
   * The level type of notification
   *
   * @generated from field: meshtastic.LogRecord.Level level = 3;
   */
  level: LogRecord_Level;
  /**
   *
   * The message body of the notification
   *
   * @generated from field: string message = 4;
   */
  message: string;
  /**
   * @generated from oneof meshtastic.ClientNotification.payload_variant
   */
  payloadVariant: {
    /**
     * @generated from field: meshtastic.KeyVerificationNumberInform key_verification_number_inform = 11;
     */
    value: KeyVerificationNumberInform;
    case: "keyVerificationNumberInform";
  } | {
    /**
     * @generated from field: meshtastic.KeyVerificationNumberRequest key_verification_number_request = 12;
     */
    value: KeyVerificationNumberRequest;
    case: "keyVerificationNumberRequest";
  } | {
    /**
     * @generated from field: meshtastic.KeyVerificationFinal key_verification_final = 13;
     */
    value: KeyVerificationFinal;
    case: "keyVerificationFinal";
  } | {
    /**
     * @generated from field: meshtastic.DuplicatedPublicKey duplicated_public_key = 14;
     */
    value: DuplicatedPublicKey;
    case: "duplicatedPublicKey";
  } | {
    /**
     * @generated from field: meshtastic.LowEntropyKey low_entropy_key = 15;
     */
    value: LowEntropyKey;
    case: "lowEntropyKey";
  } | {
    case: undefined;
    value?: undefined;
  };
};
/**
 * Describes the message meshtastic.ClientNotification.
 * Use `create(ClientNotificationSchema)` to create a new message.
 */
declare const ClientNotificationSchema: GenMessage<ClientNotification>;
/**
 * @generated from message meshtastic.KeyVerificationNumberInform
 */
type KeyVerificationNumberInform = Message<"meshtastic.KeyVerificationNumberInform"> & {
  /**
   * @generated from field: uint64 nonce = 1;
   */
  nonce: bigint;
  /**
   * @generated from field: string remote_longname = 2;
   */
  remoteLongname: string;
  /**
   * @generated from field: uint32 security_number = 3;
   */
  securityNumber: number;
};
/**
 * Describes the message meshtastic.KeyVerificationNumberInform.
 * Use `create(KeyVerificationNumberInformSchema)` to create a new message.
 */
declare const KeyVerificationNumberInformSchema: GenMessage<KeyVerificationNumberInform>;
/**
 * @generated from message meshtastic.KeyVerificationNumberRequest
 */
type KeyVerificationNumberRequest = Message<"meshtastic.KeyVerificationNumberRequest"> & {
  /**
   * @generated from field: uint64 nonce = 1;
   */
  nonce: bigint;
  /**
   * @generated from field: string remote_longname = 2;
   */
  remoteLongname: string;
};
/**
 * Describes the message meshtastic.KeyVerificationNumberRequest.
 * Use `create(KeyVerificationNumberRequestSchema)` to create a new message.
 */
declare const KeyVerificationNumberRequestSchema: GenMessage<KeyVerificationNumberRequest>;
/**
 * @generated from message meshtastic.KeyVerificationFinal
 */
type KeyVerificationFinal = Message<"meshtastic.KeyVerificationFinal"> & {
  /**
   * @generated from field: uint64 nonce = 1;
   */
  nonce: bigint;
  /**
   * @generated from field: string remote_longname = 2;
   */
  remoteLongname: string;
  /**
   * @generated from field: bool isSender = 3;
   */
  isSender: boolean;
  /**
   * @generated from field: string verification_characters = 4;
   */
  verificationCharacters: string;
};
/**
 * Describes the message meshtastic.KeyVerificationFinal.
 * Use `create(KeyVerificationFinalSchema)` to create a new message.
 */
declare const KeyVerificationFinalSchema: GenMessage<KeyVerificationFinal>;
/**
 * @generated from message meshtastic.DuplicatedPublicKey
 */
type DuplicatedPublicKey = Message<"meshtastic.DuplicatedPublicKey"> & {};
/**
 * Describes the message meshtastic.DuplicatedPublicKey.
 * Use `create(DuplicatedPublicKeySchema)` to create a new message.
 */
declare const DuplicatedPublicKeySchema: GenMessage<DuplicatedPublicKey>;
/**
 * @generated from message meshtastic.LowEntropyKey
 */
type LowEntropyKey = Message<"meshtastic.LowEntropyKey"> & {};
/**
 * Describes the message meshtastic.LowEntropyKey.
 * Use `create(LowEntropyKeySchema)` to create a new message.
 */
declare const LowEntropyKeySchema: GenMessage<LowEntropyKey>;
/**
 *
 * Individual File info for the device
 *
 * @generated from message meshtastic.FileInfo
 */
type FileInfo = Message<"meshtastic.FileInfo"> & {
  /**
   *
   * The fully qualified path of the file
   *
   * @generated from field: string file_name = 1;
   */
  fileName: string;
  /**
   *
   * The size of the file in bytes
   *
   * @generated from field: uint32 size_bytes = 2;
   */
  sizeBytes: number;
};
/**
 * Describes the message meshtastic.FileInfo.
 * Use `create(FileInfoSchema)` to create a new message.
 */
declare const FileInfoSchema: GenMessage<FileInfo>;
/**
 *
 * Packets/commands to the radio will be written (reliably) to the toRadio characteristic.
 * Once the write completes the phone can assume it is handled.
 *
 * @generated from message meshtastic.ToRadio
 */
type ToRadio = Message<"meshtastic.ToRadio"> & {
  /**
   *
   * Log levels, chosen to match python logging conventions.
   *
   * @generated from oneof meshtastic.ToRadio.payload_variant
   */
  payloadVariant: {
    /**
     *
     * Send this packet on the mesh
     *
     * @generated from field: meshtastic.MeshPacket packet = 1;
     */
    value: MeshPacket;
    case: "packet";
  } | {
    /**
     *
     * Phone wants radio to send full node db to the phone, This is
     * typically the first packet sent to the radio when the phone gets a
     * bluetooth connection. The radio will respond by sending back a
     * MyNodeInfo, a owner, a radio config and a series of
     * FromRadio.node_infos, and config_complete
     * the integer you write into this field will be reported back in the
     * config_complete_id response this allows clients to never be confused by
     * a stale old partially sent config.
     *
     * @generated from field: uint32 want_config_id = 3;
     */
    value: number;
    case: "wantConfigId";
  } | {
    /**
     *
     * Tell API server we are disconnecting now.
     * This is useful for serial links where there is no hardware/protocol based notification that the client has dropped the link.
     * (Sending this message is optional for clients)
     *
     * @generated from field: bool disconnect = 4;
     */
    value: boolean;
    case: "disconnect";
  } | {
    /**
     * @generated from field: meshtastic.XModem xmodemPacket = 5;
     */
    value: XModem;
    case: "xmodemPacket";
  } | {
    /**
     *
     * MQTT Client Proxy Message (for client / phone subscribed to MQTT sending to device)
     *
     * @generated from field: meshtastic.MqttClientProxyMessage mqttClientProxyMessage = 6;
     */
    value: MqttClientProxyMessage;
    case: "mqttClientProxyMessage";
  } | {
    /**
     *
     * Heartbeat message (used to keep the device connection awake on serial)
     *
     * @generated from field: meshtastic.Heartbeat heartbeat = 7;
     */
    value: Heartbeat;
    case: "heartbeat";
  } | {
    case: undefined;
    value?: undefined;
  };
};
/**
 * Describes the message meshtastic.ToRadio.
 * Use `create(ToRadioSchema)` to create a new message.
 */
declare const ToRadioSchema: GenMessage<ToRadio>;
/**
 *
 * Compressed message payload
 *
 * @generated from message meshtastic.Compressed
 */
type Compressed = Message<"meshtastic.Compressed"> & {
  /**
   *
   * PortNum to determine the how to handle the compressed payload.
   *
   * @generated from field: meshtastic.PortNum portnum = 1;
   */
  portnum: PortNum;
  /**
   *
   * Compressed data.
   *
   * @generated from field: bytes data = 2;
   */
  data: Uint8Array;
};
/**
 * Describes the message meshtastic.Compressed.
 * Use `create(CompressedSchema)` to create a new message.
 */
declare const CompressedSchema: GenMessage<Compressed>;
/**
 *
 * Full info on edges for a single node
 *
 * @generated from message meshtastic.NeighborInfo
 */
type NeighborInfo = Message<"meshtastic.NeighborInfo"> & {
  /**
   *
   * The node ID of the node sending info on its neighbors
   *
   * @generated from field: uint32 node_id = 1;
   */
  nodeId: number;
  /**
   *
   * Field to pass neighbor info for the next sending cycle
   *
   * @generated from field: uint32 last_sent_by_id = 2;
   */
  lastSentById: number;
  /**
   *
   * Broadcast interval of the represented node (in seconds)
   *
   * @generated from field: uint32 node_broadcast_interval_secs = 3;
   */
  nodeBroadcastIntervalSecs: number;
  /**
   *
   * The list of out edges from this node
   *
   * @generated from field: repeated meshtastic.Neighbor neighbors = 4;
   */
  neighbors: Neighbor[];
};
/**
 * Describes the message meshtastic.NeighborInfo.
 * Use `create(NeighborInfoSchema)` to create a new message.
 */
declare const NeighborInfoSchema: GenMessage<NeighborInfo>;
/**
 *
 * A single edge in the mesh
 *
 * @generated from message meshtastic.Neighbor
 */
type Neighbor = Message<"meshtastic.Neighbor"> & {
  /**
   *
   * Node ID of neighbor
   *
   * @generated from field: uint32 node_id = 1;
   */
  nodeId: number;
  /**
   *
   * SNR of last heard message
   *
   * @generated from field: float snr = 2;
   */
  snr: number;
  /**
   *
   * Reception time (in secs since 1970) of last message that was last sent by this ID.
   * Note: this is for local storage only and will not be sent out over the mesh.
   *
   * @generated from field: fixed32 last_rx_time = 3;
   */
  lastRxTime: number;
  /**
   *
   * Broadcast interval of this neighbor (in seconds).
   * Note: this is for local storage only and will not be sent out over the mesh.
   *
   * @generated from field: uint32 node_broadcast_interval_secs = 4;
   */
  nodeBroadcastIntervalSecs: number;
};
/**
 * Describes the message meshtastic.Neighbor.
 * Use `create(NeighborSchema)` to create a new message.
 */
declare const NeighborSchema: GenMessage<Neighbor>;
/**
 *
 * Device metadata response
 *
 * @generated from message meshtastic.DeviceMetadata
 */
type DeviceMetadata = Message<"meshtastic.DeviceMetadata"> & {
  /**
   *
   * Device firmware version string
   *
   * @generated from field: string firmware_version = 1;
   */
  firmwareVersion: string;
  /**
   *
   * Device state version
   *
   * @generated from field: uint32 device_state_version = 2;
   */
  deviceStateVersion: number;
  /**
   *
   * Indicates whether the device can shutdown CPU natively or via power management chip
   *
   * @generated from field: bool canShutdown = 3;
   */
  canShutdown: boolean;
  /**
   *
   * Indicates that the device has native wifi capability
   *
   * @generated from field: bool hasWifi = 4;
   */
  hasWifi: boolean;
  /**
   *
   * Indicates that the device has native bluetooth capability
   *
   * @generated from field: bool hasBluetooth = 5;
   */
  hasBluetooth: boolean;
  /**
   *
   * Indicates that the device has an ethernet peripheral
   *
   * @generated from field: bool hasEthernet = 6;
   */
  hasEthernet: boolean;
  /**
   *
   * Indicates that the device's role in the mesh
   *
   * @generated from field: meshtastic.Config.DeviceConfig.Role role = 7;
   */
  role: Config_DeviceConfig_Role;
  /**
   *
   * Indicates the device's current enabled position flags
   *
   * @generated from field: uint32 position_flags = 8;
   */
  positionFlags: number;
  /**
   *
   * Device hardware model
   *
   * @generated from field: meshtastic.HardwareModel hw_model = 9;
   */
  hwModel: HardwareModel;
  /**
   *
   * Has Remote Hardware enabled
   *
   * @generated from field: bool hasRemoteHardware = 10;
   */
  hasRemoteHardware: boolean;
  /**
   *
   * Has PKC capabilities
   *
   * @generated from field: bool hasPKC = 11;
   */
  hasPKC: boolean;
  /**
   *
   * Bit field of boolean for excluded modules
   * (bitwise OR of ExcludedModules)
   *
   * @generated from field: uint32 excluded_modules = 12;
   */
  excludedModules: number;
  /**
   *
   * Indicates whether this firmware build includes XEdDSA packet signature verification.
   * This is a read-only capability and must be false when XEdDSA is not compiled in.
   *
   * @generated from field: bool has_xeddsa = 14;
   */
  hasXeddsa: boolean;
};
/**
 * Describes the message meshtastic.DeviceMetadata.
 * Use `create(DeviceMetadataSchema)` to create a new message.
 */
declare const DeviceMetadataSchema: GenMessage<DeviceMetadata>;
/**
 *
 * A distinct set of legal modem presets shared by one or more LoRa regions.
 * Regions that have an identical preset list / default / licensing reference
 * the same group (by index) via LoRaRegionPresetMap.region_groups. This keeps
 * the whole map small enough to fit in a single FromRadio packet, since most
 * regions share the one standard preset list.
 *
 * @generated from message meshtastic.LoRaPresetGroup
 */
type LoRaPresetGroup = Message<"meshtastic.LoRaPresetGroup"> & {
  /**
   *
   * The modem presets that are legal for every region referencing this group.
   *
   * @generated from field: repeated meshtastic.Config.LoRaConfig.ModemPreset presets = 1;
   */
  presets: Config_LoRaConfig_ModemPreset[];
  /**
   *
   * The firmware's default modem preset for regions in this group.
   * Always one of `presets`. Clients should select this when switching to one
   * of these regions, or when the current preset is not legal in the new region.
   *
   * @generated from field: meshtastic.Config.LoRaConfig.ModemPreset default_preset = 2;
   */
  defaultPreset: Config_LoRaConfig_ModemPreset;
  /**
   *
   * True if regions referencing this group are for licensed operators only
   * (e.g. amateur / ham radio bands). Clients should warn or gate accordingly.
   *
   * @generated from field: bool licensed_only = 3;
   */
  licensedOnly: boolean;
};
/**
 * Describes the message meshtastic.LoRaPresetGroup.
 * Use `create(LoRaPresetGroupSchema)` to create a new message.
 */
declare const LoRaPresetGroupSchema: GenMessage<LoRaPresetGroup>;
/**
 *
 * Associates a single LoRa region with its preset group.
 *
 * @generated from message meshtastic.LoRaRegionPresets
 */
type LoRaRegionPresets = Message<"meshtastic.LoRaRegionPresets"> & {
  /**
   *
   * The LoRa region this entry describes.
   *
   * @generated from field: meshtastic.Config.LoRaConfig.RegionCode region = 1;
   */
  region: Config_LoRaConfig_RegionCode;
  /**
   *
   * Index into LoRaRegionPresetMap.groups for the preset list that is legal
   * in `region`.
   *
   * @generated from field: uint32 group_index = 2;
   */
  groupIndex: number;
};
/**
 * Describes the message meshtastic.LoRaRegionPresets.
 * Use `create(LoRaRegionPresetsSchema)` to create a new message.
 */
declare const LoRaRegionPresetsSchema: GenMessage<LoRaRegionPresets>;
/**
 *
 * Map describing which modem presets are valid for each LoRa region. Sent by
 * the firmware during the want_config handshake (as FromRadio.region_presets)
 * so that client UIs can prevent illegal region+preset selections.
 *
 * Delivery is grouped to save space: `groups` holds each distinct preset list,
 * and `region_groups` maps every known region to one of those groups by index.
 * A region that does NOT appear in `region_groups` carries no constraint
 * information and should not be restricted by the client (e.g. firmware that
 * predates this message, or a region with no firmware table entry). Clients
 * must also tolerate this whole message being absent.
 *
 * @generated from message meshtastic.LoRaRegionPresetMap
 */
type LoRaRegionPresetMap = Message<"meshtastic.LoRaRegionPresetMap"> & {
  /**
   *
   * One entry per distinct (preset-list, default, licensing) combination.
   * Referenced by index from `region_groups`.
   *
   * @generated from field: repeated meshtastic.LoRaPresetGroup groups = 1;
   */
  groups: LoRaPresetGroup[];
  /**
   *
   * One entry per known LoRa region, pointing at its preset group.
   *
   * @generated from field: repeated meshtastic.LoRaRegionPresets region_groups = 2;
   */
  regionGroups: LoRaRegionPresets[];
};
/**
 * Describes the message meshtastic.LoRaRegionPresetMap.
 * Use `create(LoRaRegionPresetMapSchema)` to create a new message.
 */
declare const LoRaRegionPresetMapSchema: GenMessage<LoRaRegionPresetMap>;
/**
 *
 * A heartbeat message is sent to the node from the client to keep the connection alive.
 * This is currently only needed to keep serial connections alive, but can be used by any PhoneAPI.
 *
 * @generated from message meshtastic.Heartbeat
 */
type Heartbeat = Message<"meshtastic.Heartbeat"> & {
  /**
   *
   * The nonce of the heartbeat message
   *
   * @generated from field: uint32 nonce = 1;
   */
  nonce: number;
};
/**
 * Describes the message meshtastic.Heartbeat.
 * Use `create(HeartbeatSchema)` to create a new message.
 */
declare const HeartbeatSchema: GenMessage<Heartbeat>;
/**
 *
 * RemoteHardwarePins associated with a node
 *
 * @generated from message meshtastic.NodeRemoteHardwarePin
 */
type NodeRemoteHardwarePin = Message<"meshtastic.NodeRemoteHardwarePin"> & {
  /**
   *
   * The node_num exposing the available gpio pin
   *
   * @generated from field: uint32 node_num = 1;
   */
  nodeNum: number;
  /**
   *
   * The the available gpio pin for usage with RemoteHardware module
   *
   * @generated from field: meshtastic.RemoteHardwarePin pin = 2;
   */
  pin?: RemoteHardwarePin;
};
/**
 * Describes the message meshtastic.NodeRemoteHardwarePin.
 * Use `create(NodeRemoteHardwarePinSchema)` to create a new message.
 */
declare const NodeRemoteHardwarePinSchema: GenMessage<NodeRemoteHardwarePin>;
/**
 * @generated from message meshtastic.ChunkedPayload
 */
type ChunkedPayload = Message<"meshtastic.ChunkedPayload"> & {
  /**
   *
   * The ID of the entire payload
   *
   * @generated from field: uint32 payload_id = 1;
   */
  payloadId: number;
  /**
   *
   * The total number of chunks in the payload
   *
   * @generated from field: uint32 chunk_count = 2;
   */
  chunkCount: number;
  /**
   *
   * The current chunk index in the total
   *
   * @generated from field: uint32 chunk_index = 3;
   */
  chunkIndex: number;
  /**
   *
   * The binary data of the current chunk
   *
   * @generated from field: bytes payload_chunk = 4;
   */
  payloadChunk: Uint8Array;
};
/**
 * Describes the message meshtastic.ChunkedPayload.
 * Use `create(ChunkedPayloadSchema)` to create a new message.
 */
declare const ChunkedPayloadSchema: GenMessage<ChunkedPayload>;
/**
 *
 * Wrapper message for broken repeated oneof support
 *
 * @generated from message meshtastic.resend_chunks
 */
type resend_chunks = Message<"meshtastic.resend_chunks"> & {
  /**
   * @generated from field: repeated uint32 chunks = 1;
   */
  chunks: number[];
};
/**
 * Describes the message meshtastic.resend_chunks.
 * Use `create(resend_chunksSchema)` to create a new message.
 */
declare const resend_chunksSchema: GenMessage<resend_chunks>;
/**
 *
 * Responses to a ChunkedPayload request
 *
 * @generated from message meshtastic.ChunkedPayloadResponse
 */
type ChunkedPayloadResponse = Message<"meshtastic.ChunkedPayloadResponse"> & {
  /**
   *
   * The ID of the entire payload
   *
   * @generated from field: uint32 payload_id = 1;
   */
  payloadId: number;
  /**
   * @generated from oneof meshtastic.ChunkedPayloadResponse.payload_variant
   */
  payloadVariant: {
    /**
     *
     * Request to transfer chunked payload
     *
     * @generated from field: bool request_transfer = 2;
     */
    value: boolean;
    case: "requestTransfer";
  } | {
    /**
     *
     * Accept the transfer chunked payload
     *
     * @generated from field: bool accept_transfer = 3;
     */
    value: boolean;
    case: "acceptTransfer";
  } | {
    /**
     *
     * Request missing indexes in the chunked payload
     *
     * @generated from field: meshtastic.resend_chunks resend_chunks = 4;
     */
    value: resend_chunks;
    case: "resendChunks";
  } | {
    case: undefined;
    value?: undefined;
  };
};
/**
 * Describes the message meshtastic.ChunkedPayloadResponse.
 * Use `create(ChunkedPayloadResponseSchema)` to create a new message.
 */
declare const ChunkedPayloadResponseSchema: GenMessage<ChunkedPayloadResponse>;
/**
 *
 * Note: these enum names must EXACTLY match the string used in the device
 * bin/build-all.sh script.
 * Because they will be used to find firmware filenames in the android app for OTA updates.
 * To match the old style filenames, _ is converted to -, p is converted to .
 *
 * @generated from enum meshtastic.HardwareModel
 */
declare enum HardwareModel {
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: UNSET = 0;
   */
  UNSET = 0,
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: TLORA_V2 = 1;
   */
  TLORA_V2 = 1,
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: TLORA_V1 = 2;
   */
  TLORA_V1 = 2,
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: TLORA_V2_1_1P6 = 3;
   */
  TLORA_V2_1_1P6 = 3,
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: TBEAM = 4;
   */
  TBEAM = 4,
  /**
   *
   * The original heltec WiFi_Lora_32_V2, which had battery voltage sensing hooked to GPIO 13
   * (see HELTEC_V2 for the new version).
   *
   * @generated from enum value: HELTEC_V2_0 = 5;
   */
  HELTEC_V2_0 = 5,
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: TBEAM_V0P7 = 6;
   */
  TBEAM_V0P7 = 6,
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: T_ECHO = 7;
   */
  T_ECHO = 7,
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: TLORA_V1_1P3 = 8;
   */
  TLORA_V1_1P3 = 8,
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: RAK4631 = 9;
   */
  RAK4631 = 9,
  /**
   *
   * The new version of the heltec WiFi_Lora_32_V2 board that has battery sensing hooked to GPIO 37.
   * Sadly they did not update anything on the silkscreen to identify this board
   *
   * @generated from enum value: HELTEC_V2_1 = 10;
   */
  HELTEC_V2_1 = 10,
  /**
   *
   * Ancient heltec WiFi_Lora_32 board
   *
   * @generated from enum value: HELTEC_V1 = 11;
   */
  HELTEC_V1 = 11,
  /**
   *
   * New T-BEAM with ESP32-S3 CPU
   *
   * @generated from enum value: LILYGO_TBEAM_S3_CORE = 12;
   */
  LILYGO_TBEAM_S3_CORE = 12,
  /**
   *
   * RAK WisBlock ESP32 core: https://docs.rakwireless.com/Product-Categories/WisBlock/RAK11200/Overview/
   *
   * @generated from enum value: RAK11200 = 13;
   */
  RAK11200 = 13,
  /**
   *
   * B&Q Consulting Nano Edition G1: https://uniteng.com/wiki/doku.php?id=meshtastic:nano
   *
   * @generated from enum value: NANO_G1 = 14;
   */
  NANO_G1 = 14,
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: TLORA_V2_1_1P8 = 15;
   */
  TLORA_V2_1_1P8 = 15,
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: TLORA_T3_S3 = 16;
   */
  TLORA_T3_S3 = 16,
  /**
   *
   * B&Q Consulting Nano G1 Explorer: https://wiki.uniteng.com/en/meshtastic/nano-g1-explorer
   *
   * @generated from enum value: NANO_G1_EXPLORER = 17;
   */
  NANO_G1_EXPLORER = 17,
  /**
   *
   * B&Q Consulting Nano G2 Ultra: https://wiki.uniteng.com/en/meshtastic/nano-g2-ultra
   *
   * @generated from enum value: NANO_G2_ULTRA = 18;
   */
  NANO_G2_ULTRA = 18,
  /**
   *
   * LoRAType device: https://loratype.org/
   *
   * @generated from enum value: LORA_TYPE = 19;
   */
  LORA_TYPE = 19,
  /**
   *
   * wiphone https://www.wiphone.io/
   *
   * @generated from enum value: WIPHONE = 20;
   */
  WIPHONE = 20,
  /**
   *
   * WIO Tracker WM1110 family from Seeed Studio. Includes wio-1110-tracker and wio-1110-sdk
   *
   * @generated from enum value: WIO_WM1110 = 21;
   */
  WIO_WM1110 = 21,
  /**
   *
   * RAK2560 Solar base station based on RAK4630
   *
   * @generated from enum value: RAK2560 = 22;
   */
  RAK2560 = 22,
  /**
   *
   * Heltec HRU-3601: https://heltec.org/project/hru-3601/
   *
   * @generated from enum value: HELTEC_HRU_3601 = 23;
   */
  HELTEC_HRU_3601 = 23,
  /**
   *
   * Heltec Wireless Bridge
   *
   * @generated from enum value: HELTEC_WIRELESS_BRIDGE = 24;
   */
  HELTEC_WIRELESS_BRIDGE = 24,
  /**
   *
   * B&Q Consulting Station Edition G1: https://uniteng.com/wiki/doku.php?id=meshtastic:station
   *
   * @generated from enum value: STATION_G1 = 25;
   */
  STATION_G1 = 25,
  /**
   *
   * RAK11310 (RP2040 + SX1262)
   *
   * @generated from enum value: RAK11310 = 26;
   */
  RAK11310 = 26,
  /**
   *
   * Makerfabs Tracker Reserved
   *
   * @generated from enum value: MAKERFABS_TRACKER = 27;
   */
  MAKERFABS_TRACKER = 27,
  /**
   *
   * Makerfabs Reserved
   *
   * @generated from enum value: MAKERFABS_RESERVED = 28;
   */
  MAKERFABS_RESERVED = 28,
  /**
   *
   * Canary Radio Company - CanaryOne: https://canaryradio.io/products/canaryone
   *
   * @generated from enum value: CANARYONE = 29;
   */
  CANARYONE = 29,
  /**
   *
   * Waveshare RP2040 LoRa - https://www.waveshare.com/rp2040-lora.htm
   *
   * @generated from enum value: RP2040_LORA = 30;
   */
  RP2040_LORA = 30,
  /**
   *
   * B&Q Consulting Station G2: https://wiki.uniteng.com/en/meshtastic/station-g2
   *
   * @generated from enum value: STATION_G2 = 31;
   */
  STATION_G2 = 31,
  /**
   *
   * ---------------------------------------------------------------------------
   * Less common/prototype boards listed here (needs one more byte over the air)
   * ---------------------------------------------------------------------------
   *
   * @generated from enum value: LORA_RELAY_V1 = 32;
   */
  LORA_RELAY_V1 = 32,
  /**
   *
   * T-Echo Plus device from LilyGo
   *
   * @generated from enum value: T_ECHO_PLUS = 33;
   */
  T_ECHO_PLUS = 33,
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: PPR = 34;
   */
  PPR = 34,
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: GENIEBLOCKS = 35;
   */
  GENIEBLOCKS = 35,
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: NRF52_UNKNOWN = 36;
   */
  NRF52_UNKNOWN = 36,
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: PORTDUINO = 37;
   */
  PORTDUINO = 37,
  /**
   *
   * The simulator built into the android app
   *
   * @generated from enum value: ANDROID_SIM = 38;
   */
  ANDROID_SIM = 38,
  /**
   *
   * Custom DIY device based on @NanoVHF schematics: https://github.com/NanoVHF/Meshtastic-DIY/tree/main/Schematics
   *
   * @generated from enum value: DIY_V1 = 39;
   */
  DIY_V1 = 39,
  /**
   *
   * nRF52840 Dongle : https://www.nordicsemi.com/Products/Development-hardware/nrf52840-dongle/
   *
   * @generated from enum value: NRF52840_PCA10059 = 40;
   */
  NRF52840_PCA10059 = 40,
  /**
   *
   * Custom Disaster Radio esp32 v3 device https://github.com/sudomesh/disaster-radio/tree/master/hardware/board_esp32_v3
   *
   * @generated from enum value: DR_DEV = 41;
   */
  DR_DEV = 41,
  /**
   *
   * M5 esp32 based MCU modules with enclosure, TFT and LORA Shields. All Variants (Basic, Core, Fire, Core2, CoreS3, Paper) https://m5stack.com/
   *
   * @generated from enum value: M5STACK = 42;
   */
  M5STACK = 42,
  /**
   *
   * New Heltec LoRA32 with ESP32-S3 CPU
   *
   * @generated from enum value: HELTEC_V3 = 43;
   */
  HELTEC_V3 = 43,
  /**
   *
   * New Heltec Wireless Stick Lite with ESP32-S3 CPU
   *
   * @generated from enum value: HELTEC_WSL_V3 = 44;
   */
  HELTEC_WSL_V3 = 44,
  /**
   *
   * New BETAFPV ELRS Micro TX Module 2.4G with ESP32 CPU
   *
   * @generated from enum value: BETAFPV_2400_TX = 45;
   */
  BETAFPV_2400_TX = 45,
  /**
   *
   * BetaFPV ExpressLRS "Nano" TX Module 900MHz with ESP32 CPU
   *
   * @generated from enum value: BETAFPV_900_NANO_TX = 46;
   */
  BETAFPV_900_NANO_TX = 46,
  /**
   *
   * Raspberry Pi Pico (W) with Waveshare SX1262 LoRa Node Module
   *
   * @generated from enum value: RPI_PICO = 47;
   */
  RPI_PICO = 47,
  /**
   *
   * Heltec Wireless Tracker with ESP32-S3 CPU, built-in GPS, and TFT
   * Newer V1.1, version is written on the PCB near the display.
   *
   * @generated from enum value: HELTEC_WIRELESS_TRACKER = 48;
   */
  HELTEC_WIRELESS_TRACKER = 48,
  /**
   *
   * Heltec Wireless Paper with ESP32-S3 CPU and E-Ink display
   *
   * @generated from enum value: HELTEC_WIRELESS_PAPER = 49;
   */
  HELTEC_WIRELESS_PAPER = 49,
  /**
   *
   * LilyGo T-Deck with ESP32-S3 CPU, Keyboard and IPS display
   *
   * @generated from enum value: T_DECK = 50;
   */
  T_DECK = 50,
  /**
   *
   * LilyGo T-Watch S3 with ESP32-S3 CPU and IPS display
   *
   * @generated from enum value: T_WATCH_S3 = 51;
   */
  T_WATCH_S3 = 51,
  /**
   *
   * Bobricius Picomputer with ESP32-S3 CPU, Keyboard and IPS display
   *
   * @generated from enum value: PICOMPUTER_S3 = 52;
   */
  PICOMPUTER_S3 = 52,
  /**
   *
   * Heltec HT-CT62 with ESP32-C3 CPU and SX1262 LoRa
   *
   * @generated from enum value: HELTEC_HT62 = 53;
   */
  HELTEC_HT62 = 53,
  /**
   *
   * EBYTE SPI LoRa module and ESP32-S3
   *
   * @generated from enum value: EBYTE_ESP32_S3 = 54;
   */
  EBYTE_ESP32_S3 = 54,
  /**
   *
   * Waveshare ESP32-S3-PICO with PICO LoRa HAT and 2.9inch e-Ink
   *
   * @generated from enum value: ESP32_S3_PICO = 55;
   */
  ESP32_S3_PICO = 55,
  /**
   *
   * CircuitMess Chatter 2 LLCC68 Lora Module and ESP32 Wroom
   * Lora module can be swapped out for a Heltec RA-62 which is "almost" pin compatible
   * with one cut and one jumper Meshtastic works
   *
   * @generated from enum value: CHATTER_2 = 56;
   */
  CHATTER_2 = 56,
  /**
   *
   * Heltec Wireless Paper, With ESP32-S3 CPU and E-Ink display
   * Older "V1.0" Variant, has no "version sticker"
   * E-Ink model is DEPG0213BNS800
   * Tab on the screen protector is RED
   * Flex connector marking is FPC-7528B
   *
   * @generated from enum value: HELTEC_WIRELESS_PAPER_V1_0 = 57;
   */
  HELTEC_WIRELESS_PAPER_V1_0 = 57,
  /**
   *
   * Heltec Wireless Tracker with ESP32-S3 CPU, built-in GPS, and TFT
   * Older "V1.0" Variant
   *
   * @generated from enum value: HELTEC_WIRELESS_TRACKER_V1_0 = 58;
   */
  HELTEC_WIRELESS_TRACKER_V1_0 = 58,
  /**
   *
   * unPhone with ESP32-S3, TFT touchscreen,  LSM6DS3TR-C accelerometer and gyroscope
   *
   * @generated from enum value: UNPHONE = 59;
   */
  UNPHONE = 59,
  /**
   *
   * Teledatics TD-LORAC NRF52840 based M.2 LoRA module
   * Compatible with the TD-WRLS development board
   *
   * @generated from enum value: TD_LORAC = 60;
   */
  TD_LORAC = 60,
  /**
   *
   * CDEBYTE EoRa-S3 board using their own MM modules, clone of LILYGO T3S3
   *
   * @generated from enum value: CDEBYTE_EORA_S3 = 61;
   */
  CDEBYTE_EORA_S3 = 61,
  /**
   *
   * TWC_MESH_V4
   * Adafruit NRF52840 feather express with SX1262, SSD1306 OLED and NEO6M GPS
   *
   * @generated from enum value: TWC_MESH_V4 = 62;
   */
  TWC_MESH_V4 = 62,
  /**
   *
   * NRF52_PROMICRO_DIY
   * Promicro NRF52840 with SX1262/LLCC68, SSD1306 OLED and NEO6M GPS
   *
   * @generated from enum value: NRF52_PROMICRO_DIY = 63;
   */
  NRF52_PROMICRO_DIY = 63,
  /**
   *
   * RadioMaster 900 Bandit Nano, https://www.radiomasterrc.com/products/bandit-nano-expresslrs-rf-module
   * ESP32-D0WDQ6 With SX1276/SKY66122, SSD1306 OLED and No GPS
   *
   * @generated from enum value: RADIOMASTER_900_BANDIT_NANO = 64;
   */
  RADIOMASTER_900_BANDIT_NANO = 64,
  /**
   *
   * Heltec Capsule Sensor V3 with ESP32-S3 CPU, Portable LoRa device that can replace GNSS modules or sensors
   *
   * @generated from enum value: HELTEC_CAPSULE_SENSOR_V3 = 65;
   */
  HELTEC_CAPSULE_SENSOR_V3 = 65,
  /**
   *
   * Heltec Vision Master T190 with ESP32-S3 CPU, and a 1.90 inch TFT display
   *
   * @generated from enum value: HELTEC_VISION_MASTER_T190 = 66;
   */
  HELTEC_VISION_MASTER_T190 = 66,
  /**
   *
   * Heltec Vision Master E213 with ESP32-S3 CPU, and a 2.13 inch E-Ink display
   *
   * @generated from enum value: HELTEC_VISION_MASTER_E213 = 67;
   */
  HELTEC_VISION_MASTER_E213 = 67,
  /**
   *
   * Heltec Vision Master E290 with ESP32-S3 CPU, and a 2.9 inch E-Ink display
   *
   * @generated from enum value: HELTEC_VISION_MASTER_E290 = 68;
   */
  HELTEC_VISION_MASTER_E290 = 68,
  /**
   *
   * Heltec Mesh Node T114 board with nRF52840 CPU, and a 1.14 inch TFT display, Ultimate low-power design,
   * specifically adapted for the Meshtatic project
   *
   * @generated from enum value: HELTEC_MESH_NODE_T114 = 69;
   */
  HELTEC_MESH_NODE_T114 = 69,
  /**
   *
   * Sensecap Indicator from Seeed Studio. ESP32-S3 device with TFT and RP2040 coprocessor
   *
   * @generated from enum value: SENSECAP_INDICATOR = 70;
   */
  SENSECAP_INDICATOR = 70,
  /**
   *
   * Seeed studio T1000-E tracker card. NRF52840 w/ LR1110 radio, GPS, button, buzzer, and sensors.
   *
   * @generated from enum value: TRACKER_T1000_E = 71;
   */
  TRACKER_T1000_E = 71,
  /**
   *
   * RAK3172 STM32WLE5 Module (https://store.rakwireless.com/products/wisduo-lpwan-module-rak3172)
   *
   * @generated from enum value: RAK3172 = 72;
   */
  RAK3172 = 72,
  /**
   *
   * Seeed Studio Wio-E5 (either mini or Dev kit) using STM32WL chip.
   *
   * @generated from enum value: WIO_E5 = 73;
   */
  WIO_E5 = 73,
  /**
   *
   * RadioMaster 900 Bandit, https://www.radiomasterrc.com/products/bandit-expresslrs-rf-module
   * SSD1306 OLED and No GPS
   *
   * @generated from enum value: RADIOMASTER_900_BANDIT = 74;
   */
  RADIOMASTER_900_BANDIT = 74,
  /**
   *
   * Minewsemi ME25LS01 (ME25LE01_V1.0). NRF52840 w/ LR1110 radio, buttons and leds and pins.
   *
   * @generated from enum value: ME25LS01_4Y10TD = 75;
   */
  ME25LS01_4Y10TD = 75,
  /**
   *
   * RP2040_FEATHER_RFM95
   * Adafruit Feather RP2040 with RFM95 LoRa Radio RFM95 with SX1272, SSD1306 OLED
   * https://www.adafruit.com/product/5714
   * https://www.adafruit.com/product/326
   * https://www.adafruit.com/product/938
   *  ^^^ short A0 to switch to I2C address 0x3C
   *
   *
   * @generated from enum value: RP2040_FEATHER_RFM95 = 76;
   */
  RP2040_FEATHER_RFM95 = 76,
  /**
   * M5 esp32 based MCU modules with enclosure, TFT and LORA Shields. All Variants (Basic, Core, Fire, Core2, CoreS3, Paper) https://m5stack.com/
   *
   * @generated from enum value: M5STACK_COREBASIC = 77;
   */
  M5STACK_COREBASIC = 77,
  /**
   * @generated from enum value: M5STACK_CORE2 = 78;
   */
  M5STACK_CORE2 = 78,
  /**
   * Pico2 with Waveshare Hat, same as Pico
   *
   * @generated from enum value: RPI_PICO2 = 79;
   */
  RPI_PICO2 = 79,
  /**
   * M5 esp32 based MCU modules with enclosure, TFT and LORA Shields. All Variants (Basic, Core, Fire, Core2, CoreS3, Paper) https://m5stack.com/
   *
   * @generated from enum value: M5STACK_CORES3 = 80;
   */
  M5STACK_CORES3 = 80,
  /**
   * Seeed XIAO S3 DK
   *
   * @generated from enum value: SEEED_XIAO_S3 = 81;
   */
  SEEED_XIAO_S3 = 81,
  /**
   *
   * Nordic nRF52840+Semtech SX1262 LoRa BLE Combo Module. nRF52840+SX1262 MS24SF1
   *
   * @generated from enum value: MS24SF1 = 82;
   */
  MS24SF1 = 82,
  /**
   *
   * Lilygo TLora-C6 with the new ESP32-C6 MCU
   *
   * @generated from enum value: TLORA_C6 = 83;
   */
  TLORA_C6 = 83,
  /**
   *
   * WisMesh Tap
   * RAK-4631 w/ TFT in injection modled case
   *
   * @generated from enum value: WISMESH_TAP = 84;
   */
  WISMESH_TAP = 84,
  /**
   *
   * Similar to PORTDUINO but used by Routastic devices, this is not any
   * particular device and does not run Meshtastic's code but supports
   * the same frame format.
   * Runs on linux, see https://github.com/Jorropo/routastic
   *
   * @generated from enum value: ROUTASTIC = 85;
   */
  ROUTASTIC = 85,
  /**
   *
   * Mesh-Tab, esp32 based
   * https://github.com/valzzu/Mesh-Tab
   *
   * @generated from enum value: MESH_TAB = 86;
   */
  MESH_TAB = 86,
  /**
   *
   * MeshLink board developed by LoraItalia. NRF52840, eByte E22900M22S (Will also come with other frequencies), 25w MPPT solar charger (5v,12v,18v selectable), support for gps, buzzer, oled or e-ink display, 10 gpios, hardware watchdog
   * https://www.loraitalia.it
   *
   * @generated from enum value: MESHLINK = 87;
   */
  MESHLINK = 87,
  /**
   *
   * Seeed XIAO nRF52840 + Wio SX1262 kit
   *
   * @generated from enum value: XIAO_NRF52_KIT = 88;
   */
  XIAO_NRF52_KIT = 88,
  /**
   *
   * Elecrow ThinkNode M1 & M2
   * https://www.elecrow.com/wiki/ThinkNode-M1_Transceiver_Device(Meshtastic)_Power_By_nRF52840.html
   * https://www.elecrow.com/wiki/ThinkNode-M2_Transceiver_Device(Meshtastic)_Power_By_NRF52840.html (this actually uses ESP32-S3)
   *
   * @generated from enum value: THINKNODE_M1 = 89;
   */
  THINKNODE_M1 = 89,
  /**
   * @generated from enum value: THINKNODE_M2 = 90;
   */
  THINKNODE_M2 = 90,
  /**
   *
   * Lilygo T-ETH-Elite
   *
   * @generated from enum value: T_ETH_ELITE = 91;
   */
  T_ETH_ELITE = 91,
  /**
   *
   * Heltec HRI-3621 industrial probe
   *
   * @generated from enum value: HELTEC_SENSOR_HUB = 92;
   */
  HELTEC_SENSOR_HUB = 92,
  /**
   *
   * Muzi Works Muzi-Base device
   *
   * @generated from enum value: MUZI_BASE = 93;
   */
  MUZI_BASE = 93,
  /**
   *
   * Heltec Magnetic Power Bank with Meshtastic compatible
   *
   * @generated from enum value: HELTEC_MESH_POCKET = 94;
   */
  HELTEC_MESH_POCKET = 94,
  /**
   *
   * Seeed Solar Node
   *
   * @generated from enum value: SEEED_SOLAR_NODE = 95;
   */
  SEEED_SOLAR_NODE = 95,
  /**
   *
   * NomadStar Meteor Pro https://nomadstar.ch/
   *
   * @generated from enum value: NOMADSTAR_METEOR_PRO = 96;
   */
  NOMADSTAR_METEOR_PRO = 96,
  /**
   *
   * Elecrow CrowPanel Advance models, ESP32-S3 and TFT with SX1262 radio plugin
   *
   * @generated from enum value: CROWPANEL = 97;
   */
  CROWPANEL = 97,
  /**
   *
   * Lilygo LINK32 board with sensors
   *
   * @generated from enum value: LINK_32 = 98;
   */
  LINK_32 = 98,
  /**
   *
   * Seeed Tracker L1
   *
   * @generated from enum value: SEEED_WIO_TRACKER_L1 = 99;
   */
  SEEED_WIO_TRACKER_L1 = 99,
  /**
   *
   * Seeed Tracker L1 EINK driver
   *
   * @generated from enum value: SEEED_WIO_TRACKER_L1_EINK = 100;
   */
  SEEED_WIO_TRACKER_L1_EINK = 100,
  /**
   *
   * Muzi Works R1 Neo
   *
   * @generated from enum value: MUZI_R1_NEO = 101;
   */
  MUZI_R1_NEO = 101,
  /**
   *
   * Lilygo T-Deck Pro
   *
   * @generated from enum value: T_DECK_PRO = 102;
   */
  T_DECK_PRO = 102,
  /**
   *
   * Lilygo TLora Pager
   *
   * @generated from enum value: T_LORA_PAGER = 103;
   */
  T_LORA_PAGER = 103,
  /**
   *
   * M5Stack Reserved
   *
   * 0x68
   *
   * @generated from enum value: M5STACK_RESERVED = 104;
   */
  M5STACK_RESERVED = 104,
  /**
   *
   * RAKwireless WisMesh Tag
   *
   * @generated from enum value: WISMESH_TAG = 105;
   */
  WISMESH_TAG = 105,
  /**
   *
   * RAKwireless WisBlock Core RAK3312 https://docs.rakwireless.com/product-categories/wisduo/rak3112-module/overview/
   *
   * @generated from enum value: RAK3312 = 106;
   */
  RAK3312 = 106,
  /**
   *
   * Elecrow ThinkNode M5 https://www.elecrow.com/wiki/ThinkNode_M5_Meshtastic_LoRa_Signal_Transceiver_ESP32-S3.html
   *
   * @generated from enum value: THINKNODE_M5 = 107;
   */
  THINKNODE_M5 = 107,
  /**
   *
   * MeshSolar is an integrated power management and communication solution designed for outdoor low-power devices.
   * https://heltec.org/project/meshsolar/
   *
   * @generated from enum value: HELTEC_MESH_SOLAR = 108;
   */
  HELTEC_MESH_SOLAR = 108,
  /**
   *
   * Lilygo T-Echo Lite
   *
   * @generated from enum value: T_ECHO_LITE = 109;
   */
  T_ECHO_LITE = 109,
  /**
   *
   * New Heltec LoRA32 with ESP32-S3 CPU
   *
   * @generated from enum value: HELTEC_V4 = 110;
   */
  HELTEC_V4 = 110,
  /**
   *
   * M5Stack C6L
   *
   * @generated from enum value: M5STACK_C6L = 111;
   */
  M5STACK_C6L = 111,
  /**
   *
   * M5Stack Cardputer Adv
   *
   * @generated from enum value: M5STACK_CARDPUTER_ADV = 112;
   */
  M5STACK_CARDPUTER_ADV = 112,
  /**
   *
   * ESP32S3 main controller with GPS and TFT screen.
   *
   * @generated from enum value: HELTEC_WIRELESS_TRACKER_V2 = 113;
   */
  HELTEC_WIRELESS_TRACKER_V2 = 113,
  /**
   *
   * LilyGo T-Watch Ultra
   *
   * @generated from enum value: T_WATCH_ULTRA = 114;
   */
  T_WATCH_ULTRA = 114,
  /**
   *
   * Elecrow ThinkNode M3
   *
   * @generated from enum value: THINKNODE_M3 = 115;
   */
  THINKNODE_M3 = 115,
  /**
   *
   * RAK WISMESH_TAP_V2 with ESP32-S3 CPU
   *
   * @generated from enum value: WISMESH_TAP_V2 = 116;
   */
  WISMESH_TAP_V2 = 116,
  /**
   *
   * RAK3401
   *
   * @generated from enum value: RAK3401 = 117;
   */
  RAK3401 = 117,
  /**
   *
   * RAK6421 Hat+
   *
   * @generated from enum value: RAK6421 = 118;
   */
  RAK6421 = 118,
  /**
   *
   * Elecrow ThinkNode M4
   *
   * @generated from enum value: THINKNODE_M4 = 119;
   */
  THINKNODE_M4 = 119,
  /**
   *
   * Elecrow ThinkNode M6
   *
   * @generated from enum value: THINKNODE_M6 = 120;
   */
  THINKNODE_M6 = 120,
  /**
   *
   * Elecrow Meshstick 1262
   *
   * @generated from enum value: MESHSTICK_1262 = 121;
   */
  MESHSTICK_1262 = 121,
  /**
   *
   * LilyGo T-Beam 1W
   *
   * @generated from enum value: TBEAM_1_WATT = 122;
   */
  TBEAM_1_WATT = 122,
  /**
   *
   * LilyGo T5 S3 ePaper Pro (V1 and V2)
   *
   * @generated from enum value: T5_S3_EPAPER_PRO = 123;
   */
  T5_S3_EPAPER_PRO = 123,
  /**
   *
   * LilyGo T-Beam BPF (144-148Mhz)
   *
   * @generated from enum value: TBEAM_BPF = 124;
   */
  TBEAM_BPF = 124,
  /**
   *
   * LilyGo T-Mini E-paper S3 Kit
   *
   * @generated from enum value: MINI_EPAPER_S3 = 125;
   */
  MINI_EPAPER_S3 = 125,
  /**
   *
   * LilyGo T-Display S3 Pro LR1121
   *
   * @generated from enum value: TDISPLAY_S3_PRO = 126;
   */
  TDISPLAY_S3_PRO = 126,
  /**
   *
   * Heltec Mesh Node T096 board features an nRF52840 CPU and a TFT screen.
   *
   * @generated from enum value: HELTEC_MESH_NODE_T096 = 127;
   */
  HELTEC_MESH_NODE_T096 = 127,
  /**
   *
   * Seeed studio Mesh Tracker X1card. NRF52840 w/ LR2021 radio,
   * GPS, button, buzzer, and sensors.
   *
   * @generated from enum value: MESH_TRACKER_X1 = 128;
   */
  MESH_TRACKER_X1 = 128,
  /**
   *
   * Elecrow ThinkNode M7, M8 and M9
   *
   * @generated from enum value: THINKNODE_M7 = 129;
   */
  THINKNODE_M7 = 129,
  /**
   * @generated from enum value: THINKNODE_M8 = 130;
   */
  THINKNODE_M8 = 130,
  /**
   * @generated from enum value: THINKNODE_M9 = 131;
   */
  THINKNODE_M9 = 131,
  /**
   *
   * The Heltec-V4-R8 uses an ESP32S3R8 chip, plus an SX1262.
   *
   * @generated from enum value: HELTEC_V4_R8 = 132;
   */
  HELTEC_V4_R8 = 132,
  /**
   *
   * The HELTEC_MESH_NODE_T1 uses an NRF52840 chip, plus an SX1262.
   *
   * @generated from enum value: HELTEC_MESH_NODE_T1 = 133;
   */
  HELTEC_MESH_NODE_T1 = 133,
  /**
   *
   * B&Q Consulting Station G3: TBD
   *
   * @generated from enum value: STATION_G3 = 134;
   */
  STATION_G3 = 134,
  /**
   *
   * Lilygo T-Impulse-Plus
   *
   * @generated from enum value: T_IMPULSE_PLUS = 135;
   */
  T_IMPULSE_PLUS = 135,
  /**
   *
   * Lilygo T-Echo Card
   *
   * @generated from enum value: T_ECHO_CARD = 136;
   */
  T_ECHO_CARD = 136,
  /**
   *
   * Seeed Tracker L2
   *
   * @generated from enum value: SEEED_WIO_TRACKER_L2 = 137;
   */
  SEEED_WIO_TRACKER_L2 = 137,
  /**
   *
   * Elecrow CrowPanel Advance P4 models, ESP32-P4 and TFT with SX1262 radio plugin
   *
   * @generated from enum value: CROWPANEL_P4 = 138;
   */
  CROWPANEL_P4 = 138,
  /**
   *
   * Heltec Mesh Tower V2
   *
   * @generated from enum value: HELTEC_MESH_TOWER_V2 = 139;
   */
  HELTEC_MESH_TOWER_V2 = 139,
  /**
   *
   * Meshnology W10
   *
   * @generated from enum value: MESHNOLOGY_W10 = 140;
   */
  MESHNOLOGY_W10 = 140,
  /**
   *
   * Heltec ESP32S3 + SX1262
   *
   * @generated from enum value: HELTEC_RC32 = 141;
   */
  HELTEC_RC32 = 141,
  /**
   *
   * Heltec NRF52840 + SX1262
   *
   * @generated from enum value: HELTEC_RC52 = 142;
   */
  HELTEC_RC52 = 142,
  /**
   *
   * Heltec ESP32C6 + SX1262
   *
   * @generated from enum value: HELTEC_RCC6 = 143;
   */
  HELTEC_RCC6 = 143,
  /**
   *
   * Seeed Wio Tracker L1 Pro 1W, nRF52840 + SX1262 with 1 W external PA
   *
   * @generated from enum value: SEEED_WIO_TRACKER_L1_PRO_1W = 144;
   */
  SEEED_WIO_TRACKER_L1_PRO_1W = 144,
  /**
   *
   * Meshnology W12
   *
   * @generated from enum value: MESHNOLOGY_W12 = 145;
   */
  MESHNOLOGY_W12 = 145,
  /**
   *
   * Seeed Studio MeshPager X2
   *
   * @generated from enum value: MESHPAGER_X2 = 146;
   */
  MESHPAGER_X2 = 146,
  /**
   *
   * ------------------------------------------------------------------------------------------------------------------------------------------
   * Reserved ID For developing private Ports. These will show up in live traffic sparsely, so we can use a high number. Keep it within 8 bits.
   * ------------------------------------------------------------------------------------------------------------------------------------------
   *
   * @generated from enum value: PRIVATE_HW = 255;
   */
  PRIVATE_HW = 255
}
/**
 * Describes the enum meshtastic.HardwareModel.
 */
declare const HardwareModelSchema: GenEnum<HardwareModel>;
/**
 *
 * Shared constants between device and phone
 *
 * @generated from enum meshtastic.Constants
 */
declare enum Constants {
  /**
   *
   * First enum must be zero, and we are just using this enum to
   * pass int constants between two very different environments
   *
   * @generated from enum value: ZERO = 0;
   */
  ZERO = 0,
  /**
   *
   * From mesh.options
   * note: this payload length is ONLY the bytes that are sent inside of the Data protobuf (excluding protobuf overhead). The 16 byte header is
   * outside of this envelope
   *
   * @generated from enum value: DATA_PAYLOAD_LEN = 233;
   */
  DATA_PAYLOAD_LEN = 233
}
/**
 * Describes the enum meshtastic.Constants.
 */
declare const ConstantsSchema: GenEnum<Constants>;
/**
 *
 * Error codes for critical errors
 * The device might report these fault codes on the screen.
 * If you encounter a fault code, please post on the meshtastic.discourse.group
 * and we'll try to help.
 *
 * @generated from enum meshtastic.CriticalErrorCode
 */
declare enum CriticalErrorCode {
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: NONE = 0;
   */
  NONE = 0,
  /**
   *
   * A software bug was detected while trying to send lora
   *
   * @generated from enum value: TX_WATCHDOG = 1;
   */
  TX_WATCHDOG = 1,
  /**
   *
   * A software bug was detected on entry to sleep
   *
   * @generated from enum value: SLEEP_ENTER_WAIT = 2;
   */
  SLEEP_ENTER_WAIT = 2,
  /**
   *
   * No Lora radio hardware could be found
   *
   * @generated from enum value: NO_RADIO = 3;
   */
  NO_RADIO = 3,
  /**
   *
   * Not normally used
   *
   * @generated from enum value: UNSPECIFIED = 4;
   */
  UNSPECIFIED = 4,
  /**
   *
   * We failed while configuring a UBlox GPS
   *
   * @generated from enum value: UBLOX_UNIT_FAILED = 5;
   */
  UBLOX_UNIT_FAILED = 5,
  /**
   *
   * This board was expected to have a power management chip and it is missing or broken
   *
   * @generated from enum value: NO_AXP192 = 6;
   */
  NO_AXP192 = 6,
  /**
   *
   * The channel tried to set a radio setting which is not supported by this chipset,
   * radio comms settings are now undefined.
   *
   * @generated from enum value: INVALID_RADIO_SETTING = 7;
   */
  INVALID_RADIO_SETTING = 7,
  /**
   *
   * Radio transmit hardware failure. We sent data to the radio chip, but it didn't
   * reply with an interrupt.
   *
   * @generated from enum value: TRANSMIT_FAILED = 8;
   */
  TRANSMIT_FAILED = 8,
  /**
   *
   * We detected that the main CPU voltage dropped below the minimum acceptable value
   *
   * @generated from enum value: BROWNOUT = 9;
   */
  BROWNOUT = 9,
  /**
   * Selftest of SX1262 radio chip failed
   *
   * @generated from enum value: SX1262_FAILURE = 10;
   */
  SX1262_FAILURE = 10,
  /**
   *
   * A (likely software but possibly hardware) failure was detected while trying to send packets.
   * If this occurs on your board, please post in the forum so that we can ask you to collect some information to allow fixing this bug
   *
   * @generated from enum value: RADIO_SPI_BUG = 11;
   */
  RADIO_SPI_BUG = 11,
  /**
   *
   * Corruption was detected on the flash filesystem but we were able to repair things.
   * If you see this failure in the field please post in the forum because we are interested in seeing if this is occurring in the field.
   *
   * @generated from enum value: FLASH_CORRUPTION_RECOVERABLE = 12;
   */
  FLASH_CORRUPTION_RECOVERABLE = 12,
  /**
   *
   * Corruption was detected on the flash filesystem but we were unable to repair things.
   * NOTE: Your node will probably need to be reconfigured the next time it reboots (it will lose the region code etc...)
   * If you see this failure in the field please post in the forum because we are interested in seeing if this is occurring in the field.
   *
   * @generated from enum value: FLASH_CORRUPTION_UNRECOVERABLE = 13;
   */
  FLASH_CORRUPTION_UNRECOVERABLE = 13
}
/**
 * Describes the enum meshtastic.CriticalErrorCode.
 */
declare const CriticalErrorCodeSchema: GenEnum<CriticalErrorCode>;
/**
 *
 * Enum to indicate to clients whether this firmware is a special firmware build, like an event.
 * The first 16 values are reserved for non-event special firmwares, like the Smart Citizen use case.
 *
 * @generated from enum meshtastic.FirmwareEdition
 */
declare enum FirmwareEdition {
  /**
   *
   * Vanilla firmware
   *
   * @generated from enum value: VANILLA = 0;
   */
  VANILLA = 0,
  /**
   *
   * Firmware for use in the Smart Citizen environmental monitoring network
   *
   * @generated from enum value: SMART_CITIZEN = 1;
   */
  SMART_CITIZEN = 1,
  /**
   *
   * Open Sauce, the maker conference held yearly in CA
   *
   * @generated from enum value: OPEN_SAUCE = 16;
   */
  OPEN_SAUCE = 16,
  /**
   *
   * DEFCON, the yearly hacker conference
   *
   * @generated from enum value: DEFCON = 17;
   */
  DEFCON = 17,
  /**
   *
   * Burning Man, the yearly hippie gathering in the desert
   *
   * @generated from enum value: BURNING_MAN = 18;
   */
  BURNING_MAN = 18,
  /**
   *
   * Hamvention, the Dayton amateur radio convention
   *
   * @generated from enum value: HAMVENTION = 19;
   */
  HAMVENTION = 19,
  /**
   *
   * FAB, the international Fab Lab digital fabrication conference
   *
   * @generated from enum value: FAB = 20;
   */
  FAB = 20,
  /**
   *
   * Dragon Con, the yearly pop culture convention in Atlanta, GA
   *
   * @generated from enum value: DRAGON_CON = 21;
   */
  DRAGON_CON = 21,
  /**
   *
   * Chaos Communication Congress, the hacker conference held yearly in Germany
   *
   * @generated from enum value: CCC = 22;
   */
  CCC = 22,
  /**
   *
   * Placeholder for DIY and unofficial events
   *
   * @generated from enum value: DIY_EDITION = 127;
   */
  DIY_EDITION = 127
}
/**
 * Describes the enum meshtastic.FirmwareEdition.
 */
declare const FirmwareEditionSchema: GenEnum<FirmwareEdition>;
/**
 *
 * Enum for modules excluded from a device's configuration.
 * Each value represents a ModuleConfigType that can be toggled as excluded
 * by setting its corresponding bit in the `excluded_modules` bitmask field.
 *
 * @generated from enum meshtastic.ExcludedModules
 */
declare enum ExcludedModules {
  /**
   *
   * Default value of 0 indicates no modules are excluded.
   *
   * @generated from enum value: EXCLUDED_NONE = 0;
   */
  EXCLUDED_NONE = 0,
  /**
   *
   * MQTT module
   *
   * @generated from enum value: MQTT_CONFIG = 1;
   */
  MQTT_CONFIG = 1,
  /**
   *
   * Serial module
   *
   * @generated from enum value: SERIAL_CONFIG = 2;
   */
  SERIAL_CONFIG = 2,
  /**
   *
   * External Notification module
   *
   * @generated from enum value: EXTNOTIF_CONFIG = 4;
   */
  EXTNOTIF_CONFIG = 4,
  /**
   *
   * Store and Forward module
   *
   * @generated from enum value: STOREFORWARD_CONFIG = 8;
   */
  STOREFORWARD_CONFIG = 8,
  /**
   *
   * Range Test module
   *
   * @generated from enum value: RANGETEST_CONFIG = 16;
   */
  RANGETEST_CONFIG = 16,
  /**
   *
   * Telemetry module
   *
   * @generated from enum value: TELEMETRY_CONFIG = 32;
   */
  TELEMETRY_CONFIG = 32,
  /**
   *
   * Canned Message module
   *
   * @generated from enum value: CANNEDMSG_CONFIG = 64;
   */
  CANNEDMSG_CONFIG = 64,
  /**
   *
   * Audio module
   *
   * @generated from enum value: AUDIO_CONFIG = 128;
   */
  AUDIO_CONFIG = 128,
  /**
   *
   * Remote Hardware module
   *
   * @generated from enum value: REMOTEHARDWARE_CONFIG = 256;
   */
  REMOTEHARDWARE_CONFIG = 256,
  /**
   *
   * Neighbor Info module
   *
   * @generated from enum value: NEIGHBORINFO_CONFIG = 512;
   */
  NEIGHBORINFO_CONFIG = 512,
  /**
   *
   * Ambient Lighting module
   *
   * @generated from enum value: AMBIENTLIGHTING_CONFIG = 1024;
   */
  AMBIENTLIGHTING_CONFIG = 1024,
  /**
   *
   * Detection Sensor module
   *
   * @generated from enum value: DETECTIONSENSOR_CONFIG = 2048;
   */
  DETECTIONSENSOR_CONFIG = 2048,
  /**
   *
   * Paxcounter module
   *
   * @generated from enum value: PAXCOUNTER_CONFIG = 4096;
   */
  PAXCOUNTER_CONFIG = 4096,
  /**
   *
   * Bluetooth config (not technically a module, but used to indicate bluetooth capabilities)
   *
   * @generated from enum value: BLUETOOTH_CONFIG = 8192;
   */
  BLUETOOTH_CONFIG = 8192,
  /**
   *
   * Network config (not technically a module, but used to indicate network capabilities)
   *
   * @generated from enum value: NETWORK_CONFIG = 16384;
   */
  NETWORK_CONFIG = 16384
}
/**
 * Describes the enum meshtastic.ExcludedModules.
 */
declare const ExcludedModulesSchema: GenEnum<ExcludedModules>;
declare namespace admin_pb_d_exports {
  export { AS3935_config, AS3935_configSchema, AdminMessage, AdminMessageSchema, AdminMessage_BackupLocation, AdminMessage_BackupLocationSchema, AdminMessage_ConfigType, AdminMessage_ConfigTypeSchema, AdminMessage_InputEvent, AdminMessage_InputEventSchema, AdminMessage_ModuleConfigType, AdminMessage_ModuleConfigTypeSchema, AdminMessage_OTAEvent, AdminMessage_OTAEventSchema, DS248X_config, DS248X_configSchema, HamParameters, HamParametersSchema, KeyVerificationAdmin, KeyVerificationAdminSchema, KeyVerificationAdmin_MessageType, KeyVerificationAdmin_MessageTypeSchema, LockdownAuth, LockdownAuthSchema, NodeRemoteHardwarePinsResponse, NodeRemoteHardwarePinsResponseSchema, OTAMode, OTAModeSchema, SCD30_config, SCD30_configSchema, SCD4X_config, SCD4X_configSchema, SEN5X_config, SEN5X_configSchema, SEN6X_config, SEN6X_configSchema, SHTXX_config, SHTXX_configSchema, SensorConfig, SensorConfigSchema, SharedContact, SharedContactSchema, file_meshtastic_admin };
}
/**
 * Describes the file meshtastic/admin.proto.
 */
declare const file_meshtastic_admin: GenFile;
/**
 *
 * This message is handled by the Admin module and is responsible for all settings/channel read/write operations.
 * This message is used to do settings operations to both remote AND local nodes.
 * (Prior to 1.2 these operations were done via special ToRadio operations)
 *
 * @generated from message meshtastic.AdminMessage
 */
type AdminMessage = Message<"meshtastic.AdminMessage"> & {
  /**
   *
   * The node generates this key and sends it with any get_x_response packets.
   * The client MUST include the same key with any set_x commands. Key expires after 300 seconds.
   * Prevents replay attacks for admin messages.
   *
   * @generated from field: bytes session_passkey = 101;
   */
  sessionPasskey: Uint8Array;
  /**
   *
   * TODO: REPLACE
   *
   * @generated from oneof meshtastic.AdminMessage.payload_variant
   */
  payloadVariant: {
    /**
     *
     * Send the specified channel in the response to this message
     * NOTE: This field is sent with the channel index + 1 (to ensure we never try to send 'zero' - which protobufs treats as not present)
     *
     * @generated from field: uint32 get_channel_request = 1;
     */
    value: number;
    case: "getChannelRequest";
  } | {
    /**
     *
     * TODO: REPLACE
     *
     * @generated from field: meshtastic.Channel get_channel_response = 2;
     */
    value: Channel;
    case: "getChannelResponse";
  } | {
    /**
     *
     * Send the current owner data in the response to this message.
     *
     * @generated from field: bool get_owner_request = 3;
     */
    value: boolean;
    case: "getOwnerRequest";
  } | {
    /**
     *
     * TODO: REPLACE
     *
     * @generated from field: meshtastic.User get_owner_response = 4;
     */
    value: User;
    case: "getOwnerResponse";
  } | {
    /**
     *
     * Ask for the following config data to be sent
     *
     * @generated from field: meshtastic.AdminMessage.ConfigType get_config_request = 5;
     */
    value: AdminMessage_ConfigType;
    case: "getConfigRequest";
  } | {
    /**
     *
     * Send the current Config in the response to this message.
     *
     * @generated from field: meshtastic.Config get_config_response = 6;
     */
    value: Config;
    case: "getConfigResponse";
  } | {
    /**
     *
     * Ask for the following config data to be sent
     *
     * @generated from field: meshtastic.AdminMessage.ModuleConfigType get_module_config_request = 7;
     */
    value: AdminMessage_ModuleConfigType;
    case: "getModuleConfigRequest";
  } | {
    /**
     *
     * Send the current Config in the response to this message.
     *
     * @generated from field: meshtastic.ModuleConfig get_module_config_response = 8;
     */
    value: ModuleConfig;
    case: "getModuleConfigResponse";
  } | {
    /**
     *
     * Get the Canned Message Module messages in the response to this message.
     *
     * @generated from field: bool get_canned_message_module_messages_request = 10;
     */
    value: boolean;
    case: "getCannedMessageModuleMessagesRequest";
  } | {
    /**
     *
     * Get the Canned Message Module messages in the response to this message.
     *
     * @generated from field: string get_canned_message_module_messages_response = 11;
     */
    value: string;
    case: "getCannedMessageModuleMessagesResponse";
  } | {
    /**
     *
     * Request the node to send device metadata (firmware, protobuf version, etc)
     *
     * @generated from field: bool get_device_metadata_request = 12;
     */
    value: boolean;
    case: "getDeviceMetadataRequest";
  } | {
    /**
     *
     * Device metadata response
     *
     * @generated from field: meshtastic.DeviceMetadata get_device_metadata_response = 13;
     */
    value: DeviceMetadata;
    case: "getDeviceMetadataResponse";
  } | {
    /**
     *
     * Get the Ringtone in the response to this message.
     *
     * @generated from field: bool get_ringtone_request = 14;
     */
    value: boolean;
    case: "getRingtoneRequest";
  } | {
    /**
     *
     * Get the Ringtone in the response to this message.
     *
     * @generated from field: string get_ringtone_response = 15;
     */
    value: string;
    case: "getRingtoneResponse";
  } | {
    /**
     *
     * Request the node to send it's connection status
     *
     * @generated from field: bool get_device_connection_status_request = 16;
     */
    value: boolean;
    case: "getDeviceConnectionStatusRequest";
  } | {
    /**
     *
     * Device connection status response
     *
     * @generated from field: meshtastic.DeviceConnectionStatus get_device_connection_status_response = 17;
     */
    value: DeviceConnectionStatus;
    case: "getDeviceConnectionStatusResponse";
  } | {
    /**
     *
     * Setup a node for licensed amateur (ham) radio operation
     *
     * @generated from field: meshtastic.HamParameters set_ham_mode = 18;
     */
    value: HamParameters;
    case: "setHamMode";
  } | {
    /**
     *
     * Get the mesh's nodes with their available gpio pins for RemoteHardware module use
     *
     * @generated from field: bool get_node_remote_hardware_pins_request = 19;
     */
    value: boolean;
    case: "getNodeRemoteHardwarePinsRequest";
  } | {
    /**
     *
     * Respond with the mesh's nodes with their available gpio pins for RemoteHardware module use
     *
     * @generated from field: meshtastic.NodeRemoteHardwarePinsResponse get_node_remote_hardware_pins_response = 20;
     */
    value: NodeRemoteHardwarePinsResponse;
    case: "getNodeRemoteHardwarePinsResponse";
  } | {
    /**
     *
     * Enter (UF2) DFU mode
     * Only implemented on NRF52 currently
     *
     * @generated from field: bool enter_dfu_mode_request = 21;
     */
    value: boolean;
    case: "enterDfuModeRequest";
  } | {
    /**
     *
     * Delete the file by the specified path from the device
     *
     * @generated from field: string delete_file_request = 22;
     */
    value: string;
    case: "deleteFileRequest";
  } | {
    /**
     *
     * Set zero and offset for scale chips
     *
     * @generated from field: uint32 set_scale = 23;
     */
    value: number;
    case: "setScale";
  } | {
    /**
     *
     * Backup the node's preferences
     *
     * @generated from field: meshtastic.AdminMessage.BackupLocation backup_preferences = 24;
     */
    value: AdminMessage_BackupLocation;
    case: "backupPreferences";
  } | {
    /**
     *
     * Restore the node's preferences
     *
     * @generated from field: meshtastic.AdminMessage.BackupLocation restore_preferences = 25;
     */
    value: AdminMessage_BackupLocation;
    case: "restorePreferences";
  } | {
    /**
     *
     * Remove backups of the node's preferences
     *
     * @generated from field: meshtastic.AdminMessage.BackupLocation remove_backup_preferences = 26;
     */
    value: AdminMessage_BackupLocation;
    case: "removeBackupPreferences";
  } | {
    /**
     *
     * Send an input event to the node.
     * This is used to trigger physical input events like button presses, touch events, etc.
     *
     * @generated from field: meshtastic.AdminMessage.InputEvent send_input_event = 27;
     */
    value: AdminMessage_InputEvent;
    case: "sendInputEvent";
  } | {
    /**
     *
     * Set the owner for this node
     *
     * @generated from field: meshtastic.User set_owner = 32;
     */
    value: User;
    case: "setOwner";
  } | {
    /**
     *
     * Set channels (using the new API).
     * A special channel is the "primary channel".
     * The other records are secondary channels.
     * Note: only one channel can be marked as primary.
     * If the client sets a particular channel to be primary, the previous channel will be set to SECONDARY automatically.
     *
     * @generated from field: meshtastic.Channel set_channel = 33;
     */
    value: Channel;
    case: "setChannel";
  } | {
    /**
     *
     * Set the current Config
     *
     * @generated from field: meshtastic.Config set_config = 34;
     */
    value: Config;
    case: "setConfig";
  } | {
    /**
     *
     * Set the current Config
     *
     * @generated from field: meshtastic.ModuleConfig set_module_config = 35;
     */
    value: ModuleConfig;
    case: "setModuleConfig";
  } | {
    /**
     *
     * Set the Canned Message Module messages text.
     *
     * @generated from field: string set_canned_message_module_messages = 36;
     */
    value: string;
    case: "setCannedMessageModuleMessages";
  } | {
    /**
     *
     * Set the ringtone for ExternalNotification.
     *
     * @generated from field: string set_ringtone_message = 37;
     */
    value: string;
    case: "setRingtoneMessage";
  } | {
    /**
     *
     * Remove the node by the specified node-num from the NodeDB on the device
     *
     * @generated from field: uint32 remove_by_nodenum = 38;
     */
    value: number;
    case: "removeByNodenum";
  } | {
    /**
     *
     * Set specified node-num to be favorited on the NodeDB on the device
     *
     * @generated from field: uint32 set_favorite_node = 39;
     */
    value: number;
    case: "setFavoriteNode";
  } | {
    /**
     *
     * Set specified node-num to be un-favorited on the NodeDB on the device
     *
     * @generated from field: uint32 remove_favorite_node = 40;
     */
    value: number;
    case: "removeFavoriteNode";
  } | {
    /**
     *
     * Set fixed position data on the node and then set the position.fixed_position = true
     *
     * @generated from field: meshtastic.Position set_fixed_position = 41;
     */
    value: Position;
    case: "setFixedPosition";
  } | {
    /**
     *
     * Clear fixed position coordinates and then set position.fixed_position = false
     *
     * @generated from field: bool remove_fixed_position = 42;
     */
    value: boolean;
    case: "removeFixedPosition";
  } | {
    /**
     *
     * Set time only on the node
     * Convenience method to set the time on the node (as Net quality) without any other position data
     *
     * @generated from field: fixed32 set_time_only = 43;
     */
    value: number;
    case: "setTimeOnly";
  } | {
    /**
     *
     * Tell the node to send the stored ui data.
     *
     * @generated from field: bool get_ui_config_request = 44;
     */
    value: boolean;
    case: "getUiConfigRequest";
  } | {
    /**
     *
     * Reply stored device ui data.
     *
     * @generated from field: meshtastic.DeviceUIConfig get_ui_config_response = 45;
     */
    value: DeviceUIConfig;
    case: "getUiConfigResponse";
  } | {
    /**
     *
     * Tell the node to store UI data persistently.
     *
     * @generated from field: meshtastic.DeviceUIConfig store_ui_config = 46;
     */
    value: DeviceUIConfig;
    case: "storeUiConfig";
  } | {
    /**
     *
     * Set specified node-num to be ignored on the NodeDB on the device
     *
     * @generated from field: uint32 set_ignored_node = 47;
     */
    value: number;
    case: "setIgnoredNode";
  } | {
    /**
     *
     * Set specified node-num to be un-ignored on the NodeDB on the device
     *
     * @generated from field: uint32 remove_ignored_node = 48;
     */
    value: number;
    case: "removeIgnoredNode";
  } | {
    /**
     *
     * Set specified node-num to be muted
     *
     * @generated from field: uint32 toggle_muted_node = 49;
     */
    value: number;
    case: "toggleMutedNode";
  } | {
    /**
     *
     * Begins an edit transaction for config, module config, owner, and channel settings changes
     * This will delay the standard *implicit* save to the file system and subsequent reboot behavior until committed (commit_edit_settings)
     *
     * @generated from field: bool begin_edit_settings = 64;
     */
    value: boolean;
    case: "beginEditSettings";
  } | {
    /**
     *
     * Commits an open transaction for any edits made to config, module config, owner, and channel settings
     *
     * @generated from field: bool commit_edit_settings = 65;
     */
    value: boolean;
    case: "commitEditSettings";
  } | {
    /**
     *
     * Add a contact (User) to the nodedb
     *
     * @generated from field: meshtastic.SharedContact add_contact = 66;
     */
    value: SharedContact;
    case: "addContact";
  } | {
    /**
     *
     * Initiate or respond to a key verification request
     *
     * @generated from field: meshtastic.KeyVerificationAdmin key_verification = 67;
     */
    value: KeyVerificationAdmin;
    case: "keyVerification";
  } | {
    /**
     *
     * Tell the node to factory reset config everything; all device state and configuration will be returned to factory defaults and BLE bonds will be cleared.
     *
     * @generated from field: int32 factory_reset_device = 94;
     */
    value: number;
    case: "factoryResetDevice";
  } | {
    /**
     *
     * Tell the node to reboot into the OTA Firmware in this many seconds (or <0 to cancel reboot)
     * Only Implemented for ESP32 Devices. This needs to be issued to send a new main firmware via bluetooth.
     * Deprecated in favor of reboot_ota_mode in 2.7.17
     *
     * @generated from field: int32 reboot_ota_seconds = 95 [deprecated = true];
     * @deprecated
     */
    value: number;
    case: "rebootOtaSeconds";
  } | {
    /**
     *
     * This message is only supported for the simulator Portduino build.
     * If received the simulator will exit successfully.
     *
     * @generated from field: bool exit_simulator = 96;
     */
    value: boolean;
    case: "exitSimulator";
  } | {
    /**
     *
     * Tell the node to reboot in this many seconds (or <0 to cancel reboot)
     *
     * @generated from field: int32 reboot_seconds = 97;
     */
    value: number;
    case: "rebootSeconds";
  } | {
    /**
     *
     * Tell the node to shutdown in this many seconds (or <0 to cancel shutdown)
     *
     * @generated from field: int32 shutdown_seconds = 98;
     */
    value: number;
    case: "shutdownSeconds";
  } | {
    /**
     *
     * Tell the node to factory reset config; all device state and configuration will be returned to factory defaults; BLE bonds will be preserved.
     *
     * @generated from field: int32 factory_reset_config = 99;
     */
    value: number;
    case: "factoryResetConfig";
  } | {
    /**
     *
     * Tell the node to reset the nodedb.
     * When true, favorites are preserved through reset.
     *
     * @generated from field: bool nodedb_reset = 100;
     */
    value: boolean;
    case: "nodedbReset";
  } | {
    /**
     *
     * Tell the node to reset into the OTA Loader
     *
     * @generated from field: meshtastic.AdminMessage.OTAEvent ota_request = 102;
     */
    value: AdminMessage_OTAEvent;
    case: "otaRequest";
  } | {
    /**
     *
     * Parameters and sensor configuration
     *
     * @generated from field: meshtastic.SensorConfig sensor_config = 103;
     */
    value: SensorConfig;
    case: "sensorConfig";
  } | {
    /**
     *
     * Lockdown passphrase delivery / unlock / lock-now command for hardened
     * firmware builds (see MESHTASTIC_LOCKDOWN). Used to provision the
     * passphrase on first boot, unlock encrypted storage on subsequent
     * reboots, re-verify on already-unlocked devices to authorize a new
     * client connection, or immediately re-lock the device.
     *
     * Replaces the earlier scheme that repurposed SecurityConfig.private_key
     * to carry passphrase bytes; that hack is retired.
     *
     * @generated from field: meshtastic.LockdownAuth lockdown_auth = 104;
     */
    value: LockdownAuth;
    case: "lockdownAuth";
  } | {
    case: undefined;
    value?: undefined;
  };
};
/**
 * Describes the message meshtastic.AdminMessage.
 * Use `create(AdminMessageSchema)` to create a new message.
 */
declare const AdminMessageSchema: GenMessage<AdminMessage>;
/**
 *
 * Input event message to be sent to the node.
 *
 * @generated from message meshtastic.AdminMessage.InputEvent
 */
type AdminMessage_InputEvent = Message<"meshtastic.AdminMessage.InputEvent"> & {
  /**
   *
   * The input event code
   *
   * @generated from field: uint32 event_code = 1;
   */
  eventCode: number;
  /**
   *
   * Keyboard character code
   *
   * @generated from field: uint32 kb_char = 2;
   */
  kbChar: number;
  /**
   *
   * The touch X coordinate
   *
   * @generated from field: uint32 touch_x = 3;
   */
  touchX: number;
  /**
   *
   * The touch Y coordinate
   *
   * @generated from field: uint32 touch_y = 4;
   */
  touchY: number;
};
/**
 * Describes the message meshtastic.AdminMessage.InputEvent.
 * Use `create(AdminMessage_InputEventSchema)` to create a new message.
 */
declare const AdminMessage_InputEventSchema: GenMessage<AdminMessage_InputEvent>;
/**
 *
 * User is requesting an over the air update.
 * Node will reboot into the OTA loader
 *
 * @generated from message meshtastic.AdminMessage.OTAEvent
 */
type AdminMessage_OTAEvent = Message<"meshtastic.AdminMessage.OTAEvent"> & {
  /**
   *
   * Tell the node to reboot into OTA mode for firmware update via BLE or WiFi (ESP32 only for now)
   *
   * @generated from field: meshtastic.OTAMode reboot_ota_mode = 1;
   */
  rebootOtaMode: OTAMode;
  /**
   *
   * A 32 byte hash of the OTA firmware.
   * Used to verify the integrity of the firmware before applying an update.
   *
   * @generated from field: bytes ota_hash = 2;
   */
  otaHash: Uint8Array;
};
/**
 * Describes the message meshtastic.AdminMessage.OTAEvent.
 * Use `create(AdminMessage_OTAEventSchema)` to create a new message.
 */
declare const AdminMessage_OTAEventSchema: GenMessage<AdminMessage_OTAEvent>;
/**
 *
 * TODO: REPLACE
 *
 * @generated from enum meshtastic.AdminMessage.ConfigType
 */
declare enum AdminMessage_ConfigType {
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: DEVICE_CONFIG = 0;
   */
  DEVICE_CONFIG = 0,
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: POSITION_CONFIG = 1;
   */
  POSITION_CONFIG = 1,
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: POWER_CONFIG = 2;
   */
  POWER_CONFIG = 2,
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: NETWORK_CONFIG = 3;
   */
  NETWORK_CONFIG = 3,
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: DISPLAY_CONFIG = 4;
   */
  DISPLAY_CONFIG = 4,
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: LORA_CONFIG = 5;
   */
  LORA_CONFIG = 5,
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: BLUETOOTH_CONFIG = 6;
   */
  BLUETOOTH_CONFIG = 6,
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: SECURITY_CONFIG = 7;
   */
  SECURITY_CONFIG = 7,
  /**
   *
   * Session key config
   *
   * @generated from enum value: SESSIONKEY_CONFIG = 8;
   */
  SESSIONKEY_CONFIG = 8,
  /**
   *
   * device-ui config
   *
   * @generated from enum value: DEVICEUI_CONFIG = 9;
   */
  DEVICEUI_CONFIG = 9
}
/**
 * Describes the enum meshtastic.AdminMessage.ConfigType.
 */
declare const AdminMessage_ConfigTypeSchema: GenEnum<AdminMessage_ConfigType>;
/**
 *
 * TODO: REPLACE
 *
 * @generated from enum meshtastic.AdminMessage.ModuleConfigType
 */
declare enum AdminMessage_ModuleConfigType {
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: MQTT_CONFIG = 0;
   */
  MQTT_CONFIG = 0,
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: SERIAL_CONFIG = 1;
   */
  SERIAL_CONFIG = 1,
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: EXTNOTIF_CONFIG = 2;
   */
  EXTNOTIF_CONFIG = 2,
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: STOREFORWARD_CONFIG = 3;
   */
  STOREFORWARD_CONFIG = 3,
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: RANGETEST_CONFIG = 4;
   */
  RANGETEST_CONFIG = 4,
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: TELEMETRY_CONFIG = 5;
   */
  TELEMETRY_CONFIG = 5,
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: CANNEDMSG_CONFIG = 6;
   */
  CANNEDMSG_CONFIG = 6,
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: AUDIO_CONFIG = 7;
   */
  AUDIO_CONFIG = 7,
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: REMOTEHARDWARE_CONFIG = 8;
   */
  REMOTEHARDWARE_CONFIG = 8,
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: NEIGHBORINFO_CONFIG = 9;
   */
  NEIGHBORINFO_CONFIG = 9,
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: AMBIENTLIGHTING_CONFIG = 10;
   */
  AMBIENTLIGHTING_CONFIG = 10,
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: DETECTIONSENSOR_CONFIG = 11;
   */
  DETECTIONSENSOR_CONFIG = 11,
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: PAXCOUNTER_CONFIG = 12;
   */
  PAXCOUNTER_CONFIG = 12,
  /**
   *
   * TODO: REPLACE
   *
   * @generated from enum value: STATUSMESSAGE_CONFIG = 13;
   */
  STATUSMESSAGE_CONFIG = 13,
  /**
   *
   * Traffic management module config
   *
   * @generated from enum value: TRAFFICMANAGEMENT_CONFIG = 14;
   */
  TRAFFICMANAGEMENT_CONFIG = 14,
  /**
   *
   * TAK module config
   *
   * @generated from enum value: TAK_CONFIG = 15;
   */
  TAK_CONFIG = 15,
  /**
   *
   * Mesh Beacon module config
   *
   * @generated from enum value: MESHBEACON_CONFIG = 16;
   */
  MESHBEACON_CONFIG = 16
}
/**
 * Describes the enum meshtastic.AdminMessage.ModuleConfigType.
 */
declare const AdminMessage_ModuleConfigTypeSchema: GenEnum<AdminMessage_ModuleConfigType>;
/**
 * @generated from enum meshtastic.AdminMessage.BackupLocation
 */
declare enum AdminMessage_BackupLocation {
  /**
   *
   * Backup to the internal flash
   *
   * @generated from enum value: FLASH = 0;
   */
  FLASH = 0,
  /**
   *
   * Backup to the SD card
   *
   * @generated from enum value: SD = 1;
   */
  SD = 1
}
/**
 * Describes the enum meshtastic.AdminMessage.BackupLocation.
 */
declare const AdminMessage_BackupLocationSchema: GenEnum<AdminMessage_BackupLocation>;
/**
 *
 * Lockdown passphrase delivery payload.
 *
 * One message handles three operations distinguished by content:
 *   - Provision (first-time): passphrase set, lock_now=false. Firmware
 *     generates DEK, wraps with passphrase-derived KEK, persists.
 *   - Unlock: passphrase set, lock_now=false. Firmware verifies
 *     passphrase against stored DEK, unlocks storage, authorizes the
 *     connection that delivered this packet.
 *   - Lock now: lock_now=true, passphrase ignored. Firmware revokes
 *     all client auth and reboots into the locked state.
 *
 * Firmware decides between provision and unlock based on its own state
 * (whether a DEK file already exists). Clients do not need to track
 * which case applies.
 *
 * @generated from message meshtastic.LockdownAuth
 */
type LockdownAuth = Message<"meshtastic.LockdownAuth"> & {
  /**
   *
   * Passphrase bytes (1-32). Empty when lock_now is true.
   * Capped to 32 to match the proto cap on related security fields.
   *
   * @generated from field: bytes passphrase = 1;
   */
  passphrase: Uint8Array;
  /**
   *
   * Optional override of the boot-count token TTL granted on success.
   * 0 = use firmware default (TOKEN_DEFAULT_BOOTS).
   * On reboot the firmware decrements this; when it reaches 0 the
   * device boots fully locked and requires a fresh passphrase.
   *
   * @generated from field: uint32 boots_remaining = 2;
   */
  bootsRemaining: number;
  /**
   *
   * Optional wall-clock expiry for the unlock token, as absolute
   * Unix-epoch seconds. 0 = no time limit (only the boot-count TTL
   * applies). On boot, if the device RTC is set and now > this value,
   * the token is treated as expired.
   *
   * @generated from field: uint32 valid_until_epoch = 3;
   */
  validUntilEpoch: number;
  /**
   *
   * If true, ignore passphrase fields, immediately revoke all
   * connection-level admin authorization, and reboot the device into
   * the locked state. Always honoured regardless of current lock state.
   *
   * @generated from field: bool lock_now = 4;
   */
  lockNow: boolean;
  /**
   *
   * Optional per-boot uptime cap on the unlocked session, in seconds.
   * 0 = unlimited (token-only enforcement, suitable for unattended
   * tower / infrastructure nodes).
   *
   * When non-zero, the firmware arms an uptime timer at unlock. On
   * each expiry, while there is still boot-count budget, the firmware
   * decrements the on-flash boot count in place, revokes per-
   * connection admin auth (clients must re-authenticate to see
   * content), re-engages the screen lock, and re-arms the timer
   * without rebooting. Mesh routing keeps running across session
   * boundaries; only when the boot-count budget reaches zero does
   * the device hard-lock and reboot.
   *
   * Total exposure ceiling = ((resolved boot count) + 1) * max_session_seconds.
   * The +1 accounts for the initial passphrase-unlocked session
   * itself, since boots_remaining is the number of subsequent
   * session rolls (each consuming one boot from the rollback ledger).
   * The resolved boot count is the value the firmware writes into the
   * token at unlock time: the client-supplied boots_remaining when
   * non-zero, otherwise the firmware default (TOKEN_DEFAULT_BOOTS).
   * Note that boots_remaining == 0 in this message means "use firmware
   * default", NOT "zero boots" — a client computing the ceiling for
   * display should mirror that resolution rather than multiplying the
   * raw request value.
   *
   * The cap is persisted in the token, so it survives token-based
   * auto-unlock across reboots. Explicit operator Lock Now still
   * deletes the token and forces passphrase re-entry.
   *
   * Uses millis() (CPU uptime), not wall-clock time, so the cap is
   * immune to GPS spoofing, RTC backup-battery removal, and Faraday
   * cage isolation — none of those move the uptime counter. The only
   * way to reset the session clock is a reboot, which costs a boot
   * from the on-flash, HMAC-bound counter.
   *
   * @generated from field: uint32 max_session_seconds = 5;
   */
  maxSessionSeconds: number;
  /**
   *
   * Disable lockdown mode. Requires a valid passphrase in the same
   * message (the device must prove the operator owns it before
   * reverting at-rest encryption). On success the firmware decrypts
   * every stored config / channel / nodedb file back to plaintext,
   * removes the wrapped DEK, unlock token, monotonic-counter, and
   * backoff files, and reboots out of lockdown.
   *
   * This is the inverse of the provision/unlock path: it is how the
   * client app's "lockdown mode" toggle returns a device to normal
   * operation.
   *
   * NOT reversed by this operation: APPROTECT. Once the debug port
   * lockout has been burned (on silicon where it is effective) it is
   * permanent — disabling lockdown decrypts your data and removes the
   * access gates, but the SWD/JTAG port stays locked for the life of
   * the device (recoverable only via a full chip erase over a debug
   * probe, which destroys all data). Clients should make this
   * irreversibility clear at the moment lockdown is first enabled.
   *
   * When true the passphrase field is still required; boots_remaining,
   * valid_until_epoch, max_session_seconds, and lock_now are ignored.
   *
   * @generated from field: bool disable = 6;
   */
  disable: boolean;
};
/**
 * Describes the message meshtastic.LockdownAuth.
 * Use `create(LockdownAuthSchema)` to create a new message.
 */
declare const LockdownAuthSchema: GenMessage<LockdownAuth>;
/**
 *
 * Parameters for setting up Meshtastic for ameteur radio usage
 *
 * @generated from message meshtastic.HamParameters
 */
type HamParameters = Message<"meshtastic.HamParameters"> & {
  /**
   *
   * Amateur radio call sign, eg. KD2ABC
   *
   * @generated from field: string call_sign = 1;
   */
  callSign: string;
  /**
   *
   * Transmit power in dBm at the LoRA transceiver, not including any amplification
   *
   * @generated from field: int32 tx_power = 2;
   */
  txPower: number;
  /**
   *
   * The selected frequency of LoRA operation
   * Please respect your local laws, regulations, and band plans.
   * Ensure your radio is capable of operating of the selected frequency before setting this.
   *
   * @generated from field: float frequency = 3;
   */
  frequency: number;
  /**
   *
   * Optional short name of user
   *
   * @generated from field: string short_name = 4;
   */
  shortName: string;
  /**
   *
   * Optional long name of user
   * Appended to callsign
   *
   * @generated from field: string long_name = 5;
   */
  longName: string;
};
/**
 * Describes the message meshtastic.HamParameters.
 * Use `create(HamParametersSchema)` to create a new message.
 */
declare const HamParametersSchema: GenMessage<HamParameters>;
/**
 *
 * Response envelope for node_remote_hardware_pins
 *
 * @generated from message meshtastic.NodeRemoteHardwarePinsResponse
 */
type NodeRemoteHardwarePinsResponse = Message<"meshtastic.NodeRemoteHardwarePinsResponse"> & {
  /**
   *
   * Nodes and their respective remote hardware GPIO pins
   *
   * @generated from field: repeated meshtastic.NodeRemoteHardwarePin node_remote_hardware_pins = 1;
   */
  nodeRemoteHardwarePins: NodeRemoteHardwarePin[];
};
/**
 * Describes the message meshtastic.NodeRemoteHardwarePinsResponse.
 * Use `create(NodeRemoteHardwarePinsResponseSchema)` to create a new message.
 */
declare const NodeRemoteHardwarePinsResponseSchema: GenMessage<NodeRemoteHardwarePinsResponse>;
/**
 * @generated from message meshtastic.SharedContact
 */
type SharedContact = Message<"meshtastic.SharedContact"> & {
  /**
   *
   * The node number of the contact
   *
   * @generated from field: uint32 node_num = 1;
   */
  nodeNum: number;
  /**
   *
   * The User of the contact
   *
   * @generated from field: meshtastic.User user = 2;
   */
  user?: User;
  /**
   *
   * Add this contact to the blocked / ignored list
   *
   * @generated from field: bool should_ignore = 3;
   */
  shouldIgnore: boolean;
  /**
   *
   * Set the IS_KEY_MANUALLY_VERIFIED bit
   *
   * @generated from field: bool manually_verified = 4;
   */
  manuallyVerified: boolean;
};
/**
 * Describes the message meshtastic.SharedContact.
 * Use `create(SharedContactSchema)` to create a new message.
 */
declare const SharedContactSchema: GenMessage<SharedContact>;
/**
 *
 * This message is used by a client to initiate or complete a key verification
 *
 * @generated from message meshtastic.KeyVerificationAdmin
 */
type KeyVerificationAdmin = Message<"meshtastic.KeyVerificationAdmin"> & {
  /**
   * @generated from field: meshtastic.KeyVerificationAdmin.MessageType message_type = 1;
   */
  messageType: KeyVerificationAdmin_MessageType;
  /**
   *
   * The nodenum we're requesting
   *
   * @generated from field: uint32 remote_nodenum = 2;
   */
  remoteNodenum: number;
  /**
   *
   * The nonce is used to track the connection
   *
   * @generated from field: uint64 nonce = 3;
   */
  nonce: bigint;
  /**
   *
   * The 4 digit code generated by the remote node, and communicated outside the mesh
   *
   * @generated from field: optional uint32 security_number = 4;
   */
  securityNumber?: number;
};
/**
 * Describes the message meshtastic.KeyVerificationAdmin.
 * Use `create(KeyVerificationAdminSchema)` to create a new message.
 */
declare const KeyVerificationAdminSchema: GenMessage<KeyVerificationAdmin>;
/**
 *
 * Three stages of this request.
 *
 * @generated from enum meshtastic.KeyVerificationAdmin.MessageType
 */
declare enum KeyVerificationAdmin_MessageType {
  /**
   *
   * This is the first stage, where a client initiates
   *
   * @generated from enum value: INITIATE_VERIFICATION = 0;
   */
  INITIATE_VERIFICATION = 0,
  /**
   *
   * After the nonce has been returned over the mesh, the client prompts for the security number
   * And uses this message to provide it to the node.
   *
   * @generated from enum value: PROVIDE_SECURITY_NUMBER = 1;
   */
  PROVIDE_SECURITY_NUMBER = 1,
  /**
   *
   * Once the user has compared the verification message, this message notifies the node.
   *
   * @generated from enum value: DO_VERIFY = 2;
   */
  DO_VERIFY = 2,
  /**
   *
   * This is the cancel path, can be taken at any point
   *
   * @generated from enum value: DO_NOT_VERIFY = 3;
   */
  DO_NOT_VERIFY = 3
}
/**
 * Describes the enum meshtastic.KeyVerificationAdmin.MessageType.
 */
declare const KeyVerificationAdmin_MessageTypeSchema: GenEnum<KeyVerificationAdmin_MessageType>;
/**
 * @generated from message meshtastic.SensorConfig
 */
type SensorConfig = Message<"meshtastic.SensorConfig"> & {
  /**
   *
   * SCD4X CO2 Sensor configuration
   *
   * @generated from field: meshtastic.SCD4X_config scd4x_config = 1;
   */
  scd4xConfig?: SCD4X_config;
  /**
   *
   * SEN5X PM Sensor configuration
   *
   * @generated from field: meshtastic.SEN5X_config sen5x_config = 2;
   */
  sen5xConfig?: SEN5X_config;
  /**
   *
   * SCD30 CO2 Sensor configuration
   *
   * @generated from field: meshtastic.SCD30_config scd30_config = 3;
   */
  scd30Config?: SCD30_config;
  /**
   *
   * SHTXX temperature and relative humidity sensor configuration
   *
   * @generated from field: meshtastic.SHTXX_config shtxx_config = 4;
   */
  shtxxConfig?: SHTXX_config;
  /**
   *
   * DS248X-800 temperature sensor configuration
   *
   * @generated from field: meshtastic.DS248X_config ds248x_config = 5;
   */
  ds248xConfig?: DS248X_config;
  /**
   *
   * SEN6X PM/RHT/VOC/NOx/CO2/HCHO Sensor configuration
   *
   * @generated from field: meshtastic.SEN6X_config sen6x_config = 6;
   */
  sen6xConfig?: SEN6X_config;
  /**
   *
   * AS3935 lightning sensor configuration
   *
   * @generated from field: meshtastic.AS3935_config as3935_config = 7;
   */
  as3935Config?: AS3935_config;
};
/**
 * Describes the message meshtastic.SensorConfig.
 * Use `create(SensorConfigSchema)` to create a new message.
 */
declare const SensorConfigSchema: GenMessage<SensorConfig>;
/**
 * @generated from message meshtastic.SCD4X_config
 */
type SCD4X_config = Message<"meshtastic.SCD4X_config"> & {
  /**
   *
   * Set Automatic self-calibration enabled
   *
   * @generated from field: optional bool set_asc = 1;
   */
  setAsc?: boolean;
  /**
   *
   * Recalibration target CO2 concentration in ppm (FRC or ASC)
   *
   * @generated from field: optional uint32 set_target_co2_conc = 2;
   */
  setTargetCo2Conc?: number;
  /**
   *
   * Reference temperature in degC
   *
   * @generated from field: optional float set_temperature = 3;
   */
  setTemperature?: number;
  /**
   *
   * Altitude of sensor in meters above sea level. 0 - 3000m (overrides ambient pressure)
   *
   * @generated from field: optional uint32 set_altitude = 4;
   */
  setAltitude?: number;
  /**
   *
   * Sensor ambient pressure in Pa. 70000 - 120000 Pa (overrides altitude)
   *
   * @generated from field: optional uint32 set_ambient_pressure = 5;
   */
  setAmbientPressure?: number;
  /**
   *
   * Perform a factory reset of the sensor
   *
   * @generated from field: optional bool factory_reset = 6;
   */
  factoryReset?: boolean;
  /**
   *
   * Power mode for sensor (true for low power, false for normal)
   *
   * @generated from field: optional bool set_power_mode = 7;
   */
  setPowerMode?: boolean;
};
/**
 * Describes the message meshtastic.SCD4X_config.
 * Use `create(SCD4X_configSchema)` to create a new message.
 */
declare const SCD4X_configSchema: GenMessage<SCD4X_config>;
/**
 * @generated from message meshtastic.SEN5X_config
 */
type SEN5X_config = Message<"meshtastic.SEN5X_config"> & {
  /**
   *
   * Reference temperature in degC
   *
   * @generated from field: optional float set_temperature = 1;
   */
  setTemperature?: number;
  /**
   *
   * One-shot mode (true for low power - one-shot mode, false for normal - continuous mode)
   *
   * @generated from field: optional bool set_one_shot_mode = 2;
   */
  setOneShotMode?: boolean;
  /**
   *
   * Trigger a fan cleaning cycle
   *
   * @generated from field: optional bool start_fan_cleaning = 3;
   */
  startFanCleaning?: boolean;
};
/**
 * Describes the message meshtastic.SEN5X_config.
 * Use `create(SEN5X_configSchema)` to create a new message.
 */
declare const SEN5X_configSchema: GenMessage<SEN5X_config>;
/**
 * @generated from message meshtastic.SEN6X_config
 */
type SEN6X_config = Message<"meshtastic.SEN6X_config"> & {
  /**
   *
   * Reference temperature in degC
   *
   * @generated from field: optional float set_temperature = 1;
   */
  setTemperature?: number;
  /**
   *
   * One-shot mode (true for low power - one-shot mode, false for normal - continuous mode)
   *
   * @generated from field: optional bool set_one_shot_mode = 2;
   */
  setOneShotMode?: boolean;
  /**
   *
   * Trigger a fan cleaning cycle
   *
   * @generated from field: optional bool start_fan_cleaning = 3;
   */
  startFanCleaning?: boolean;
  /**
   *
   * Set Automatic self-calibration enabled (CO2-capable variants only: SEN63C, SEN66, SEN69C)
   *
   * @generated from field: optional bool set_asc = 4;
   */
  setAsc?: boolean;
  /**
   *
   * Recalibration target CO2 concentration in ppm (FRC only), CO2-capable variants only
   *
   * @generated from field: optional uint32 set_target_co2_conc = 5;
   */
  setTargetCo2Conc?: number;
  /**
   *
   * Altitude of sensor in meters above sea level. 0 - 3000m (overrides ambient pressure), CO2-capable variants only
   *
   * @generated from field: optional uint32 set_altitude = 6;
   */
  setAltitude?: number;
  /**
   *
   * Sensor ambient pressure in Pa. 70000 - 120000 Pa (overrides altitude), CO2-capable variants only
   *
   * @generated from field: optional uint32 set_ambient_pressure = 7;
   */
  setAmbientPressure?: number;
  /**
   *
   * Perform a factory reset of the CO2 sensor's calibration, CO2-capable variants only
   *
   * @generated from field: optional bool factory_reset = 8;
   */
  factoryReset?: boolean;
};
/**
 * Describes the message meshtastic.SEN6X_config.
 * Use `create(SEN6X_configSchema)` to create a new message.
 */
declare const SEN6X_configSchema: GenMessage<SEN6X_config>;
/**
 * @generated from message meshtastic.SCD30_config
 */
type SCD30_config = Message<"meshtastic.SCD30_config"> & {
  /**
   *
   * Set Automatic self-calibration enabled
   *
   * @generated from field: optional bool set_asc = 1;
   */
  setAsc?: boolean;
  /**
   *
   * Recalibration target CO2 concentration in ppm (FRC or ASC)
   *
   * @generated from field: optional uint32 set_target_co2_conc = 2;
   */
  setTargetCo2Conc?: number;
  /**
   *
   * Reference temperature in degC
   *
   * @generated from field: optional float set_temperature = 3;
   */
  setTemperature?: number;
  /**
   *
   * Altitude of sensor in meters above sea level. 0 - 3000m (overrides ambient pressure)
   *
   * @generated from field: optional uint32 set_altitude = 4;
   */
  setAltitude?: number;
  /**
   *
   * Power mode for sensor (true for low power, false for normal)
   *
   * @generated from field: optional uint32 set_measurement_interval = 5;
   */
  setMeasurementInterval?: number;
  /**
   *
   * Perform a factory reset of the sensor
   *
   * @generated from field: optional bool soft_reset = 6;
   */
  softReset?: boolean;
};
/**
 * Describes the message meshtastic.SCD30_config.
 * Use `create(SCD30_configSchema)` to create a new message.
 */
declare const SCD30_configSchema: GenMessage<SCD30_config>;
/**
 * @generated from message meshtastic.SHTXX_config
 */
type SHTXX_config = Message<"meshtastic.SHTXX_config"> & {
  /**
   *
   * Accuracy mode (0 = low, 1 = medium, 2 = high)
   *
   * @generated from field: optional uint32 set_accuracy = 1;
   */
  setAccuracy?: number;
};
/**
 * Describes the message meshtastic.SHTXX_config.
 * Use `create(SHTXX_configSchema)` to create a new message.
 */
declare const SHTXX_configSchema: GenMessage<SHTXX_config>;
/**
 * @generated from message meshtastic.DS248X_config
 */
type DS248X_config = Message<"meshtastic.DS248X_config"> & {
  /**
   *
   * Main channel for temperature reporting (0-7)
   *
   * @generated from field: optional uint32 main_temperature_channel = 1;
   */
  mainTemperatureChannel?: number;
};
/**
 * Describes the message meshtastic.DS248X_config.
 * Use `create(DS248X_configSchema)` to create a new message.
 */
declare const DS248X_configSchema: GenMessage<DS248X_config>;
/**
 * @generated from message meshtastic.AS3935_config
 */
type AS3935_config = Message<"meshtastic.AS3935_config"> & {
  /**
   *
   * Antenna tuning capacitance in pF, 0 to 120 in steps of 8. The antenna tank must
   * resonate within 3.5% of 500kHz; the correct trim is specific to the sensor board.
   *
   * @generated from field: optional uint32 set_tuning_cap_pf = 1;
   */
  setTuningCapPf?: number;
};
/**
 * Describes the message meshtastic.AS3935_config.
 * Use `create(AS3935_configSchema)` to create a new message.
 */
declare const AS3935_configSchema: GenMessage<AS3935_config>;
/**
 *
 * Firmware update mode for OTA updates
 *
 * @generated from enum meshtastic.OTAMode
 */
declare enum OTAMode {
  /**
   *
   * Do not reboot into OTA mode
   *
   * @generated from enum value: NO_REBOOT_OTA = 0;
   */
  NO_REBOOT_OTA = 0,
  /**
   *
   * Reboot into OTA mode for BLE firmware update
   *
   * @generated from enum value: OTA_BLE = 1;
   */
  OTA_BLE = 1,
  /**
   *
   * Reboot into OTA mode for WiFi firmware update
   *
   * @generated from enum value: OTA_WIFI = 2;
   */
  OTA_WIFI = 2
}
/**
 * Describes the enum meshtastic.OTAMode.
 */
declare const OTAModeSchema: GenEnum<OTAMode>;
declare namespace apponly_pb_d_exports {
  export { ChannelSet, ChannelSetSchema, file_meshtastic_apponly };
}
/**
 * Describes the file meshtastic/apponly.proto.
 */
declare const file_meshtastic_apponly: GenFile;
/**
 *
 * This is the most compact possible representation for a set of channels.
 * It includes only one PRIMARY channel (which must be first) and
 * any SECONDARY channels.
 * No DISABLED channels are included.
 * This abstraction is used only on the the 'app side' of the world (ie python, javascript and android etc) to show a group of Channels as a (long) URL
 *
 * @generated from message meshtastic.ChannelSet
 */
type ChannelSet = Message<"meshtastic.ChannelSet"> & {
  /**
   *
   * Channel list with settings
   *
   * @generated from field: repeated meshtastic.ChannelSettings settings = 1;
   */
  settings: ChannelSettings[];
  /**
   *
   * LoRa config
   *
   * @generated from field: meshtastic.Config.LoRaConfig lora_config = 2;
   */
  loraConfig?: Config_LoRaConfig;
};
/**
 * Describes the message meshtastic.ChannelSet.
 * Use `create(ChannelSetSchema)` to create a new message.
 */
declare const ChannelSetSchema: GenMessage<ChannelSet>;
declare namespace cannedmessages_pb_d_exports {
  export { CannedMessageModuleConfig, CannedMessageModuleConfigSchema, file_meshtastic_cannedmessages };
}
/**
 * Describes the file meshtastic/cannedmessages.proto.
 */
declare const file_meshtastic_cannedmessages: GenFile;
/**
 *
 * Canned message module configuration.
 *
 * @generated from message meshtastic.CannedMessageModuleConfig
 */
type CannedMessageModuleConfig = Message<"meshtastic.CannedMessageModuleConfig"> & {
  /**
   *
   * Predefined messages for canned message module separated by '|' characters.
   *
   * @generated from field: string messages = 1;
   */
  messages: string;
};
/**
 * Describes the message meshtastic.CannedMessageModuleConfig.
 * Use `create(CannedMessageModuleConfigSchema)` to create a new message.
 */
declare const CannedMessageModuleConfigSchema: GenMessage<CannedMessageModuleConfig>;
declare namespace localonly_pb_d_exports {
  export { LocalConfig, LocalConfigSchema, LocalModuleConfig, LocalModuleConfigSchema, file_meshtastic_localonly };
}
/**
 * Describes the file meshtastic/localonly.proto.
 */
declare const file_meshtastic_localonly: GenFile;
/**
 * @generated from message meshtastic.LocalConfig
 */
type LocalConfig = Message<"meshtastic.LocalConfig"> & {
  /**
   *
   * The part of the config that is specific to the Device
   *
   * @generated from field: meshtastic.Config.DeviceConfig device = 1;
   */
  device?: Config_DeviceConfig;
  /**
   *
   * The part of the config that is specific to the GPS Position
   *
   * @generated from field: meshtastic.Config.PositionConfig position = 2;
   */
  position?: Config_PositionConfig;
  /**
   *
   * The part of the config that is specific to the Power settings
   *
   * @generated from field: meshtastic.Config.PowerConfig power = 3;
   */
  power?: Config_PowerConfig;
  /**
   *
   * The part of the config that is specific to the Wifi Settings
   *
   * @generated from field: meshtastic.Config.NetworkConfig network = 4;
   */
  network?: Config_NetworkConfig;
  /**
   *
   * The part of the config that is specific to the Display
   *
   * @generated from field: meshtastic.Config.DisplayConfig display = 5;
   */
  display?: Config_DisplayConfig;
  /**
   *
   * The part of the config that is specific to the Lora Radio
   *
   * @generated from field: meshtastic.Config.LoRaConfig lora = 6;
   */
  lora?: Config_LoRaConfig;
  /**
   *
   * The part of the config that is specific to the Bluetooth settings
   *
   * @generated from field: meshtastic.Config.BluetoothConfig bluetooth = 7;
   */
  bluetooth?: Config_BluetoothConfig;
  /**
   *
   * A version integer used to invalidate old save files when we make
   * incompatible changes This integer is set at build time and is private to
   * NodeDB.cpp in the device code.
   *
   * @generated from field: uint32 version = 8;
   */
  version: number;
  /**
   *
   * The part of the config that is specific to Security settings
   *
   * @generated from field: meshtastic.Config.SecurityConfig security = 9;
   */
  security?: Config_SecurityConfig;
};
/**
 * Describes the message meshtastic.LocalConfig.
 * Use `create(LocalConfigSchema)` to create a new message.
 */
declare const LocalConfigSchema: GenMessage<LocalConfig>;
/**
 * @generated from message meshtastic.LocalModuleConfig
 */
type LocalModuleConfig = Message<"meshtastic.LocalModuleConfig"> & {
  /**
   *
   * The part of the config that is specific to the MQTT module
   *
   * @generated from field: meshtastic.ModuleConfig.MQTTConfig mqtt = 1;
   */
  mqtt?: ModuleConfig_MQTTConfig;
  /**
   *
   * The part of the config that is specific to the Serial module
   *
   * @generated from field: meshtastic.ModuleConfig.SerialConfig serial = 2;
   */
  serial?: ModuleConfig_SerialConfig;
  /**
   *
   * The part of the config that is specific to the ExternalNotification module
   *
   * @generated from field: meshtastic.ModuleConfig.ExternalNotificationConfig external_notification = 3;
   */
  externalNotification?: ModuleConfig_ExternalNotificationConfig;
  /**
   *
   * The part of the config that is specific to the Store & Forward module
   *
   * @generated from field: meshtastic.ModuleConfig.StoreForwardConfig store_forward = 4;
   */
  storeForward?: ModuleConfig_StoreForwardConfig;
  /**
   *
   * The part of the config that is specific to the RangeTest module
   *
   * @generated from field: meshtastic.ModuleConfig.RangeTestConfig range_test = 5;
   */
  rangeTest?: ModuleConfig_RangeTestConfig;
  /**
   *
   * The part of the config that is specific to the Telemetry module
   *
   * @generated from field: meshtastic.ModuleConfig.TelemetryConfig telemetry = 6;
   */
  telemetry?: ModuleConfig_TelemetryConfig;
  /**
   *
   * The part of the config that is specific to the Canned Message module
   *
   * @generated from field: meshtastic.ModuleConfig.CannedMessageConfig canned_message = 7;
   */
  cannedMessage?: ModuleConfig_CannedMessageConfig;
  /**
   *
   * The part of the config that is specific to the Audio module
   *
   * @generated from field: meshtastic.ModuleConfig.AudioConfig audio = 9;
   */
  audio?: ModuleConfig_AudioConfig;
  /**
   *
   * The part of the config that is specific to the Remote Hardware module
   *
   * @generated from field: meshtastic.ModuleConfig.RemoteHardwareConfig remote_hardware = 10;
   */
  remoteHardware?: ModuleConfig_RemoteHardwareConfig;
  /**
   *
   * The part of the config that is specific to the Neighbor Info module
   *
   * @generated from field: meshtastic.ModuleConfig.NeighborInfoConfig neighbor_info = 11;
   */
  neighborInfo?: ModuleConfig_NeighborInfoConfig;
  /**
   *
   * The part of the config that is specific to the Ambient Lighting module
   *
   * @generated from field: meshtastic.ModuleConfig.AmbientLightingConfig ambient_lighting = 12;
   */
  ambientLighting?: ModuleConfig_AmbientLightingConfig;
  /**
   *
   * The part of the config that is specific to the Detection Sensor module
   *
   * @generated from field: meshtastic.ModuleConfig.DetectionSensorConfig detection_sensor = 13;
   */
  detectionSensor?: ModuleConfig_DetectionSensorConfig;
  /**
   *
   * Paxcounter Config
   *
   * @generated from field: meshtastic.ModuleConfig.PaxcounterConfig paxcounter = 14;
   */
  paxcounter?: ModuleConfig_PaxcounterConfig;
  /**
   *
   * StatusMessage Config
   *
   * @generated from field: meshtastic.ModuleConfig.StatusMessageConfig statusmessage = 15;
   */
  statusmessage?: ModuleConfig_StatusMessageConfig;
  /**
   *
   * The part of the config that is specific to the Traffic Management module
   *
   * @generated from field: meshtastic.ModuleConfig.TrafficManagementConfig traffic_management = 16;
   */
  trafficManagement?: ModuleConfig_TrafficManagementConfig;
  /**
   *
   * TAK Config
   *
   * @generated from field: meshtastic.ModuleConfig.TAKConfig tak = 17;
   */
  tak?: ModuleConfig_TAKConfig;
  /**
   *
   * MeshBeacon Config
   *
   * @generated from field: meshtastic.ModuleConfig.MeshBeaconConfig mesh_beacon = 18;
   */
  meshBeacon?: ModuleConfig_MeshBeaconConfig;
  /**
   *
   * A version integer used to invalidate old save files when we make
   * incompatible changes This integer is set at build time and is private to
   * NodeDB.cpp in the device code.
   *
   * @generated from field: uint32 version = 8;
   */
  version: number;
};
/**
 * Describes the message meshtastic.LocalModuleConfig.
 * Use `create(LocalModuleConfigSchema)` to create a new message.
 */
declare const LocalModuleConfigSchema: GenMessage<LocalModuleConfig>;
declare namespace clientonly_pb_d_exports {
  export { DeviceProfile, DeviceProfileSchema, file_meshtastic_clientonly };
}
/**
 * Describes the file meshtastic/clientonly.proto.
 */
declare const file_meshtastic_clientonly: GenFile;
/**
 *
 * This abstraction is used to contain any configuration for provisioning a node on any client.
 * It is useful for importing and exporting configurations.
 *
 * @generated from message meshtastic.DeviceProfile
 */
type DeviceProfile = Message<"meshtastic.DeviceProfile"> & {
  /**
   *
   * Long name for the node
   *
   * @generated from field: optional string long_name = 1;
   */
  longName?: string;
  /**
   *
   * Short name of the node
   *
   * @generated from field: optional string short_name = 2;
   */
  shortName?: string;
  /**
   *
   * The url of the channels from our node
   *
   * @generated from field: optional string channel_url = 3;
   */
  channelUrl?: string;
  /**
   *
   * The Config of the node
   *
   * @generated from field: optional meshtastic.LocalConfig config = 4;
   */
  config?: LocalConfig;
  /**
   *
   * The ModuleConfig of the node
   *
   * @generated from field: optional meshtastic.LocalModuleConfig module_config = 5;
   */
  moduleConfig?: LocalModuleConfig;
  /**
   *
   * Fixed position data
   *
   * @generated from field: optional meshtastic.Position fixed_position = 6;
   */
  fixedPosition?: Position;
  /**
   *
   * Ringtone for ExternalNotification
   *
   * @generated from field: optional string ringtone = 7;
   */
  ringtone?: string;
  /**
   *
   * Predefined messages for CannedMessage
   *
   * @generated from field: optional string canned_messages = 8;
   */
  cannedMessages?: string;
  /**
   *
   * Is the node unmessagable
   *
   * @generated from field: optional bool is_unmessagable = 9;
   */
  isUnmessagable?: boolean;
  /**
   *
   * Is this node in licensed user mode
   *
   * @generated from field: optional bool is_licensed = 10;
   */
  isLicensed?: boolean;
};
/**
 * Describes the message meshtastic.DeviceProfile.
 * Use `create(DeviceProfileSchema)` to create a new message.
 */
declare const DeviceProfileSchema: GenMessage<DeviceProfile>;
declare namespace mqtt_pb_d_exports {
  export { MapReport, MapReportSchema, ServiceEnvelope, ServiceEnvelopeSchema, file_meshtastic_mqtt };
}
/**
 * Describes the file meshtastic/mqtt.proto.
 */
declare const file_meshtastic_mqtt: GenFile;
/**
 *
 * This message wraps a MeshPacket with extra metadata about the sender and how it arrived.
 *
 * @generated from message meshtastic.ServiceEnvelope
 */
type ServiceEnvelope = Message<"meshtastic.ServiceEnvelope"> & {
  /**
   *
   * The (probably encrypted) packet
   *
   * @generated from field: meshtastic.MeshPacket packet = 1;
   */
  packet?: MeshPacket;
  /**
   *
   * The global channel ID it was sent on
   *
   * @generated from field: string channel_id = 2;
   */
  channelId: string;
  /**
   *
   * The sending gateway node ID. Can we use this to authenticate/prevent fake
   * nodeid impersonation for senders? - i.e. use gateway/mesh id (which is authenticated) + local node id as
   * the globally trusted nodenum
   *
   * @generated from field: string gateway_id = 3;
   */
  gatewayId: string;
};
/**
 * Describes the message meshtastic.ServiceEnvelope.
 * Use `create(ServiceEnvelopeSchema)` to create a new message.
 */
declare const ServiceEnvelopeSchema: GenMessage<ServiceEnvelope>;
/**
 *
 * Information about a node intended to be reported unencrypted to a map using MQTT.
 *
 * @generated from message meshtastic.MapReport
 */
type MapReport = Message<"meshtastic.MapReport"> & {
  /**
   *
   * A full name for this user, i.e. "Kevin Hester"
   *
   * @generated from field: string long_name = 1;
   */
  longName: string;
  /**
   *
   * A VERY short name, ideally two characters.
   * Suitable for a tiny OLED screen
   *
   * @generated from field: string short_name = 2;
   */
  shortName: string;
  /**
   *
   * Role of the node that applies specific settings for a particular use-case
   *
   * @generated from field: meshtastic.Config.DeviceConfig.Role role = 3;
   */
  role: Config_DeviceConfig_Role;
  /**
   *
   * Hardware model of the node, i.e. T-Beam, Heltec V3, etc...
   *
   * @generated from field: meshtastic.HardwareModel hw_model = 4;
   */
  hwModel: HardwareModel;
  /**
   *
   * Device firmware version string
   *
   * @generated from field: string firmware_version = 5;
   */
  firmwareVersion: string;
  /**
   *
   * The region code for the radio (US, CN, EU433, etc...)
   *
   * @generated from field: meshtastic.Config.LoRaConfig.RegionCode region = 6;
   */
  region: Config_LoRaConfig_RegionCode;
  /**
   *
   * Modem preset used by the radio (LongFast, MediumSlow, etc...)
   *
   * @generated from field: meshtastic.Config.LoRaConfig.ModemPreset modem_preset = 7;
   */
  modemPreset: Config_LoRaConfig_ModemPreset;
  /**
   *
   * Whether the node has a channel with default PSK and name (LongFast, MediumSlow, etc...)
   * and it uses the default frequency slot given the region and modem preset.
   *
   * @generated from field: bool has_default_channel = 8;
   */
  hasDefaultChannel: boolean;
  /**
   *
   * Latitude: multiply by 1e-7 to get degrees in floating point
   *
   * @generated from field: sfixed32 latitude_i = 9;
   */
  latitudeI: number;
  /**
   *
   * Longitude: multiply by 1e-7 to get degrees in floating point
   *
   * @generated from field: sfixed32 longitude_i = 10;
   */
  longitudeI: number;
  /**
   *
   * Altitude in meters above MSL
   *
   * @generated from field: int32 altitude = 11;
   */
  altitude: number;
  /**
   *
   * Indicates the bits of precision for latitude and longitude set by the sending node
   *
   * @generated from field: uint32 position_precision = 12;
   */
  positionPrecision: number;
  /**
   *
   * Number of online nodes (heard in the last 2 hours) this node has in its list that were received locally (not via MQTT)
   *
   * @generated from field: uint32 num_online_local_nodes = 13;
   */
  numOnlineLocalNodes: number;
  /**
   *
   * User has opted in to share their location (map report) with the mqtt server
   * Controlled by map_report.should_report_location
   *
   * @generated from field: bool has_opted_report_location = 14;
   */
  hasOptedReportLocation: boolean;
};
/**
 * Describes the message meshtastic.MapReport.
 * Use `create(MapReportSchema)` to create a new message.
 */
declare const MapReportSchema: GenMessage<MapReport>;
declare namespace paxcount_pb_d_exports {
  export { Paxcount, PaxcountSchema, file_meshtastic_paxcount };
}
/**
 * Describes the file meshtastic/paxcount.proto.
 */
declare const file_meshtastic_paxcount: GenFile;
/**
 *
 * TODO: REPLACE
 *
 * @generated from message meshtastic.Paxcount
 */
type Paxcount = Message<"meshtastic.Paxcount"> & {
  /**
   *
   * seen Wifi devices
   *
   * @generated from field: uint32 wifi = 1;
   */
  wifi: number;
  /**
   *
   * Seen BLE devices
   *
   * @generated from field: uint32 ble = 2;
   */
  ble: number;
  /**
   *
   * Uptime in seconds
   *
   * @generated from field: uint32 uptime = 3;
   */
  uptime: number;
};
/**
 * Describes the message meshtastic.Paxcount.
 * Use `create(PaxcountSchema)` to create a new message.
 */
declare const PaxcountSchema: GenMessage<Paxcount>;
declare namespace powermon_pb_d_exports {
  export { PowerMon, PowerMonSchema, PowerMon_State, PowerMon_StateSchema, PowerStressMessage, PowerStressMessageSchema, PowerStressMessage_Opcode, PowerStressMessage_OpcodeSchema, file_meshtastic_powermon };
}
/**
 * Describes the file meshtastic/powermon.proto.
 */
declare const file_meshtastic_powermon: GenFile;
/**
 * Note: There are no 'PowerMon' messages normally in use (PowerMons are sent only as structured logs - slogs).
 * But we wrap our State enum in this message to effectively nest a namespace (without our linter yelling at us)
 *
 * @generated from message meshtastic.PowerMon
 */
type PowerMon = Message<"meshtastic.PowerMon"> & {};
/**
 * Describes the message meshtastic.PowerMon.
 * Use `create(PowerMonSchema)` to create a new message.
 */
declare const PowerMonSchema: GenMessage<PowerMon>;
/**
 * Any significant power changing event in meshtastic should be tagged with a powermon state transition.
 * If you are making new meshtastic features feel free to add new entries at the end of this definition.
 *
 * @generated from enum meshtastic.PowerMon.State
 */
declare enum PowerMon_State {
  /**
   * @generated from enum value: None = 0;
   */
  None = 0,
  /**
   * @generated from enum value: CPU_DeepSleep = 1;
   */
  CPU_DeepSleep = 1,
  /**
   * @generated from enum value: CPU_LightSleep = 2;
   */
  CPU_LightSleep = 2,
  /**
   *
   * The external Vext1 power is on.  Many boards have auxillary power rails that the CPU turns on only
   * occasionally.  In cases where that rail has multiple devices on it we usually want to have logging on
   * the state of that rail as an independent record.
   * For instance on the Heltec Tracker 1.1 board, this rail is the power source for the GPS and screen.
   *
   * The log messages will be short and complete (see PowerMon.Event in the protobufs for details).
   * something like "S:PM:C,0x00001234,REASON" where the hex number is the bitmask of all current states.
   * (We use a bitmask for states so that if a log message gets lost it won't be fatal)
   *
   * @generated from enum value: Vext1_On = 4;
   */
  Vext1_On = 4,
  /**
   * @generated from enum value: Lora_RXOn = 8;
   */
  Lora_RXOn = 8,
  /**
   * @generated from enum value: Lora_TXOn = 16;
   */
  Lora_TXOn = 16,
  /**
   * @generated from enum value: Lora_RXActive = 32;
   */
  Lora_RXActive = 32,
  /**
   * @generated from enum value: BT_On = 64;
   */
  BT_On = 64,
  /**
   * @generated from enum value: LED_On = 128;
   */
  LED_On = 128,
  /**
   * @generated from enum value: Screen_On = 256;
   */
  Screen_On = 256,
  /**
   * @generated from enum value: Screen_Drawing = 512;
   */
  Screen_Drawing = 512,
  /**
   * @generated from enum value: Wifi_On = 1024;
   */
  Wifi_On = 1024,
  /**
   *
   * GPS is actively trying to find our location
   * See GPSPowerState for more details
   *
   * @generated from enum value: GPS_Active = 2048;
   */
  GPS_Active = 2048
}
/**
 * Describes the enum meshtastic.PowerMon.State.
 */
declare const PowerMon_StateSchema: GenEnum<PowerMon_State>;
/**
 *
 * PowerStress testing support via the C++ PowerStress module
 *
 * @generated from message meshtastic.PowerStressMessage
 */
type PowerStressMessage = Message<"meshtastic.PowerStressMessage"> & {
  /**
   *
   * What type of HardwareMessage is this?
   *
   * @generated from field: meshtastic.PowerStressMessage.Opcode cmd = 1;
   */
  cmd: PowerStressMessage_Opcode;
  /**
   * @generated from field: float num_seconds = 2;
   */
  numSeconds: number;
};
/**
 * Describes the message meshtastic.PowerStressMessage.
 * Use `create(PowerStressMessageSchema)` to create a new message.
 */
declare const PowerStressMessageSchema: GenMessage<PowerStressMessage>;
/**
 *
 * What operation would we like the UUT to perform.
 * note: senders should probably set want_response in their request packets, so that they can know when the state
 * machine has started processing their request
 *
 * @generated from enum meshtastic.PowerStressMessage.Opcode
 */
declare enum PowerStressMessage_Opcode {
  /**
   *
   * Unset/unused
   *
   * @generated from enum value: UNSET = 0;
   */
  UNSET = 0,
  /**
   * Print board version slog and send an ack that we are alive and ready to process commands
   *
   * @generated from enum value: PRINT_INFO = 1;
   */
  PRINT_INFO = 1,
  /**
   * Try to turn off all automatic processing of packets, screen, sleeping, etc (to make it easier to measure in isolation)
   *
   * @generated from enum value: FORCE_QUIET = 2;
   */
  FORCE_QUIET = 2,
  /**
   * Stop powerstress processing - probably by just rebooting the board
   *
   * @generated from enum value: END_QUIET = 3;
   */
  END_QUIET = 3,
  /**
   * Turn the screen on
   *
   * @generated from enum value: SCREEN_ON = 16;
   */
  SCREEN_ON = 16,
  /**
   * Turn the screen off
   *
   * @generated from enum value: SCREEN_OFF = 17;
   */
  SCREEN_OFF = 17,
  /**
   * Let the CPU run but we assume mostly idling for num_seconds
   *
   * @generated from enum value: CPU_IDLE = 32;
   */
  CPU_IDLE = 32,
  /**
   * Force deep sleep for FIXME seconds
   *
   * @generated from enum value: CPU_DEEPSLEEP = 33;
   */
  CPU_DEEPSLEEP = 33,
  /**
   * Spin the CPU as fast as possible for num_seconds
   *
   * @generated from enum value: CPU_FULLON = 34;
   */
  CPU_FULLON = 34,
  /**
   * Turn the LED on for num_seconds (and leave it on - for baseline power measurement purposes)
   *
   * @generated from enum value: LED_ON = 48;
   */
  LED_ON = 48,
  /**
   * Force the LED off for num_seconds
   *
   * @generated from enum value: LED_OFF = 49;
   */
  LED_OFF = 49,
  /**
   * Completely turn off the LORA radio for num_seconds
   *
   * @generated from enum value: LORA_OFF = 64;
   */
  LORA_OFF = 64,
  /**
   * Send Lora packets for num_seconds
   *
   * @generated from enum value: LORA_TX = 65;
   */
  LORA_TX = 65,
  /**
   * Receive Lora packets for num_seconds (node will be mostly just listening, unless an external agent is helping stress this by sending packets on the current channel)
   *
   * @generated from enum value: LORA_RX = 66;
   */
  LORA_RX = 66,
  /**
   * Turn off the BT radio for num_seconds
   *
   * @generated from enum value: BT_OFF = 80;
   */
  BT_OFF = 80,
  /**
   * Turn on the BT radio for num_seconds
   *
   * @generated from enum value: BT_ON = 81;
   */
  BT_ON = 81,
  /**
   * Turn off the WIFI radio for num_seconds
   *
   * @generated from enum value: WIFI_OFF = 96;
   */
  WIFI_OFF = 96,
  /**
   * Turn on the WIFI radio for num_seconds
   *
   * @generated from enum value: WIFI_ON = 97;
   */
  WIFI_ON = 97,
  /**
   * Turn off the GPS radio for num_seconds
   *
   * @generated from enum value: GPS_OFF = 112;
   */
  GPS_OFF = 112,
  /**
   * Turn on the GPS radio for num_seconds
   *
   * @generated from enum value: GPS_ON = 113;
   */
  GPS_ON = 113
}
/**
 * Describes the enum meshtastic.PowerStressMessage.Opcode.
 */
declare const PowerStressMessage_OpcodeSchema: GenEnum<PowerStressMessage_Opcode>;
declare namespace remote_hardware_pb_d_exports {
  export { HardwareMessage, HardwareMessageSchema, HardwareMessage_Type, HardwareMessage_TypeSchema, file_meshtastic_remote_hardware };
}
/**
 * Describes the file meshtastic/remote_hardware.proto.
 */
declare const file_meshtastic_remote_hardware: GenFile;
/**
 *
 * An example app to show off the module system. This message is used for
 * REMOTE_HARDWARE_APP PortNums.
 * Also provides easy remote access to any GPIO.
 * In the future other remote hardware operations can be added based on user interest
 * (i.e. serial output, spi/i2c input/output).
 * FIXME - currently this feature is turned on by default which is dangerous
 * because no security yet (beyond the channel mechanism).
 * It should be off by default and then protected based on some TBD mechanism
 * (a special channel once multichannel support is included?)
 *
 * @generated from message meshtastic.HardwareMessage
 */
type HardwareMessage = Message<"meshtastic.HardwareMessage"> & {
  /**
   *
   * What type of HardwareMessage is this?
   *
   * @generated from field: meshtastic.HardwareMessage.Type type = 1;
   */
  type: HardwareMessage_Type;
  /**
   *
   * What gpios are we changing. Not used for all MessageTypes, see MessageType for details
   *
   * @generated from field: uint64 gpio_mask = 2;
   */
  gpioMask: bigint;
  /**
   *
   * For gpios that were listed in gpio_mask as valid, what are the signal levels for those gpios.
   * Not used for all MessageTypes, see MessageType for details
   *
   * @generated from field: uint64 gpio_value = 3;
   */
  gpioValue: bigint;
};
/**
 * Describes the message meshtastic.HardwareMessage.
 * Use `create(HardwareMessageSchema)` to create a new message.
 */
declare const HardwareMessageSchema: GenMessage<HardwareMessage>;
/**
 *
 * TODO: REPLACE
 *
 * @generated from enum meshtastic.HardwareMessage.Type
 */
declare enum HardwareMessage_Type {
  /**
   *
   * Unset/unused
   *
   * @generated from enum value: UNSET = 0;
   */
  UNSET = 0,
  /**
   *
   * Set gpio gpios based on gpio_mask/gpio_value
   *
   * @generated from enum value: WRITE_GPIOS = 1;
   */
  WRITE_GPIOS = 1,
  /**
   *
   * We are now interested in watching the gpio_mask gpios.
   * If the selected gpios change, please broadcast GPIOS_CHANGED.
   * Will implicitly change the gpios requested to be INPUT gpios.
   *
   * @generated from enum value: WATCH_GPIOS = 2;
   */
  WATCH_GPIOS = 2,
  /**
   *
   * The gpios listed in gpio_mask have changed, the new values are listed in gpio_value
   *
   * @generated from enum value: GPIOS_CHANGED = 3;
   */
  GPIOS_CHANGED = 3,
  /**
   *
   * Read the gpios specified in gpio_mask, send back a READ_GPIOS_REPLY reply with gpio_value populated
   *
   * @generated from enum value: READ_GPIOS = 4;
   */
  READ_GPIOS = 4,
  /**
   *
   * A reply to READ_GPIOS. gpio_mask and gpio_value will be populated
   *
   * @generated from enum value: READ_GPIOS_REPLY = 5;
   */
  READ_GPIOS_REPLY = 5
}
/**
 * Describes the enum meshtastic.HardwareMessage.Type.
 */
declare const HardwareMessage_TypeSchema: GenEnum<HardwareMessage_Type>;
declare namespace rtttl_pb_d_exports {
  export { RTTTLConfig, RTTTLConfigSchema, file_meshtastic_rtttl };
}
/**
 * Describes the file meshtastic/rtttl.proto.
 */
declare const file_meshtastic_rtttl: GenFile;
/**
 *
 * Canned message module configuration.
 *
 * @generated from message meshtastic.RTTTLConfig
 */
type RTTTLConfig = Message<"meshtastic.RTTTLConfig"> & {
  /**
   *
   * Ringtone for PWM Buzzer in RTTTL Format.
   *
   * @generated from field: string ringtone = 1;
   */
  ringtone: string;
};
/**
 * Describes the message meshtastic.RTTTLConfig.
 * Use `create(RTTTLConfigSchema)` to create a new message.
 */
declare const RTTTLConfigSchema: GenMessage<RTTTLConfig>;
declare namespace storeforward_pb_d_exports {
  export { StoreAndForward, StoreAndForwardSchema, StoreAndForward_Heartbeat, StoreAndForward_HeartbeatSchema, StoreAndForward_History, StoreAndForward_HistorySchema, StoreAndForward_RequestResponse, StoreAndForward_RequestResponseSchema, StoreAndForward_Statistics, StoreAndForward_StatisticsSchema, file_meshtastic_storeforward };
}
/**
 * Describes the file meshtastic/storeforward.proto.
 */
declare const file_meshtastic_storeforward: GenFile;
/**
 *
 * TODO: REPLACE
 *
 * @generated from message meshtastic.StoreAndForward
 */
type StoreAndForward = Message<"meshtastic.StoreAndForward"> & {
  /**
   *
   * TODO: REPLACE
   *
   * @generated from field: meshtastic.StoreAndForward.RequestResponse rr = 1;
   */
  rr: StoreAndForward_RequestResponse;
  /**
   *
   * TODO: REPLACE
   *
   * @generated from oneof meshtastic.StoreAndForward.variant
   */
  variant: {
    /**
     *
     * TODO: REPLACE
     *
     * @generated from field: meshtastic.StoreAndForward.Statistics stats = 2;
     */
    value: StoreAndForward_Statistics;
    case: "stats";
  } | {
    /**
     *
     * TODO: REPLACE
     *
     * @generated from field: meshtastic.StoreAndForward.History history = 3;
     */
    value: StoreAndForward_History;
    case: "history";
  } | {
    /**
     *
     * TODO: REPLACE
     *
     * @generated from field: meshtastic.StoreAndForward.Heartbeat heartbeat = 4;
     */
    value: StoreAndForward_Heartbeat;
    case: "heartbeat";
  } | {
    /**
     *
     * Text from history message.
     *
     * @generated from field: bytes text = 5;
     */
    value: Uint8Array;
    case: "text";
  } | {
    case: undefined;
    value?: undefined;
  };
};
/**
 * Describes the message meshtastic.StoreAndForward.
 * Use `create(StoreAndForwardSchema)` to create a new message.
 */
declare const StoreAndForwardSchema: GenMessage<StoreAndForward>;
/**
 *
 * TODO: REPLACE
 *
 * @generated from message meshtastic.StoreAndForward.Statistics
 */
type StoreAndForward_Statistics = Message<"meshtastic.StoreAndForward.Statistics"> & {
  /**
   *
   * Number of messages we have ever seen
   *
   * @generated from field: uint32 messages_total = 1;
   */
  messagesTotal: number;
  /**
   *
   * Number of messages we have currently saved our history.
   *
   * @generated from field: uint32 messages_saved = 2;
   */
  messagesSaved: number;
  /**
   *
   * Maximum number of messages we will save
   *
   * @generated from field: uint32 messages_max = 3;
   */
  messagesMax: number;
  /**
   *
   * Router uptime in seconds
   *
   * @generated from field: uint32 up_time = 4;
   */
  upTime: number;
  /**
   *
   * Number of times any client sent a request to the S&F.
   *
   * @generated from field: uint32 requests = 5;
   */
  requests: number;
  /**
   *
   * Number of times the history was requested.
   *
   * @generated from field: uint32 requests_history = 6;
   */
  requestsHistory: number;
  /**
   *
   * Is the heartbeat enabled on the server?
   *
   * @generated from field: bool heartbeat = 7;
   */
  heartbeat: boolean;
  /**
   *
   * Maximum number of messages the server will return.
   *
   * @generated from field: uint32 return_max = 8;
   */
  returnMax: number;
  /**
   *
   * Maximum history window in minutes the server will return messages from.
   *
   * @generated from field: uint32 return_window = 9;
   */
  returnWindow: number;
};
/**
 * Describes the message meshtastic.StoreAndForward.Statistics.
 * Use `create(StoreAndForward_StatisticsSchema)` to create a new message.
 */
declare const StoreAndForward_StatisticsSchema: GenMessage<StoreAndForward_Statistics>;
/**
 *
 * TODO: REPLACE
 *
 * @generated from message meshtastic.StoreAndForward.History
 */
type StoreAndForward_History = Message<"meshtastic.StoreAndForward.History"> & {
  /**
   *
   * Number of that will be sent to the client
   *
   * @generated from field: uint32 history_messages = 1;
   */
  historyMessages: number;
  /**
   *
   * The window of messages that was used to filter the history client requested
   *
   * @generated from field: uint32 window = 2;
   */
  window: number;
  /**
   *
   * Index in the packet history of the last message sent in a previous request to the server.
   * Will be sent to the client before sending the history and can be set in a subsequent request to avoid getting packets the server already sent to the client.
   *
   * @generated from field: uint32 last_request = 3;
   */
  lastRequest: number;
};
/**
 * Describes the message meshtastic.StoreAndForward.History.
 * Use `create(StoreAndForward_HistorySchema)` to create a new message.
 */
declare const StoreAndForward_HistorySchema: GenMessage<StoreAndForward_History>;
/**
 *
 * TODO: REPLACE
 *
 * @generated from message meshtastic.StoreAndForward.Heartbeat
 */
type StoreAndForward_Heartbeat = Message<"meshtastic.StoreAndForward.Heartbeat"> & {
  /**
   *
   * Period in seconds that the heartbeat is sent out that will be sent to the client
   *
   * @generated from field: uint32 period = 1;
   */
  period: number;
  /**
   *
   * If set, this is not the primary Store & Forward router on the mesh
   *
   * @generated from field: uint32 secondary = 2;
   */
  secondary: number;
};
/**
 * Describes the message meshtastic.StoreAndForward.Heartbeat.
 * Use `create(StoreAndForward_HeartbeatSchema)` to create a new message.
 */
declare const StoreAndForward_HeartbeatSchema: GenMessage<StoreAndForward_Heartbeat>;
/**
 *
 * 001 - 063 = From Router
 * 064 - 127 = From Client
 *
 * @generated from enum meshtastic.StoreAndForward.RequestResponse
 */
declare enum StoreAndForward_RequestResponse {
  /**
   *
   * Unset/unused
   *
   * @generated from enum value: UNSET = 0;
   */
  UNSET = 0,
  /**
   *
   * Router is an in error state.
   *
   * @generated from enum value: ROUTER_ERROR = 1;
   */
  ROUTER_ERROR = 1,
  /**
   *
   * Router heartbeat
   *
   * @generated from enum value: ROUTER_HEARTBEAT = 2;
   */
  ROUTER_HEARTBEAT = 2,
  /**
   *
   * Router has requested the client respond. This can work as a
   * "are you there" message.
   *
   * @generated from enum value: ROUTER_PING = 3;
   */
  ROUTER_PING = 3,
  /**
   *
   * The response to a "Ping"
   *
   * @generated from enum value: ROUTER_PONG = 4;
   */
  ROUTER_PONG = 4,
  /**
   *
   * Router is currently busy. Please try again later.
   *
   * @generated from enum value: ROUTER_BUSY = 5;
   */
  ROUTER_BUSY = 5,
  /**
   *
   * Router is responding to a request for history.
   *
   * @generated from enum value: ROUTER_HISTORY = 6;
   */
  ROUTER_HISTORY = 6,
  /**
   *
   * Router is responding to a request for stats.
   *
   * @generated from enum value: ROUTER_STATS = 7;
   */
  ROUTER_STATS = 7,
  /**
   *
   * Router sends a text message from its history that was a direct message.
   *
   * @generated from enum value: ROUTER_TEXT_DIRECT = 8;
   */
  ROUTER_TEXT_DIRECT = 8,
  /**
   *
   * Router sends a text message from its history that was a broadcast.
   *
   * @generated from enum value: ROUTER_TEXT_BROADCAST = 9;
   */
  ROUTER_TEXT_BROADCAST = 9,
  /**
   *
   * Client is an in error state.
   *
   * @generated from enum value: CLIENT_ERROR = 64;
   */
  CLIENT_ERROR = 64,
  /**
   *
   * Client has requested a replay from the router.
   *
   * @generated from enum value: CLIENT_HISTORY = 65;
   */
  CLIENT_HISTORY = 65,
  /**
   *
   * Client has requested stats from the router.
   *
   * @generated from enum value: CLIENT_STATS = 66;
   */
  CLIENT_STATS = 66,
  /**
   *
   * Client has requested the router respond. This can work as a
   * "are you there" message.
   *
   * @generated from enum value: CLIENT_PING = 67;
   */
  CLIENT_PING = 67,
  /**
   *
   * The response to a "Ping"
   *
   * @generated from enum value: CLIENT_PONG = 68;
   */
  CLIENT_PONG = 68,
  /**
   *
   * Client has requested that the router abort processing the client's request
   *
   * @generated from enum value: CLIENT_ABORT = 106;
   */
  CLIENT_ABORT = 106
}
/**
 * Describes the enum meshtastic.StoreAndForward.RequestResponse.
 */
declare const StoreAndForward_RequestResponseSchema: GenEnum<StoreAndForward_RequestResponse>;
//#endregion
export { atak_pb_d_exports as ATAK, admin_pb_d_exports as Admin, apponly_pb_d_exports as AppOnly, cannedmessages_pb_d_exports as CannedMessages, channel_pb_d_exports as Channel, clientonly_pb_d_exports as ClientOnly, config_pb_d_exports as Config, connection_status_pb_d_exports as ConnectionStatus, localonly_pb_d_exports as LocalOnly, mesh_pb_d_exports as Mesh, module_config_pb_d_exports as ModuleConfig, mqtt_pb_d_exports as Mqtt, paxcount_pb_d_exports as PaxCount, portnums_pb_d_exports as Portnums, powermon_pb_d_exports as PowerMon, remote_hardware_pb_d_exports as RemoteHardware, rtttl_pb_d_exports as Rtttl, storeforward_pb_d_exports as StoreForward, telemetry_pb_d_exports as Telemetry, xmodem_pb_d_exports as Xmodem };