diff --git a/ie/apply_action.go b/ie/apply_action.go
index 3b5c991..c8af8fa 100644
--- a/ie/apply_action.go
+++ b/ie/apply_action.go
@@ -193,23 +193,18 @@ func (applyaction ApplyAction) IsZeroValue() bool {
 	return applyaction.Header.Length == 0
 }
 
-func DeserializeApplyAction(ieHeader Header, ieValue []byte) (ApplyAction, error) {
-	var applyaction ApplyAction
-
-	if ieHeader.Type != ApplyActionIEType {
-		return applyaction, fmt.Errorf("invalid IE type: expected %d, got %d", ApplyActionIEType, ieHeader.Type)
-	}
+func (applyaction ApplyAction) SetHeader(header Header) InformationElement {
+	applyaction.Header = header
+	return applyaction
+}
 
-	if ieHeader.Length != 2 {
-		return applyaction, fmt.Errorf("invalid length field for ApplyAction: expected 2, got %d", ieHeader.Length)
-	}
+func DeserializeApplyAction(ieValue []byte) (ApplyAction, error) {
+	var applyaction ApplyAction
 
 	if len(ieValue) != 2 {
-		return applyaction, fmt.Errorf("invalid length for ApplyAction: got %d bytes, want 2", len(ieValue))
+		return ApplyAction{}, fmt.Errorf("invalid length for ApplyAction: got %d bytes, want 2", len(ieValue))
 	}
 
-	applyaction.Header = ieHeader
-
 	// Deserialize the first byte (Octet 5)
 	byte5 := ieValue[0]
 	applyaction.DFRT = byte5&(1<<7) != 0
diff --git a/ie/apply_action_test.go b/ie/apply_action_test.go
index afae546..220da4f 100644
--- a/ie/apply_action_test.go
+++ b/ie/apply_action_test.go
@@ -114,25 +114,12 @@ func TestGivenApplyActionSerializedWhenDeserializeThenFieldsSetCorrectly(t *test
 
 	serialized := applyAction.Serialize()
 
-	ieHeader := ie.Header{
-		Type:   44,
-		Length: 2,
-	}
-
-	deserialized, err := ie.DeserializeApplyAction(ieHeader, serialized[4:])
+	deserialized, err := ie.DeserializeApplyAction(serialized[4:])
 
 	if err != nil {
 		t.Fatalf("Error deserializing ApplyAction: %v", err)
 	}
 
-	if deserialized.Header.Type != 44 {
-		t.Errorf("Expected IEType 44, got %d", deserialized.Header.Type)
-	}
-
-	if deserialized.Header.Length != 2 {
-		t.Errorf("Expected Length 2, got %d", deserialized.Header.Length)
-	}
-
 	if deserialized.DFRT != false {
 		t.Errorf("Expected no DFRT, got %v", deserialized.DFRT)
 	}
diff --git a/ie/cause.go b/ie/cause.go
index bc3c566..40a5cb2 100644
--- a/ie/cause.go
+++ b/ie/cause.go
@@ -65,15 +65,18 @@ func (cause Cause) IsZeroValue() bool {
 	return cause.Value == 0
 }
 
-func DeserializeCause(ieHeader Header, ieValue []byte) (Cause, error) {
-	var cause Cause
+func (cause Cause) SetHeader(ieHeader Header) InformationElement {
+	cause.Header = ieHeader
+	return cause
+}
+
+func DeserializeCause(ieValue []byte) (Cause, error) {
 
 	if len(ieValue) != 1 {
-		return cause, fmt.Errorf("invalid length for Cause: got %d bytes, want 1", len(ieValue))
+		return Cause{}, fmt.Errorf("invalid length for Cause: got %d bytes, want 1", len(ieValue))
 	}
 
 	return Cause{
-		Header: ieHeader,
-		Value:  CauseValue(ieValue[0]),
+		Value: CauseValue(ieValue[0]),
 	}, nil
 }
diff --git a/ie/create_far.go b/ie/create_far.go
index 0efb9ab..c60b8f2 100644
--- a/ie/create_far.go
+++ b/ie/create_far.go
@@ -47,25 +47,28 @@ func (createfar CreateFAR) IsZeroValue() bool {
 	return createfar.Header.Length == 0
 }
 
-func DeserializeCreateFAR(ieHeader Header, value []byte) (CreateFAR, error) {
+func (createfar CreateFAR) SetHeader(header Header) InformationElement {
+	createfar.Header = header
+	return createfar
+}
+
+func DeserializeCreateFAR(value []byte) (CreateFAR, error) {
 	var createfar CreateFAR
 
 	if len(value) < HeaderLength {
-		return createfar, fmt.Errorf("invalid length for CreateFAR: got %d bytes, want at least %d", len(value), HeaderLength)
+		return CreateFAR{}, fmt.Errorf("invalid length for CreateFAR: got %d bytes, want at least %d", len(value), HeaderLength)
 	}
 
-	createfar.Header = ieHeader
-
 	buffer := bytes.NewBuffer(value)
 
 	// Deserialize FARID
 	if buffer.Len() < 2 {
-		return createfar, fmt.Errorf("not enough data for FARID type")
+		return CreateFAR{}, fmt.Errorf("not enough data for FARID type")
 	}
 	faridIEType := binary.BigEndian.Uint16(buffer.Next(2))
 
 	if buffer.Len() < 2 {
-		return createfar, fmt.Errorf("not enough data for FARID length")
+		return CreateFAR{}, fmt.Errorf("not enough data for FARID length")
 	}
 
 	faridIELength := binary.BigEndian.Uint16(buffer.Next(2))
@@ -76,24 +79,29 @@ func DeserializeCreateFAR(ieHeader Header, value []byte) (CreateFAR, error) {
 		Length: faridIELength,
 	}
 
-	farid, err := DeserializeFARID(faridIEHEader, faridIEValue)
+	tempFarid, err := DeserializeFARID(faridIEValue)
 	if err != nil {
-		return createfar, fmt.Errorf("failed to deserialize FARID: %v", err)
+		return CreateFAR{}, fmt.Errorf("failed to deserialize FARID: %v", err)
+	}
+	farid, ok := tempFarid.SetHeader(faridIEHEader).(FARID)
+	if !ok {
+		return CreateFAR{}, fmt.Errorf("type assertion to FarID failed")
 	}
+
 	createfar.FARID = farid
 
 	if buffer.Len() < 2 {
-		return createfar, fmt.Errorf("not enough data for ApplyAction type")
+		return CreateFAR{}, fmt.Errorf("not enough data for ApplyAction type")
 	}
 	applyactionIEType := binary.BigEndian.Uint16(buffer.Next(2))
 
 	if buffer.Len() < 2 {
-		return createfar, fmt.Errorf("not enough data for ApplyAction length")
+		return CreateFAR{}, fmt.Errorf("not enough data for ApplyAction length")
 	}
 	applyactionIELength := binary.BigEndian.Uint16(buffer.Next(2))
 
 	if buffer.Len() < int(applyactionIELength) {
-		return createfar, fmt.Errorf("not enough data for ApplyAction value, expected %d, got %d", applyactionIELength, buffer.Len())
+		return CreateFAR{}, fmt.Errorf("not enough data for ApplyAction value, expected %d, got %d", applyactionIELength, buffer.Len())
 	}
 	applyactionIEValue := buffer.Next(int(applyactionIELength))
 
@@ -102,10 +110,16 @@ func DeserializeCreateFAR(ieHeader Header, value []byte) (CreateFAR, error) {
 		Length: applyactionIELength,
 	}
 
-	applyaction, err := DeserializeApplyAction(applyActionHeader, applyactionIEValue)
+	tempApplyaction, err := DeserializeApplyAction(applyactionIEValue)
 	if err != nil {
-		return createfar, fmt.Errorf("failed to deserialize ApplyAction: %v", err)
+		return CreateFAR{}, fmt.Errorf("failed to deserialize ApplyAction: %v", err)
+	}
+
+	applyaction, ok := tempApplyaction.SetHeader(applyActionHeader).(ApplyAction)
+	if !ok {
+		return CreateFAR{}, fmt.Errorf("type assertion to ApplyAction failed")
 	}
+
 	createfar.ApplyAction = applyaction
 	return createfar, nil
 }
diff --git a/ie/create_far_test.go b/ie/create_far_test.go
index 534fe1d..1f89388 100644
--- a/ie/create_far_test.go
+++ b/ie/create_far_test.go
@@ -26,14 +26,6 @@ func TestGivenCorrectValuesWhenNewFarThenFieldsSetCorrectly(t *testing.T) {
 		t.Fatalf("Error creating CreateFAR: %v", err)
 	}
 
-	if createFar.Header.Type != 3 {
-		t.Errorf("Expected IEType 3, got %d", createFar.Header.Type)
-	}
-
-	if createFar.Header.Length != 14 {
-		t.Errorf("Expected Length 14, got %d", createFar.Header.Length)
-	}
-
 	if createFar.FARID.Value != 1 {
 		t.Errorf("Expected FARID 1, got %d", createFar.FARID.Value)
 	}
@@ -113,25 +105,12 @@ func TestGivenSerializedWhenDeserializeCreateFarThenFieldsSetCorrectly(t *testin
 
 	serialized := createFar.Serialize()
 
-	ieHeader := ie.Header{
-		Type:   3,
-		Length: 14,
-	}
-
-	deserialized, err := ie.DeserializeCreateFAR(ieHeader, serialized[4:])
+	deserialized, err := ie.DeserializeCreateFAR(serialized[4:])
 
 	if err != nil {
 		t.Fatalf("Error deserializing CreateFAR: %v", err)
 	}
 
-	if deserialized.Header.Type != 3 {
-		t.Errorf("Expected IEType 3, got %d", deserialized.Header.Type)
-	}
-
-	if deserialized.Header.Length != 14 {
-		t.Errorf("Expected Length 14, got %d", deserialized.Header.Length)
-	}
-
 	if deserialized.FARID != farId {
 		t.Errorf("Expected FARID %v, got %v", farId, deserialized.FARID)
 	}
diff --git a/ie/create_pdr.go b/ie/create_pdr.go
index b328a34..aa3cccf 100644
--- a/ie/create_pdr.go
+++ b/ie/create_pdr.go
@@ -53,9 +53,13 @@ func (createPDR CreatePDR) Serialize() []byte {
 
 }
 
-func DeserializeCreatePDR(ieHeader Header, value []byte) (CreatePDR, error) {
+func (createPDR CreatePDR) SetHeader(header Header) InformationElement {
+	createPDR.Header = header
+	return createPDR
+}
+
+func DeserializeCreatePDR(value []byte) (CreatePDR, error) {
 	createPDR := CreatePDR{
-		Header:     ieHeader,
 		PDRID:      PDRID{},
 		Precedence: Precedence{},
 		PDI:        PDI{},
@@ -82,30 +86,43 @@ func DeserializeCreatePDR(ieHeader Header, value []byte) (CreatePDR, error) {
 				Type:   IEType(currentIEType),
 				Length: currentIELength,
 			}
-			pdrID, err := DeserializePDRID(pdrIDHeader, currentIEValue)
+
+			tempPdrID, err := DeserializePDRID(currentIEValue)
 			if err != nil {
 				return CreatePDR{}, fmt.Errorf("failed to deserialize PDR ID: %v", err)
 			}
+			pdrID, ok := tempPdrID.SetHeader(pdrIDHeader).(PDRID)
+			if !ok {
+				return CreatePDR{}, fmt.Errorf("type assertion to PDRID failed")
+			}
 			createPDR.PDRID = pdrID
 		case PrecedenceIEType:
 			precedenceHeader := Header{
 				Type:   IEType(currentIEType),
 				Length: currentIELength,
 			}
-			precedence, err := DeserializePrecedence(precedenceHeader, currentIEValue)
+			tempPrecedence, err := DeserializePrecedence(currentIEValue)
 			if err != nil {
 				return CreatePDR{}, fmt.Errorf("failed to deserialize Precedence: %v", err)
 			}
+			precedence, ok := tempPrecedence.SetHeader(precedenceHeader).(Precedence)
+			if !ok {
+				return CreatePDR{}, fmt.Errorf("type assertion to Precedence failed")
+			}
 			createPDR.Precedence = precedence
 		case PDIIEType:
-			pdiIEHEader := Header{
+			pdiIEHeader := Header{
 				Type:   IEType(currentIEType),
 				Length: currentIELength,
 			}
-			pdi, err := DeserializePDI(pdiIEHEader, currentIEValue)
+			tempPDI, err := DeserializePDI(currentIEValue)
 			if err != nil {
 				return CreatePDR{}, fmt.Errorf("failed to deserialize PDI: %v", err)
 			}
+			pdi, ok := tempPDI.SetHeader(pdiIEHeader).(PDI)
+			if !ok {
+				return CreatePDR{}, fmt.Errorf("type assertion to PDI failed")
+			}
 			createPDR.PDI = pdi
 		}
 
diff --git a/ie/create_pdr_test.go b/ie/create_pdr_test.go
index 3d69111..ce24473 100644
--- a/ie/create_pdr_test.go
+++ b/ie/create_pdr_test.go
@@ -41,14 +41,6 @@ func TestGivenCorrectParametersWhenNewCreatePDRThenFieldsSetCorrectly(t *testing
 		t.Fatalf("Error creating CreatePDR: %v", err)
 	}
 
-	if createPDR.Header.Type != 1 {
-		t.Errorf("Expected CreatePDR IEType 1, got %d", createPDR.Header.Type)
-	}
-
-	if createPDR.Header.Length != 29 {
-		t.Errorf("Expected CreatePDR length 29, got %d", createPDR.Header.Length)
-	}
-
 	if createPDR.PDRID != pdrID {
 		t.Errorf("Expected CreatePDR PDRID %v, got %v", pdrID, createPDR.PDRID)
 	}
@@ -145,25 +137,12 @@ func TestGivenSerializedWhenDeserializeCreatePDRThenFieldsSetCorrectly(t *testin
 
 	serialized := createPDR.Serialize()
 
-	ieHeader := ie.Header{
-		Type:   1,
-		Length: 17,
-	}
-
-	deserialized, err := ie.DeserializeCreatePDR(ieHeader, serialized[4:])
+	deserialized, err := ie.DeserializeCreatePDR(serialized[4:])
 
 	if err != nil {
 		t.Fatalf("Error deserializing CreatePDR: %v", err)
 	}
 
-	if deserialized.Header.Type != 1 {
-		t.Errorf("Expected CreatePDR IEType 1, got %d", deserialized.Header.Type)
-	}
-
-	if deserialized.Header.Length != 17 {
-		t.Errorf("Expected CreatePDR length 17, got %d", deserialized.Header.Length)
-	}
-
 	if deserialized.PDRID != pdrID {
 		t.Errorf("Expected CreatePDR PDRID %v, got %v", pdrID, deserialized.PDRID)
 	}
diff --git a/ie/farID.go b/ie/farID.go
index bd72efb..cf57ea1 100644
--- a/ie/farID.go
+++ b/ie/farID.go
@@ -39,17 +39,17 @@ func (farID FARID) IsZeroValue() bool {
 	return farID.Header.Length == 0
 }
 
-func DeserializeFARID(ieHeader Header, ieValue []byte) (FARID, error) {
+func (farID FARID) SetHeader(header Header) InformationElement {
+	farID.Header = header
+	return farID
+}
+
+func DeserializeFARID(ieValue []byte) (FARID, error) {
 	if len(ieValue) != 4 {
 		return FARID{}, fmt.Errorf("invalid length for FARID: got %d bytes, want 4", len(ieValue))
 	}
 
-	if ieHeader.Type != FARIDIEType {
-		return FARID{}, fmt.Errorf("invalid IE type for FARID: got %d, want %d", ieHeader.Type, FARIDIEType)
-	}
-
 	return FARID{
-		Header: ieHeader,
-		Value:  binary.BigEndian.Uint32(ieValue),
+		Value: binary.BigEndian.Uint32(ieValue),
 	}, nil
 }
diff --git a/ie/farID_test.go b/ie/farID_test.go
index 4f7e527..fa9de25 100644
--- a/ie/farID_test.go
+++ b/ie/farID_test.go
@@ -15,14 +15,6 @@ func TestGivenCorrectFarIDValueWhenNewFarIDThenFieldsSetCorrectly(t *testing.T)
 		t.Fatalf("Expected no error, got %v", err)
 	}
 
-	if farID.Header.Type != 108 {
-		t.Errorf("Expected IEType %d, got %d", 108, farID.Header.Type)
-	}
-
-	if farID.Header.Length != 4 {
-		t.Errorf("Expected Length %d, got %d", 4, farID.Header.Length)
-	}
-
 	if farID.Value != farIDValue {
 		t.Errorf("Expected FarIDValue %d, got %d", farIDValue, farID.Value)
 	}
@@ -38,24 +30,12 @@ func TestGivenFarIDSerializedWhenDeserializeThenFieldsSetCorrectly(t *testing.T)
 
 	farIDSerialized := farID.Serialize()
 
-	ieHeader := ie.Header{
-		Type:   108,
-		Length: 4,
-	}
-	deserializedFarID, err := ie.DeserializeFARID(ieHeader, farIDSerialized[4:])
+	deserializedFarID, err := ie.DeserializeFARID(farIDSerialized[4:])
 
 	if err != nil {
 		t.Fatalf("Expected no error, got %v", err)
 	}
 
-	if deserializedFarID.Header.Type != 108 {
-		t.Errorf("Expected IEType %d, got %d", 108, deserializedFarID.Header.Type)
-	}
-
-	if deserializedFarID.Header.Length != 4 {
-		t.Errorf("Expected Length %d, got %d", 4, deserializedFarID.Header.Length)
-	}
-
 	if deserializedFarID.Value != farIDValue {
 		t.Errorf("Expected FarIDValue %d, got %d", farIDValue, deserializedFarID.Value)
 	}
diff --git a/ie/fseid.go b/ie/fseid.go
index 515ba33..a09f1f1 100644
--- a/ie/fseid.go
+++ b/ie/fseid.go
@@ -85,7 +85,12 @@ func (fseid FSEID) Serialize() []byte {
 	return buf.Bytes()
 }
 
-func DeserializeFSEID(ieHeader Header, ieValue []byte) (FSEID, error) {
+func (fseid FSEID) SetHeader(ieHeader Header) InformationElement {
+	fseid.Header = ieHeader
+	return fseid
+}
+
+func DeserializeFSEID(ieValue []byte) (FSEID, error) {
 	v4 := ieValue[0]&0x02 > 0
 	v6 := ieValue[0]&0x01 > 0
 	seid := binary.BigEndian.Uint64(ieValue[1:9])
@@ -109,12 +114,11 @@ func DeserializeFSEID(ieHeader Header, ieValue []byte) (FSEID, error) {
 	}
 
 	return FSEID{
-		Header: ieHeader,
-		V4:     v4,
-		V6:     v6,
-		SEID:   seid,
-		IPv4:   ipv4,
-		IPv6:   ipv6,
+		V4:   v4,
+		V6:   v6,
+		SEID: seid,
+		IPv4: ipv4,
+		IPv6: ipv6,
 	}, nil
 }
 
diff --git a/ie/fseid_test.go b/ie/fseid_test.go
index bb242c1..b023071 100644
--- a/ie/fseid_test.go
+++ b/ie/fseid_test.go
@@ -16,14 +16,6 @@ func TestGivenValidIPv4AddressWhenNewFSEIDThenFieldsAreSetCorrectly(t *testing.T
 		t.Fatalf("Error creating FSEID: %v", err)
 	}
 
-	if fseid.Header.Type != 57 {
-		t.Errorf("Expected FSEID IEType 97, got %d", fseid.Header.Type)
-	}
-
-	if fseid.Header.Length != 13 {
-		t.Errorf("Expected FSEID length 13, got %d", fseid.Header.Length)
-	}
-
 	if fseid.V4 != true {
 		t.Errorf("Expected FSEID V4 true, got %v", fseid.V4)
 	}
@@ -54,14 +46,6 @@ func TestGivenValidIPv6AddressWhenNewFSEIDThenFieldsAreSetCorrectly(t *testing.T
 		t.Fatalf("Error creating FSEID: %v", err)
 	}
 
-	if fseid.Header.Type != 57 {
-		t.Errorf("Expected FSEID IEType 97, got %d", fseid.Header.Type)
-	}
-
-	if fseid.Header.Length != 25 {
-		t.Errorf("Expected FSEID length 25, got %d", fseid.Header.Length)
-	}
-
 	if fseid.V4 != false {
 		t.Errorf("Expected FSEID V4 false, got %v", fseid.V4)
 	}
@@ -92,14 +76,6 @@ func TestGivenIPv4AndIPv6AddressWhenNewFSEIDThenFieldsAreSetCorrectly(t *testing
 		t.Fatalf("Error creating FSEID: %v", err)
 	}
 
-	if fseid.Header.Type != 57 {
-		t.Errorf("Expected FSEID IEType 57, got %d", fseid.Header.Type)
-	}
-
-	if fseid.Header.Length != 29 {
-		t.Errorf("Expected FSEID length 29, got %d", fseid.Header.Length)
-	}
-
 	if fseid.V4 != true {
 		t.Errorf("Expected FSEID V4 true, got %v", fseid.V4)
 	}
@@ -141,25 +117,12 @@ func TestGivenIPv4SerializedWhenDeserializeThenFieldsSetCorrectly(t *testing.T)
 
 	serialized := fseid.Serialize()
 
-	ieHeader := ie.Header{
-		Type:   57,
-		Length: 13,
-	}
-
-	deserialized, err := ie.DeserializeFSEID(ieHeader, serialized[4:])
+	deserialized, err := ie.DeserializeFSEID(serialized[4:])
 
 	if err != nil {
 		t.Fatalf("Error deserializing FSEID: %v", err)
 	}
 
-	if deserialized.Header.Type != 57 {
-		t.Errorf("Expected FSEID IEType 57, got %d", deserialized.Header.Type)
-	}
-
-	if deserialized.Header.Length != 13 {
-		t.Errorf("Expected FSEID length 13, got %d", deserialized.Header.Length)
-	}
-
 	if deserialized.V4 != true {
 		t.Errorf("Expected FSEID V4 true, got %v", deserialized.V4)
 	}
diff --git a/ie/ie.go b/ie/ie.go
index 00df19a..bfe6380 100644
--- a/ie/ie.go
+++ b/ie/ie.go
@@ -30,6 +30,7 @@ const (
 type InformationElement interface {
 	Serialize() []byte
 	IsZeroValue() bool
+	SetHeader(Header) InformationElement
 }
 
 func DeserializeInformationElements(b []byte) ([]InformationElement, error) {
@@ -60,44 +61,45 @@ func DeserializeInformationElements(b []byte) ([]InformationElement, error) {
 		var ie InformationElement
 		switch ieHeader.Type {
 		case CauseIEType:
-			ie, err = DeserializeCause(ieHeader, ieValue)
+			ie, err = DeserializeCause(ieValue)
 		case NodeIDIEType:
-			ie, err = DeserializeNodeID(ieHeader, ieValue)
+			ie, err = DeserializeNodeID(ieValue)
 		case RecoveryTimeStampIEType:
-			ie, err = DeserializeRecoveryTimeStamp(ieHeader, ieValue)
+			ie, err = DeserializeRecoveryTimeStamp(ieValue)
 		case NodeReportTypeIEType:
-			ie, err = DeserializeNodeReportType(ieHeader, ieValue)
+			ie, err = DeserializeNodeReportType(ieValue)
 		case SourceIPAddressIEType:
-			ie, err = DeserializeSourceIPAddress(ieHeader, ieValue)
+			ie, err = DeserializeSourceIPAddress(ieValue)
 		case UPFunctionFeaturesIEType:
-			ie, err = DeserializeUPFunctionFeatures(ieHeader, ieValue)
+			ie, err = DeserializeUPFunctionFeatures(ieValue)
 		case FSEIDIEType:
-			ie, err = DeserializeFSEID(ieHeader, ieValue)
+			ie, err = DeserializeFSEID(ieValue)
 		case PDRIDIEType:
-			ie, err = DeserializePDRID(ieHeader, ieValue)
+			ie, err = DeserializePDRID(ieValue)
 		case PrecedenceIEType:
-			ie, err = DeserializePrecedence(ieHeader, ieValue)
+			ie, err = DeserializePrecedence(ieValue)
 		case SourceInterfaceIEType:
-			ie, err = DeserializeSourceInterface(ieHeader, ieValue)
+			ie, err = DeserializeSourceInterface(ieValue)
 		case PDIIEType:
-			ie, err = DeserializePDI(ieHeader, ieValue)
+			ie, err = DeserializePDI(ieValue)
 		case CreatePDRIEType:
-			ie, err = DeserializeCreatePDR(ieHeader, ieValue)
+			ie, err = DeserializeCreatePDR(ieValue)
 		case FARIDIEType:
-			ie, err = DeserializeFARID(ieHeader, ieValue)
+			ie, err = DeserializeFARID(ieValue)
 		case ApplyActionIEType:
-			ie, err = DeserializeApplyAction(ieHeader, ieValue)
+			ie, err = DeserializeApplyAction(ieValue)
 		case CreateFARIEType:
-			ie, err = DeserializeCreateFAR(ieHeader, ieValue)
+			ie, err = DeserializeCreateFAR(ieValue)
 		case ReportTypeIEType:
-			ie, err = DeserializeReportType(ieHeader, ieValue)
+			ie, err = DeserializeReportType(ieValue)
 		case UEIPAddressIEType:
-			ie, err = DeserializeUEIPAddress(ieHeader, ieValue)
+			ie, err = DeserializeUEIPAddress(ieValue)
 		default:
 			err = fmt.Errorf("unknown IE type %d", ieHeader.Type)
 		}
 
 		if ie != nil {
+			ie = ie.SetHeader(ieHeader)
 			ies = append(ies, ie)
 		}
 
diff --git a/ie/nodeId.go b/ie/nodeId.go
index ec28e61..440ee1e 100644
--- a/ie/nodeId.go
+++ b/ie/nodeId.go
@@ -88,16 +88,17 @@ func (n NodeID) IsZeroValue() bool {
 	return n.Header.Length == 0
 }
 
-func DeserializeNodeID(ieHeader Header, ieValue []byte) (NodeID, error) {
+func (n NodeID) SetHeader(ieHeader Header) InformationElement {
+	n.Header = ieHeader
+	return n
+}
+
+func DeserializeNodeID(ieValue []byte) (NodeID, error) {
 
 	if len(ieValue) < 1 {
 		return NodeID{}, fmt.Errorf("invalid length for NodeID: got %d bytes, expected at least 1", len(ieValue))
 	}
 
-	if uint16(ieHeader.Type) != uint16(NodeIDIEType) {
-		return NodeID{}, fmt.Errorf("invalid IE type: expected %d, got %d", NodeIDIEType, ieHeader.Type)
-	}
-
 	nodeIDType := NodeIDType(ieValue[0] & 0x0F)
 	if nodeIDType != IPv4 && nodeIDType != IPv6 && nodeIDType != FQDN {
 		return NodeID{}, fmt.Errorf("invalid NodeIDType: %d", nodeIDType)
@@ -114,9 +115,8 @@ func DeserializeNodeID(ieHeader Header, ieValue []byte) (NodeID, error) {
 	}
 
 	nodeID := NodeID{
-		Header: ieHeader,
-		Type:   nodeIDType,
-		Value:  ieValue[1:],
+		Type:  nodeIDType,
+		Value: ieValue[1:],
 	}
 
 	return nodeID, nil
diff --git a/ie/nodeId_test.go b/ie/nodeId_test.go
index 0c2dcdb..eb5ec08 100644
--- a/ie/nodeId_test.go
+++ b/ie/nodeId_test.go
@@ -124,21 +124,12 @@ func TestGivenSerializedWhenDeserializNodeIDThenFieldsSetCorrectly(t *testing.T)
 
 	serializedNodeID := nodeID.Serialize()
 
-	ieHeader := ie.Header{
-		Type:   60,
-		Length: 5,
-	}
-
-	deserializedNodeID, err := ie.DeserializeNodeID(ieHeader, serializedNodeID[4:])
+	deserializedNodeID, err := ie.DeserializeNodeID(serializedNodeID[4:])
 
 	if err != nil {
 		t.Fatalf("Expected no error, got %v", err)
 	}
 
-	if deserializedNodeID.Header.Type != 60 {
-		t.Errorf("Expected NodeID, got %d", deserializedNodeID.Header.Type)
-	}
-
 	if deserializedNodeID.Type != 0 {
 		t.Errorf("Expected NodeID type FQDN, got %d", deserializedNodeID.Type)
 	}
diff --git a/ie/nodeReportType.go b/ie/nodeReportType.go
index 7abd54c..2af13b8 100644
--- a/ie/nodeReportType.go
+++ b/ie/nodeReportType.go
@@ -56,16 +56,17 @@ func (nrt NodeReportType) IsZeroValue() bool {
 	return nrt.Header.Length == 0
 }
 
-func DeserializeNodeReportType(ieHeader Header, ieValue []byte) (NodeReportType, error) {
+func (nrt NodeReportType) SetHeader(header Header) InformationElement {
+	nrt.Header = header
+	return nrt
+}
+
+func DeserializeNodeReportType(ieValue []byte) (NodeReportType, error) {
 
 	if len(ieValue) < 1 {
 		return NodeReportType{}, fmt.Errorf("invalid length for NodeReportType: got %d bytes, expected at least 1", len(ieValue))
 	}
 
-	if uint16(ieHeader.Type) != uint16(NodeReportTypeIEType) {
-		return NodeReportType{}, fmt.Errorf("invalid IE type: expected %d, got %d", NodeReportTypeIEType, ieHeader.Type)
-	}
-
 	buf := bytes.NewBuffer(ieValue)
 
 	var octet5 byte
@@ -75,11 +76,10 @@ func DeserializeNodeReportType(ieHeader Header, ieValue []byte) (NodeReportType,
 	}
 
 	nrt := NodeReportType{
-		Header: ieHeader,
-		GPQR:   octet5&0x08 != 0,
-		CKDR:   octet5&0x04 != 0,
-		UPRR:   octet5&0x02 != 0,
-		UPFR:   octet5&0x01 != 0,
+		GPQR: octet5&0x08 != 0,
+		CKDR: octet5&0x04 != 0,
+		UPRR: octet5&0x02 != 0,
+		UPFR: octet5&0x01 != 0,
 	}
 
 	return nrt, nil
diff --git a/ie/pdi.go b/ie/pdi.go
index 1ac490d..4d9a538 100644
--- a/ie/pdi.go
+++ b/ie/pdi.go
@@ -49,13 +49,17 @@ func (pdi PDI) IsZeroValue() bool {
 	return pdi.Header.Length == 0
 }
 
-func DeserializePDI(ieHeader Header, ieValue []byte) (PDI, error) {
+func (pdi PDI) SetHeader(header Header) InformationElement {
+	pdi.Header = header
+	return pdi
+}
+
+func DeserializePDI(ieValue []byte) (PDI, error) {
 	if len(ieValue) < 1 {
 		return PDI{}, fmt.Errorf("invalid length for PDI: got %d bytes, want at least 1", len(ieValue))
 	}
 
 	pdi := PDI{
-		Header:          ieHeader,
 		SourceInterface: SourceInterface{},
 		UEIPAddress:     UEIPAddress{},
 	}
@@ -81,20 +85,31 @@ func DeserializePDI(ieHeader Header, ieValue []byte) (PDI, error) {
 				Type:   IEType(currentIEType),
 				Length: currentIELength,
 			}
-			sourceInterface, err := DeserializeSourceInterface(sourceInterfaceHeader, currentIEValue)
+
+			tempSourceInterface, err := DeserializeSourceInterface(currentIEValue)
 			if err != nil {
 				return PDI{}, fmt.Errorf("failed to deserialize Source Interface: %v", err)
 			}
+
+			sourceInterface, ok := tempSourceInterface.SetHeader(sourceInterfaceHeader).(SourceInterface)
+			if !ok {
+				return PDI{}, fmt.Errorf("type assertion to FarID failed")
+			}
+
 			pdi.SourceInterface = sourceInterface
 		case UEIPAddressIEType:
 			ueIPAddressHeader := Header{
 				Type:   IEType(currentIEType),
 				Length: currentIELength,
 			}
-			ueIPAddress, err := DeserializeUEIPAddress(ueIPAddressHeader, currentIEValue)
+			tempUeIPAddress, err := DeserializeUEIPAddress(currentIEValue)
 			if err != nil {
 				return PDI{}, fmt.Errorf("failed to deserialize UE IP Address: %v", err)
 			}
+			ueIPAddress, ok := tempUeIPAddress.SetHeader(ueIPAddressHeader).(UEIPAddress)
+			if !ok {
+				return PDI{}, fmt.Errorf("type assertion to FarID failed")
+			}
 			pdi.UEIPAddress = ueIPAddress
 		}
 		index += 4 + int(currentIELength)
diff --git a/ie/pdi_test.go b/ie/pdi_test.go
index 05fda8e..b5314f4 100644
--- a/ie/pdi_test.go
+++ b/ie/pdi_test.go
@@ -110,37 +110,16 @@ func TestGivenPDISerializedWhenDeserializeThenFieldsSetCorrectly(t *testing.T) {
 
 	pdiSerialized := pdi.Serialize()
 
-	ieHeader := ie.Header{
-		Type:   17,
-		Length: 11,
-	}
-
-	deserializedPDI, err := ie.DeserializePDI(ieHeader, pdiSerialized[4:])
+	deserializedPDI, err := ie.DeserializePDI(pdiSerialized[4:])
 
 	if err != nil {
 		t.Fatalf("Expected no error, got %v", err)
 	}
 
-	if deserializedPDI.Header.Type != 17 {
-		t.Errorf("Expected IEType %d, got %d", 17, deserializedPDI.Header.Type)
-	}
-
-	if deserializedPDI.Header.Length != 11 {
-		t.Errorf("Expected Length %d, got %d", 11, deserializedPDI.Header.Length)
-	}
-
 	if deserializedPDI.SourceInterface != sourceInterface {
 		t.Errorf("Expected SourceInterface %v, got %v", sourceInterface, deserializedPDI.SourceInterface)
 	}
 
-	if deserializedPDI.UEIPAddress.Header.Type != 93 {
-		t.Errorf("Expected UEIPAddress IEType %d, got %d", 93, deserializedPDI.UEIPAddress.Header.Type)
-	}
-
-	if deserializedPDI.UEIPAddress.Header.Length != 2 {
-		t.Errorf("Expected UEIPAddress Length %d, got %d", 2, deserializedPDI.UEIPAddress.Header.Length)
-	}
-
 	if deserializedPDI.UEIPAddress.IP6PL != true {
 		t.Errorf("Expected UEIPAddress IP6PL true, got %v", deserializedPDI.UEIPAddress.IP6PL)
 	}
diff --git a/ie/pdrID.go b/ie/pdrID.go
index 0965333..b0f8656 100644
--- a/ie/pdrID.go
+++ b/ie/pdrID.go
@@ -39,12 +39,16 @@ func (pdrID PDRID) IsZeroValue() bool {
 	return pdrID.Header.Length == 0
 }
 
-func DeserializePDRID(ieHeader Header, ieValue []byte) (PDRID, error) {
+func (pdrID PDRID) SetHeader(header Header) InformationElement {
+	pdrID.Header = header
+	return pdrID
+}
+
+func DeserializePDRID(ieValue []byte) (PDRID, error) {
 	if len(ieValue) != 2 {
 		return PDRID{}, fmt.Errorf("invalid length for PDRID: got %d bytes, want 2", len(ieValue))
 	}
 	return PDRID{
-		Header: ieHeader,
 		RuleID: binary.BigEndian.Uint16(ieValue),
 	}, nil
 }
diff --git a/ie/pdrID_test.go b/ie/pdrID_test.go
index c51b725..53b1382 100644
--- a/ie/pdrID_test.go
+++ b/ie/pdrID_test.go
@@ -39,24 +39,12 @@ func TestGivenPDRIDSerializedWhenDeserializeThenFieldsSetCorrectly(t *testing.T)
 
 	pdrIDSerialized := pdrID.Serialize()
 
-	ieHeader := ie.Header{
-		Type:   56,
-		Length: 2,
-	}
-	deserializedPDRID, err := ie.DeserializePDRID(ieHeader, pdrIDSerialized[4:])
+	deserializedPDRID, err := ie.DeserializePDRID(pdrIDSerialized[4:])
 
 	if err != nil {
 		t.Fatalf("Expected no error, got %v", err)
 	}
 
-	if deserializedPDRID.Header.Type != 56 {
-		t.Errorf("Expected IEType %d, got %d", 56, deserializedPDRID.Header.Type)
-	}
-
-	if deserializedPDRID.Header.Length != 2 {
-		t.Errorf("Expected Length %d, got %d", 2, deserializedPDRID.Header.Length)
-	}
-
 	if deserializedPDRID.RuleID != ruleID {
 		t.Errorf("Expected RuleID %d, got %d", ruleID, deserializedPDRID.RuleID)
 	}
diff --git a/ie/precedence.go b/ie/precedence.go
index fcb4122..96ce932 100644
--- a/ie/precedence.go
+++ b/ie/precedence.go
@@ -39,12 +39,16 @@ func (precedence Precedence) IsZeroValue() bool {
 	return precedence.Header.Length == 0
 }
 
-func DeserializePrecedence(ieHeader Header, ieValue []byte) (Precedence, error) {
+func (precedence Precedence) SetHeader(header Header) InformationElement {
+	precedence.Header = header
+	return precedence
+}
+
+func DeserializePrecedence(ieValue []byte) (Precedence, error) {
 	if len(ieValue) != 4 {
 		return Precedence{}, fmt.Errorf("invalid length for Precedence: got %d bytes, want 4", len(ieValue))
 	}
 	return Precedence{
-		Header: ieHeader,
-		Value:  binary.BigEndian.Uint32(ieValue),
+		Value: binary.BigEndian.Uint32(ieValue),
 	}, nil
 }
diff --git a/ie/precedence_test.go b/ie/precedence_test.go
index 5b16aed..f1c49e9 100644
--- a/ie/precedence_test.go
+++ b/ie/precedence_test.go
@@ -37,25 +37,13 @@ func TestGivenPrecedenceSerializedWhenDeserializeThenFieldsSetCorrectly(t *testi
 	}
 
 	precedenceSerialized := precedence.Serialize()
-	ieHeader := ie.Header{
-		Type:   29,
-		Length: 4,
-	}
 
-	deserializedPrecedence, err := ie.DeserializePrecedence(ieHeader, precedenceSerialized[4:])
+	deserializedPrecedence, err := ie.DeserializePrecedence(precedenceSerialized[4:])
 
 	if err != nil {
 		t.Fatalf("Expected no error, got %v", err)
 	}
 
-	if deserializedPrecedence.Header.Type != 29 {
-		t.Errorf("Expected IEType %d, got %d", 29, deserializedPrecedence.Header.Type)
-	}
-
-	if deserializedPrecedence.Header.Length != 4 {
-		t.Errorf("Expected Length %d, got %d", 4, deserializedPrecedence.Header.Length)
-	}
-
 	if deserializedPrecedence.Value != precedenceValue {
 		t.Errorf("Expected PrecedenceValue %d, got %d", precedenceValue, deserializedPrecedence.Value)
 	}
diff --git a/ie/recoveryTimeStamp.go b/ie/recoveryTimeStamp.go
index 9c29f9f..5a5056e 100644
--- a/ie/recoveryTimeStamp.go
+++ b/ie/recoveryTimeStamp.go
@@ -41,22 +41,19 @@ func (rt RecoveryTimeStamp) IsZeroValue() bool {
 	return rt.Value == 0
 }
 
-func DeserializeRecoveryTimeStamp(ieHeader Header, ieValue []byte) (RecoveryTimeStamp, error) {
+func (rt RecoveryTimeStamp) SetHeader(ieHeader Header) InformationElement {
+	rt.Header = ieHeader
+	return rt
+}
 
-	if uint16(ieHeader.Type) != uint16(RecoveryTimeStampIEType) {
-		return RecoveryTimeStamp{}, fmt.Errorf("invalid IE type for RecoveryTimeStamp: expected %d, got %d", RecoveryTimeStampIEType, ieHeader.Type)
-	}
-	if ieHeader.Length != 4 {
-		return RecoveryTimeStamp{}, fmt.Errorf("invalid length for RecoveryTimeStamp: expected 4, got %d", ieHeader.Length)
-	}
+func DeserializeRecoveryTimeStamp(ieValue []byte) (RecoveryTimeStamp, error) {
 
 	if len(ieValue) < 4 {
 		return RecoveryTimeStamp{}, fmt.Errorf("invalid length for RecoveryTimeStamp value: expected at least 4 bytes, got %d", len(ieValue))
 	}
 
 	rt := RecoveryTimeStamp{
-		Header: ieHeader,
-		Value:  int64(binary.BigEndian.Uint32(ieValue)),
+		Value: int64(binary.BigEndian.Uint32(ieValue)),
 	}
 	return rt, nil
 }
diff --git a/ie/recoveryTimeStamp_test.go b/ie/recoveryTimeStamp_test.go
index 98dc091..ac76fe8 100644
--- a/ie/recoveryTimeStamp_test.go
+++ b/ie/recoveryTimeStamp_test.go
@@ -40,25 +40,13 @@ func TestGivenRecoveryTimeStampSerializedWhenDeserializeThenFieldsSetCorrectly(t
 	}
 
 	recoveryTimeStampSerialized := recoveryTimeStamp.Serialize()
-	ieHeader := ie.Header{
-		Type:   96,
-		Length: 4,
-	}
 
-	deserializedRecoveryTimeStamp, err := ie.DeserializeRecoveryTimeStamp(ieHeader, recoveryTimeStampSerialized[4:])
+	deserializedRecoveryTimeStamp, err := ie.DeserializeRecoveryTimeStamp(recoveryTimeStampSerialized[4:])
 
 	if err != nil {
 		t.Fatalf("Expected no error, got %v", err)
 	}
 
-	if deserializedRecoveryTimeStamp.Header.Type != 96 {
-		t.Errorf("Expected IEType %d, got %d", 96, deserializedRecoveryTimeStamp.Header.Type)
-	}
-
-	if deserializedRecoveryTimeStamp.Header.Length != 4 {
-		t.Errorf("Expected Length %d, got %d", 4, deserializedRecoveryTimeStamp.Header.Length)
-	}
-
 	// Validate that secodns match num of seconds since 1900
 	if deserializedRecoveryTimeStamp.Value != time.Unix()+2208988800 {
 		t.Errorf("Expected Value %d, got %d", time.Unix()+2208988800, deserializedRecoveryTimeStamp.Value)
diff --git a/ie/reportType.go b/ie/reportType.go
index b218575..e9aa96e 100644
--- a/ie/reportType.go
+++ b/ie/reportType.go
@@ -2,7 +2,6 @@ package ie
 
 import (
 	"bytes"
-	"fmt"
 )
 
 type Report int
@@ -55,10 +54,12 @@ func (reportType ReportType) IsZeroValue() bool {
 	return reportType.Header.Length == 0
 }
 
-func DeserializeReportType(ieHeader Header, ieValue []byte) (ReportType, error) {
-	if len(ieValue) != int(ieHeader.Length) {
-		return ReportType{}, fmt.Errorf("invalid length for ReportType")
-	}
+func (reportType ReportType) SetHeader(header Header) InformationElement {
+	reportType.Header = header
+	return reportType
+}
+
+func DeserializeReportType(ieValue []byte) (ReportType, error) {
 
 	var reports []Report
 	reportsByte := ieValue[0]
@@ -70,7 +71,6 @@ func DeserializeReportType(ieHeader Header, ieValue []byte) (ReportType, error)
 	}
 
 	return ReportType{
-		Header:  ieHeader,
 		Reports: reports,
 	}, nil
 }
diff --git a/ie/reportType_test.go b/ie/reportType_test.go
index 64fd02f..8cbbaf7 100644
--- a/ie/reportType_test.go
+++ b/ie/reportType_test.go
@@ -47,24 +47,11 @@ func TestGivenSerializedWhenDeserializeReportTypeThenFieldsSetCorrectly(t *testi
 
 	serializedReportType := reportType.Serialize()
 
-	ieHeader := ie.Header{
-		Type:   ie.ReportTypeIEType,
-		Length: 1,
-	}
-
-	deserializedReportType, err := ie.DeserializeReportType(ieHeader, serializedReportType[4:])
+	deserializedReportType, err := ie.DeserializeReportType(serializedReportType[4:])
 	if err != nil {
 		t.Fatalf("Unexpected error: %v", err)
 	}
 
-	if deserializedReportType.Header.Type != ie.ReportTypeIEType {
-		t.Errorf("Expected IE type %d, got %d", ie.ReportTypeIEType, deserializedReportType.Header.Type)
-	}
-
-	if deserializedReportType.Header.Length != 1 {
-		t.Errorf("Expected length 1, got %d", deserializedReportType.Header.Length)
-	}
-
 	if len(deserializedReportType.Reports) != 2 {
 		t.Errorf("Expected 2 reports, got %d", len(deserializedReportType.Reports))
 	}
diff --git a/ie/sourceIPAddress.go b/ie/sourceIPAddress.go
index 59c2863..8a48da7 100644
--- a/ie/sourceIPAddress.go
+++ b/ie/sourceIPAddress.go
@@ -101,7 +101,12 @@ func (sourceIPAddress SourceIPAddress) Serialize() []byte {
 	return buf.Bytes()
 }
 
-func DeserializeSourceIPAddress(ieHeader Header, ieValue []byte) (SourceIPAddress, error) {
+func (sourceIPAddress SourceIPAddress) SetHeader(header Header) InformationElement {
+	sourceIPAddress.Header = header
+	return sourceIPAddress
+}
+
+func DeserializeSourceIPAddress(ieValue []byte) (SourceIPAddress, error) {
 	var mpl bool
 	var v4 bool
 	var v6 bool
@@ -127,15 +132,12 @@ func DeserializeSourceIPAddress(ieHeader Header, ieValue []byte) (SourceIPAddres
 		}
 	}
 
-	sourceIPAddress := SourceIPAddress{
-		Header:           ieHeader,
+	return SourceIPAddress{
 		MPL:              mpl,
 		V4:               v4,
 		V6:               v6,
 		IPv4Address:      ipv4Address,
 		IPv6Address:      ipv6Address,
 		MaskPrefixLength: maskPrefixLength,
-	}
-
-	return sourceIPAddress, nil
+	}, nil
 }
diff --git a/ie/sourceIPAddress_test.go b/ie/sourceIPAddress_test.go
index ea88002..5992994 100644
--- a/ie/sourceIPAddress_test.go
+++ b/ie/sourceIPAddress_test.go
@@ -82,25 +82,12 @@ func TestGivenSerializedAddressWhenDeserializeThenFieldsSetCorrectly(t *testing.
 
 	serializedSourceIPAddress := sourceIPAddress.Serialize()
 
-	ieHeader := ie.Header{
-		Type:   192,
-		Length: 6,
-	}
-
-	deserializedSourceIPAddress, err := ie.DeserializeSourceIPAddress(ieHeader, serializedSourceIPAddress[4:])
+	deserializedSourceIPAddress, err := ie.DeserializeSourceIPAddress(serializedSourceIPAddress[4:])
 
 	if err != nil {
 		t.Fatalf("Error deserializing SourceIPAddress: %v", err)
 	}
 
-	if deserializedSourceIPAddress.Header.Type != 192 {
-		t.Errorf("Expected NodeID, got %d", deserializedSourceIPAddress.Header.Type)
-	}
-
-	if deserializedSourceIPAddress.Header.Length != 6 {
-		t.Errorf("Expected NodeID length 5, got %d", deserializedSourceIPAddress.Header.Length)
-	}
-
 	if deserializedSourceIPAddress.MPL != true {
 		t.Errorf("Expected NodeID MPL true, got %v", deserializedSourceIPAddress.MPL)
 	}
diff --git a/ie/sourceInterface.go b/ie/sourceInterface.go
index 8734f67..acf716d 100644
--- a/ie/sourceInterface.go
+++ b/ie/sourceInterface.go
@@ -43,14 +43,18 @@ func (sourceInterface SourceInterface) IsZeroValue() bool {
 	return sourceInterface.Header.Length == 0
 }
 
-func DeserializeSourceInterface(ieHeader Header, ieValue []byte) (SourceInterface, error) {
+func (sourceInterface SourceInterface) SetHeader(header Header) InformationElement {
+	sourceInterface.Header = header
+	return sourceInterface
+}
+
+func DeserializeSourceInterface(ieValue []byte) (SourceInterface, error) {
 	if len(ieValue) != 1 {
 		return SourceInterface{}, fmt.Errorf("invalid length for PDRID: got %d bytes, want 2", len(ieValue))
 	}
 	value := int(ieValue[0] & 0x0F)
 
 	return SourceInterface{
-		Header: ieHeader,
-		Value:  value,
+		Value: value,
 	}, nil
 }
diff --git a/ie/sourceInterface_test.go b/ie/sourceInterface_test.go
index 7146ea6..336509f 100644
--- a/ie/sourceInterface_test.go
+++ b/ie/sourceInterface_test.go
@@ -38,25 +38,12 @@ func TestGivenSourceInterfaceSerializedWhenDeserializeThenFieldsSetCorrectly(t *
 
 	sourceInterfaceSerialized := sourceInterface.Serialize()
 
-	ieHeader := ie.Header{
-		Type:   20,
-		Length: 1,
-	}
-
-	deserializedSourceInterface, err := ie.DeserializeSourceInterface(ieHeader, sourceInterfaceSerialized[4:])
+	deserializedSourceInterface, err := ie.DeserializeSourceInterface(sourceInterfaceSerialized[4:])
 
 	if err != nil {
 		t.Fatalf("Expected no error, got %v", err)
 	}
 
-	if deserializedSourceInterface.Header.Type != 20 {
-		t.Errorf("Expected IEType %d, got %d", 20, deserializedSourceInterface.Header.Type)
-	}
-
-	if deserializedSourceInterface.Header.Length != 1 {
-		t.Errorf("Expected Length %d, got %d", 1, deserializedSourceInterface.Header.Length)
-	}
-
 	if deserializedSourceInterface.Value != value {
 		t.Errorf("Expected Value %d, got %d", value, deserializedSourceInterface.Value)
 	}
diff --git a/ie/ue_ip_address.go b/ie/ue_ip_address.go
index ae8a43a..d98b7c0 100644
--- a/ie/ue_ip_address.go
+++ b/ie/ue_ip_address.go
@@ -160,18 +160,17 @@ func (ueIPaddress UEIPAddress) Serialize() []byte {
 	return buf.Bytes()
 }
 
-func DeserializeUEIPAddress(ieHeader Header, ieValue []byte) (UEIPAddress, error) {
+func (ueIPaddress UEIPAddress) SetHeader(ieHeader Header) InformationElement {
+	ueIPaddress.Header = ieHeader
+	return ueIPaddress
+}
+
+func DeserializeUEIPAddress(ieValue []byte) (UEIPAddress, error) {
 	if len(ieValue) < 1 {
 		return UEIPAddress{}, fmt.Errorf("invalid length for UEIPAddress")
 	}
 
-	if ieHeader.Type != UEIPAddressIEType {
-		return UEIPAddress{}, fmt.Errorf("invalid IE type for UEIPAddress")
-	}
-
-	ueIPAddress := UEIPAddress{
-		Header: ieHeader,
-	}
+	ueIPAddress := UEIPAddress{}
 
 	octet5 := ieValue[0]
 	ueIPAddress.IP6PL = octet5&(1<<7) > 0
diff --git a/ie/ue_ip_address_test.go b/ie/ue_ip_address_test.go
index cdb7ce9..e22656e 100644
--- a/ie/ue_ip_address_test.go
+++ b/ie/ue_ip_address_test.go
@@ -327,25 +327,12 @@ func TestGivenSerializesWhenDeserializeUEIPAddressThenFieldsSetCorrectly(t *test
 
 	serializedUEIPAddress := ueIPAddress.Serialize()
 
-	ieHeader := ie.Header{
-		Type:   93,
-		Length: 2,
-	}
-
-	deserialized, err := ie.DeserializeUEIPAddress(ieHeader, serializedUEIPAddress[4:])
+	deserialized, err := ie.DeserializeUEIPAddress(serializedUEIPAddress[4:])
 
 	if err != nil {
 		t.Fatalf("Error deserializing UEIPAddress: %v", err)
 	}
 
-	if deserialized.Header.Type != 93 {
-		t.Errorf("Expected UEIPAddress, got %d", deserialized.Header.Type)
-	}
-
-	if deserialized.Header.Length != 2 {
-		t.Errorf("Expected UEIPAddress length 2, got %d", deserialized.Header.Length)
-	}
-
 	if deserialized.IP6PL != true {
 		t.Errorf("Expected UEIPAddress IP6PL true, got %v", deserialized.IP6PL)
 	}
diff --git a/ie/upFunctionFeatures.go b/ie/upFunctionFeatures.go
index 9758159..44f0118 100644
--- a/ie/upFunctionFeatures.go
+++ b/ie/upFunctionFeatures.go
@@ -113,26 +113,25 @@ func (ie UPFunctionFeatures) IsZeroValue() bool {
 	return ie.Header.Length == 0
 }
 
-func DeserializeUPFunctionFeatures(ieHeader Header, ieValue []byte) (UPFunctionFeatures, error) {
-	if ieHeader.Type != 43 {
-		return UPFunctionFeatures{}, fmt.Errorf("incorrect IE type")
-	}
-	if len(ieValue) != int(ieHeader.Length) {
-		return UPFunctionFeatures{}, fmt.Errorf("incorrect length: expected %d, got %d", ieHeader.Length, len(ieValue))
-	}
+func (ie UPFunctionFeatures) SetHeader(header Header) InformationElement {
+	ie.Header = header
+	return ie
+}
 
-	upFuncFeatures := UPFunctionFeatures{
-		Header:                       ieHeader,
-		SupportedFeatures:            make([]byte, 0),
-		AdditionalSupportedFeatures1: make([]byte, 0),
-		AdditionalSupportedFeatures2: make([]byte, 0),
+func DeserializeUPFunctionFeatures(ieValue []byte) (UPFunctionFeatures, error) {
+	upFuncFeatures := UPFunctionFeatures{}
+
+	if len(ieValue) < 2 {
+		return UPFunctionFeatures{}, fmt.Errorf("invalid UPFunctionFeatures length: got %d bytes, expected at least 2", len(ieValue))
 	}
 
-	if ieHeader.Length >= 1 {
-		upFuncFeatures.SupportedFeatures = append(upFuncFeatures.SupportedFeatures, ieValue[0])
+	upFuncFeatures.SupportedFeatures = ieValue[:2]
+
+	if len(ieValue) > 2 {
+		upFuncFeatures.AdditionalSupportedFeatures1 = ieValue[2:3]
 	}
-	if ieHeader.Length >= 2 {
-		upFuncFeatures.SupportedFeatures = append(upFuncFeatures.SupportedFeatures, ieValue[1])
+	if len(ieValue) > 3 {
+		upFuncFeatures.AdditionalSupportedFeatures2 = ieValue[3:4]
 	}
 
 	return upFuncFeatures, nil
diff --git a/ie/upFunctionFeatures_test.go b/ie/upFunctionFeatures_test.go
index 7ca6b9f..9bab707 100644
--- a/ie/upFunctionFeatures_test.go
+++ b/ie/upFunctionFeatures_test.go
@@ -6,7 +6,7 @@ import (
 	"github.com/dot-5g/pfcp/ie"
 )
 
-func TestGivenSerializedWhenDeserializedThenDeserializedCorrectly(t *testing.T) {
+func TestGivenSerializedWhenDeserializeUPFunctionFeaturesThenDeserializedCorrectly(t *testing.T) {
 	features := [](ie.UPFeature){
 		ie.BUCP,
 		ie.TRACE,
@@ -20,23 +20,11 @@ func TestGivenSerializedWhenDeserializedThenDeserializedCorrectly(t *testing.T)
 
 	serializedUPFunctionFeatures := upFunctionFeatures.Serialize()
 
-	ieHeader := ie.Header{
-		Type:   43,
-		Length: 2,
-	}
-	deserializedUPFunctionFeatures, err := ie.DeserializeUPFunctionFeatures(ieHeader, serializedUPFunctionFeatures[4:])
+	deserializedUPFunctionFeatures, err := ie.DeserializeUPFunctionFeatures(serializedUPFunctionFeatures[4:])
 	if err != nil {
 		t.Fatalf("Error deserializing UPFunctionFeatures: %v", err)
 	}
 
-	if deserializedUPFunctionFeatures.Header.Type != 43 {
-		t.Errorf("Expected IE type 43, got %d", deserializedUPFunctionFeatures.Header.Type)
-	}
-
-	if deserializedUPFunctionFeatures.Header.Length != 2 {
-		t.Errorf("Expected IE length 2, got %d", deserializedUPFunctionFeatures.Header.Length)
-	}
-
 	if len(deserializedUPFunctionFeatures.SupportedFeatures) != 2 {
 		t.Errorf("Expected 2 supported features, got %d", len(deserializedUPFunctionFeatures.SupportedFeatures))
 	}
diff --git a/tests/pfcp_session_establishment_test.go b/tests/pfcp_session_establishment_test.go
index f9fc038..a05fbe1 100644
--- a/tests/pfcp_session_establishment_test.go
+++ b/tests/pfcp_session_establishment_test.go
@@ -53,7 +53,7 @@ func HandlePFCPSessionEstablishmentResponse(client *client.Pfcp, sequenceNumber
 
 func TestPFCPSessionEstablishment(t *testing.T) {
 	t.Run("TestPFCPSessionEstablishmentRequest", PFCPSessionEstablishmentRequest)
-	// t.Run("TestPFCPSessionEstablishmentResponse", PFCPSessionEstablishmentResponse)
+	t.Run("TestPFCPSessionEstablishmentResponse", PFCPSessionEstablishmentResponse)
 }
 
 func PFCPSessionEstablishmentRequest(t *testing.T) {