diff --git a/library/RSL_Types.ttcn b/library/RSL_Types.ttcn
index 2171fc0..035d2e3 100644
--- a/library/RSL_Types.ttcn
+++ b/library/RSL_Types.ttcn
@@ -538,6 +538,14 @@
 		ies := *
 	}
 
+	template RSL_Message ts_RSL_MsgDiscType(template RSL_MessageDiscriminator m_disc,
+						template RSL_MessageType msg_type,
+						template RSL_IE_List ies := omit) := {
+		msg_disc := m_disc,
+		msg_type := msg_type,
+		ies := ies
+	}
+
 template RSL_Message tr_RSL_MsgType(template RSL_MessageType msg_type) := {
 	msg_disc := ?,
 	msg_type := msg_type,
@@ -708,6 +716,12 @@
 		msg_type := RSL_MT_MODE_MODIFY_NACK
 	}
 
+	/* 8.4.19 BTS -> BSC */
+	template RSL_Message ts_RSL_RF_CHAN_REL_ACK(RslChannelNr chan_nr) :=
+		ts_RSL_MsgDiscType(ts_RSL_MsgDisc(RSL_MDISC_DCHAN, false),
+				   RSL_MT_RF_CHAN_REL_ACK,
+				   { t_RSL_IE(RSL_IE_Body:{chan_nr := chan_nr}) });
+
 	/* COMMON CHANNEL MANAGEMENT MESSAGES */
 
 	/* 8.5.2 BTS -> BSC */
