kv_types.h

Go to the documentation of this file.

 
#ifndef INFUSE_SDK_INCLUDE_GENERATED_KV_DEFINITIONS_H_
#define INFUSE_SDK_INCLUDE_GENERATED_KV_DEFINITIONS_H_
 
#include <stdint.h>
 
#include <zephyr/toolchain.h>
#include <zephyr/sys/util_macro.h>
 
#ifdef __cplusplus
extern "C" {
#endif


struct gcs_location {
        int32_t latitude;
        int32_t longitude;
        int32_t height;
} __packed;

struct bt_addr_le {
        uint8_t type;
        uint8_t val[6];
} __packed;

struct kv_string {
        uint8_t value_num;
        char value[];
} __packed;
 
/* clang-format off */
#define KV_STRUCT_KV_STRING_VAR(num) \
        struct { \
                uint8_t value_num; \
                char value[num]; \
        } __packed
/* clang-format on */

struct kv_mcuboot_img_sem_ver {
        uint8_t major;
        uint8_t minor;
        uint16_t revision;
        uint32_t build_num;
} __packed;

struct kv_range_u8 {
        uint8_t lower;
        uint8_t upper;
} __packed;

struct kv_utc_hms {
        uint8_t hour;
        uint8_t minute;
        uint8_t second;
} __packed;

struct kv_algorithm_logging {
        uint8_t loggers;
        uint8_t tdf_mask;
} __packed;

struct kv_algorithm_stationary_windowed_args {
        uint32_t window_seconds;
        uint32_t std_dev_threshold_ug;
} __packed;

struct kv_algorithm_tilt_args {
        float iir_filter_alpha;
        uint8_t one_g_percent;
} __packed;

struct kv_algorithm_movement_threshold_args {
        uint32_t moving_for;
        uint32_t threshold_ug;
} __packed;

struct kv_algorithm_movement_threshold_args_v2 {
        uint32_t moving_for;
        uint32_t initial_threshold_ug;
        uint32_t continue_threshold_ug;
} __packed;



struct kv_reboots {
        uint32_t count;
} __packed;

struct kv_bluetooth_addr {
        struct bt_addr_le address;
} __packed;

struct kv_exfat_disk_info {
        uint32_t block_count;
        uint32_t block_size;
} __packed;

struct kv_bluetooth_ctlr_version {
        uint32_t application;
        struct kv_mcuboot_img_sem_ver version;
} __packed;

struct kv_device_name {
        struct kv_string name;
} __packed;
 
/* clang-format off */
#define _KV_KEY_DEVICE_NAME_VAR(num) \
        struct { \
                KV_STRUCT_KV_STRING_VAR(num) name; \
        } __packed
/* clang-format on */

struct kv_infuse_application_id {
        uint32_t application_id;
} __packed;

struct kv_application_active {
        uint8_t active;
} __packed;

struct kv_board_target {
        struct kv_string board_target;
} __packed;
 
/* clang-format off */
#define _KV_KEY_BOARD_TARGET_VAR(num) \
        struct { \
                KV_STRUCT_KV_STRING_VAR(num) board_target; \
        } __packed
/* clang-format on */

struct kv_secondary_remote_public_key {
        uint8_t public_key[32];
} __packed;

struct kv_fixed_location {
        struct gcs_location location;
} __packed;

struct kv_broadcast_fixed_indoors {
        uint8_t indoors;
} __packed;

struct kv_littlefs_fs_state {
        uint32_t disk_version;
        uint32_t block_size;
        uint32_t block_count;
        uint32_t blocks_used;
} __packed;

struct kv_littlefs_algorithms_state {
        uint8_t count;
        uint32_t crc_xor;
} __packed;

struct kv_wifi_ssid {
        struct kv_string ssid;
} __packed;
 
/* clang-format off */
#define _KV_KEY_WIFI_SSID_VAR(num) \
        struct { \
                KV_STRUCT_KV_STRING_VAR(num) ssid; \
        } __packed
/* clang-format on */

struct kv_wifi_psk {
        struct kv_string psk;
} __packed;
 
/* clang-format off */
#define _KV_KEY_WIFI_PSK_VAR(num) \
        struct { \
                KV_STRUCT_KV_STRING_VAR(num) psk; \
        } __packed
/* clang-format on */

struct kv_wifi_channels {
        uint8_t band;
        uint8_t channels[];
} __packed;
 
/* clang-format off */
#define _KV_KEY_WIFI_CHANNELS_VAR(num) \
        struct { \
                uint8_t band; \
                uint8_t channels[num]; \
        } __packed
/* clang-format on */

struct kv_ntp_server_url {
        struct kv_string url;
} __packed;
 
/* clang-format off */
#define _KV_KEY_NTP_SERVER_URL_VAR(num) \
        struct { \
                KV_STRUCT_KV_STRING_VAR(num) url; \
        } __packed
/* clang-format on */

struct kv_epacket_udp_url {
        struct kv_string server;
} __packed;
 
/* clang-format off */
#define _KV_KEY_EPACKET_UDP_URL_VAR(num) \
        struct { \
                KV_STRUCT_KV_STRING_VAR(num) server; \
        } __packed
/* clang-format on */

struct kv_epacket_udp_port {
        uint32_t port;
} __packed;

struct kv_lte_modem_model {
        struct kv_string model;
} __packed;
 
/* clang-format off */
#define _KV_KEY_LTE_MODEM_MODEL_VAR(num) \
        struct { \
                KV_STRUCT_KV_STRING_VAR(num) model; \
        } __packed
/* clang-format on */

struct kv_lte_modem_firmware_revision {
        struct kv_string revision;
} __packed;
 
/* clang-format off */
#define _KV_KEY_LTE_MODEM_FIRMWARE_REVISION_VAR(num) \
        struct { \
                KV_STRUCT_KV_STRING_VAR(num) revision; \
        } __packed
/* clang-format on */

struct kv_lte_modem_esn {
        struct kv_string esn;
} __packed;
 
/* clang-format off */
#define _KV_KEY_LTE_MODEM_ESN_VAR(num) \
        struct { \
                KV_STRUCT_KV_STRING_VAR(num) esn; \
        } __packed
/* clang-format on */

struct kv_lte_modem_imei {
        uint64_t imei;
} __packed;

struct kv_lte_sim_uicc {
        struct kv_string uicc;
} __packed;
 
/* clang-format off */
#define _KV_KEY_LTE_SIM_UICC_VAR(num) \
        struct { \
                KV_STRUCT_KV_STRING_VAR(num) uicc; \
        } __packed
/* clang-format on */

struct kv_lte_pdp_config {
        uint8_t family;
        struct kv_string apn;
} __packed;
 
/* clang-format off */
#define _KV_KEY_LTE_PDP_CONFIG_VAR(num) \
        struct { \
                uint8_t family; \
                KV_STRUCT_KV_STRING_VAR(num) apn; \
        } __packed
/* clang-format on */

struct kv_lte_networking_modes {
        uint8_t modes;
        uint8_t prefer;
} __packed;

struct kv_lte_sim_imsi {
        uint64_t imsi;
} __packed;

struct kv_bluetooth_peer {
        struct bt_addr_le address;
} __packed;

struct kv_lora_config {
        uint32_t frequency;
        uint8_t bandwidth;
        uint8_t spreading_factor;
        uint8_t coding_rate;
        uint16_t preamble_len;
        int8_t tx_power;
        uint8_t sync_word;
} __packed;

struct kv_bluetooth_throughput_limit {
        uint16_t limit_kbps;
} __packed;

struct kv_led_disable_daily_time_range {
        struct kv_utc_hms disable_start;
        struct kv_utc_hms disable_end;
} __packed;

struct kv_memfault_disable {
        uint8_t disable;
} __packed;

struct kv_gateway_bluetooth_forward_options {
        uint8_t flags;
        uint8_t percent;
} __packed;

struct kv_nrf_edge_ai_runtime_version {
        uint8_t major;
        uint8_t minor;
        uint16_t patch;
} __packed;

struct kv_gravity_reference {
        int16_t x;
        int16_t y;
        int16_t z;
} __packed;

struct kv_geofence {
        uint8_t points_num;
        struct gcs_location points[];
} __packed;
 
/* clang-format off */
#define _KV_KEY_GEOFENCE_VAR(num) \
        struct { \
                uint8_t points_num; \
                struct gcs_location points[num]; \
        } __packed
/* clang-format on */

struct kv_alg_stationary_windowed_args {
        struct kv_algorithm_logging logging;
        struct kv_algorithm_stationary_windowed_args args;
} __packed;

struct kv_alg_tilt_args {
        struct kv_algorithm_logging logging;
        struct kv_algorithm_tilt_args args;
} __packed;

struct kv_alg_movement_threshold_args {
        struct kv_algorithm_logging logging;
        struct kv_algorithm_movement_threshold_args args;
} __packed;

struct kv_alg_movement_threshold_args_v2 {
        struct kv_algorithm_logging logging;
        struct kv_algorithm_movement_threshold_args_v2 args;
} __packed;

struct kv_task_schedules_default_id {
        uint32_t set_id;
} __packed;

struct kv_task_schedules {
        uint8_t task_id;
        uint8_t validity;
        uint8_t periodicity_type;
        uint8_t boot_lockout_minutes;
        uint32_t timeout_s;
        struct kv_range_u8 battery_start;
        struct kv_range_u8 battery_terminate;
        uint8_t _remainder[];
} __packed;
 
/* clang-format off */
#define _KV_KEY_TASK_SCHEDULES_VAR(num) \
        struct { \
                uint8_t task_id; \
                uint8_t validity; \
                uint8_t periodicity_type; \
                uint8_t boot_lockout_minutes; \
                uint32_t timeout_s; \
                struct kv_range_u8 battery_start; \
                struct kv_range_u8 battery_terminate; \
                uint8_t _remainder[num]; \
        } __packed
/* clang-format on */

struct kv_secure_storage_reserved {
        uint8_t data_num;
        uint8_t data[];
} __packed;
 
/* clang-format off */
#define _KV_KEY_SECURE_STORAGE_RESERVED_VAR(num) \
        struct { \
                uint8_t data_num; \
                uint8_t data[num]; \
        } __packed
/* clang-format on */
 
/* Infuse-IoT builtin KV definitions */
enum kv_builtin_id {
        KV_KEY_REBOOTS = 0,
        KV_KEY_BLUETOOTH_ADDR = 1,
        KV_KEY_EXFAT_DISK_INFO = 2,
        KV_KEY_BLUETOOTH_CTLR_VERSION = 3,
        KV_KEY_DEVICE_NAME = 4,
        KV_KEY_INFUSE_APPLICATION_ID = 5,
        KV_KEY_APPLICATION_ACTIVE = 6,
        KV_KEY_BOARD_TARGET = 7,
        KV_KEY_SECONDARY_REMOTE_PUBLIC_KEY = 8,
        KV_KEY_FIXED_LOCATION = 10,
        KV_KEY_BROADCAST_FIXED_INDOORS = 11,
        KV_KEY_LITTLEFS_FS_STATE = 12,
        KV_KEY_LITTLEFS_ALGORITHMS_STATE = 13,
        KV_KEY_WIFI_SSID = 20,
        KV_KEY_WIFI_PSK = 21,
        KV_KEY_WIFI_CHANNELS = 22,
        KV_KEY_NTP_SERVER_URL = 30,
        KV_KEY_EPACKET_UDP_URL = 31,
        KV_KEY_EPACKET_UDP_PORT = 32,
        KV_KEY_LTE_MODEM_MODEL = 40,
        KV_KEY_LTE_MODEM_FIRMWARE_REVISION = 41,
        KV_KEY_LTE_MODEM_ESN = 42,
        KV_KEY_LTE_MODEM_IMEI = 43,
        KV_KEY_LTE_SIM_UICC = 44,
        KV_KEY_LTE_PDP_CONFIG = 45,
        KV_KEY_LTE_NETWORKING_MODES = 46,
        KV_KEY_LTE_SIM_IMSI = 47,
        KV_KEY_BLUETOOTH_PEER = 50,
        KV_KEY_LORA_CONFIG = 51,
        KV_KEY_BLUETOOTH_THROUGHPUT_LIMIT = 52,
        KV_KEY_LED_DISABLE_DAILY_TIME_RANGE = 53,
        KV_KEY_MEMFAULT_DISABLE = 54,
        KV_KEY_GATEWAY_BLUETOOTH_FORWARD_OPTIONS = 55,
        KV_KEY_NRF_EDGE_AI_RUNTIME_VERSION = 56,
        KV_KEY_GRAVITY_REFERENCE = 60,
        KV_KEY_GEOFENCE = 100,
#ifdef CONFIG_KV_STORE_KEY_GEOFENCE_RANGE
        KV_KEY_GEOFENCE_END = 100 + CONFIG_KV_STORE_KEY_GEOFENCE_RANGE - 1,
#endif
        KV_KEY_GEOFENCE_MAX = 115,
        KV_KEY_ALG_STATIONARY_WINDOWED_ARGS = 200,
        KV_KEY_ALG_TILT_ARGS = 201,
        KV_KEY_ALG_MOVEMENT_THRESHOLD_ARGS = 202,
        KV_KEY_ALG_MOVEMENT_THRESHOLD_ARGS_V2 = 203,
        KV_KEY_TASK_SCHEDULES_DEFAULT_ID = 1000,
        KV_KEY_TASK_SCHEDULES = 1001,
#ifdef CONFIG_KV_STORE_KEY_TASK_SCHEDULES_RANGE
        KV_KEY_TASK_SCHEDULES_END = 1001 + CONFIG_KV_STORE_KEY_TASK_SCHEDULES_RANGE - 1,
#endif
        KV_KEY_TASK_SCHEDULES_MAX = 1032,
        KV_KEY_SECURE_STORAGE_RESERVED = 30000,
#ifdef CONFIG_KV_STORE_KEY_SECURE_STORAGE_RESERVED_RANGE
        KV_KEY_SECURE_STORAGE_RESERVED_END =
                30000 + CONFIG_KV_STORE_KEY_SECURE_STORAGE_RESERVED_RANGE - 1,
#endif
        KV_KEY_SECURE_STORAGE_RESERVED_MAX = 30009,
        KV_KEY_BUILTIN_END = 32768,
};

enum kv_builtin_size {
        _KV_KEY_REBOOTS_SIZE = sizeof(struct kv_reboots),
        _KV_KEY_BLUETOOTH_ADDR_SIZE = sizeof(struct kv_bluetooth_addr),
        _KV_KEY_EXFAT_DISK_INFO_SIZE = sizeof(struct kv_exfat_disk_info),
        _KV_KEY_BLUETOOTH_CTLR_VERSION_SIZE = sizeof(struct kv_bluetooth_ctlr_version),
        _KV_KEY_INFUSE_APPLICATION_ID_SIZE = sizeof(struct kv_infuse_application_id),
        _KV_KEY_APPLICATION_ACTIVE_SIZE = sizeof(struct kv_application_active),
        _KV_KEY_SECONDARY_REMOTE_PUBLIC_KEY_SIZE = sizeof(struct kv_secondary_remote_public_key),
        _KV_KEY_FIXED_LOCATION_SIZE = sizeof(struct kv_fixed_location),
        _KV_KEY_BROADCAST_FIXED_INDOORS_SIZE = sizeof(struct kv_broadcast_fixed_indoors),
        _KV_KEY_LITTLEFS_FS_STATE_SIZE = sizeof(struct kv_littlefs_fs_state),
        _KV_KEY_LITTLEFS_ALGORITHMS_STATE_SIZE = sizeof(struct kv_littlefs_algorithms_state),
        _KV_KEY_EPACKET_UDP_PORT_SIZE = sizeof(struct kv_epacket_udp_port),
        _KV_KEY_LTE_MODEM_IMEI_SIZE = sizeof(struct kv_lte_modem_imei),
        _KV_KEY_LTE_NETWORKING_MODES_SIZE = sizeof(struct kv_lte_networking_modes),
        _KV_KEY_LTE_SIM_IMSI_SIZE = sizeof(struct kv_lte_sim_imsi),
        _KV_KEY_BLUETOOTH_PEER_SIZE = sizeof(struct kv_bluetooth_peer),
        _KV_KEY_LORA_CONFIG_SIZE = sizeof(struct kv_lora_config),
        _KV_KEY_BLUETOOTH_THROUGHPUT_LIMIT_SIZE = sizeof(struct kv_bluetooth_throughput_limit),
        _KV_KEY_LED_DISABLE_DAILY_TIME_RANGE_SIZE = sizeof(struct kv_led_disable_daily_time_range),
        _KV_KEY_MEMFAULT_DISABLE_SIZE = sizeof(struct kv_memfault_disable),
        _KV_KEY_GATEWAY_BLUETOOTH_FORWARD_OPTIONS_SIZE =
                sizeof(struct kv_gateway_bluetooth_forward_options),
        _KV_KEY_NRF_EDGE_AI_RUNTIME_VERSION_SIZE = sizeof(struct kv_nrf_edge_ai_runtime_version),
        _KV_KEY_GRAVITY_REFERENCE_SIZE = sizeof(struct kv_gravity_reference),
        _KV_KEY_ALG_STATIONARY_WINDOWED_ARGS_SIZE = sizeof(struct kv_alg_stationary_windowed_args),
        _KV_KEY_ALG_TILT_ARGS_SIZE = sizeof(struct kv_alg_tilt_args),
        _KV_KEY_ALG_MOVEMENT_THRESHOLD_ARGS_SIZE = sizeof(struct kv_alg_movement_threshold_args),
        _KV_KEY_ALG_MOVEMENT_THRESHOLD_ARGS_V2_SIZE =
                sizeof(struct kv_alg_movement_threshold_args_v2),
        _KV_KEY_TASK_SCHEDULES_DEFAULT_ID_SIZE = sizeof(struct kv_task_schedules_default_id),
};
 
/* clang-format off */
/* Types of builtin KV definitions */
#define _KV_KEY_REBOOTS_TYPE struct kv_reboots
#define _KV_KEY_BLUETOOTH_ADDR_TYPE struct kv_bluetooth_addr
#define _KV_KEY_EXFAT_DISK_INFO_TYPE struct kv_exfat_disk_info
#define _KV_KEY_BLUETOOTH_CTLR_VERSION_TYPE struct kv_bluetooth_ctlr_version
#define _KV_KEY_DEVICE_NAME_TYPE struct kv_device_name
#define _KV_KEY_INFUSE_APPLICATION_ID_TYPE struct kv_infuse_application_id
#define _KV_KEY_APPLICATION_ACTIVE_TYPE struct kv_application_active
#define _KV_KEY_BOARD_TARGET_TYPE struct kv_board_target
#define _KV_KEY_SECONDARY_REMOTE_PUBLIC_KEY_TYPE struct kv_secondary_remote_public_key
#define _KV_KEY_FIXED_LOCATION_TYPE struct kv_fixed_location
#define _KV_KEY_BROADCAST_FIXED_INDOORS_TYPE struct kv_broadcast_fixed_indoors
#define _KV_KEY_LITTLEFS_FS_STATE_TYPE struct kv_littlefs_fs_state
#define _KV_KEY_LITTLEFS_ALGORITHMS_STATE_TYPE struct kv_littlefs_algorithms_state
#define _KV_KEY_WIFI_SSID_TYPE struct kv_wifi_ssid
#define _KV_KEY_WIFI_PSK_TYPE struct kv_wifi_psk
#define _KV_KEY_WIFI_CHANNELS_TYPE struct kv_wifi_channels
#define _KV_KEY_NTP_SERVER_URL_TYPE struct kv_ntp_server_url
#define _KV_KEY_EPACKET_UDP_URL_TYPE struct kv_epacket_udp_url
#define _KV_KEY_EPACKET_UDP_PORT_TYPE struct kv_epacket_udp_port
#define _KV_KEY_LTE_MODEM_MODEL_TYPE struct kv_lte_modem_model
#define _KV_KEY_LTE_MODEM_FIRMWARE_REVISION_TYPE struct kv_lte_modem_firmware_revision
#define _KV_KEY_LTE_MODEM_ESN_TYPE struct kv_lte_modem_esn
#define _KV_KEY_LTE_MODEM_IMEI_TYPE struct kv_lte_modem_imei
#define _KV_KEY_LTE_SIM_UICC_TYPE struct kv_lte_sim_uicc
#define _KV_KEY_LTE_PDP_CONFIG_TYPE struct kv_lte_pdp_config
#define _KV_KEY_LTE_NETWORKING_MODES_TYPE struct kv_lte_networking_modes
#define _KV_KEY_LTE_SIM_IMSI_TYPE struct kv_lte_sim_imsi
#define _KV_KEY_BLUETOOTH_PEER_TYPE struct kv_bluetooth_peer
#define _KV_KEY_LORA_CONFIG_TYPE struct kv_lora_config
#define _KV_KEY_BLUETOOTH_THROUGHPUT_LIMIT_TYPE struct kv_bluetooth_throughput_limit
#define _KV_KEY_LED_DISABLE_DAILY_TIME_RANGE_TYPE struct kv_led_disable_daily_time_range
#define _KV_KEY_MEMFAULT_DISABLE_TYPE struct kv_memfault_disable
#define _KV_KEY_GATEWAY_BLUETOOTH_FORWARD_OPTIONS_TYPE struct kv_gateway_bluetooth_forward_options
#define _KV_KEY_NRF_EDGE_AI_RUNTIME_VERSION_TYPE struct kv_nrf_edge_ai_runtime_version
#define _KV_KEY_GRAVITY_REFERENCE_TYPE struct kv_gravity_reference
#define _KV_KEY_GEOFENCE_TYPE struct kv_geofence
#define _KV_KEY_ALG_STATIONARY_WINDOWED_ARGS_TYPE struct kv_alg_stationary_windowed_args
#define _KV_KEY_ALG_TILT_ARGS_TYPE struct kv_alg_tilt_args
#define _KV_KEY_ALG_MOVEMENT_THRESHOLD_ARGS_TYPE struct kv_alg_movement_threshold_args
#define _KV_KEY_ALG_MOVEMENT_THRESHOLD_ARGS_V2_TYPE struct kv_alg_movement_threshold_args_v2
#define _KV_KEY_TASK_SCHEDULES_DEFAULT_ID_TYPE struct kv_task_schedules_default_id
#define _KV_KEY_TASK_SCHEDULES_TYPE struct kv_task_schedules
#define _KV_KEY_SECURE_STORAGE_RESERVED_TYPE struct kv_secure_storage_reserved
/* clang-format on */
 
/* clang-format off */
#define KV_REFLECT_NUM ( \
        IF_ENABLED(CONFIG_KV_STORE_KEY_BLUETOOTH_ADDR, \
                   (1 +)) \
        IF_ENABLED(CONFIG_KV_STORE_KEY_EXFAT_DISK_INFO, \
                   (1 +)) \
        IF_ENABLED(CONFIG_KV_STORE_KEY_BLUETOOTH_CTLR_VERSION, \
                   (1 +)) \
        IF_ENABLED(CONFIG_KV_STORE_KEY_DEVICE_NAME, \
                   (1 +)) \
        IF_ENABLED(CONFIG_KV_STORE_KEY_BOARD_TARGET, \
                   (1 +)) \
        IF_ENABLED(CONFIG_KV_STORE_KEY_SECONDARY_REMOTE_PUBLIC_KEY, \
                   (1 +)) \
        IF_ENABLED(CONFIG_KV_STORE_KEY_FIXED_LOCATION, \
                   (1 +)) \
        IF_ENABLED(CONFIG_KV_STORE_KEY_BROADCAST_FIXED_INDOORS, \
                   (1 +)) \
        IF_ENABLED(CONFIG_KV_STORE_KEY_LITTLEFS_FS_STATE, \
                   (1 +)) \
        IF_ENABLED(CONFIG_KV_STORE_KEY_LITTLEFS_ALGORITHMS_STATE, \
                   (1 +)) \
        IF_ENABLED(CONFIG_KV_STORE_KEY_WIFI_SSID, \
                   (1 +)) \
        IF_ENABLED(CONFIG_KV_STORE_KEY_WIFI_PSK, \
                   (1 +)) \
        IF_ENABLED(CONFIG_KV_STORE_KEY_WIFI_CHANNELS, \
                   (1 +)) \
        IF_ENABLED(CONFIG_KV_STORE_KEY_NTP_SERVER_URL, \
                   (1 +)) \
        IF_ENABLED(CONFIG_KV_STORE_KEY_EPACKET_UDP_URL, \
                   (1 +)) \
        IF_ENABLED(CONFIG_KV_STORE_KEY_EPACKET_UDP_PORT, \
                   (1 +)) \
        IF_ENABLED(CONFIG_KV_STORE_KEY_LTE_MODEM_MODEL, \
                   (1 +)) \
        IF_ENABLED(CONFIG_KV_STORE_KEY_LTE_MODEM_FIRMWARE_REVISION, \
                   (1 +)) \
        IF_ENABLED(CONFIG_KV_STORE_KEY_LTE_MODEM_ESN, \
                   (1 +)) \
        IF_ENABLED(CONFIG_KV_STORE_KEY_LTE_MODEM_IMEI, \
                   (1 +)) \
        IF_ENABLED(CONFIG_KV_STORE_KEY_LTE_SIM_UICC, \
                   (1 +)) \
        IF_ENABLED(CONFIG_KV_STORE_KEY_LTE_PDP_CONFIG, \
                   (1 +)) \
        IF_ENABLED(CONFIG_KV_STORE_KEY_LTE_NETWORKING_MODES, \
                   (1 +)) \
        IF_ENABLED(CONFIG_KV_STORE_KEY_LTE_SIM_IMSI, \
                   (1 +)) \
        IF_ENABLED(CONFIG_KV_STORE_KEY_BLUETOOTH_PEER, \
                   (1 +)) \
        IF_ENABLED(CONFIG_KV_STORE_KEY_LORA_CONFIG, \
                   (1 +)) \
        IF_ENABLED(CONFIG_KV_STORE_KEY_BLUETOOTH_THROUGHPUT_LIMIT, \
                   (1 +)) \
        IF_ENABLED(CONFIG_KV_STORE_KEY_LED_DISABLE_DAILY_TIME_RANGE, \
                   (1 +)) \
        IF_ENABLED(CONFIG_KV_STORE_KEY_GATEWAY_BLUETOOTH_FORWARD_OPTIONS, \
                   (1 +)) \
        IF_ENABLED(CONFIG_KV_STORE_KEY_NRF_EDGE_AI_RUNTIME_VERSION, \
                   (1 +)) \
        IF_ENABLED(CONFIG_KV_STORE_KEY_GRAVITY_REFERENCE, \
                   (1 +)) \
        IF_ENABLED(CONFIG_KV_STORE_KEY_GEOFENCE, \
                   (CONFIG_KV_STORE_KEY_GEOFENCE_RANGE +)) \
        IF_ENABLED(CONFIG_KV_STORE_KEY_ALG_STATIONARY_WINDOWED_ARGS, \
                   (1 +)) \
        IF_ENABLED(CONFIG_KV_STORE_KEY_ALG_TILT_ARGS, \
                   (1 +)) \
        IF_ENABLED(CONFIG_KV_STORE_KEY_ALG_MOVEMENT_THRESHOLD_ARGS, \
                   (1 +)) \
        IF_ENABLED(CONFIG_KV_STORE_KEY_ALG_MOVEMENT_THRESHOLD_ARGS_V2, \
                   (1 +)) \
        IF_ENABLED(CONFIG_KV_STORE_KEY_TASK_SCHEDULES_DEFAULT_ID, \
                   (1 +)) \
        IF_ENABLED(CONFIG_KV_STORE_KEY_TASK_SCHEDULES, \
                   (CONFIG_KV_STORE_KEY_TASK_SCHEDULES_RANGE +)) \
        0)
/* clang-format on */

#define KV_KEY_TYPE(key) _##key##_TYPE
 
#define _KV_KEY_TYPE_VAR_EXEC(macro, num) macro(num)

#define KV_KEY_TYPE_VAR(key, num) _KV_KEY_TYPE_VAR_EXEC(_##key##_VAR, num)

#define KV_STRING_CONST(name, val) KV_STRUCT_KV_STRING_VAR(sizeof(val)) name = {sizeof(val), val};

enum kv_slot_flags {
        KV_FLAGS_REFLECT = BIT(0),
        KV_FLAGS_WRITE_ONLY = BIT(1),
        KV_FLAGS_READ_ONLY = BIT(2),
};

struct key_value_slot_definition {
        uint16_t key;
        uint8_t range;
        uint8_t flags;
};
 
#ifdef _KV_SLOTS_ARRAY_DEFINE
static struct key_value_slot_definition _KV_SLOTS_ARRAY_DEFINE[] = {
#ifdef CONFIG_KV_STORE_KEY_REBOOTS
        {
                .key = KV_KEY_REBOOTS,
                .range = 1,
                .flags = 0,
        },
#endif /* CONFIG_KV_STORE_KEY_REBOOTS */
#ifdef CONFIG_KV_STORE_KEY_BLUETOOTH_ADDR
        {
                .key = KV_KEY_BLUETOOTH_ADDR,
                .range = 1,
                .flags = KV_FLAGS_REFLECT | KV_FLAGS_READ_ONLY,
        },
#endif /* CONFIG_KV_STORE_KEY_BLUETOOTH_ADDR */
#ifdef CONFIG_KV_STORE_KEY_EXFAT_DISK_INFO
        {
                .key = KV_KEY_EXFAT_DISK_INFO,
                .range = 1,
                .flags = KV_FLAGS_REFLECT | KV_FLAGS_READ_ONLY,
        },
#endif /* CONFIG_KV_STORE_KEY_EXFAT_DISK_INFO */
#ifdef CONFIG_KV_STORE_KEY_BLUETOOTH_CTLR_VERSION
        {
                .key = KV_KEY_BLUETOOTH_CTLR_VERSION,
                .range = 1,
                .flags = KV_FLAGS_REFLECT,
        },
#endif /* CONFIG_KV_STORE_KEY_BLUETOOTH_CTLR_VERSION */
#ifdef CONFIG_KV_STORE_KEY_DEVICE_NAME
        {
                .key = KV_KEY_DEVICE_NAME,
                .range = 1,
                .flags = KV_FLAGS_REFLECT,
        },
#endif /* CONFIG_KV_STORE_KEY_DEVICE_NAME */
#ifdef CONFIG_KV_STORE_KEY_INFUSE_APPLICATION_ID
        {
                .key = KV_KEY_INFUSE_APPLICATION_ID,
                .range = 1,
                .flags = 0,
        },
#endif /* CONFIG_KV_STORE_KEY_INFUSE_APPLICATION_ID */
#ifdef CONFIG_KV_STORE_KEY_APPLICATION_ACTIVE
        {
                .key = KV_KEY_APPLICATION_ACTIVE,
                .range = 1,
                .flags = 0,
        },
#endif /* CONFIG_KV_STORE_KEY_APPLICATION_ACTIVE */
#ifdef CONFIG_KV_STORE_KEY_BOARD_TARGET
        {
                .key = KV_KEY_BOARD_TARGET,
                .range = 1,
                .flags = KV_FLAGS_REFLECT | KV_FLAGS_READ_ONLY,
        },
#endif /* CONFIG_KV_STORE_KEY_BOARD_TARGET */
#ifdef CONFIG_KV_STORE_KEY_SECONDARY_REMOTE_PUBLIC_KEY
        {
                .key = KV_KEY_SECONDARY_REMOTE_PUBLIC_KEY,
                .range = 1,
                .flags = KV_FLAGS_REFLECT,
        },
#endif /* CONFIG_KV_STORE_KEY_SECONDARY_REMOTE_PUBLIC_KEY */
#ifdef CONFIG_KV_STORE_KEY_FIXED_LOCATION
        {
                .key = KV_KEY_FIXED_LOCATION,
                .range = 1,
                .flags = KV_FLAGS_REFLECT,
        },
#endif /* CONFIG_KV_STORE_KEY_FIXED_LOCATION */
#ifdef CONFIG_KV_STORE_KEY_BROADCAST_FIXED_INDOORS
        {
                .key = KV_KEY_BROADCAST_FIXED_INDOORS,
                .range = 1,
                .flags = KV_FLAGS_REFLECT,
        },
#endif /* CONFIG_KV_STORE_KEY_BROADCAST_FIXED_INDOORS */
#ifdef CONFIG_KV_STORE_KEY_LITTLEFS_FS_STATE
        {
                .key = KV_KEY_LITTLEFS_FS_STATE,
                .range = 1,
                .flags = KV_FLAGS_REFLECT | KV_FLAGS_READ_ONLY,
        },
#endif /* CONFIG_KV_STORE_KEY_LITTLEFS_FS_STATE */
#ifdef CONFIG_KV_STORE_KEY_LITTLEFS_ALGORITHMS_STATE
        {
                .key = KV_KEY_LITTLEFS_ALGORITHMS_STATE,
                .range = 1,
                .flags = KV_FLAGS_REFLECT | KV_FLAGS_READ_ONLY,
        },
#endif /* CONFIG_KV_STORE_KEY_LITTLEFS_ALGORITHMS_STATE */
#ifdef CONFIG_KV_STORE_KEY_WIFI_SSID
        {
                .key = KV_KEY_WIFI_SSID,
                .range = 1,
                .flags = KV_FLAGS_REFLECT,
        },
#endif /* CONFIG_KV_STORE_KEY_WIFI_SSID */
#ifdef CONFIG_KV_STORE_KEY_WIFI_PSK
        {
                .key = KV_KEY_WIFI_PSK,
                .range = 1,
                .flags = KV_FLAGS_REFLECT | KV_FLAGS_WRITE_ONLY,
        },
#endif /* CONFIG_KV_STORE_KEY_WIFI_PSK */
#ifdef CONFIG_KV_STORE_KEY_WIFI_CHANNELS
        {
                .key = KV_KEY_WIFI_CHANNELS,
                .range = 1,
                .flags = KV_FLAGS_REFLECT,
        },
#endif /* CONFIG_KV_STORE_KEY_WIFI_CHANNELS */
#ifdef CONFIG_KV_STORE_KEY_NTP_SERVER_URL
        {
                .key = KV_KEY_NTP_SERVER_URL,
                .range = 1,
                .flags = KV_FLAGS_REFLECT,
        },
#endif /* CONFIG_KV_STORE_KEY_NTP_SERVER_URL */
#ifdef CONFIG_KV_STORE_KEY_EPACKET_UDP_URL
        {
                .key = KV_KEY_EPACKET_UDP_URL,
                .range = 1,
                .flags = KV_FLAGS_REFLECT,
        },
#endif /* CONFIG_KV_STORE_KEY_EPACKET_UDP_URL */
#ifdef CONFIG_KV_STORE_KEY_EPACKET_UDP_PORT
        {
                .key = KV_KEY_EPACKET_UDP_PORT,
                .range = 1,
                .flags = KV_FLAGS_REFLECT,
        },
#endif /* CONFIG_KV_STORE_KEY_EPACKET_UDP_PORT */
#ifdef CONFIG_KV_STORE_KEY_LTE_MODEM_MODEL
        {
                .key = KV_KEY_LTE_MODEM_MODEL,
                .range = 1,
                .flags = KV_FLAGS_REFLECT | KV_FLAGS_READ_ONLY,
        },
#endif /* CONFIG_KV_STORE_KEY_LTE_MODEM_MODEL */
#ifdef CONFIG_KV_STORE_KEY_LTE_MODEM_FIRMWARE_REVISION
        {
                .key = KV_KEY_LTE_MODEM_FIRMWARE_REVISION,
                .range = 1,
                .flags = KV_FLAGS_REFLECT | KV_FLAGS_READ_ONLY,
        },
#endif /* CONFIG_KV_STORE_KEY_LTE_MODEM_FIRMWARE_REVISION */
#ifdef CONFIG_KV_STORE_KEY_LTE_MODEM_ESN
        {
                .key = KV_KEY_LTE_MODEM_ESN,
                .range = 1,
                .flags = KV_FLAGS_REFLECT | KV_FLAGS_READ_ONLY,
        },
#endif /* CONFIG_KV_STORE_KEY_LTE_MODEM_ESN */
#ifdef CONFIG_KV_STORE_KEY_LTE_MODEM_IMEI
        {
                .key = KV_KEY_LTE_MODEM_IMEI,
                .range = 1,
                .flags = KV_FLAGS_REFLECT | KV_FLAGS_READ_ONLY,
        },
#endif /* CONFIG_KV_STORE_KEY_LTE_MODEM_IMEI */
#ifdef CONFIG_KV_STORE_KEY_LTE_SIM_UICC
        {
                .key = KV_KEY_LTE_SIM_UICC,
                .range = 1,
                .flags = KV_FLAGS_REFLECT | KV_FLAGS_READ_ONLY,
        },
#endif /* CONFIG_KV_STORE_KEY_LTE_SIM_UICC */
#ifdef CONFIG_KV_STORE_KEY_LTE_PDP_CONFIG
        {
                .key = KV_KEY_LTE_PDP_CONFIG,
                .range = 1,
                .flags = KV_FLAGS_REFLECT,
        },
#endif /* CONFIG_KV_STORE_KEY_LTE_PDP_CONFIG */
#ifdef CONFIG_KV_STORE_KEY_LTE_NETWORKING_MODES
        {
                .key = KV_KEY_LTE_NETWORKING_MODES,
                .range = 1,
                .flags = KV_FLAGS_REFLECT,
        },
#endif /* CONFIG_KV_STORE_KEY_LTE_NETWORKING_MODES */
#ifdef CONFIG_KV_STORE_KEY_LTE_SIM_IMSI
        {
                .key = KV_KEY_LTE_SIM_IMSI,
                .range = 1,
                .flags = KV_FLAGS_REFLECT | KV_FLAGS_READ_ONLY,
        },
#endif /* CONFIG_KV_STORE_KEY_LTE_SIM_IMSI */
#ifdef CONFIG_KV_STORE_KEY_BLUETOOTH_PEER
        {
                .key = KV_KEY_BLUETOOTH_PEER,
                .range = 1,
                .flags = KV_FLAGS_REFLECT,
        },
#endif /* CONFIG_KV_STORE_KEY_BLUETOOTH_PEER */
#ifdef CONFIG_KV_STORE_KEY_LORA_CONFIG
        {
                .key = KV_KEY_LORA_CONFIG,
                .range = 1,
                .flags = KV_FLAGS_REFLECT,
        },
#endif /* CONFIG_KV_STORE_KEY_LORA_CONFIG */
#ifdef CONFIG_KV_STORE_KEY_BLUETOOTH_THROUGHPUT_LIMIT
        {
                .key = KV_KEY_BLUETOOTH_THROUGHPUT_LIMIT,
                .range = 1,
                .flags = KV_FLAGS_REFLECT,
        },
#endif /* CONFIG_KV_STORE_KEY_BLUETOOTH_THROUGHPUT_LIMIT */
#ifdef CONFIG_KV_STORE_KEY_LED_DISABLE_DAILY_TIME_RANGE
        {
                .key = KV_KEY_LED_DISABLE_DAILY_TIME_RANGE,
                .range = 1,
                .flags = KV_FLAGS_REFLECT,
        },
#endif /* CONFIG_KV_STORE_KEY_LED_DISABLE_DAILY_TIME_RANGE */
#ifdef CONFIG_KV_STORE_KEY_MEMFAULT_DISABLE
        {
                .key = KV_KEY_MEMFAULT_DISABLE,
                .range = 1,
                .flags = 0,
        },
#endif /* CONFIG_KV_STORE_KEY_MEMFAULT_DISABLE */
#ifdef CONFIG_KV_STORE_KEY_GATEWAY_BLUETOOTH_FORWARD_OPTIONS
        {
                .key = KV_KEY_GATEWAY_BLUETOOTH_FORWARD_OPTIONS,
                .range = 1,
                .flags = KV_FLAGS_REFLECT,
        },
#endif /* CONFIG_KV_STORE_KEY_GATEWAY_BLUETOOTH_FORWARD_OPTIONS */
#ifdef CONFIG_KV_STORE_KEY_NRF_EDGE_AI_RUNTIME_VERSION
        {
                .key = KV_KEY_NRF_EDGE_AI_RUNTIME_VERSION,
                .range = 1,
                .flags = KV_FLAGS_REFLECT,
        },
#endif /* CONFIG_KV_STORE_KEY_NRF_EDGE_AI_RUNTIME_VERSION */
#ifdef CONFIG_KV_STORE_KEY_GRAVITY_REFERENCE
        {
                .key = KV_KEY_GRAVITY_REFERENCE,
                .range = 1,
                .flags = KV_FLAGS_REFLECT,
        },
#endif /* CONFIG_KV_STORE_KEY_GRAVITY_REFERENCE */
#ifdef CONFIG_KV_STORE_KEY_GEOFENCE
        {
                .key = KV_KEY_GEOFENCE,
                .range = CONFIG_KV_STORE_KEY_GEOFENCE_RANGE,
                .flags = KV_FLAGS_REFLECT,
        },
#endif /* CONFIG_KV_STORE_KEY_GEOFENCE */
#ifdef CONFIG_KV_STORE_KEY_ALG_STATIONARY_WINDOWED_ARGS
        {
                .key = KV_KEY_ALG_STATIONARY_WINDOWED_ARGS,
                .range = 1,
                .flags = KV_FLAGS_REFLECT,
        },
#endif /* CONFIG_KV_STORE_KEY_ALG_STATIONARY_WINDOWED_ARGS */
#ifdef CONFIG_KV_STORE_KEY_ALG_TILT_ARGS
        {
                .key = KV_KEY_ALG_TILT_ARGS,
                .range = 1,
                .flags = KV_FLAGS_REFLECT,
        },
#endif /* CONFIG_KV_STORE_KEY_ALG_TILT_ARGS */
#ifdef CONFIG_KV_STORE_KEY_ALG_MOVEMENT_THRESHOLD_ARGS
        {
                .key = KV_KEY_ALG_MOVEMENT_THRESHOLD_ARGS,
                .range = 1,
                .flags = KV_FLAGS_REFLECT,
        },
#endif /* CONFIG_KV_STORE_KEY_ALG_MOVEMENT_THRESHOLD_ARGS */
#ifdef CONFIG_KV_STORE_KEY_ALG_MOVEMENT_THRESHOLD_ARGS_V2
        {
                .key = KV_KEY_ALG_MOVEMENT_THRESHOLD_ARGS_V2,
                .range = 1,
                .flags = KV_FLAGS_REFLECT,
        },
#endif /* CONFIG_KV_STORE_KEY_ALG_MOVEMENT_THRESHOLD_ARGS_V2 */
#ifdef CONFIG_KV_STORE_KEY_TASK_SCHEDULES_DEFAULT_ID
        {
                .key = KV_KEY_TASK_SCHEDULES_DEFAULT_ID,
                .range = 1,
                .flags = KV_FLAGS_REFLECT,
        },
#endif /* CONFIG_KV_STORE_KEY_TASK_SCHEDULES_DEFAULT_ID */
#ifdef CONFIG_KV_STORE_KEY_TASK_SCHEDULES
        {
                .key = KV_KEY_TASK_SCHEDULES,
                .range = CONFIG_KV_STORE_KEY_TASK_SCHEDULES_RANGE,
                .flags = KV_FLAGS_REFLECT,
        },
#endif /* CONFIG_KV_STORE_KEY_TASK_SCHEDULES */
#ifdef CONFIG_KV_STORE_KEY_SECURE_STORAGE_RESERVED
        {
                .key = KV_KEY_SECURE_STORAGE_RESERVED,
                .range = CONFIG_KV_STORE_KEY_SECURE_STORAGE_RESERVED_RANGE,
                .flags = 0,
        },
#endif /* CONFIG_KV_STORE_KEY_SECURE_STORAGE_RESERVED */
};
#endif /* _KV_SLOTS_ARRAY_DEFINE */

 
#ifdef __cplusplus
}
#endif
 
#endif /* INFUSE_SDK_INCLUDE_GENERATED_KV_DEFINITIONS_H_ */