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_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_fixed_location {
        struct gcs_location location;
} __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_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_task_schedules_default_id {
        uint32_t set_id;
} __packed;
 
struct kv_task_schedules {
        uint8_t task_id;
        uint8_t validity;
        uint8_t periodicity_type;
        uint32_t timeout_s;
        struct kv_range_u8 battery_start;
        struct kv_range_u8 battery_terminate;
        uint32_t periodicity;
        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; \
                uint32_t timeout_s; \
                struct kv_range_u8 battery_start; \
                struct kv_range_u8 battery_terminate; \
                uint32_t periodicity; \
                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_FIXED_LOCATION = 10,
        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_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_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_FIXED_LOCATION_SIZE = sizeof(struct kv_fixed_location),
        _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_GRAVITY_REFERENCE_SIZE = sizeof(struct kv_gravity_reference),
        _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_FIXED_LOCATION_TYPE struct kv_fixed_location
#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_GRAVITY_REFERENCE_TYPE struct kv_gravity_reference
#define _KV_KEY_GEOFENCE_TYPE struct kv_geofence
#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_FIXED_LOCATION, \
                   (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_GRAVITY_REFERENCE, \
                   (1 +)) \
        IF_ENABLED(CONFIG_KV_STORE_KEY_GEOFENCE, \
                   (CONFIG_KV_STORE_KEY_GEOFENCE_RANGE +)) \
        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_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_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_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_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_ */