// @generated by protoc-gen-es v2.12.0 with parameter "target=ts"
// @generated from file meshtastic/module_config.proto (package meshtastic, syntax proto3)
/* eslint-disable */

import type { GenEnum, GenFile, GenMessage } from "@bufbuild/protobuf/codegenv2";
import { enumDesc, fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv2";
import type { MemberRole, Team } from "./atak_pb";
import { file_meshtastic_atak } from "./atak_pb";
import type { Message } from "@bufbuild/protobuf";

/**
 * Describes the file meshtastic/module_config.proto.
 */
export const file_meshtastic_module_config: GenFile = /*@__PURE__*/
  fileDesc(" ", [file_meshtastic_atak]);

/**
 *
 * Module Config
 *
 * @generated from message meshtastic.ModuleConfig
 */
export 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";
  } | { case: undefined; value?: undefined };
};

/**
 * Describes the message meshtastic.ModuleConfig.
 * Use `create(ModuleConfigSchema)` to create a new message.
 */
export const ModuleConfigSchema: GenMessage<ModuleConfig> = /*@__PURE__*/
  messageDesc(file_meshtastic_module_config, 0);

/**
 *
 * MQTT Client Config
 *
 * @generated from message meshtastic.ModuleConfig.MQTTConfig
 */
export 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 | undefined;
};

/**
 * Describes the message meshtastic.ModuleConfig.MQTTConfig.
 * Use `create(ModuleConfig_MQTTConfigSchema)` to create a new message.
 */
export const ModuleConfig_MQTTConfigSchema: GenMessage<ModuleConfig_MQTTConfig> = /*@__PURE__*/
  messageDesc(file_meshtastic_module_config, 0, 0);

/**
 *
 * Settings for reporting unencrypted information about our node to a map via MQTT
 *
 * @generated from message meshtastic.ModuleConfig.MapReportSettings
 */
export 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.
 */
export const ModuleConfig_MapReportSettingsSchema: GenMessage<ModuleConfig_MapReportSettings> = /*@__PURE__*/
  messageDesc(file_meshtastic_module_config, 0, 1);

/**
 *
 * RemoteHardwareModule Config
 *
 * @generated from message meshtastic.ModuleConfig.RemoteHardwareConfig
 */
export 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.
 */
export const ModuleConfig_RemoteHardwareConfigSchema: GenMessage<ModuleConfig_RemoteHardwareConfig> = /*@__PURE__*/
  messageDesc(file_meshtastic_module_config, 0, 2);

/**
 *
 * NeighborInfoModule Config
 *
 * @generated from message meshtastic.ModuleConfig.NeighborInfoConfig
 */
export 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.
 */
export const ModuleConfig_NeighborInfoConfigSchema: GenMessage<ModuleConfig_NeighborInfoConfig> = /*@__PURE__*/
  messageDesc(file_meshtastic_module_config, 0, 3);

/**
 *
 * Detection Sensor Module Config
 *
 * @generated from message meshtastic.ModuleConfig.DetectionSensorConfig
 */
export 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.
 */
export const ModuleConfig_DetectionSensorConfigSchema: GenMessage<ModuleConfig_DetectionSensorConfig> = /*@__PURE__*/
  messageDesc(file_meshtastic_module_config, 0, 4);

/**
 * @generated from enum meshtastic.ModuleConfig.DetectionSensorConfig.TriggerType
 */
export 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.
 */
export const ModuleConfig_DetectionSensorConfig_TriggerTypeSchema: GenEnum<ModuleConfig_DetectionSensorConfig_TriggerType> = /*@__PURE__*/
  enumDesc(file_meshtastic_module_config, 0, 4, 0);

/**
 *
 * Audio Config for codec2 voice
 *
 * @generated from message meshtastic.ModuleConfig.AudioConfig
 */
export 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.
 */
export const ModuleConfig_AudioConfigSchema: GenMessage<ModuleConfig_AudioConfig> = /*@__PURE__*/
  messageDesc(file_meshtastic_module_config, 0, 5);

/**
 *
 * Baudrate for codec2 voice
 *
 * @generated from enum meshtastic.ModuleConfig.AudioConfig.Audio_Baud
 */
export 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.
 */
export const ModuleConfig_AudioConfig_Audio_BaudSchema: GenEnum<ModuleConfig_AudioConfig_Audio_Baud> = /*@__PURE__*/
  enumDesc(file_meshtastic_module_config, 0, 5, 0);

/**
 *
 * Config for the Paxcounter Module
 *
 * @generated from message meshtastic.ModuleConfig.PaxcounterConfig
 */
export 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.
 */
export const ModuleConfig_PaxcounterConfigSchema: GenMessage<ModuleConfig_PaxcounterConfig> = /*@__PURE__*/
  messageDesc(file_meshtastic_module_config, 0, 6);

/**
 *
 * Config for the Traffic Management module.
 * Provides packet inspection and traffic shaping to help reduce channel utilization
 *
 * @generated from message meshtastic.ModuleConfig.TrafficManagementConfig
 */
export type ModuleConfig_TrafficManagementConfig = Message<"meshtastic.ModuleConfig.TrafficManagementConfig"> & {
  /**
   *
   * Master enable for traffic management module
   *
   * @generated from field: bool enabled = 1;
   */
  enabled: boolean;

  /**
   *
   * Enable position deduplication to drop redundant position broadcasts
   *
   * @generated from field: bool position_dedup_enabled = 2;
   */
  positionDedupEnabled: boolean;

  /**
   *
   * Number of bits of precision for position deduplication (0-32)
   *
   * @generated from field: uint32 position_precision_bits = 3;
   */
  positionPrecisionBits: number;

  /**
   *
   * Minimum interval in seconds between position updates from the same node
   *
   * @generated from field: uint32 position_min_interval_secs = 4;
   */
  positionMinIntervalSecs: number;

  /**
   *
   * Enable direct response to NodeInfo requests from local cache
   *
   * @generated from field: bool nodeinfo_direct_response = 5;
   */
  nodeinfoDirectResponse: boolean;

  /**
   *
   * Minimum hop distance from requestor before responding to NodeInfo requests
   *
   * @generated from field: uint32 nodeinfo_direct_response_max_hops = 6;
   */
  nodeinfoDirectResponseMaxHops: number;

  /**
   *
   * Enable per-node rate limiting to throttle chatty nodes
   *
   * @generated from field: bool rate_limit_enabled = 7;
   */
  rateLimitEnabled: boolean;

  /**
   *
   * Time window in seconds for rate limiting calculations
   *
   * @generated from field: uint32 rate_limit_window_secs = 8;
   */
  rateLimitWindowSecs: number;

  /**
   *
   * Maximum packets allowed per node within the rate limit window
   *
   * @generated from field: uint32 rate_limit_max_packets = 9;
   */
  rateLimitMaxPackets: number;

  /**
   *
   * Enable dropping of unknown/undecryptable packets per rate_limit_window_secs
   *
   * @generated from field: bool drop_unknown_enabled = 10;
   */
  dropUnknownEnabled: boolean;

  /**
   *
   * Number of unknown packets before dropping from a node
   *
   * @generated from field: uint32 unknown_packet_threshold = 11;
   */
  unknownPacketThreshold: number;

  /**
   *
   * Set hop_limit to 0 for relayed telemetry broadcasts (own packets unaffected)
   *
   * @generated from field: bool exhaust_hop_telemetry = 12;
   */
  exhaustHopTelemetry: boolean;

  /**
   *
   * Set hop_limit to 0 for relayed position broadcasts (own packets unaffected)
   *
   * @generated from field: bool exhaust_hop_position = 13;
   */
  exhaustHopPosition: boolean;

  /**
   *
   * Preserve hop_limit for router-to-router traffic
   *
   * @generated from field: bool router_preserve_hops = 14;
   */
  routerPreserveHops: boolean;
};

/**
 * Describes the message meshtastic.ModuleConfig.TrafficManagementConfig.
 * Use `create(ModuleConfig_TrafficManagementConfigSchema)` to create a new message.
 */
export const ModuleConfig_TrafficManagementConfigSchema: GenMessage<ModuleConfig_TrafficManagementConfig> = /*@__PURE__*/
  messageDesc(file_meshtastic_module_config, 0, 7);

/**
 *
 * Serial Config
 *
 * @generated from message meshtastic.ModuleConfig.SerialConfig
 */
export 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.
 */
export const ModuleConfig_SerialConfigSchema: GenMessage<ModuleConfig_SerialConfig> = /*@__PURE__*/
  messageDesc(file_meshtastic_module_config, 0, 8);

/**
 *
 * TODO: REPLACE
 *
 * @generated from enum meshtastic.ModuleConfig.SerialConfig.Serial_Baud
 */
export 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.
 */
export const ModuleConfig_SerialConfig_Serial_BaudSchema: GenEnum<ModuleConfig_SerialConfig_Serial_Baud> = /*@__PURE__*/
  enumDesc(file_meshtastic_module_config, 0, 8, 0);

/**
 *
 * TODO: REPLACE
 *
 * @generated from enum meshtastic.ModuleConfig.SerialConfig.Serial_Mode
 */
export 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.
 */
export const ModuleConfig_SerialConfig_Serial_ModeSchema: GenEnum<ModuleConfig_SerialConfig_Serial_Mode> = /*@__PURE__*/
  enumDesc(file_meshtastic_module_config, 0, 8, 1);

/**
 *
 * External Notifications Config
 *
 * @generated from message meshtastic.ModuleConfig.ExternalNotificationConfig
 */
export 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.
 */
export const ModuleConfig_ExternalNotificationConfigSchema: GenMessage<ModuleConfig_ExternalNotificationConfig> = /*@__PURE__*/
  messageDesc(file_meshtastic_module_config, 0, 9);

/**
 *
 * Store and Forward Module Config
 *
 * @generated from message meshtastic.ModuleConfig.StoreForwardConfig
 */
export 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.
 */
export const ModuleConfig_StoreForwardConfigSchema: GenMessage<ModuleConfig_StoreForwardConfig> = /*@__PURE__*/
  messageDesc(file_meshtastic_module_config, 0, 10);

/**
 *
 * Preferences for the RangeTestModule
 *
 * @generated from message meshtastic.ModuleConfig.RangeTestConfig
 */
export 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.
 */
export const ModuleConfig_RangeTestConfigSchema: GenMessage<ModuleConfig_RangeTestConfig> = /*@__PURE__*/
  messageDesc(file_meshtastic_module_config, 0, 11);

/**
 *
 * Configuration for both device and environment metrics
 *
 * @generated from message meshtastic.ModuleConfig.TelemetryConfig
 */
export 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.
 */
export const ModuleConfig_TelemetryConfigSchema: GenMessage<ModuleConfig_TelemetryConfig> = /*@__PURE__*/
  messageDesc(file_meshtastic_module_config, 0, 12);

/**
 *
 * Canned Messages Module Config
 *
 * @generated from message meshtastic.ModuleConfig.CannedMessageConfig
 */
export 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.
 */
export const ModuleConfig_CannedMessageConfigSchema: GenMessage<ModuleConfig_CannedMessageConfig> = /*@__PURE__*/
  messageDesc(file_meshtastic_module_config, 0, 13);

/**
 *
 * TODO: REPLACE
 *
 * @generated from enum meshtastic.ModuleConfig.CannedMessageConfig.InputEventChar
 */
export 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.
 */
export const ModuleConfig_CannedMessageConfig_InputEventCharSchema: GenEnum<ModuleConfig_CannedMessageConfig_InputEventChar> = /*@__PURE__*/
  enumDesc(file_meshtastic_module_config, 0, 13, 0);

/**
 *
 * 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
 */
export 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.
 */
export const ModuleConfig_AmbientLightingConfigSchema: GenMessage<ModuleConfig_AmbientLightingConfig> = /*@__PURE__*/
  messageDesc(file_meshtastic_module_config, 0, 14);

/**
 *
 * StatusMessage config - Allows setting a status message for a node to periodically rebroadcast
 *
 * @generated from message meshtastic.ModuleConfig.StatusMessageConfig
 */
export 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.
 */
export const ModuleConfig_StatusMessageConfigSchema: GenMessage<ModuleConfig_StatusMessageConfig> = /*@__PURE__*/
  messageDesc(file_meshtastic_module_config, 0, 15);

/**
 *
 * TAK team/role configuration
 *
 * @generated from message meshtastic.ModuleConfig.TAKConfig
 */
export 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.
 */
export const ModuleConfig_TAKConfigSchema: GenMessage<ModuleConfig_TAKConfig> = /*@__PURE__*/
  messageDesc(file_meshtastic_module_config, 0, 16);

/**
 *
 * A GPIO pin definition for remote hardware module
 *
 * @generated from message meshtastic.RemoteHardwarePin
 */
export 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.
 */
export const RemoteHardwarePinSchema: GenMessage<RemoteHardwarePin> = /*@__PURE__*/
  messageDesc(file_meshtastic_module_config, 1);

/**
 * @generated from enum meshtastic.RemoteHardwarePinType
 */
export 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.
 */
export const RemoteHardwarePinTypeSchema: GenEnum<RemoteHardwarePinType> = /*@__PURE__*/
  enumDesc(file_meshtastic_module_config, 0);

