diff --git a/lib/yang_wrappers.c b/lib/yang_wrappers.c
index dc049a374a..53f40e89b7 100644
--- a/lib/yang_wrappers.c
+++ b/lib/yang_wrappers.c
@@ -1046,6 +1046,17 @@ struct yang_data *yang_data_new_date_and_time(const char *xpath, time_t time)
 	return yang_data_new(xpath, timebuf);
 }
 
+float yang_dnode_get_bandwidth_ieee_float32(const struct lyd_node *dnode,
+					    const char *xpath_fmt, ...)
+{
+	const char *canon = YANG_DNODE_XPATH_GET_CANON(dnode, xpath_fmt);
+	float value;
+
+	assert(sscanf(canon, "%a", &value) == 1);
+
+	return value;
+}
+
 const char *yang_nexthop_type2str(uint32_t ntype)
 {
 	switch (ntype) {
diff --git a/lib/yang_wrappers.h b/lib/yang_wrappers.h
index 06e05872e3..4fb33542b3 100644
--- a/lib/yang_wrappers.h
+++ b/lib/yang_wrappers.h
@@ -200,6 +200,11 @@ extern void yang_str2mac(const char *value, struct ethaddr *mac);
 extern struct yang_data *yang_data_new_date_and_time(const char *xpath,
 						     time_t time);
 
+/* rt-types:bandwidth-ieee-float32 */
+extern float yang_dnode_get_bandwidth_ieee_float32(const struct lyd_node *dnode,
+						   const char *xpath_fmt, ...)
+	PRINTFRR(2, 3);
+
 /* nexthop enum2str */
 extern const char *yang_nexthop_type2str(uint32_t ntype);
 
diff --git a/yang/frr-zebra.yang b/yang/frr-zebra.yang
index ccaf10066b..8e22c334e7 100644
--- a/yang/frr-zebra.yang
+++ b/yang/frr-zebra.yang
@@ -2055,6 +2055,54 @@ module frr-zebra {
           description
             "Link metric for MPLS-TE purpose.";
         }
+        leaf max-bandwidth {
+          type rt-types:bandwidth-ieee-float32;
+          description
+            "Maximum bandwidth.";
+        }
+        leaf max-reservable-bandwidth {
+          type rt-types:bandwidth-ieee-float32;
+          description
+            "Maximum reservable bandwidth.";
+        }
+        container unreserved-bandwidths {
+          description
+            "All unreserved bandwidths.";
+          list unreserved-bandwidth {
+            key "priority";
+            leaf priority {
+              type uint8 {
+                range "0 .. 7";
+              }
+              description
+                "Priority from 0 to 7.";
+            }
+            leaf unreserved-bandwidth {
+              type rt-types:bandwidth-ieee-float32;
+              mandatory true;
+              description
+                "Unreserved bandwidth.";
+            }
+            description
+              "List of unreserved bandwidths for different
+                priorities.";
+          }
+        }
+        leaf residual-bandwidth {
+          type rt-types:bandwidth-ieee-float32;
+          description
+            "Unidirectional residual bandwidth.";
+        }
+        leaf available-bandwidth {
+          type rt-types:bandwidth-ieee-float32;
+          description
+            "Unidirectional available bandwidth.";
+        }
+        leaf utilized-bandwidth {
+          type rt-types:bandwidth-ieee-float32;
+          description
+            "Unidirectional utilized bandwidth.";
+        }
         choice admin-group-mode {
           description "Admin-group mode";
           case legacy {
diff --git a/zebra/interface.c b/zebra/interface.c
index 7e1bc3e4b2..b47ca6a5ca 100644
--- a/zebra/interface.c
+++ b/zebra/interface.c
@@ -4021,125 +4021,73 @@ DEFPY_YANG (link_params_metric,
 	return nb_cli_apply_changes(vty, NULL);
 }
 
-DEFUN (link_params_maxbw,
+DEFPY_YANG (link_params_maxbw,
        link_params_maxbw_cmd,
        "max-bw BANDWIDTH",
        "Maximum bandwidth that can be used\n"
        "Bytes/second (IEEE floating point format)\n")
 {
-	int idx_bandwidth = 1;
-	VTY_DECLVAR_CONTEXT(interface, ifp);
-	struct if_link_params *iflp = if_link_params_get(ifp);
-
+	char value[YANG_VALUE_MAXLEN];
 	float bw;
 
-	if (sscanf(argv[idx_bandwidth]->arg, "%g", &bw) != 1) {
-		vty_out(vty, "link_params_maxbw: fscanf: %s\n",
-			safe_strerror(errno));
+	if (sscanf(bandwidth, "%g", &bw) != 1) {
+		vty_out(vty, "Invalid bandwidth value\n");
 		return CMD_WARNING_CONFIG_FAILED;
 	}
 
-	/* Check that Maximum bandwidth is not lower than other bandwidth
-	 * parameters */
-	if (iflp && ((bw <= iflp->max_rsv_bw) || (bw <= iflp->unrsv_bw[0]) ||
-		     (bw <= iflp->unrsv_bw[1]) || (bw <= iflp->unrsv_bw[2]) ||
-		     (bw <= iflp->unrsv_bw[3]) || (bw <= iflp->unrsv_bw[4]) ||
-		     (bw <= iflp->unrsv_bw[5]) || (bw <= iflp->unrsv_bw[6]) ||
-		     (bw <= iflp->unrsv_bw[7]) || (bw <= iflp->ava_bw) ||
-		     (bw <= iflp->res_bw) || (bw <= iflp->use_bw))) {
-		vty_out(vty,
-			"Maximum Bandwidth could not be lower than others bandwidth\n");
-		return CMD_WARNING_CONFIG_FAILED;
-	}
+	snprintf(value, sizeof(value), "%a", bw);
 
-	if (!iflp)
-		iflp = if_link_params_enable(ifp);
+	nb_cli_enqueue_change(vty, "./max-bandwidth", NB_OP_MODIFY, value);
 
-	/* Update Maximum Bandwidth if needed */
-	link_param_cmd_set_float(ifp, &iflp->max_bw, LP_MAX_BW, bw);
-
-	return CMD_SUCCESS;
+	return nb_cli_apply_changes(vty, NULL);
 }
 
-DEFUN (link_params_max_rsv_bw,
+DEFPY_YANG (link_params_max_rsv_bw,
        link_params_max_rsv_bw_cmd,
        "max-rsv-bw BANDWIDTH",
        "Maximum bandwidth that may be reserved\n"
        "Bytes/second (IEEE floating point format)\n")
 {
-	int idx_bandwidth = 1;
-	VTY_DECLVAR_CONTEXT(interface, ifp);
-	struct if_link_params *iflp = if_link_params_get(ifp);
+	char value[YANG_VALUE_MAXLEN];
 	float bw;
 
-	if (sscanf(argv[idx_bandwidth]->arg, "%g", &bw) != 1) {
-		vty_out(vty, "link_params_max_rsv_bw: fscanf: %s\n",
-			safe_strerror(errno));
+	if (sscanf(bandwidth, "%g", &bw) != 1) {
+		vty_out(vty, "Invalid bandwidth value\n");
 		return CMD_WARNING_CONFIG_FAILED;
 	}
 
-	/* Check that bandwidth is not greater than maximum bandwidth parameter
-	 */
-	if (iflp && bw > iflp->max_bw) {
-		vty_out(vty,
-			"Maximum Reservable Bandwidth could not be greater than Maximum Bandwidth (%g)\n",
-			iflp->max_bw);
-		return CMD_WARNING_CONFIG_FAILED;
-	}
+	snprintf(value, sizeof(value), "%a", bw);
 
-	if (!iflp)
-		iflp = if_link_params_enable(ifp);
+	nb_cli_enqueue_change(vty, "./max-reservable-bandwidth", NB_OP_MODIFY,
+			      value);
 
-	/* Update Maximum Reservable Bandwidth if needed */
-	link_param_cmd_set_float(ifp, &iflp->max_rsv_bw, LP_MAX_RSV_BW, bw);
-
-	return CMD_SUCCESS;
+	return nb_cli_apply_changes(vty, NULL);
 }
 
-DEFUN (link_params_unrsv_bw,
+DEFPY_YANG (link_params_unrsv_bw,
        link_params_unrsv_bw_cmd,
-       "unrsv-bw (0-7) BANDWIDTH",
+       "unrsv-bw (0-7)$priority BANDWIDTH",
        "Unreserved bandwidth at each priority level\n"
        "Priority\n"
        "Bytes/second (IEEE floating point format)\n")
 {
-	int idx_number = 1;
-	int idx_bandwidth = 2;
-	VTY_DECLVAR_CONTEXT(interface, ifp);
-	struct if_link_params *iflp = if_link_params_get(ifp);
-	int priority;
+	char xpath[XPATH_MAXLEN];
+	char value[YANG_VALUE_MAXLEN];
 	float bw;
 
-	/* We don't have to consider about range check here. */
-	if (sscanf(argv[idx_number]->arg, "%d", &priority) != 1) {
-		vty_out(vty, "link_params_unrsv_bw: fscanf: %s\n",
-			safe_strerror(errno));
+	if (sscanf(bandwidth, "%g", &bw) != 1) {
+		vty_out(vty, "Invalid bandwidth value\n");
 		return CMD_WARNING_CONFIG_FAILED;
 	}
 
-	if (sscanf(argv[idx_bandwidth]->arg, "%g", &bw) != 1) {
-		vty_out(vty, "link_params_unrsv_bw: fscanf: %s\n",
-			safe_strerror(errno));
-		return CMD_WARNING_CONFIG_FAILED;
-	}
+	snprintf(xpath, sizeof(xpath),
+		 "./unreserved-bandwidths/unreserved-bandwidth[priority='%s']/unreserved-bandwidth",
+		 priority_str);
+	snprintf(value, sizeof(value), "%a", bw);
 
-	/* Check that bandwidth is not greater than maximum bandwidth parameter
-	 */
-	if (iflp && bw > iflp->max_bw) {
-		vty_out(vty,
-			"UnReserved Bandwidth could not be greater than Maximum Bandwidth (%g)\n",
-			iflp->max_bw);
-		return CMD_WARNING_CONFIG_FAILED;
-	}
+	nb_cli_enqueue_change(vty, xpath, NB_OP_MODIFY, value);
 
-	if (!iflp)
-		iflp = if_link_params_enable(ifp);
-
-	/* Update Unreserved Bandwidth if needed */
-	link_param_cmd_set_float(ifp, &iflp->unrsv_bw[priority], LP_UNRSV_BW,
-				 bw);
-
-	return CMD_SUCCESS;
+	return nb_cli_apply_changes(vty, NULL);
 }
 
 DEFPY_YANG(link_params_admin_grp, link_params_admin_grp_cmd,
@@ -4449,151 +4397,88 @@ DEFUN (no_link_params_pkt_loss,
 	return CMD_SUCCESS;
 }
 
-DEFUN (link_params_res_bw,
+DEFPY_YANG (link_params_res_bw,
        link_params_res_bw_cmd,
-       "res-bw BANDWIDTH",
+       "[no] res-bw ![BANDWIDTH]",
+       NO_STR
        "Unidirectional Residual Bandwidth\n"
        "Bytes/second (IEEE floating point format)\n")
 {
-	int idx_bandwidth = 1;
-	VTY_DECLVAR_CONTEXT(interface, ifp);
-	struct if_link_params *iflp = if_link_params_get(ifp);
+	char value[YANG_VALUE_MAXLEN];
 	float bw;
 
-	if (sscanf(argv[idx_bandwidth]->arg, "%g", &bw) != 1) {
-		vty_out(vty, "link_params_res_bw: fscanf: %s\n",
-			safe_strerror(errno));
-		return CMD_WARNING_CONFIG_FAILED;
+	if (!no) {
+		if (sscanf(bandwidth, "%g", &bw) != 1) {
+			vty_out(vty, "Invalid bandwidth value\n");
+			return CMD_WARNING_CONFIG_FAILED;
+		}
+
+		snprintf(value, sizeof(value), "%a", bw);
+
+		nb_cli_enqueue_change(vty, "./residual-bandwidth", NB_OP_MODIFY,
+				      value);
+	} else {
+		nb_cli_enqueue_change(vty, "./residual-bandwidth",
+				      NB_OP_DESTROY, NULL);
 	}
 
-	/* Check that bandwidth is not greater than maximum bandwidth parameter
-	 */
-	if (iflp && bw > iflp->max_bw) {
-		vty_out(vty,
-			"Residual Bandwidth could not be greater than Maximum Bandwidth (%g)\n",
-			iflp->max_bw);
-		return CMD_WARNING_CONFIG_FAILED;
-	}
-
-	if (!iflp)
-		iflp = if_link_params_enable(ifp);
-
-	/* Update Residual Bandwidth if needed */
-	link_param_cmd_set_float(ifp, &iflp->res_bw, LP_RES_BW, bw);
-
-	return CMD_SUCCESS;
+	return nb_cli_apply_changes(vty, NULL);
 }
 
-DEFUN (no_link_params_res_bw,
-       no_link_params_res_bw_cmd,
-       "no res-bw",
-       NO_STR
-       "Disable Unidirectional Residual Bandwidth on this interface\n")
-{
-	VTY_DECLVAR_CONTEXT(interface, ifp);
-
-	/* Unset Residual Bandwidth */
-	link_param_cmd_unset(ifp, LP_RES_BW);
-
-	return CMD_SUCCESS;
-}
-
-DEFUN (link_params_ava_bw,
+DEFPY_YANG (link_params_ava_bw,
        link_params_ava_bw_cmd,
-       "ava-bw BANDWIDTH",
+       "[no] ava-bw ![BANDWIDTH]",
+       NO_STR
        "Unidirectional Available Bandwidth\n"
        "Bytes/second (IEEE floating point format)\n")
 {
-	int idx_bandwidth = 1;
-	VTY_DECLVAR_CONTEXT(interface, ifp);
-	struct if_link_params *iflp = if_link_params_get(ifp);
+	char value[YANG_VALUE_MAXLEN];
 	float bw;
 
-	if (sscanf(argv[idx_bandwidth]->arg, "%g", &bw) != 1) {
-		vty_out(vty, "link_params_ava_bw: fscanf: %s\n",
-			safe_strerror(errno));
-		return CMD_WARNING_CONFIG_FAILED;
+	if (!no) {
+		if (sscanf(bandwidth, "%g", &bw) != 1) {
+			vty_out(vty, "Invalid bandwidth value\n");
+			return CMD_WARNING_CONFIG_FAILED;
+		}
+
+		snprintf(value, sizeof(value), "%a", bw);
+
+		nb_cli_enqueue_change(vty, "./available-bandwidth",
+				      NB_OP_MODIFY, value);
+	} else {
+		nb_cli_enqueue_change(vty, "./available-bandwidth",
+				      NB_OP_DESTROY, NULL);
 	}
 
-	/* Check that bandwidth is not greater than maximum bandwidth parameter
-	 */
-	if (iflp && bw > iflp->max_bw) {
-		vty_out(vty,
-			"Available Bandwidth could not be greater than Maximum Bandwidth (%g)\n",
-			iflp->max_bw);
-		return CMD_WARNING_CONFIG_FAILED;
-	}
-
-	if (!iflp)
-		iflp = if_link_params_enable(ifp);
-
-	/* Update Residual Bandwidth if needed */
-	link_param_cmd_set_float(ifp, &iflp->ava_bw, LP_AVA_BW, bw);
-
-	return CMD_SUCCESS;
+	return nb_cli_apply_changes(vty, NULL);
 }
 
-DEFUN (no_link_params_ava_bw,
-       no_link_params_ava_bw_cmd,
-       "no ava-bw",
-       NO_STR
-       "Disable Unidirectional Available Bandwidth on this interface\n")
-{
-	VTY_DECLVAR_CONTEXT(interface, ifp);
-
-	/* Unset Available Bandwidth */
-	link_param_cmd_unset(ifp, LP_AVA_BW);
-
-	return CMD_SUCCESS;
-}
-
-DEFUN (link_params_use_bw,
+DEFPY_YANG (link_params_use_bw,
        link_params_use_bw_cmd,
-       "use-bw BANDWIDTH",
+       "[no] use-bw ![BANDWIDTH]",
+       NO_STR
        "Unidirectional Utilised Bandwidth\n"
        "Bytes/second (IEEE floating point format)\n")
 {
-	int idx_bandwidth = 1;
-	VTY_DECLVAR_CONTEXT(interface, ifp);
-	struct if_link_params *iflp = if_link_params_get(ifp);
+	char value[YANG_VALUE_MAXLEN];
 	float bw;
 
-	if (sscanf(argv[idx_bandwidth]->arg, "%g", &bw) != 1) {
-		vty_out(vty, "link_params_use_bw: fscanf: %s\n",
-			safe_strerror(errno));
-		return CMD_WARNING_CONFIG_FAILED;
+	if (!no) {
+		if (sscanf(bandwidth, "%g", &bw) != 1) {
+			vty_out(vty, "Invalid bandwidth value\n");
+			return CMD_WARNING_CONFIG_FAILED;
+		}
+
+		snprintf(value, sizeof(value), "%a", bw);
+
+		nb_cli_enqueue_change(vty, "./utilized-bandwidth", NB_OP_MODIFY,
+				      value);
+	} else {
+		nb_cli_enqueue_change(vty, "./utilized-bandwidth",
+				      NB_OP_DESTROY, NULL);
 	}
 
-	/* Check that bandwidth is not greater than maximum bandwidth parameter
-	 */
-	if (iflp && bw > iflp->max_bw) {
-		vty_out(vty,
-			"Utilised Bandwidth could not be greater than Maximum Bandwidth (%g)\n",
-			iflp->max_bw);
-		return CMD_WARNING_CONFIG_FAILED;
-	}
-
-	if (!iflp)
-		iflp = if_link_params_enable(ifp);
-
-	/* Update Utilized Bandwidth if needed */
-	link_param_cmd_set_float(ifp, &iflp->use_bw, LP_USE_BW, bw);
-
-	return CMD_SUCCESS;
-}
-
-DEFUN (no_link_params_use_bw,
-       no_link_params_use_bw_cmd,
-       "no use-bw",
-       NO_STR
-       "Disable Unidirectional Utilised Bandwidth on this interface\n")
-{
-	VTY_DECLVAR_CONTEXT(interface, ifp);
-
-	/* Unset Utilised Bandwidth */
-	link_param_cmd_unset(ifp, LP_USE_BW);
-
-	return CMD_SUCCESS;
+	return nb_cli_apply_changes(vty, NULL);
 }
 
 static int ag_change(struct vty *vty, int argc, struct cmd_token **argv,
@@ -5167,11 +5052,8 @@ void zebra_if_init(void)
 	install_element(LINK_PARAMS_NODE, &link_params_pkt_loss_cmd);
 	install_element(LINK_PARAMS_NODE, &no_link_params_pkt_loss_cmd);
 	install_element(LINK_PARAMS_NODE, &link_params_ava_bw_cmd);
-	install_element(LINK_PARAMS_NODE, &no_link_params_ava_bw_cmd);
 	install_element(LINK_PARAMS_NODE, &link_params_res_bw_cmd);
-	install_element(LINK_PARAMS_NODE, &no_link_params_res_bw_cmd);
 	install_element(LINK_PARAMS_NODE, &link_params_use_bw_cmd);
-	install_element(LINK_PARAMS_NODE, &no_link_params_use_bw_cmd);
 	install_element(LINK_PARAMS_NODE, &link_params_affinity_cmd);
 	install_element(LINK_PARAMS_NODE, &link_params_affinity_mode_cmd);
 	install_element(LINK_PARAMS_NODE, &no_link_params_affinity_mode_cmd);
diff --git a/zebra/zebra_nb.c b/zebra/zebra_nb.c
index 608c204989..314c142d4e 100644
--- a/zebra/zebra_nb.c
+++ b/zebra/zebra_nb.c
@@ -372,6 +372,54 @@ const struct frr_yang_module_info frr_zebra_info = {
 				.destroy = lib_interface_zebra_link_params_metric_destroy,
 			}
 		},
+		{
+			.xpath = "/frr-interface:lib/interface/frr-zebra:zebra/link-params/max-bandwidth",
+			.cbs = {
+				.modify = lib_interface_zebra_link_params_max_bandwidth_modify,
+				.destroy = lib_interface_zebra_link_params_max_bandwidth_destroy,
+			}
+		},
+		{
+			.xpath = "/frr-interface:lib/interface/frr-zebra:zebra/link-params/max-reservable-bandwidth",
+			.cbs = {
+				.modify = lib_interface_zebra_link_params_max_reservable_bandwidth_modify,
+				.destroy = lib_interface_zebra_link_params_max_reservable_bandwidth_destroy,
+			}
+		},
+		{
+			.xpath = "/frr-interface:lib/interface/frr-zebra:zebra/link-params/unreserved-bandwidths/unreserved-bandwidth",
+			.cbs = {
+				.create = lib_interface_zebra_link_params_unreserved_bandwidths_unreserved_bandwidth_create,
+				.destroy = lib_interface_zebra_link_params_unreserved_bandwidths_unreserved_bandwidth_destroy,
+			}
+		},
+		{
+			.xpath = "/frr-interface:lib/interface/frr-zebra:zebra/link-params/unreserved-bandwidths/unreserved-bandwidth/unreserved-bandwidth",
+			.cbs = {
+				.modify = lib_interface_zebra_link_params_unreserved_bandwidths_unreserved_bandwidth_unreserved_bandwidth_modify,
+			}
+		},
+		{
+			.xpath = "/frr-interface:lib/interface/frr-zebra:zebra/link-params/residual-bandwidth",
+			.cbs = {
+				.modify = lib_interface_zebra_link_params_residual_bandwidth_modify,
+				.destroy = lib_interface_zebra_link_params_residual_bandwidth_destroy,
+			}
+		},
+		{
+			.xpath = "/frr-interface:lib/interface/frr-zebra:zebra/link-params/available-bandwidth",
+			.cbs = {
+				.modify = lib_interface_zebra_link_params_available_bandwidth_modify,
+				.destroy = lib_interface_zebra_link_params_available_bandwidth_destroy,
+			}
+		},
+		{
+			.xpath = "/frr-interface:lib/interface/frr-zebra:zebra/link-params/utilized-bandwidth",
+			.cbs = {
+				.modify = lib_interface_zebra_link_params_utilized_bandwidth_modify,
+				.destroy = lib_interface_zebra_link_params_utilized_bandwidth_destroy,
+			}
+		},
 		{
 			.xpath = "/frr-interface:lib/interface/frr-zebra:zebra/link-params/legacy-admin-group",
 			.cbs = {
diff --git a/zebra/zebra_nb.h b/zebra/zebra_nb.h
index 5b872a4d48..52e2590d02 100644
--- a/zebra/zebra_nb.h
+++ b/zebra/zebra_nb.h
@@ -106,6 +106,32 @@ int lib_interface_zebra_link_params_destroy(struct nb_cb_destroy_args *args);
 int lib_interface_zebra_link_params_metric_modify(struct nb_cb_modify_args *args);
 int lib_interface_zebra_link_params_metric_destroy(
 	struct nb_cb_destroy_args *args);
+int lib_interface_zebra_link_params_max_bandwidth_modify(
+	struct nb_cb_modify_args *args);
+int lib_interface_zebra_link_params_max_bandwidth_destroy(
+	struct nb_cb_destroy_args *args);
+int lib_interface_zebra_link_params_max_reservable_bandwidth_modify(
+	struct nb_cb_modify_args *args);
+int lib_interface_zebra_link_params_max_reservable_bandwidth_destroy(
+	struct nb_cb_destroy_args *args);
+int lib_interface_zebra_link_params_unreserved_bandwidths_unreserved_bandwidth_create(
+	struct nb_cb_create_args *args);
+int lib_interface_zebra_link_params_unreserved_bandwidths_unreserved_bandwidth_destroy(
+	struct nb_cb_destroy_args *args);
+int lib_interface_zebra_link_params_unreserved_bandwidths_unreserved_bandwidth_unreserved_bandwidth_modify(
+	struct nb_cb_modify_args *args);
+int lib_interface_zebra_link_params_residual_bandwidth_modify(
+	struct nb_cb_modify_args *args);
+int lib_interface_zebra_link_params_residual_bandwidth_destroy(
+	struct nb_cb_destroy_args *args);
+int lib_interface_zebra_link_params_available_bandwidth_modify(
+	struct nb_cb_modify_args *args);
+int lib_interface_zebra_link_params_available_bandwidth_destroy(
+	struct nb_cb_destroy_args *args);
+int lib_interface_zebra_link_params_utilized_bandwidth_modify(
+	struct nb_cb_modify_args *args);
+int lib_interface_zebra_link_params_utilized_bandwidth_destroy(
+	struct nb_cb_destroy_args *args);
 int lib_interface_zebra_legacy_admin_group_modify(
 	struct nb_cb_modify_args *args);
 int lib_interface_zebra_legacy_admin_group_destroy(
diff --git a/zebra/zebra_nb_config.c b/zebra/zebra_nb_config.c
index 5d77212f20..c155ae6a2e 100644
--- a/zebra/zebra_nb_config.c
+++ b/zebra/zebra_nb_config.c
@@ -1339,6 +1339,333 @@ int lib_interface_zebra_link_params_metric_destroy(struct nb_cb_destroy_args *ar
 	return NB_OK;
 }
 
+/*
+ * XPath: /frr-interface:lib/interface/frr-zebra:zebra/link-params/max-bandwidth
+ */
+int lib_interface_zebra_link_params_max_bandwidth_modify(
+	struct nb_cb_modify_args *args)
+{
+	struct interface *ifp;
+	struct if_link_params *iflp;
+	float max_bw, res_bw, ava_bw, use_bw;
+
+	max_bw = yang_dnode_get_bandwidth_ieee_float32(args->dnode, NULL);
+
+	switch (args->event) {
+	case NB_EV_VALIDATE:
+		if (yang_dnode_exists(args->dnode, "../residual-bandwidth")) {
+			res_bw = yang_dnode_get_bandwidth_ieee_float32(
+				args->dnode, "../residual-bandwidth");
+			if (max_bw < res_bw) {
+				snprintfrr(args->errmsg, args->errmsg_len,
+					   "max-bandwidth %f is less than residual-bandwidth %f",
+					   max_bw, res_bw);
+				return NB_ERR_VALIDATION;
+			}
+		}
+		if (yang_dnode_exists(args->dnode, "../available-bandwidth")) {
+			ava_bw = yang_dnode_get_bandwidth_ieee_float32(
+				args->dnode, "../available-bandwidth");
+			if (max_bw < ava_bw) {
+				snprintfrr(args->errmsg, args->errmsg_len,
+					   "max-bandwidth %f is less than available-bandwidth %f",
+					   max_bw, ava_bw);
+				return NB_ERR_VALIDATION;
+			}
+		}
+		if (yang_dnode_exists(args->dnode, "../utilized-bandwidth")) {
+			use_bw = yang_dnode_get_bandwidth_ieee_float32(
+				args->dnode, "../utilized-bandwidth");
+			if (max_bw < use_bw) {
+				snprintfrr(args->errmsg, args->errmsg_len,
+					   "max-bandwidth %f is less than utilized-bandwidth %f",
+					   max_bw, use_bw);
+				return NB_ERR_VALIDATION;
+			}
+		}
+		break;
+	case NB_EV_PREPARE:
+	case NB_EV_ABORT:
+		break;
+	case NB_EV_APPLY:
+		ifp = nb_running_get_entry(args->dnode, NULL, true);
+		iflp = if_link_params_get(ifp);
+		link_param_cmd_set_float(ifp, &iflp->max_bw, LP_MAX_BW, max_bw);
+		break;
+	}
+
+	return NB_OK;
+}
+
+int lib_interface_zebra_link_params_max_bandwidth_destroy(
+	struct nb_cb_destroy_args *args)
+{
+	if (args->event == NB_EV_VALIDATE) {
+		snprintfrr(args->errmsg, args->errmsg_len,
+			   "Removing max-bandwidth is not allowed");
+		return NB_ERR_VALIDATION;
+	}
+
+	return NB_OK;
+}
+
+/*
+ * XPath: /frr-interface:lib/interface/frr-zebra:zebra/link-params/max-reservable-bandwidth
+ */
+int lib_interface_zebra_link_params_max_reservable_bandwidth_modify(
+	struct nb_cb_modify_args *args)
+{
+	struct interface *ifp;
+	struct if_link_params *iflp;
+	float max_rsv_bw;
+
+	if (args->event != NB_EV_APPLY)
+		return NB_OK;
+
+	max_rsv_bw = yang_dnode_get_bandwidth_ieee_float32(args->dnode, NULL);
+
+	ifp = nb_running_get_entry(args->dnode, NULL, true);
+	iflp = if_link_params_get(ifp);
+	link_param_cmd_set_float(ifp, &iflp->max_rsv_bw, LP_MAX_RSV_BW,
+				 max_rsv_bw);
+
+	return NB_OK;
+}
+
+int lib_interface_zebra_link_params_max_reservable_bandwidth_destroy(
+	struct nb_cb_destroy_args *args)
+{
+	if (args->event == NB_EV_VALIDATE) {
+		snprintfrr(args->errmsg, args->errmsg_len,
+			   "Removing max-reservable-bandwidth is not allowed");
+		return NB_ERR_VALIDATION;
+	}
+
+	return NB_OK;
+}
+
+/*
+ * XPath: /frr-interface:lib/interface/frr-zebra:zebra/link-params/unreserved-bandwidths/unreserved-bandwidth
+ */
+int lib_interface_zebra_link_params_unreserved_bandwidths_unreserved_bandwidth_create(
+	struct nb_cb_create_args *args)
+{
+	struct interface *ifp;
+	struct if_link_params *iflp;
+	uint8_t priority;
+	float unrsv_bw;
+
+	if (args->event != NB_EV_APPLY)
+		return NB_OK;
+
+	priority = yang_dnode_get_uint8(args->dnode, "priority");
+	unrsv_bw = yang_dnode_get_bandwidth_ieee_float32(args->dnode,
+							 "unreserved-bandwidth");
+
+	ifp = nb_running_get_entry(args->dnode, NULL, true);
+	iflp = if_link_params_get(ifp);
+	link_param_cmd_set_float(ifp, &iflp->unrsv_bw[priority], LP_UNRSV_BW,
+				 unrsv_bw);
+
+	return NB_OK;
+}
+
+int lib_interface_zebra_link_params_unreserved_bandwidths_unreserved_bandwidth_destroy(
+	struct nb_cb_destroy_args *args)
+{
+	if (args->event == NB_EV_VALIDATE) {
+		snprintfrr(args->errmsg, args->errmsg_len,
+			   "Removing unreserved-bandwidth is not allowed");
+		return NB_ERR_VALIDATION;
+	}
+
+	return NB_OK;
+}
+
+/*
+ * XPath: /frr-interface:lib/interface/frr-zebra:zebra/link-params/unreserved-bandwidths/unreserved-bandwidth/unreserved-bandwidth
+ */
+int lib_interface_zebra_link_params_unreserved_bandwidths_unreserved_bandwidth_unreserved_bandwidth_modify(
+	struct nb_cb_modify_args *args)
+{
+	struct interface *ifp;
+	struct if_link_params *iflp;
+	uint8_t priority;
+	float unrsv_bw;
+
+	if (args->event != NB_EV_APPLY)
+		return NB_OK;
+
+	priority = yang_dnode_get_uint8(args->dnode, "../priority");
+	unrsv_bw = yang_dnode_get_bandwidth_ieee_float32(args->dnode, NULL);
+
+	ifp = nb_running_get_entry(args->dnode, NULL, true);
+	iflp = if_link_params_get(ifp);
+	link_param_cmd_set_float(ifp, &iflp->unrsv_bw[priority], LP_UNRSV_BW,
+				 unrsv_bw);
+
+	return NB_OK;
+}
+
+/*
+ * XPath: /frr-interface:lib/interface/frr-zebra:zebra/link-params/residual-bandwidth
+ */
+int lib_interface_zebra_link_params_residual_bandwidth_modify(
+	struct nb_cb_modify_args *args)
+{
+	struct interface *ifp;
+	struct if_link_params *iflp;
+	float max_bw, res_bw;
+
+	res_bw = yang_dnode_get_bandwidth_ieee_float32(args->dnode, NULL);
+
+	switch (args->event) {
+	case NB_EV_VALIDATE:
+		if (yang_dnode_exists(args->dnode, "../max-bandwidth")) {
+			max_bw =
+				yang_dnode_get_bandwidth_ieee_float32(args->dnode,
+								      "../max-bandwidth");
+			if (max_bw < res_bw) {
+				snprintfrr(args->errmsg, args->errmsg_len,
+					   "max-bandwidth %f is less than residual-bandwidth %f",
+					   max_bw, res_bw);
+				return NB_ERR_VALIDATION;
+			}
+		}
+		break;
+	case NB_EV_PREPARE:
+	case NB_EV_ABORT:
+		break;
+	case NB_EV_APPLY:
+		ifp = nb_running_get_entry(args->dnode, NULL, true);
+		iflp = if_link_params_get(ifp);
+		link_param_cmd_set_float(ifp, &iflp->res_bw, LP_RES_BW, res_bw);
+		break;
+	}
+
+	return NB_OK;
+}
+
+int lib_interface_zebra_link_params_residual_bandwidth_destroy(
+	struct nb_cb_destroy_args *args)
+{
+	struct interface *ifp;
+
+	if (args->event != NB_EV_APPLY)
+		return NB_OK;
+
+	ifp = nb_running_get_entry(args->dnode, NULL, true);
+	link_param_cmd_unset(ifp, LP_RES_BW);
+
+	return NB_OK;
+}
+
+/*
+ * XPath: /frr-interface:lib/interface/frr-zebra:zebra/link-params/available-bandwidth
+ */
+int lib_interface_zebra_link_params_available_bandwidth_modify(
+	struct nb_cb_modify_args *args)
+{
+	struct interface *ifp;
+	struct if_link_params *iflp;
+	float max_bw, ava_bw;
+
+	ava_bw = yang_dnode_get_bandwidth_ieee_float32(args->dnode, NULL);
+
+	switch (args->event) {
+	case NB_EV_VALIDATE:
+		if (yang_dnode_exists(args->dnode, "../max-bandwidth")) {
+			max_bw =
+				yang_dnode_get_bandwidth_ieee_float32(args->dnode,
+								      "../max-bandwidth");
+			if (max_bw < ava_bw) {
+				snprintfrr(args->errmsg, args->errmsg_len,
+					   "max-bandwidth %f is less than available-bandwidth %f",
+					   max_bw, ava_bw);
+				return NB_ERR_VALIDATION;
+			}
+		}
+		break;
+	case NB_EV_PREPARE:
+	case NB_EV_ABORT:
+		break;
+	case NB_EV_APPLY:
+		ifp = nb_running_get_entry(args->dnode, NULL, true);
+		iflp = if_link_params_get(ifp);
+		link_param_cmd_set_float(ifp, &iflp->ava_bw, LP_AVA_BW, ava_bw);
+		break;
+	}
+
+	return NB_OK;
+}
+
+int lib_interface_zebra_link_params_available_bandwidth_destroy(
+	struct nb_cb_destroy_args *args)
+{
+	struct interface *ifp;
+
+	if (args->event != NB_EV_APPLY)
+		return NB_OK;
+
+	ifp = nb_running_get_entry(args->dnode, NULL, true);
+	link_param_cmd_unset(ifp, LP_AVA_BW);
+
+	return NB_OK;
+}
+
+/*
+ * XPath: /frr-interface:lib/interface/frr-zebra:zebra/link-params/utilized-bandwidth
+ */
+int lib_interface_zebra_link_params_utilized_bandwidth_modify(
+	struct nb_cb_modify_args *args)
+{
+	struct interface *ifp;
+	struct if_link_params *iflp;
+	float max_bw, use_bw;
+
+	use_bw = yang_dnode_get_bandwidth_ieee_float32(args->dnode, NULL);
+
+	switch (args->event) {
+	case NB_EV_VALIDATE:
+		if (yang_dnode_exists(args->dnode, "../max-bandwidth")) {
+			max_bw =
+				yang_dnode_get_bandwidth_ieee_float32(args->dnode,
+								      "../max-bandwidth");
+			if (max_bw < use_bw) {
+				snprintfrr(args->errmsg, args->errmsg_len,
+					   "max-bandwidth %f is less than utilized-bandwidth %f",
+					   max_bw, use_bw);
+				return NB_ERR_VALIDATION;
+			}
+		}
+		break;
+	case NB_EV_PREPARE:
+	case NB_EV_ABORT:
+		break;
+	case NB_EV_APPLY:
+		ifp = nb_running_get_entry(args->dnode, NULL, true);
+		iflp = if_link_params_get(ifp);
+		link_param_cmd_set_float(ifp, &iflp->use_bw, LP_USE_BW, use_bw);
+		break;
+	}
+
+	return NB_OK;
+}
+
+int lib_interface_zebra_link_params_utilized_bandwidth_destroy(
+	struct nb_cb_destroy_args *args)
+{
+	struct interface *ifp;
+
+	if (args->event != NB_EV_APPLY)
+		return NB_OK;
+
+	ifp = nb_running_get_entry(args->dnode, NULL, true);
+	link_param_cmd_unset(ifp, LP_USE_BW);
+
+	return NB_OK;
+}
+
 /*
  * XPath:
  * /frr-interface:lib/interface/frr-zebra:zebra/link-params/legacy-admin-group