diff --git a/ChangeLog.d/bugfix/ZBX-23688 b/ChangeLog.d/bugfix/ZBX-23688
new file mode 100644
index 00000000000..8bc5e9c0ff5
--- /dev/null
+++ b/ChangeLog.d/bugfix/ZBX-23688
@@ -0,0 +1 @@
+........S. [ZBX-23688] improved new item value retrieval performance by adding such items to value cache after configuration sync (wiper)
diff --git a/include/dbcache.h b/include/dbcache.h
index a2dd39234b7..13e421aab1c 100644
--- a/include/dbcache.h
+++ b/include/dbcache.h
@@ -222,6 +222,7 @@ typedef struct
 	unsigned char		history;
 	unsigned char		trends;
 	unsigned char		flags;
+	unsigned char		has_trigger;
 }
 zbx_history_sync_item_t;
 
@@ -927,6 +928,7 @@ void	zbx_dc_get_hostids_by_group_name(const char *name, zbx_vector_uint64_t *hos
 #define ZBX_DC_FLAG_UNDEF	0x08	/* unsupported or undefined (delta calculation failed) value */
 #define ZBX_DC_FLAG_NOHISTORY	0x10	/* values should not be kept in history */
 #define ZBX_DC_FLAG_NOTRENDS	0x20	/* values should not be kept in trends */
+#define ZBX_DC_FLAG_HASTRIGGER	0x40	/* value is used in trigger expression */
 
 typedef struct zbx_hc_data
 {
diff --git a/src/libs/zbxdbcache/dbcache.c b/src/libs/zbxdbcache/dbcache.c
index 9a5528d893a..b5bcb40c270 100644
--- a/src/libs/zbxdbcache/dbcache.c
+++ b/src/libs/zbxdbcache/dbcache.c
@@ -2741,6 +2741,9 @@ static void	DCmass_prepare_history(ZBX_DC_HISTORY *history, zbx_history_sync_ite
 
 			zbx_vector_uint64_pair_append(proxy_subscribtions, p);
 		}
+
+		if (0 != item->has_trigger)
+			h->flags |= ZBX_DC_FLAG_HASTRIGGER;
 	}
 
 	zbx_vector_ptr_sort(inventory_values, ZBX_DEFAULT_UINT64_PTR_COMPARE_FUNC);
diff --git a/src/libs/zbxdbcache/dbconfig.c b/src/libs/zbxdbcache/dbconfig.c
index 8865f998154..96d95bc28f2 100644
--- a/src/libs/zbxdbcache/dbconfig.c
+++ b/src/libs/zbxdbcache/dbconfig.c
@@ -33,6 +33,7 @@
 #include "zbxtrends.h"
 #include "zbxvault.h"
 #include "zbxserialize.h"
+#include "valuecache.h"
 
 int	sync_in_progress = 0;
 
@@ -61,6 +62,8 @@ int	sync_in_progress = 0;
 		in_maintenance_without_data_collection(dc_host->maintenance_status,	\
 				dc_host->maintenance_type, dc_item->type)
 
+ZBX_PTR_VECTOR_IMPL(dc_item_ptr, ZBX_DC_ITEM *)
+
 /******************************************************************************
  *                                                                            *
  * Purpose: validate macro value when expanding user macros                   *
@@ -2690,7 +2693,7 @@ static unsigned char	*config_decode_serialized_expression(const char *src)
 	return dst;
 }
 
-static void	DCsync_items(zbx_dbsync_t *sync, int flags)
+static void	DCsync_items(zbx_dbsync_t *sync, int flags, zbx_vector_dc_item_ptr_t *new_items)
 {
 	char			**row;
 	zbx_uint64_t		rowid;
@@ -2816,7 +2819,15 @@ static void	DCsync_items(zbx_dbsync_t *sync, int flags)
 		if (0 == found)
 		{
 			item->triggers = NULL;
-			item->update_triggers = 0;
+
+			if (NULL != new_items)
+			{
+				zbx_vector_dc_item_ptr_append(new_items, item);
+				item->update_triggers = ZBX_ITEM_UPDATE_TRIGGER_NEW_ITEM;
+			}
+			else
+				item->update_triggers = ZBX_DC_ITEM_UPDATE_TRIGGER_NONE;
+
 			item->nextcheck = 0;
 			item->state = (unsigned char)atoi(row[12]);
 			ZBX_STR2UINT64(item->lastlogsize, row[20]);
@@ -5735,7 +5746,7 @@ static void	dc_item_reset_triggers(ZBX_DC_ITEM *item, ZBX_DC_TRIGGER *trigger_ex
 {
 	ZBX_DC_TRIGGER	**trigger;
 
-	item->update_triggers = 1;
+	item->update_triggers = ZBX_DC_ITEM_UPDATE_TRIGGER_REFRESH;
 
 	if (NULL == item->triggers)
 		return;
@@ -5807,7 +5818,7 @@ static void	dc_trigger_update_cache(void)
 		}
 
 		/* cache item - trigger link */
-		if (0 != item->update_triggers)
+		if (ZBX_DC_ITEM_UPDATE_TRIGGER_REFRESH == item->update_triggers)
 		{
 			itemtrig.first = item;
 			itemtrig.second = trigger;
@@ -5845,7 +5856,7 @@ static void	dc_trigger_update_cache(void)
 			}
 
 			item = (ZBX_DC_ITEM *)itemtrigs.values[i].first;
-			item->update_triggers = 0;
+			item->update_triggers = ZBX_DC_ITEM_UPDATE_TRIGGER_NONE;
 			item->triggers = (ZBX_DC_TRIGGER **)config->items.mem_realloc_func(item->triggers,
 					(size_t)(j - i + 1) * sizeof(ZBX_DC_TRIGGER *));
 
@@ -5948,6 +5959,43 @@ static void	dc_load_trigger_queue(zbx_hashset_t *trend_functions)
 	DBfree_result(result);
 }
 
+/******************************************************************************
+ *                                                                            *
+ * Purpose: add new items with triggers to value cache                        *
+ *                                                                            *
+ ******************************************************************************/
+static void	dc_add_new_items_to_valuecache(const zbx_vector_dc_item_ptr_t *items)
+{
+	if (0 != items->values_num)
+	{
+		zbx_vector_uint64_pair_t	vc_items;
+		int				i;
+
+		zbx_vector_uint64_pair_create(&vc_items);
+		zbx_vector_uint64_pair_reserve(&vc_items, items->values_num);
+
+		for (i = 0; i < items->values_num; i++)
+		{
+			if (ZBX_DC_ITEM_UPDATE_TRIGGER_REFRESH == items->values[i]->update_triggers)
+			{
+				zbx_uint64_pair_t	pair = {
+						.first = items->values[i]->itemid,
+						.second = (zbx_uint64_t)items->values[i]->value_type
+				};
+
+				zbx_vector_uint64_pair_append_ptr(&vc_items, &pair);
+			}
+			else
+				items->values[i]->update_triggers = ZBX_DC_ITEM_UPDATE_TRIGGER_NONE;
+		}
+
+		if (0 != items->values_num)
+			zbx_vc_add_new_items(&vc_items);
+
+		zbx_vector_uint64_pair_destroy(&vc_items);
+	}
+}
+
 /******************************************************************************
  *                                                                            *
  * Purpose: Synchronize configuration data from database                      *
@@ -5976,7 +6024,8 @@ void	DCsync_configuration(unsigned char mode)
 	zbx_dbsync_t	autoreg_config_sync;
 	zbx_uint64_t	update_flags = 0;
 
-	zbx_hashset_t		trend_queue;
+	zbx_hashset_t			trend_queue;
+	zbx_vector_dc_item_ptr_t	new_items, *pnew_items = NULL;
 
 	zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __func__);
 
@@ -5989,6 +6038,11 @@ void	DCsync_configuration(unsigned char mode)
 		zbx_hashset_create(&trend_queue, 1000, ZBX_DEFAULT_UINT64_HASH_FUNC, ZBX_DEFAULT_UINT64_COMPARE_FUNC);
 		dc_load_trigger_queue(&trend_queue);
 	}
+	else if (0 != (program_type & ZBX_PROGRAM_TYPE_SERVER))
+	{
+		zbx_vector_dc_item_ptr_create(&new_items);
+		pnew_items = &new_items;
+	}
 
 	/* global configuration must be synchronized directly with database */
 	zbx_dbsync_init(&config_sync, ZBX_DBSYNC_INIT);
@@ -6218,7 +6272,7 @@ void	DCsync_configuration(unsigned char mode)
 	/* relies on hosts, proxies and interfaces, must be after DCsync_{hosts,interfaces}() */
 
 	sec = zbx_time();
-	DCsync_items(&items_sync, flags);
+	DCsync_items(&items_sync, flags, pnew_items);
 	isec2 = zbx_time() - sec;
 
 	sec = zbx_time();
@@ -6267,6 +6321,12 @@ void	DCsync_configuration(unsigned char mode)
 	fsec2 = zbx_time() - sec;
 	FINISH_SYNC;
 
+	if (NULL != pnew_items)
+	{
+		dc_add_new_items_to_valuecache(pnew_items);
+		zbx_vector_dc_item_ptr_clear(pnew_items);
+	}
+
 	/* sync rest of the data */
 
 	sec = zbx_time();
@@ -6719,6 +6779,16 @@ out:
 
 	zbx_dbsync_free_env();
 
+	if (NULL != pnew_items)
+	{
+		/* Reset update trigger flags for items that could be left because of database errors. */
+		/* Can be done without locking as no other processes can remove items.                 */
+		for (i = 0; i < pnew_items->values_num; i++)
+			pnew_items->values[i]->update_triggers = ZBX_DC_ITEM_UPDATE_TRIGGER_NONE;
+
+		zbx_vector_dc_item_ptr_destroy(pnew_items);
+	}
+
 	if (SUCCEED == ZBX_CHECK_LOG_LEVEL(LOG_LEVEL_TRACE))
 		DCdump_configuration();
 
diff --git a/src/libs/zbxdbcache/dbconfig.h b/src/libs/zbxdbcache/dbconfig.h
index b7f3525cbf0..948e7061a18 100644
--- a/src/libs/zbxdbcache/dbconfig.h
+++ b/src/libs/zbxdbcache/dbconfig.h
@@ -316,6 +316,8 @@ typedef struct
 ZBX_DC_PSK;
 #endif
 
+ZBX_PTR_VECTOR_DECL(dc_item_ptr, ZBX_DC_ITEM *)
+
 #define ZBX_LOC_NOWHERE	0
 #define ZBX_LOC_QUEUE	1
 #define ZBX_LOC_POLLER	2
@@ -969,4 +971,8 @@ int	dc_expand_user_macros_len(const char *text, size_t text_len, zbx_uint64_t *h
 #define ZBX_TRIGGER_TIMER_FUNCTION_TREND	0x0004
 #define ZBX_TRIGGER_TIMER_FUNCTION		(ZBX_TRIGGER_TIMER_FUNCTION_TIME | ZBX_TRIGGER_TIMER_FUNCTION_TREND)
 
+#define ZBX_DC_ITEM_UPDATE_TRIGGER_NONE		0
+#define ZBX_DC_ITEM_UPDATE_TRIGGER_REFRESH	1
+#define ZBX_ITEM_UPDATE_TRIGGER_NEW_ITEM	2
+
 #endif
diff --git a/src/libs/zbxdbcache/dbhistoryconfig.c b/src/libs/zbxdbcache/dbhistoryconfig.c
index 3db8e3e8edd..f1aa615aa32 100644
--- a/src/libs/zbxdbcache/dbhistoryconfig.c
+++ b/src/libs/zbxdbcache/dbhistoryconfig.c
@@ -93,6 +93,8 @@ static void	dc_get_history_sync_item(zbx_history_sync_item_t *dst_item, const ZB
 			dst_item->trends_sec = 0;
 			dst_item->units = NULL;
 	}
+
+	dst_item->has_trigger = (ZBX_DC_ITEM_UPDATE_TRIGGER_NONE == src_item->update_triggers ? 0 : 1);
 }
 
 /******************************************************************************
diff --git a/src/libs/zbxdbcache/valuecache.c b/src/libs/zbxdbcache/valuecache.c
index 3e1d067387c..866863be460 100644
--- a/src/libs/zbxdbcache/valuecache.c
+++ b/src/libs/zbxdbcache/valuecache.c
@@ -2506,7 +2506,20 @@ int	zbx_vc_add_values(zbx_vector_ptr_t *history, int *ret_flush)
 	{
 		h = (ZBX_DC_HISTORY *)history->values[i];
 
-		if (NULL != (item = (zbx_vc_item_t *)zbx_hashset_search(&vc_cache->items, &h->itemid)))
+		item = (zbx_vc_item_t *)zbx_hashset_search(&vc_cache->items, &h->itemid);
+
+		if (NULL == item && 0 != (h->flags & ZBX_DC_FLAG_HASTRIGGER) && ZBX_VC_MODE_NORMAL == vc_cache->mode)
+		{
+			zbx_vc_item_t	item_local = {
+					.itemid = h->itemid,
+					.value_type = h->value_type,
+					.last_accessed = (int)time(NULL)
+			};
+
+			item = (zbx_vc_item_t *)zbx_hashset_insert(&vc_cache->items, &item_local, sizeof(item_local));
+		}
+
+		if (NULL != item)
 		{
 			zbx_history_record_t	record = {h->ts, h->value};
 			zbx_vc_chunk_t		*head = item->head;
@@ -2527,7 +2540,6 @@ int	zbx_vc_add_values(zbx_vector_ptr_t *history, int *ret_flush)
 			/* try to remove old (unused) chunks if a new chunk was added */
 			if (head != item->head)
 				vch_item_clean_cache(item);
-
 		}
 	}
 
@@ -2836,6 +2848,42 @@ void	zbx_vc_flush_stats(void)
 	zbx_vector_vc_itemupdate_clear(&vc_itemupdates);
 }
 
-#ifdef HAVE_TESTS
-#	include "../../../tests/libs/zbxdbcache/valuecache_test.c"
-#endif
+/******************************************************************************
+ *                                                                            *
+ * Purpose: add newly created items with triggers to value cache              *
+ *                                                                            *
+ ******************************************************************************/
+void	zbx_vc_add_new_items(const zbx_vector_uint64_pair_t *items)
+{
+	if (ZBX_VC_DISABLED == vc_state || 0 == items->values_num)
+		return;
+
+	WRLOCK_CACHE;
+
+	if (ZBX_VC_MODE_NORMAL == vc_cache->mode)
+	{
+		int	i;
+
+		for (i = 0; i < items->values_num; i++)
+		{
+			if (NULL != zbx_hashset_search(&vc_cache->items, &items->values[i].first))
+				continue;
+
+			zbx_vc_item_t	item_local = {
+					.itemid = items->values[i].first,
+					.value_type = (unsigned char)items->values[i].second,
+					.status = ZBX_ITEM_STATUS_CACHED_ALL,
+					.last_accessed = (int)time(NULL)
+
+			};
+
+			if (NULL == zbx_hashset_insert(&vc_cache->items, &item_local, sizeof(item_local)))
+			{
+				/* out of memory - cache will switch to low memory mode on next caching request */
+				break;
+			}
+		}
+	}
+
+	UNLOCK_CACHE;
+}
diff --git a/src/libs/zbxdbcache/valuecache.h b/src/libs/zbxdbcache/valuecache.h
index 03f359945e2..48908c709ed 100644
--- a/src/libs/zbxdbcache/valuecache.h
+++ b/src/libs/zbxdbcache/valuecache.h
@@ -118,4 +118,6 @@ void	zbx_vc_get_mem_stats(zbx_mem_stats_t *mem);
 void	zbx_vc_get_item_stats(zbx_vector_ptr_t *stats);
 void	zbx_vc_flush_stats(void);
 
+void	zbx_vc_add_new_items(const zbx_vector_uint64_pair_t *items);
+
 #endif	/* ZABBIX_VALUECACHE_H */
diff --git a/src/zabbix_server/dbconfig/dbconfig.c b/src/zabbix_server/dbconfig/dbconfig.c
index 59d5c5ac0b7..9187514f4ae 100644
--- a/src/zabbix_server/dbconfig/dbconfig.c
+++ b/src/zabbix_server/dbconfig/dbconfig.c
@@ -24,6 +24,7 @@
 #include "log.h"
 #include "dbcache.h"
 #include "zbxrtc.h"
+#include "../../libs/zbxdbcache/valuecache.h"
 
 extern int		CONFIG_CONFSYNCER_FREQUENCY;
 extern ZBX_THREAD_LOCAL unsigned char	process_type;
@@ -69,6 +70,8 @@ ZBX_THREAD_ENTRY(dbconfig_thread, args)
 
 	nextcheck = (int)time(NULL) + CONFIG_CONFSYNCER_FREQUENCY;
 
+	zbx_vc_enable();
+
 	while (ZBX_IS_RUNNING())
 	{
 		zbx_uint32_t	rtc_cmd;
diff --git a/tests/libs/zbxdbcache/Makefile.am b/tests/libs/zbxdbcache/Makefile.am
index d6a13a440e9..1badaa0f5bf 100644
--- a/tests/libs/zbxdbcache/Makefile.am
+++ b/tests/libs/zbxdbcache/Makefile.am
@@ -102,7 +102,7 @@ COMMON_WRAP_FUNCS = \
 zbx_vc_get_values_SOURCES = \
 	zbx_vc_common.c \
 	zbx_vc_get_values.c \
-	@top_srcdir@/src/libs/zbxdbcache/valuecache.c \
+	valuecache_test.c \
 	@top_srcdir@/src/libs/zbxhistory/history.c \
 	../../zbxmocktest.h
 
@@ -118,7 +118,7 @@ zbx_vc_get_values_CFLAGS = \
 zbx_vc_add_values_SOURCES = \
 	zbx_vc_common.c \
 	zbx_vc_add_values.c \
-	@top_srcdir@/src/libs/zbxdbcache/valuecache.c \
+	valuecache_test.c \
 	@top_srcdir@/src/libs/zbxhistory/history.c \
 	../../zbxmocktest.h
 
@@ -134,7 +134,7 @@ zbx_vc_add_values_CFLAGS = \
 zbx_vc_get_value_SOURCES = \
 	zbx_vc_common.c \
 	zbx_vc_get_value.c \
-	@top_srcdir@/src/libs/zbxdbcache/valuecache.c \
+	valuecache_test.c \
 	@top_srcdir@/src/libs/zbxhistory/history.c \
 	../../zbxmocktest.h
 
diff --git a/tests/libs/zbxdbcache/valuecache_test.c b/tests/libs/zbxdbcache/valuecache_test.c
index 934fc1399cc..3924c9ca5e9 100644
--- a/tests/libs/zbxdbcache/valuecache_test.c
+++ b/tests/libs/zbxdbcache/valuecache_test.c
@@ -17,7 +17,10 @@
 ** Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 **/
 
+#include "../../../src/libs/zbxdbcache/valuecache.c"
+
 #include "valuecache_test.h"
+#include "zbxmocktest.h"
 
 void	zbx_vc_set_mode(int mode)
 {
@@ -104,3 +107,45 @@ int	zbx_vc_get_cache_state(int *mode, zbx_uint64_t *hits, zbx_uint64_t *misses)
 
 	return SUCCEED;
 }
+
+/*
+ * cache working mode handling
+ */
+
+/******************************************************************************
+ *                                                                            *
+ * Purpose: sets value cache mode if the specified key is present in input    *
+ *          data                                                              *
+ *                                                                            *
+ ******************************************************************************/
+void	zbx_vcmock_set_mode(zbx_mock_handle_t hitem, const char *key)
+{
+	const char		*data;
+	zbx_mock_handle_t	hmode;
+	zbx_mock_error_t	err;
+
+	if (ZBX_MOCK_SUCCESS == zbx_mock_object_member(hitem, key, &hmode))
+	{
+		if (ZBX_MOCK_SUCCESS != (err = zbx_mock_string(hmode, &data)))
+			fail_msg("Cannot read \"%s\" parameter: %s", key, zbx_mock_error_string(err));
+
+		zbx_vc_set_mode(zbx_vcmock_str_to_cache_mode(data));
+	}
+}
+
+/******************************************************************************
+ *                                                                            *
+ * Purpose: converts value cache mode from text format                        *
+ *                                                                            *
+ ******************************************************************************/
+int	zbx_vcmock_str_to_cache_mode(const char *mode)
+{
+	if (0 == strcmp(mode, "ZBX_VC_MODE_NORMAL"))
+		return ZBX_VC_MODE_NORMAL;
+
+	if (0 == strcmp(mode, "ZBX_VC_MODE_LOWMEM"))
+		return ZBX_VC_MODE_LOWMEM;
+
+	fail_msg("Unknown value cache mode \"%s\"", mode);
+	return FAIL;
+}
diff --git a/tests/libs/zbxdbcache/valuecache_test.h b/tests/libs/zbxdbcache/valuecache_test.h
index 07dcd14d040..362b1deea3d 100644
--- a/tests/libs/zbxdbcache/valuecache_test.h
+++ b/tests/libs/zbxdbcache/valuecache_test.h
@@ -20,6 +20,8 @@
 #ifndef ZABBIX_VALUECACHE_TEST_H
 #define ZABBIX_VALUECACHE_TEST_H
 
+#include "zbxmockdata.h"
+
 void	zbx_vc_set_mode(int mode);
 int	zbx_vc_get_cached_values(zbx_uint64_t itemid, unsigned char value_type, zbx_vector_history_record_t *values);
 int	zbx_vc_precache_values(zbx_uint64_t itemid, int value_type, int seconds, int count, const zbx_timespec_t *ts);
@@ -27,4 +29,7 @@ int	zbx_vc_get_item_state(zbx_uint64_t itemid, int *status, int *active_range, i
 		int *db_cached_from);
 int	zbx_vc_get_cache_state(int *mode, zbx_uint64_t *hits, zbx_uint64_t *misses);
 
+void	zbx_vcmock_set_mode(zbx_mock_handle_t hitem, const char *key);
+int	zbx_vcmock_str_to_cache_mode(const char *mode);
+
 #endif
diff --git a/tests/mocks/valuecache/valuecache_mock.c b/tests/mocks/valuecache/valuecache_mock.c
index f9b423b0417..5a6039653e4 100644
--- a/tests/mocks/valuecache/valuecache_mock.c
+++ b/tests/mocks/valuecache/valuecache_mock.c
@@ -326,23 +326,6 @@ zbx_vcmock_ds_item_t	*zbx_vcmock_ds_first_item(void)
 	return (zbx_vcmock_ds_item_t *)zbx_hashset_iter_next(&iter);
 }
 
-/******************************************************************************
- *                                                                            *
- * Purpose: converts value cache mode from text format                        *
- *                                                                            *
- ******************************************************************************/
-int	zbx_vcmock_str_to_cache_mode(const char *mode)
-{
-	if (0 == strcmp(mode, "ZBX_VC_MODE_NORMAL"))
-		return ZBX_VC_MODE_NORMAL;
-
-	if (0 == strcmp(mode, "ZBX_VC_MODE_LOWMEM"))
-		return ZBX_VC_MODE_LOWMEM;
-
-	fail_msg("Unknown value cache mode \"%s\"", mode);
-	return FAIL;
-}
-
 /******************************************************************************
  *                                                                            *
  * Purpose: converts value cache item status from text format                 *
@@ -741,31 +724,6 @@ void	zbx_vcmock_get_request_params(zbx_mock_handle_t handle, zbx_uint64_t *itemi
 	zbx_strtime_to_timespec(zbx_mock_get_object_member_string(handle, "end"), end);
 }
 
-/*
- * cache working mode handling
- */
-
-/******************************************************************************
- *                                                                            *
- * Purpose: sets value cache mode if the specified key is present in input    *
- *          data                                                              *
- *                                                                            *
- ******************************************************************************/
-void	zbx_vcmock_set_mode(zbx_mock_handle_t hitem, const char *key)
-{
-	const char		*data;
-	zbx_mock_handle_t	hmode;
-	zbx_mock_error_t	err;
-
-	if (ZBX_MOCK_SUCCESS == zbx_mock_object_member(hitem, key, &hmode))
-	{
-		if (ZBX_MOCK_SUCCESS != (err = zbx_mock_string(hmode, &data)))
-			fail_msg("Cannot read \"%s\" parameter: %s", key, zbx_mock_error_string(err));
-
-		zbx_vc_set_mode(zbx_vcmock_str_to_cache_mode(data));
-	}
-}
-
 /*
  * time() emulation
  */
diff --git a/tests/mocks/valuecache/valuecache_mock.h b/tests/mocks/valuecache/valuecache_mock.h
index 5cf01958528..9470c2ea609 100644
--- a/tests/mocks/valuecache/valuecache_mock.h
+++ b/tests/mocks/valuecache/valuecache_mock.h
@@ -39,7 +39,6 @@ void	zbx_vcmock_ds_destroy(void);
 void	zbx_vcmock_ds_dump(void);
 zbx_vcmock_ds_item_t	*zbx_vcmock_ds_first_item(void);
 
-int	zbx_vcmock_str_to_cache_mode(const char *mode);
 int	zbx_vcmock_str_to_item_status(const char *str);
 
 void	zbx_vcmock_read_values(zbx_mock_handle_t hdata, unsigned char value_type, zbx_vector_history_record_t *values);
@@ -54,7 +53,6 @@ zbx_timespec_t	zbx_vcmock_get_ts(void);
 void	zbx_vcmock_set_cache_size(zbx_mock_handle_t hitem, const char *key);
 void	zbx_vcmock_get_request_params(zbx_mock_handle_t handle, zbx_uint64_t *itemid, unsigned char *value_type,
 		int *seconds, int *count, zbx_timespec_t *end);
-void	zbx_vcmock_set_mode(zbx_mock_handle_t hitem, const char *key);
 
 void	zbx_vcmock_get_dc_history(zbx_mock_handle_t handle, zbx_vector_ptr_t *history);
 void	zbx_vcmock_free_dc_history(void *ptr);
