diff --git a/code-generation/language-go/src/main/java/org/apache/plc4x/language/go/GoLanguageTemplateHelper.java b/code-generation/language-go/src/main/java/org/apache/plc4x/language/go/GoLanguageTemplateHelper.java
index acdde73f3e4..b06af131185 100644
--- a/code-generation/language-go/src/main/java/org/apache/plc4x/language/go/GoLanguageTemplateHelper.java
+++ b/code-generation/language-go/src/main/java/org/apache/plc4x/language/go/GoLanguageTemplateHelper.java
@@ -22,7 +22,10 @@
 import org.apache.commons.lang3.math.NumberUtils;
 import org.apache.commons.text.CaseUtils;
 import org.apache.plc4x.plugins.codegenerator.language.mspec.model.definitions.DefaultArgument;
-import org.apache.plc4x.plugins.codegenerator.language.mspec.model.references.*;
+import org.apache.plc4x.plugins.codegenerator.language.mspec.model.references.DefaultBooleanTypeReference;
+import org.apache.plc4x.plugins.codegenerator.language.mspec.model.references.DefaultByteOrderTypeReference;
+import org.apache.plc4x.plugins.codegenerator.language.mspec.model.references.DefaultFloatTypeReference;
+import org.apache.plc4x.plugins.codegenerator.language.mspec.model.references.DefaultIntegerTypeReference;
 import org.apache.plc4x.plugins.codegenerator.language.mspec.model.terms.DefaultStringLiteral;
 import org.apache.plc4x.plugins.codegenerator.protocol.freemarker.BaseFreemarkerLanguageTemplateHelper;
 import org.apache.plc4x.plugins.codegenerator.protocol.freemarker.FreemarkerException;
@@ -379,7 +382,7 @@ public String getReadBufferReadMethodCall(String logicalName, SimpleTypeReferenc
                         .orElseThrow(() -> new FreemarkerException("Encoding must be a quoted string value")).getValue();
                 }
                 String length = Integer.toString(simpleTypeReference.getSizeInBits());
-                return "readBuffer.ReadString(\"" + logicalName + "\", uint32(" + length + "), \"" + encoding + "\")";
+                return "readBuffer.ReadString(\"" + logicalName + "\", uint32(" + length + "), utils.WithEncoding(\"" + encoding + "\"))";
             }
             case VSTRING: {
                 String encoding = "UTF-8";
@@ -397,7 +400,7 @@ public String getReadBufferReadMethodCall(String logicalName, SimpleTypeReferenc
                 } else {
                     lengthExpression = "uint32(" + lengthExpression + ")";
                 }
-                return "readBuffer.ReadString(\"" + logicalName + "\", " + lengthExpression + ", \"" + encoding + "\")";
+                return "readBuffer.ReadString(\"" + logicalName + "\", " + lengthExpression + ", utils.WithEncoding(\"" + encoding + "\"))";
             }
             case TIME:
             case DATE:
@@ -493,8 +496,7 @@ public String getWriteBufferWriteMethodCall(String logicalName, SimpleTypeRefere
                         .orElseThrow(() -> new FreemarkerException("Encoding must be a quoted string value")).getValue();
                 }
                 String length = Integer.toString(simpleTypeReference.getSizeInBits());
-                return "writeBuffer.WriteString(\"" + logicalName + "\", uint32(" + length + "), \"" +
-                    encoding + "\", " + fieldName + writerArgsString + ")";
+                return "writeBuffer.WriteString(\"" + logicalName + "\", uint32(" + length + "), " + fieldName + writerArgsString + ", utils.WithEncoding(\"" + encoding + ")\"))";
             }
             case VSTRING: {
                 VstringTypeReference vstringTypeReference = (VstringTypeReference) simpleTypeReference;
@@ -513,8 +515,7 @@ public String getWriteBufferWriteMethodCall(String logicalName, SimpleTypeRefere
                     lengthExpression = "uint32(" + lengthExpression + ")";
                 }
                 String length = Integer.toString(simpleTypeReference.getSizeInBits());
-                return "writeBuffer.WriteString(\"" + logicalName + "\", " + lengthExpression + ", \"" +
-                    encoding + "\", " + fieldName + writerArgsString + ")";
+                return "writeBuffer.WriteString(\"" + logicalName + "\", " + lengthExpression + ", " + fieldName + writerArgsString +  ", utils.WithEncoding(\"" + encoding + ")\"))";
             }
             case DATE:
             case TIME:
diff --git a/plc4go/internal/ads/model/AdsSubscriptionHandle_plc4xgen.go b/plc4go/internal/ads/model/AdsSubscriptionHandle_plc4xgen.go
index f0f51c3cd3f..977cd6179d6 100644
--- a/plc4go/internal/ads/model/AdsSubscriptionHandle_plc4xgen.go
+++ b/plc4go/internal/ads/model/AdsSubscriptionHandle_plc4xgen.go
@@ -56,19 +56,19 @@ func (d *AdsSubscriptionHandle) SerializeWithWriteBuffer(ctx context.Context, wr
 			}
 		} else {
 			stringValue := fmt.Sprintf("%v", d.subscriber)
-			if err := writeBuffer.WriteString("subscriber", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+			if err := writeBuffer.WriteString("subscriber", uint32(len(stringValue)*8), stringValue); err != nil {
 				return err
 			}
 		}
 	}
 
-	if err := writeBuffer.WriteString("tagName", uint32(len(d.tagName)*8), "UTF-8", d.tagName); err != nil {
+	if err := writeBuffer.WriteString("tagName", uint32(len(d.tagName)*8), d.tagName); err != nil {
 		return err
 	}
 	{
 		_value := fmt.Sprintf("%v", d.directTag)
 
-		if err := writeBuffer.WriteString("directTag", uint32(len(_value)*8), "UTF-8", _value); err != nil {
+		if err := writeBuffer.WriteString("directTag", uint32(len(_value)*8), _value); err != nil {
 			return err
 		}
 	}
@@ -91,7 +91,7 @@ func (d *AdsSubscriptionHandle) SerializeWithWriteBuffer(ctx context.Context, wr
 				}
 			} else {
 				stringValue := fmt.Sprintf("%v", elem)
-				if err := writeBuffer.WriteString("value", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+				if err := writeBuffer.WriteString("value", uint32(len(stringValue)*8), stringValue); err != nil {
 					return err
 				}
 			}
@@ -119,7 +119,7 @@ func (d *AdsSubscriptionHandle) SerializeWithWriteBuffer(ctx context.Context, wr
 				}
 			} else {
 				stringValue := fmt.Sprintf("%v", elem)
-				if err := writeBuffer.WriteString("value", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+				if err := writeBuffer.WriteString("value", uint32(len(stringValue)*8), stringValue); err != nil {
 					return err
 				}
 			}
diff --git a/plc4go/internal/ads/model/Tag.go b/plc4go/internal/ads/model/Tag.go
index d9d6d736887..a3972abc768 100644
--- a/plc4go/internal/ads/model/Tag.go
+++ b/plc4go/internal/ads/model/Tag.go
@@ -122,7 +122,7 @@ func (m DirectPlcTag) SerializeWithWriteBuffer(ctx context.Context, writeBuffer
 	if err := writeBuffer.WriteUint32("indexOffset", 32, m.IndexOffset); err != nil {
 		return err
 	}
-	if err := writeBuffer.WriteString("adsDatatypeName", uint32(len([]rune(m.ValueType.String()))*8), "UTF-8", m.ValueType.String()); err != nil {
+	if err := writeBuffer.WriteString("adsDatatypeName", uint32(len([]rune(m.ValueType.String()))*8), m.ValueType.String()); err != nil {
 		return err
 	}
 	if (m.ValueType == apiValues.STRING || m.ValueType == apiValues.WSTRING) && (m.StringLength != NONE) {
@@ -218,7 +218,7 @@ func (m SymbolicPlcTag) SerializeWithWriteBuffer(writeBuffer utils.WriteBuffer)
 		return err
 	}
 
-	if err := writeBuffer.WriteString("symbolicAddress", uint32(len([]rune(m.SymbolicAddress))*8), "UTF-8", m.SymbolicAddress); err != nil {
+	if err := writeBuffer.WriteString("symbolicAddress", uint32(len([]rune(m.SymbolicAddress))*8), m.SymbolicAddress); err != nil {
 		return err
 	}
 	if len(m.ArrayInfo) > 0 {
diff --git a/plc4go/internal/bacnetip/ApplicationLayerMessageCodec_plc4xgen.go b/plc4go/internal/bacnetip/ApplicationLayerMessageCodec_plc4xgen.go
index 58e5feaabda..e2f4347c7ac 100644
--- a/plc4go/internal/bacnetip/ApplicationLayerMessageCodec_plc4xgen.go
+++ b/plc4go/internal/bacnetip/ApplicationLayerMessageCodec_plc4xgen.go
@@ -45,31 +45,31 @@ func (d *ApplicationLayerMessageCodec) SerializeWithWriteBuffer(ctx context.Cont
 	{
 		_value := fmt.Sprintf("%v", d.bipSimpleApplication)
 
-		if err := writeBuffer.WriteString("bipSimpleApplication", uint32(len(_value)*8), "UTF-8", _value); err != nil {
+		if err := writeBuffer.WriteString("bipSimpleApplication", uint32(len(_value)*8), _value); err != nil {
 			return err
 		}
 	}
 	{
 		_value := fmt.Sprintf("%v", d.messageCode)
 
-		if err := writeBuffer.WriteString("messageCode", uint32(len(_value)*8), "UTF-8", _value); err != nil {
+		if err := writeBuffer.WriteString("messageCode", uint32(len(_value)*8), _value); err != nil {
 			return err
 		}
 	}
 	{
 		_value := fmt.Sprintf("%v", d.deviceInfoCache)
 
-		if err := writeBuffer.WriteString("deviceInfoCache", uint32(len(_value)*8), "UTF-8", _value); err != nil {
+		if err := writeBuffer.WriteString("deviceInfoCache", uint32(len(_value)*8), _value); err != nil {
 			return err
 		}
 	}
 	if d.localAddress != nil {
-		if err := writeBuffer.WriteString("localAddress", uint32(len(d.localAddress.String())*8), "UTF-8", d.localAddress.String()); err != nil {
+		if err := writeBuffer.WriteString("localAddress", uint32(len(d.localAddress.String())*8), d.localAddress.String()); err != nil {
 			return err
 		}
 	}
 	if d.remoteAddress != nil {
-		if err := writeBuffer.WriteString("remoteAddress", uint32(len(d.remoteAddress.String())*8), "UTF-8", d.remoteAddress.String()); err != nil {
+		if err := writeBuffer.WriteString("remoteAddress", uint32(len(d.remoteAddress.String())*8), d.remoteAddress.String()); err != nil {
 			return err
 		}
 	}
diff --git a/plc4go/internal/bacnetip/DeviceInfo_plc4xgen.go b/plc4go/internal/bacnetip/DeviceInfo_plc4xgen.go
index 002cd8ec2e4..a05a31109dc 100644
--- a/plc4go/internal/bacnetip/DeviceInfo_plc4xgen.go
+++ b/plc4go/internal/bacnetip/DeviceInfo_plc4xgen.go
@@ -56,7 +56,7 @@ func (d *DeviceInfo) SerializeWithWriteBuffer(ctx context.Context, writeBuffer u
 			}
 		} else {
 			stringValue := fmt.Sprintf("%v", d.DeviceIdentifier)
-			if err := writeBuffer.WriteString("deviceIdentifier", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+			if err := writeBuffer.WriteString("deviceIdentifier", uint32(len(stringValue)*8), stringValue); err != nil {
 				return err
 			}
 		}
@@ -64,34 +64,34 @@ func (d *DeviceInfo) SerializeWithWriteBuffer(ctx context.Context, writeBuffer u
 	{
 		_value := fmt.Sprintf("%v", d.Address)
 
-		if err := writeBuffer.WriteString("address", uint32(len(_value)*8), "UTF-8", _value); err != nil {
+		if err := writeBuffer.WriteString("address", uint32(len(_value)*8), _value); err != nil {
 			return err
 		}
 	}
 	if d.MaximumApduLengthAccepted != nil {
-		if err := writeBuffer.WriteString("maximumApduLengthAccepted", uint32(len(d.MaximumApduLengthAccepted.String())*8), "UTF-8", d.MaximumApduLengthAccepted.String()); err != nil {
+		if err := writeBuffer.WriteString("maximumApduLengthAccepted", uint32(len(d.MaximumApduLengthAccepted.String())*8), d.MaximumApduLengthAccepted.String()); err != nil {
 			return err
 		}
 	}
 	if d.SegmentationSupported != nil {
-		if err := writeBuffer.WriteString("segmentationSupported", uint32(len(d.SegmentationSupported.String())*8), "UTF-8", d.SegmentationSupported.String()); err != nil {
+		if err := writeBuffer.WriteString("segmentationSupported", uint32(len(d.SegmentationSupported.String())*8), d.SegmentationSupported.String()); err != nil {
 			return err
 		}
 	}
 	if d.MaxSegmentsAccepted != nil {
-		if err := writeBuffer.WriteString("maxSegmentsAccepted", uint32(len(d.MaxSegmentsAccepted.String())*8), "UTF-8", d.MaxSegmentsAccepted.String()); err != nil {
+		if err := writeBuffer.WriteString("maxSegmentsAccepted", uint32(len(d.MaxSegmentsAccepted.String())*8), d.MaxSegmentsAccepted.String()); err != nil {
 			return err
 		}
 	}
 	if d.VendorId != nil {
-		if err := writeBuffer.WriteString("vendorId", uint32(len(d.VendorId.String())*8), "UTF-8", d.VendorId.String()); err != nil {
+		if err := writeBuffer.WriteString("vendorId", uint32(len(d.VendorId.String())*8), d.VendorId.String()); err != nil {
 			return err
 		}
 	}
 	{
 		_value := fmt.Sprintf("%v", d.MaximumNpduLength)
 
-		if err := writeBuffer.WriteString("maximumNpduLength", uint32(len(_value)*8), "UTF-8", _value); err != nil {
+		if err := writeBuffer.WriteString("maximumNpduLength", uint32(len(_value)*8), _value); err != nil {
 			return err
 		}
 	}
@@ -102,7 +102,7 @@ func (d *DeviceInfo) SerializeWithWriteBuffer(ctx context.Context, writeBuffer u
 	{
 		_value := fmt.Sprintf("%v", d._cacheKey)
 
-		if err := writeBuffer.WriteString("_cacheKey", uint32(len(_value)*8), "UTF-8", _value); err != nil {
+		if err := writeBuffer.WriteString("_cacheKey", uint32(len(_value)*8), _value); err != nil {
 			return err
 		}
 	}
diff --git a/plc4go/internal/bacnetip/IOCB_plc4xgen.go b/plc4go/internal/bacnetip/IOCB_plc4xgen.go
index 1bc51822330..740fb670187 100644
--- a/plc4go/internal/bacnetip/IOCB_plc4xgen.go
+++ b/plc4go/internal/bacnetip/IOCB_plc4xgen.go
@@ -49,42 +49,42 @@ func (d *IOCB) SerializeWithWriteBuffer(ctx context.Context, writeBuffer utils.W
 	{
 		_value := fmt.Sprintf("%v", d.request)
 
-		if err := writeBuffer.WriteString("request", uint32(len(_value)*8), "UTF-8", _value); err != nil {
+		if err := writeBuffer.WriteString("request", uint32(len(_value)*8), _value); err != nil {
 			return err
 		}
 	}
 	{
 		_value := fmt.Sprintf("%v", d.destination)
 
-		if err := writeBuffer.WriteString("destination", uint32(len(_value)*8), "UTF-8", _value); err != nil {
+		if err := writeBuffer.WriteString("destination", uint32(len(_value)*8), _value); err != nil {
 			return err
 		}
 	}
 	{
 		_value := fmt.Sprintf("%v", d.ioState)
 
-		if err := writeBuffer.WriteString("ioState", uint32(len(_value)*8), "UTF-8", _value); err != nil {
+		if err := writeBuffer.WriteString("ioState", uint32(len(_value)*8), _value); err != nil {
 			return err
 		}
 	}
 	{
 		_value := fmt.Sprintf("%v", d.ioResponse)
 
-		if err := writeBuffer.WriteString("ioResponse", uint32(len(_value)*8), "UTF-8", _value); err != nil {
+		if err := writeBuffer.WriteString("ioResponse", uint32(len(_value)*8), _value); err != nil {
 			return err
 		}
 	}
 
 	if d.ioError != nil {
 		_errString := d.ioError.Error()
-		if err := writeBuffer.WriteString("ioError", uint32(len(_errString)*8), "UTF-8", _errString); err != nil {
+		if err := writeBuffer.WriteString("ioError", uint32(len(_errString)*8), _errString); err != nil {
 			return err
 		}
 	}
 	{
 		_value := fmt.Sprintf("%v", d.ioController)
 
-		if err := writeBuffer.WriteString("ioController", uint32(len(_value)*8), "UTF-8", _value); err != nil {
+		if err := writeBuffer.WriteString("ioController", uint32(len(_value)*8), _value); err != nil {
 			return err
 		}
 	}
@@ -98,7 +98,7 @@ func (d *IOCB) SerializeWithWriteBuffer(ctx context.Context, writeBuffer utils.W
 	for _, elem := range d.ioQueue {
 		_value := fmt.Sprintf("%v", elem)
 
-		if err := writeBuffer.WriteString("ioQueue", uint32(len(_value)*8), "UTF-8", _value); err != nil {
+		if err := writeBuffer.WriteString("ioQueue", uint32(len(_value)*8), _value); err != nil {
 			return err
 		}
 	}
@@ -107,7 +107,7 @@ func (d *IOCB) SerializeWithWriteBuffer(ctx context.Context, writeBuffer utils.W
 	}
 
 	_ioTimoutCancel_plx4gen_description := fmt.Sprintf("%d element(s)", len(d.ioTimoutCancel))
-	if err := writeBuffer.WriteString("ioTimoutCancel", uint32(len(_ioTimoutCancel_plx4gen_description)*8), "UTF-8", _ioTimoutCancel_plx4gen_description); err != nil {
+	if err := writeBuffer.WriteString("ioTimoutCancel", uint32(len(_ioTimoutCancel_plx4gen_description)*8), _ioTimoutCancel_plx4gen_description); err != nil {
 		return err
 	}
 
diff --git a/plc4go/internal/bacnetip/IOController_plc4xgen.go b/plc4go/internal/bacnetip/IOController_plc4xgen.go
index 4f6f33fa93f..6c4e8413de8 100644
--- a/plc4go/internal/bacnetip/IOController_plc4xgen.go
+++ b/plc4go/internal/bacnetip/IOController_plc4xgen.go
@@ -43,13 +43,13 @@ func (d *IOController) SerializeWithWriteBuffer(ctx context.Context, writeBuffer
 		return err
 	}
 
-	if err := writeBuffer.WriteString("name", uint32(len(d.name)*8), "UTF-8", d.name); err != nil {
+	if err := writeBuffer.WriteString("name", uint32(len(d.name)*8), d.name); err != nil {
 		return err
 	}
 	{
 		_value := fmt.Sprintf("%v", d.requirements)
 
-		if err := writeBuffer.WriteString("requirements", uint32(len(_value)*8), "UTF-8", _value); err != nil {
+		if err := writeBuffer.WriteString("requirements", uint32(len(_value)*8), _value); err != nil {
 			return err
 		}
 	}
diff --git a/plc4go/internal/bacnetip/IOQController_plc4xgen.go b/plc4go/internal/bacnetip/IOQController_plc4xgen.go
index b41ffcd9b5c..051d87b85c1 100644
--- a/plc4go/internal/bacnetip/IOQController_plc4xgen.go
+++ b/plc4go/internal/bacnetip/IOQController_plc4xgen.go
@@ -48,26 +48,26 @@ func (d *IOQController) SerializeWithWriteBuffer(ctx context.Context, writeBuffe
 	{
 		_value := fmt.Sprintf("%v", d.state)
 
-		if err := writeBuffer.WriteString("state", uint32(len(_value)*8), "UTF-8", _value); err != nil {
+		if err := writeBuffer.WriteString("state", uint32(len(_value)*8), _value); err != nil {
 			return err
 		}
 	}
 	{
 		_value := fmt.Sprintf("%v", d.activeIOCB)
 
-		if err := writeBuffer.WriteString("activeIOCB", uint32(len(_value)*8), "UTF-8", _value); err != nil {
+		if err := writeBuffer.WriteString("activeIOCB", uint32(len(_value)*8), _value); err != nil {
 			return err
 		}
 	}
 	{
 		_value := fmt.Sprintf("%v", d.ioQueue)
 
-		if err := writeBuffer.WriteString("ioQueue", uint32(len(_value)*8), "UTF-8", _value); err != nil {
+		if err := writeBuffer.WriteString("ioQueue", uint32(len(_value)*8), _value); err != nil {
 			return err
 		}
 	}
 
-	if err := writeBuffer.WriteString("waitTime", uint32(len(d.waitTime.String())*8), "UTF-8", d.waitTime.String()); err != nil {
+	if err := writeBuffer.WriteString("waitTime", uint32(len(d.waitTime.String())*8), d.waitTime.String()); err != nil {
 		return err
 	}
 	if err := writeBuffer.PopContext("IOQController"); err != nil {
diff --git a/plc4go/internal/bacnetip/IOQueue_plc4xgen.go b/plc4go/internal/bacnetip/IOQueue_plc4xgen.go
index 4404835cc33..d1dbbabe140 100644
--- a/plc4go/internal/bacnetip/IOQueue_plc4xgen.go
+++ b/plc4go/internal/bacnetip/IOQueue_plc4xgen.go
@@ -43,7 +43,7 @@ func (d *IOQueue) SerializeWithWriteBuffer(ctx context.Context, writeBuffer util
 		return err
 	}
 
-	if err := writeBuffer.WriteString("name", uint32(len(d.name)*8), "UTF-8", d.name); err != nil {
+	if err := writeBuffer.WriteString("name", uint32(len(d.name)*8), d.name); err != nil {
 		return err
 	}
 	if err := writeBuffer.PopContext("IOQueue"); err != nil {
diff --git a/plc4go/internal/bacnetip/SieveQueue_plc4xgen.go b/plc4go/internal/bacnetip/SieveQueue_plc4xgen.go
index c162aaa81bc..59875cb6207 100644
--- a/plc4go/internal/bacnetip/SieveQueue_plc4xgen.go
+++ b/plc4go/internal/bacnetip/SieveQueue_plc4xgen.go
@@ -52,7 +52,7 @@ func (d *SieveQueue) SerializeWithWriteBuffer(ctx context.Context, writeBuffer u
 	{
 		_value := fmt.Sprintf("%v", d.address)
 
-		if err := writeBuffer.WriteString("address", uint32(len(_value)*8), "UTF-8", _value); err != nil {
+		if err := writeBuffer.WriteString("address", uint32(len(_value)*8), _value); err != nil {
 			return err
 		}
 	}
diff --git a/plc4go/internal/bacnetip/Subscriber_plc4xgen.go b/plc4go/internal/bacnetip/Subscriber_plc4xgen.go
index eb3286b0ec9..d4eace4731c 100644
--- a/plc4go/internal/bacnetip/Subscriber_plc4xgen.go
+++ b/plc4go/internal/bacnetip/Subscriber_plc4xgen.go
@@ -45,7 +45,7 @@ func (d *Subscriber) SerializeWithWriteBuffer(ctx context.Context, writeBuffer u
 	{
 		_value := fmt.Sprintf("%v", d.connection)
 
-		if err := writeBuffer.WriteString("connection", uint32(len(_value)*8), "UTF-8", _value); err != nil {
+		if err := writeBuffer.WriteString("connection", uint32(len(_value)*8), _value); err != nil {
 			return err
 		}
 	}
@@ -68,7 +68,7 @@ func (d *Subscriber) SerializeWithWriteBuffer(ctx context.Context, writeBuffer u
 			}
 		} else {
 			elemAsString := fmt.Sprintf("%v", elem)
-			if err := writeBuffer.WriteString(name, uint32(len(elemAsString)*8), "UTF-8", elemAsString); err != nil {
+			if err := writeBuffer.WriteString(name, uint32(len(elemAsString)*8), elemAsString); err != nil {
 				return err
 			}
 		}
@@ -95,7 +95,7 @@ func (d *Subscriber) SerializeWithWriteBuffer(ctx context.Context, writeBuffer u
 				}
 			} else {
 				stringValue := fmt.Sprintf("%v", elem)
-				if err := writeBuffer.WriteString("value", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+				if err := writeBuffer.WriteString("value", uint32(len(stringValue)*8), stringValue); err != nil {
 					return err
 				}
 			}
diff --git a/plc4go/internal/bacnetip/Tag.go b/plc4go/internal/bacnetip/Tag.go
index 0f7eeb8b2e6..28af094b780 100644
--- a/plc4go/internal/bacnetip/Tag.go
+++ b/plc4go/internal/bacnetip/Tag.go
@@ -140,7 +140,7 @@ func (m plcTag) SerializeWithWriteBuffer(ctx context.Context, writeBuffer utils.
 		return err
 	}
 
-	if err := writeBuffer.WriteString("objectId", uint32(len([]rune(m.ObjectId.String()))*8), "UTF-8", m.ObjectId.String()); err != nil {
+	if err := writeBuffer.WriteString("objectId", uint32(len([]rune(m.ObjectId.String()))*8), m.ObjectId.String()); err != nil {
 		return err
 	}
 
@@ -148,7 +148,7 @@ func (m plcTag) SerializeWithWriteBuffer(ctx context.Context, writeBuffer utils.
 		return err
 	}
 	for _, p := range m.Properties {
-		if err := writeBuffer.WriteString("property", uint32(len([]rune(p.String()))*8), "UTF-8", p.String()); err != nil {
+		if err := writeBuffer.WriteString("property", uint32(len([]rune(p.String()))*8), p.String()); err != nil {
 			return err
 		}
 	}
diff --git a/plc4go/internal/bacnetip/UDPActor_plc4xgen.go b/plc4go/internal/bacnetip/UDPActor_plc4xgen.go
index 5a82145868b..f164def31ce 100644
--- a/plc4go/internal/bacnetip/UDPActor_plc4xgen.go
+++ b/plc4go/internal/bacnetip/UDPActor_plc4xgen.go
@@ -45,7 +45,7 @@ func (d *UDPActor) SerializeWithWriteBuffer(ctx context.Context, writeBuffer uti
 	{
 		_value := fmt.Sprintf("%v", d.director)
 
-		if err := writeBuffer.WriteString("director", uint32(len(_value)*8), "UTF-8", _value); err != nil {
+		if err := writeBuffer.WriteString("director", uint32(len(_value)*8), _value); err != nil {
 			return err
 		}
 	}
@@ -56,12 +56,12 @@ func (d *UDPActor) SerializeWithWriteBuffer(ctx context.Context, writeBuffer uti
 	{
 		_value := fmt.Sprintf("%v", d.timer)
 
-		if err := writeBuffer.WriteString("timer", uint32(len(_value)*8), "UTF-8", _value); err != nil {
+		if err := writeBuffer.WriteString("timer", uint32(len(_value)*8), _value); err != nil {
 			return err
 		}
 	}
 
-	if err := writeBuffer.WriteString("peer", uint32(len(d.peer)*8), "UTF-8", d.peer); err != nil {
+	if err := writeBuffer.WriteString("peer", uint32(len(d.peer)*8), d.peer); err != nil {
 		return err
 	}
 	if err := writeBuffer.PopContext("UDPActor"); err != nil {
diff --git a/plc4go/internal/cbus/Connection_plc4xgen.go b/plc4go/internal/cbus/Connection_plc4xgen.go
index cd7908c00fa..c49d71a0e75 100644
--- a/plc4go/internal/cbus/Connection_plc4xgen.go
+++ b/plc4go/internal/cbus/Connection_plc4xgen.go
@@ -46,13 +46,13 @@ func (d *Connection) SerializeWithWriteBuffer(ctx context.Context, writeBuffer u
 		return err
 	}
 
-	if err := writeBuffer.WriteString("alphaGenerator", uint32(len(d.alphaGenerator.String())*8), "UTF-8", d.alphaGenerator.String()); err != nil {
+	if err := writeBuffer.WriteString("alphaGenerator", uint32(len(d.alphaGenerator.String())*8), d.alphaGenerator.String()); err != nil {
 		return err
 	}
 	{
 		_value := fmt.Sprintf("%v", d.messageCodec)
 
-		if err := writeBuffer.WriteString("messageCodec", uint32(len(_value)*8), "UTF-8", _value); err != nil {
+		if err := writeBuffer.WriteString("messageCodec", uint32(len(_value)*8), _value); err != nil {
 			return err
 		}
 	}
@@ -75,7 +75,7 @@ func (d *Connection) SerializeWithWriteBuffer(ctx context.Context, writeBuffer u
 				}
 			} else {
 				stringValue := fmt.Sprintf("%v", elem)
-				if err := writeBuffer.WriteString("value", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+				if err := writeBuffer.WriteString("value", uint32(len(stringValue)*8), stringValue); err != nil {
 					return err
 				}
 			}
@@ -98,21 +98,21 @@ func (d *Connection) SerializeWithWriteBuffer(ctx context.Context, writeBuffer u
 			}
 		} else {
 			stringValue := fmt.Sprintf("%v", d.tm)
-			if err := writeBuffer.WriteString("tm", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+			if err := writeBuffer.WriteString("tm", uint32(len(stringValue)*8), stringValue); err != nil {
 				return err
 			}
 		}
 	}
 
-	if err := writeBuffer.WriteString("configuration", uint32(len(d.configuration.String())*8), "UTF-8", d.configuration.String()); err != nil {
+	if err := writeBuffer.WriteString("configuration", uint32(len(d.configuration.String())*8), d.configuration.String()); err != nil {
 		return err
 	}
 
-	if err := writeBuffer.WriteString("driverContext", uint32(len(d.driverContext.String())*8), "UTF-8", d.driverContext.String()); err != nil {
+	if err := writeBuffer.WriteString("driverContext", uint32(len(d.driverContext.String())*8), d.driverContext.String()); err != nil {
 		return err
 	}
 
-	if err := writeBuffer.WriteString("connectionId", uint32(len(d.connectionId)*8), "UTF-8", d.connectionId); err != nil {
+	if err := writeBuffer.WriteString("connectionId", uint32(len(d.connectionId)*8), d.connectionId); err != nil {
 		return err
 	}
 
@@ -129,7 +129,7 @@ func (d *Connection) SerializeWithWriteBuffer(ctx context.Context, writeBuffer u
 			}
 		} else {
 			stringValue := fmt.Sprintf("%v", d.tracer)
-			if err := writeBuffer.WriteString("tracer", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+			if err := writeBuffer.WriteString("tracer", uint32(len(stringValue)*8), stringValue); err != nil {
 				return err
 			}
 		}
diff --git a/plc4go/internal/cbus/MessageCodec_plc4xgen.go b/plc4go/internal/cbus/MessageCodec_plc4xgen.go
index 6d9f7f5798b..1e1cdc8003f 100644
--- a/plc4go/internal/cbus/MessageCodec_plc4xgen.go
+++ b/plc4go/internal/cbus/MessageCodec_plc4xgen.go
@@ -59,7 +59,7 @@ func (d *MessageCodec) SerializeWithWriteBuffer(ctx context.Context, writeBuffer
 			}
 		} else {
 			stringValue := fmt.Sprintf("%v", d.requestContext)
-			if err := writeBuffer.WriteString("requestContext", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+			if err := writeBuffer.WriteString("requestContext", uint32(len(stringValue)*8), stringValue); err != nil {
 				return err
 			}
 		}
@@ -78,19 +78,19 @@ func (d *MessageCodec) SerializeWithWriteBuffer(ctx context.Context, writeBuffer
 			}
 		} else {
 			stringValue := fmt.Sprintf("%v", d.cbusOptions)
-			if err := writeBuffer.WriteString("cbusOptions", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+			if err := writeBuffer.WriteString("cbusOptions", uint32(len(stringValue)*8), stringValue); err != nil {
 				return err
 			}
 		}
 	}
 
 	_monitoredMMIs_plx4gen_description := fmt.Sprintf("%d element(s)", len(d.monitoredMMIs))
-	if err := writeBuffer.WriteString("monitoredMMIs", uint32(len(_monitoredMMIs_plx4gen_description)*8), "UTF-8", _monitoredMMIs_plx4gen_description); err != nil {
+	if err := writeBuffer.WriteString("monitoredMMIs", uint32(len(_monitoredMMIs_plx4gen_description)*8), _monitoredMMIs_plx4gen_description); err != nil {
 		return err
 	}
 
 	_monitoredSALs_plx4gen_description := fmt.Sprintf("%d element(s)", len(d.monitoredSALs))
-	if err := writeBuffer.WriteString("monitoredSALs", uint32(len(_monitoredSALs_plx4gen_description)*8), "UTF-8", _monitoredSALs_plx4gen_description); err != nil {
+	if err := writeBuffer.WriteString("monitoredSALs", uint32(len(_monitoredSALs_plx4gen_description)*8), _monitoredSALs_plx4gen_description); err != nil {
 		return err
 	}
 
diff --git a/plc4go/internal/cbus/Subscriber_plc4xgen.go b/plc4go/internal/cbus/Subscriber_plc4xgen.go
index dae32c24c56..7ca20619872 100644
--- a/plc4go/internal/cbus/Subscriber_plc4xgen.go
+++ b/plc4go/internal/cbus/Subscriber_plc4xgen.go
@@ -64,7 +64,7 @@ func (d *Subscriber) SerializeWithWriteBuffer(ctx context.Context, writeBuffer u
 				}
 			} else {
 				elemAsString := fmt.Sprintf("%v", elem)
-				if err := writeBuffer.WriteString(name, uint32(len(elemAsString)*8), "UTF-8", elemAsString); err != nil {
+				if err := writeBuffer.WriteString(name, uint32(len(elemAsString)*8), elemAsString); err != nil {
 					return err
 				}
 			}
diff --git a/plc4go/internal/cbus/Tag.go b/plc4go/internal/cbus/Tag.go
index e279eeec85a..988e2502427 100644
--- a/plc4go/internal/cbus/Tag.go
+++ b/plc4go/internal/cbus/Tag.go
@@ -694,7 +694,7 @@ func (s salTag) SerializeWithWriteBuffer(ctx context.Context, writeBuffer utils.
 		return err
 	}
 
-	if err := writeBuffer.WriteString("salCommand", uint32(len(s.salCommand)*8), "UTF-8", s.salCommand); err != nil {
+	if err := writeBuffer.WriteString("salCommand", uint32(len(s.salCommand)*8), s.salCommand); err != nil {
 		return err
 	}
 
diff --git a/plc4go/internal/eip/Tag.go b/plc4go/internal/eip/Tag.go
index 869f3f6dd64..b290072669a 100644
--- a/plc4go/internal/eip/Tag.go
+++ b/plc4go/internal/eip/Tag.go
@@ -93,12 +93,12 @@ func (m plcTag) SerializeWithWriteBuffer(ctx context.Context, writeBuffer utils.
 		return err
 	}
 
-	if err := writeBuffer.WriteString("node", uint32(len([]rune(m.Tag))*8), "UTF-8", m.Tag); err != nil {
+	if err := writeBuffer.WriteString("node", uint32(len([]rune(m.Tag))*8), m.Tag); err != nil {
 		return err
 	}
 
 	if m.Type != 0 {
-		if err := writeBuffer.WriteString("type", uint32(len([]rune(m.Type.String()))*8), "UTF-8", m.Type.String()); err != nil {
+		if err := writeBuffer.WriteString("type", uint32(len([]rune(m.Type.String()))*8), m.Type.String()); err != nil {
 			return err
 		}
 	}
diff --git a/plc4go/internal/knxnetip/ConnectionMetadata_plc4xgen.go b/plc4go/internal/knxnetip/ConnectionMetadata_plc4xgen.go
index a7db28858db..c26064a2efd 100644
--- a/plc4go/internal/knxnetip/ConnectionMetadata_plc4xgen.go
+++ b/plc4go/internal/knxnetip/ConnectionMetadata_plc4xgen.go
@@ -43,32 +43,32 @@ func (d *ConnectionMetadata) SerializeWithWriteBuffer(ctx context.Context, write
 		return err
 	}
 
-	if err := writeBuffer.WriteString("knxMedium", uint32(len(d.KnxMedium.String())*8), "UTF-8", d.KnxMedium.String()); err != nil {
+	if err := writeBuffer.WriteString("knxMedium", uint32(len(d.KnxMedium.String())*8), d.KnxMedium.String()); err != nil {
 		return err
 	}
 
-	if err := writeBuffer.WriteString("gatewayName", uint32(len(d.GatewayName)*8), "UTF-8", d.GatewayName); err != nil {
+	if err := writeBuffer.WriteString("gatewayName", uint32(len(d.GatewayName)*8), d.GatewayName); err != nil {
 		return err
 	}
 
-	if err := writeBuffer.WriteString("gatewayKnxAddress", uint32(len(d.GatewayKnxAddress)*8), "UTF-8", d.GatewayKnxAddress); err != nil {
+	if err := writeBuffer.WriteString("gatewayKnxAddress", uint32(len(d.GatewayKnxAddress)*8), d.GatewayKnxAddress); err != nil {
 		return err
 	}
 
-	if err := writeBuffer.WriteString("clientKnxAddress", uint32(len(d.ClientKnxAddress)*8), "UTF-8", d.ClientKnxAddress); err != nil {
+	if err := writeBuffer.WriteString("clientKnxAddress", uint32(len(d.ClientKnxAddress)*8), d.ClientKnxAddress); err != nil {
 		return err
 	}
 	{
 		_value := fmt.Sprintf("%v", d.ProjectNumber)
 
-		if err := writeBuffer.WriteString("projectNumber", uint32(len(_value)*8), "UTF-8", _value); err != nil {
+		if err := writeBuffer.WriteString("projectNumber", uint32(len(_value)*8), _value); err != nil {
 			return err
 		}
 	}
 	{
 		_value := fmt.Sprintf("%v", d.InstallationNumber)
 
-		if err := writeBuffer.WriteString("installationNumber", uint32(len(_value)*8), "UTF-8", _value); err != nil {
+		if err := writeBuffer.WriteString("installationNumber", uint32(len(_value)*8), _value); err != nil {
 			return err
 		}
 	}
@@ -85,7 +85,7 @@ func (d *ConnectionMetadata) SerializeWithWriteBuffer(ctx context.Context, write
 		return err
 	}
 	for _, elem := range d.SupportedServices {
-		if err := writeBuffer.WriteString("", uint32(len(elem)*8), "UTF-8", elem); err != nil {
+		if err := writeBuffer.WriteString("", uint32(len(elem)*8), elem); err != nil {
 			return err
 		}
 	}
diff --git a/plc4go/internal/knxnetip/Subscriber_plc4xgen.go b/plc4go/internal/knxnetip/Subscriber_plc4xgen.go
index 133af0e985f..2d18f0d2b94 100644
--- a/plc4go/internal/knxnetip/Subscriber_plc4xgen.go
+++ b/plc4go/internal/knxnetip/Subscriber_plc4xgen.go
@@ -45,7 +45,7 @@ func (d *Subscriber) SerializeWithWriteBuffer(ctx context.Context, writeBuffer u
 	{
 		_value := fmt.Sprintf("%v", d.connection)
 
-		if err := writeBuffer.WriteString("connection", uint32(len(_value)*8), "UTF-8", _value); err != nil {
+		if err := writeBuffer.WriteString("connection", uint32(len(_value)*8), _value); err != nil {
 			return err
 		}
 	}
@@ -68,7 +68,7 @@ func (d *Subscriber) SerializeWithWriteBuffer(ctx context.Context, writeBuffer u
 			}
 		} else {
 			elemAsString := fmt.Sprintf("%v", elem)
-			if err := writeBuffer.WriteString(name, uint32(len(elemAsString)*8), "UTF-8", elemAsString); err != nil {
+			if err := writeBuffer.WriteString(name, uint32(len(elemAsString)*8), elemAsString); err != nil {
 				return err
 			}
 		}
@@ -99,7 +99,7 @@ func (d *Subscriber) SerializeWithWriteBuffer(ctx context.Context, writeBuffer u
 				}
 			} else {
 				stringValue := fmt.Sprintf("%v", elem)
-				if err := writeBuffer.WriteString("value", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+				if err := writeBuffer.WriteString("value", uint32(len(stringValue)*8), stringValue); err != nil {
 					return err
 				}
 			}
diff --git a/plc4go/internal/modbus/Tag.go b/plc4go/internal/modbus/Tag.go
index 7a52e727b29..e7e26cfaee5 100644
--- a/plc4go/internal/modbus/Tag.go
+++ b/plc4go/internal/modbus/Tag.go
@@ -126,7 +126,7 @@ func (m modbusTag) SerializeWithWriteBuffer(ctx context.Context, writeBuffer uti
 		return err
 	}
 	dataType := m.Datatype.String()
-	if err := writeBuffer.WriteString("dataType", uint32(len([]rune(dataType))*8), "UTF-8", dataType); err != nil {
+	if err := writeBuffer.WriteString("dataType", uint32(len([]rune(dataType))*8), dataType); err != nil {
 		return err
 	}
 
diff --git a/plc4go/internal/opcua/Configuration_plc4xgen.go b/plc4go/internal/opcua/Configuration_plc4xgen.go
index 359d1c1b499..eb733660b73 100644
--- a/plc4go/internal/opcua/Configuration_plc4xgen.go
+++ b/plc4go/internal/opcua/Configuration_plc4xgen.go
@@ -43,27 +43,27 @@ func (d *Configuration) SerializeWithWriteBuffer(ctx context.Context, writeBuffe
 		return err
 	}
 
-	if err := writeBuffer.WriteString("code", uint32(len(d.Code)*8), "UTF-8", d.Code); err != nil {
+	if err := writeBuffer.WriteString("code", uint32(len(d.Code)*8), d.Code); err != nil {
 		return err
 	}
 
-	if err := writeBuffer.WriteString("host", uint32(len(d.Host)*8), "UTF-8", d.Host); err != nil {
+	if err := writeBuffer.WriteString("host", uint32(len(d.Host)*8), d.Host); err != nil {
 		return err
 	}
 
-	if err := writeBuffer.WriteString("port", uint32(len(d.Port)*8), "UTF-8", d.Port); err != nil {
+	if err := writeBuffer.WriteString("port", uint32(len(d.Port)*8), d.Port); err != nil {
 		return err
 	}
 
-	if err := writeBuffer.WriteString("endpoint", uint32(len(d.Endpoint)*8), "UTF-8", d.Endpoint); err != nil {
+	if err := writeBuffer.WriteString("endpoint", uint32(len(d.Endpoint)*8), d.Endpoint); err != nil {
 		return err
 	}
 
-	if err := writeBuffer.WriteString("transportEndpoint", uint32(len(d.TransportEndpoint)*8), "UTF-8", d.TransportEndpoint); err != nil {
+	if err := writeBuffer.WriteString("transportEndpoint", uint32(len(d.TransportEndpoint)*8), d.TransportEndpoint); err != nil {
 		return err
 	}
 
-	if err := writeBuffer.WriteString("params", uint32(len(d.Params)*8), "UTF-8", d.Params); err != nil {
+	if err := writeBuffer.WriteString("params", uint32(len(d.Params)*8), d.Params); err != nil {
 		return err
 	}
 
@@ -84,7 +84,7 @@ func (d *Configuration) SerializeWithWriteBuffer(ctx context.Context, writeBuffe
 			}
 		} else {
 			stringValue := fmt.Sprintf("%v", d.Thumbprint)
-			if err := writeBuffer.WriteString("thumbprint", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+			if err := writeBuffer.WriteString("thumbprint", uint32(len(stringValue)*8), stringValue); err != nil {
 				return err
 			}
 		}
@@ -97,33 +97,33 @@ func (d *Configuration) SerializeWithWriteBuffer(ctx context.Context, writeBuffe
 		return err
 	}
 
-	if err := writeBuffer.WriteString("username", uint32(len(d.Username)*8), "UTF-8", d.Username); err != nil {
+	if err := writeBuffer.WriteString("username", uint32(len(d.Username)*8), d.Username); err != nil {
 		return err
 	}
 
-	if err := writeBuffer.WriteString("password", uint32(len(d.Password)*8), "UTF-8", d.Password); err != nil {
+	if err := writeBuffer.WriteString("password", uint32(len(d.Password)*8), d.Password); err != nil {
 		return err
 	}
 
-	if err := writeBuffer.WriteString("securityPolicy", uint32(len(d.SecurityPolicy)*8), "UTF-8", d.SecurityPolicy); err != nil {
+	if err := writeBuffer.WriteString("securityPolicy", uint32(len(d.SecurityPolicy)*8), d.SecurityPolicy); err != nil {
 		return err
 	}
 
-	if err := writeBuffer.WriteString("keyStoreFile", uint32(len(d.KeyStoreFile)*8), "UTF-8", d.KeyStoreFile); err != nil {
+	if err := writeBuffer.WriteString("keyStoreFile", uint32(len(d.KeyStoreFile)*8), d.KeyStoreFile); err != nil {
 		return err
 	}
 
-	if err := writeBuffer.WriteString("certDirectory", uint32(len(d.CertDirectory)*8), "UTF-8", d.CertDirectory); err != nil {
+	if err := writeBuffer.WriteString("certDirectory", uint32(len(d.CertDirectory)*8), d.CertDirectory); err != nil {
 		return err
 	}
 
-	if err := writeBuffer.WriteString("keyStorePassword", uint32(len(d.KeyStorePassword)*8), "UTF-8", d.KeyStorePassword); err != nil {
+	if err := writeBuffer.WriteString("keyStorePassword", uint32(len(d.KeyStorePassword)*8), d.KeyStorePassword); err != nil {
 		return err
 	}
 	{
 		_value := fmt.Sprintf("%v", d.Ckp)
 
-		if err := writeBuffer.WriteString("ckp", uint32(len(_value)*8), "UTF-8", _value); err != nil {
+		if err := writeBuffer.WriteString("ckp", uint32(len(_value)*8), _value); err != nil {
 			return err
 		}
 	}
diff --git a/plc4go/internal/opcua/Connection_plc4xgen.go b/plc4go/internal/opcua/Connection_plc4xgen.go
index e731a642e6d..a317dfb514b 100644
--- a/plc4go/internal/opcua/Connection_plc4xgen.go
+++ b/plc4go/internal/opcua/Connection_plc4xgen.go
@@ -48,7 +48,7 @@ func (d *Connection) SerializeWithWriteBuffer(ctx context.Context, writeBuffer u
 	{
 		_value := fmt.Sprintf("%v", d.messageCodec)
 
-		if err := writeBuffer.WriteString("messageCodec", uint32(len(_value)*8), "UTF-8", _value); err != nil {
+		if err := writeBuffer.WriteString("messageCodec", uint32(len(_value)*8), _value); err != nil {
 			return err
 		}
 	}
@@ -71,7 +71,7 @@ func (d *Connection) SerializeWithWriteBuffer(ctx context.Context, writeBuffer u
 				}
 			} else {
 				stringValue := fmt.Sprintf("%v", elem)
-				if err := writeBuffer.WriteString("value", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+				if err := writeBuffer.WriteString("value", uint32(len(stringValue)*8), stringValue); err != nil {
 					return err
 				}
 			}
@@ -81,40 +81,40 @@ func (d *Connection) SerializeWithWriteBuffer(ctx context.Context, writeBuffer u
 		return err
 	}
 
-	if err := writeBuffer.WriteString("configuration", uint32(len(d.configuration.String())*8), "UTF-8", d.configuration.String()); err != nil {
+	if err := writeBuffer.WriteString("configuration", uint32(len(d.configuration.String())*8), d.configuration.String()); err != nil {
 		return err
 	}
 
-	if err := writeBuffer.WriteString("driverContext", uint32(len(d.driverContext.String())*8), "UTF-8", d.driverContext.String()); err != nil {
+	if err := writeBuffer.WriteString("driverContext", uint32(len(d.driverContext.String())*8), d.driverContext.String()); err != nil {
 		return err
 	}
 	{
 		_value := fmt.Sprintf("%v", d.channel)
 
-		if err := writeBuffer.WriteString("channel", uint32(len(_value)*8), "UTF-8", _value); err != nil {
+		if err := writeBuffer.WriteString("channel", uint32(len(_value)*8), _value); err != nil {
 			return err
 		}
 	}
 
 	_connectEvent_plx4gen_description := fmt.Sprintf("%d element(s)", len(d.connectEvent))
-	if err := writeBuffer.WriteString("connectEvent", uint32(len(_connectEvent_plx4gen_description)*8), "UTF-8", _connectEvent_plx4gen_description); err != nil {
+	if err := writeBuffer.WriteString("connectEvent", uint32(len(_connectEvent_plx4gen_description)*8), _connectEvent_plx4gen_description); err != nil {
 		return err
 	}
 
-	if err := writeBuffer.WriteString("connectTimeout", uint32(len(d.connectTimeout.String())*8), "UTF-8", d.connectTimeout.String()); err != nil {
+	if err := writeBuffer.WriteString("connectTimeout", uint32(len(d.connectTimeout.String())*8), d.connectTimeout.String()); err != nil {
 		return err
 	}
 
 	_disconnectEvent_plx4gen_description := fmt.Sprintf("%d element(s)", len(d.disconnectEvent))
-	if err := writeBuffer.WriteString("disconnectEvent", uint32(len(_disconnectEvent_plx4gen_description)*8), "UTF-8", _disconnectEvent_plx4gen_description); err != nil {
+	if err := writeBuffer.WriteString("disconnectEvent", uint32(len(_disconnectEvent_plx4gen_description)*8), _disconnectEvent_plx4gen_description); err != nil {
 		return err
 	}
 
-	if err := writeBuffer.WriteString("disconnectTimeout", uint32(len(d.disconnectTimeout.String())*8), "UTF-8", d.disconnectTimeout.String()); err != nil {
+	if err := writeBuffer.WriteString("disconnectTimeout", uint32(len(d.disconnectTimeout.String())*8), d.disconnectTimeout.String()); err != nil {
 		return err
 	}
 
-	if err := writeBuffer.WriteString("connectionId", uint32(len(d.connectionId)*8), "UTF-8", d.connectionId); err != nil {
+	if err := writeBuffer.WriteString("connectionId", uint32(len(d.connectionId)*8), d.connectionId); err != nil {
 		return err
 	}
 
@@ -131,7 +131,7 @@ func (d *Connection) SerializeWithWriteBuffer(ctx context.Context, writeBuffer u
 			}
 		} else {
 			stringValue := fmt.Sprintf("%v", d.tracer)
-			if err := writeBuffer.WriteString("tracer", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+			if err := writeBuffer.WriteString("tracer", uint32(len(stringValue)*8), stringValue); err != nil {
 				return err
 			}
 		}
diff --git a/plc4go/internal/opcua/SecureChannelTransactionManager_plc4xgen.go b/plc4go/internal/opcua/SecureChannelTransactionManager_plc4xgen.go
index 5564b5b0cac..f5b210b7682 100644
--- a/plc4go/internal/opcua/SecureChannelTransactionManager_plc4xgen.go
+++ b/plc4go/internal/opcua/SecureChannelTransactionManager_plc4xgen.go
@@ -61,7 +61,7 @@ func (d *SecureChannelTransactionManager) SerializeWithWriteBuffer(ctx context.C
 		name := fmt.Sprintf("%v", _name)
 		_value := fmt.Sprintf("%v", elem)
 
-		if err := writeBuffer.WriteString(name, uint32(len(_value)*8), "UTF-8", _value); err != nil {
+		if err := writeBuffer.WriteString(name, uint32(len(_value)*8), _value); err != nil {
 			return err
 		}
 	}
diff --git a/plc4go/internal/opcua/SecureChannel_plc4xgen.go b/plc4go/internal/opcua/SecureChannel_plc4xgen.go
index 8f957d364b8..9a6ade218de 100644
--- a/plc4go/internal/opcua/SecureChannel_plc4xgen.go
+++ b/plc4go/internal/opcua/SecureChannel_plc4xgen.go
@@ -43,7 +43,7 @@ func (d *SecureChannel) SerializeWithWriteBuffer(ctx context.Context, writeBuffe
 		return err
 	}
 
-	if err := writeBuffer.WriteString("sessionName", uint32(len(d.sessionName)*8), "UTF-8", d.sessionName); err != nil {
+	if err := writeBuffer.WriteString("sessionName", uint32(len(d.sessionName)*8), d.sessionName); err != nil {
 		return err
 	}
 	if err := writeBuffer.WriteByteArray("clientNonce", d.clientNonce); err != nil {
@@ -67,13 +67,13 @@ func (d *SecureChannel) SerializeWithWriteBuffer(ctx context.Context, writeBuffe
 			}
 		} else {
 			stringValue := fmt.Sprintf("%v", d.policyId)
-			if err := writeBuffer.WriteString("policyId", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+			if err := writeBuffer.WriteString("policyId", uint32(len(stringValue)*8), stringValue); err != nil {
 				return err
 			}
 		}
 	}
 
-	if err := writeBuffer.WriteString("tokenType", uint32(len(d.tokenType.String())*8), "UTF-8", d.tokenType.String()); err != nil {
+	if err := writeBuffer.WriteString("tokenType", uint32(len(d.tokenType.String())*8), d.tokenType.String()); err != nil {
 		return err
 	}
 
@@ -81,17 +81,17 @@ func (d *SecureChannel) SerializeWithWriteBuffer(ctx context.Context, writeBuffe
 		return err
 	}
 
-	if err := writeBuffer.WriteString("certFile", uint32(len(d.certFile)*8), "UTF-8", d.certFile); err != nil {
+	if err := writeBuffer.WriteString("certFile", uint32(len(d.certFile)*8), d.certFile); err != nil {
 		return err
 	}
 
-	if err := writeBuffer.WriteString("keyStoreFile", uint32(len(d.keyStoreFile)*8), "UTF-8", d.keyStoreFile); err != nil {
+	if err := writeBuffer.WriteString("keyStoreFile", uint32(len(d.keyStoreFile)*8), d.keyStoreFile); err != nil {
 		return err
 	}
 	{
 		_value := fmt.Sprintf("%v", d.ckp)
 
-		if err := writeBuffer.WriteString("ckp", uint32(len(_value)*8), "UTF-8", _value); err != nil {
+		if err := writeBuffer.WriteString("ckp", uint32(len(_value)*8), _value); err != nil {
 			return err
 		}
 	}
@@ -109,21 +109,21 @@ func (d *SecureChannel) SerializeWithWriteBuffer(ctx context.Context, writeBuffe
 			}
 		} else {
 			stringValue := fmt.Sprintf("%v", d.endpoint)
-			if err := writeBuffer.WriteString("endpoint", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+			if err := writeBuffer.WriteString("endpoint", uint32(len(stringValue)*8), stringValue); err != nil {
 				return err
 			}
 		}
 	}
 
-	if err := writeBuffer.WriteString("username", uint32(len(d.username)*8), "UTF-8", d.username); err != nil {
+	if err := writeBuffer.WriteString("username", uint32(len(d.username)*8), d.username); err != nil {
 		return err
 	}
 
-	if err := writeBuffer.WriteString("password", uint32(len(d.password)*8), "UTF-8", d.password); err != nil {
+	if err := writeBuffer.WriteString("password", uint32(len(d.password)*8), d.password); err != nil {
 		return err
 	}
 
-	if err := writeBuffer.WriteString("securityPolicy", uint32(len(d.securityPolicy)*8), "UTF-8", d.securityPolicy); err != nil {
+	if err := writeBuffer.WriteString("securityPolicy", uint32(len(d.securityPolicy)*8), d.securityPolicy); err != nil {
 		return err
 	}
 
@@ -140,7 +140,7 @@ func (d *SecureChannel) SerializeWithWriteBuffer(ctx context.Context, writeBuffe
 			}
 		} else {
 			stringValue := fmt.Sprintf("%v", d.publicCertificate)
-			if err := writeBuffer.WriteString("publicCertificate", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+			if err := writeBuffer.WriteString("publicCertificate", uint32(len(stringValue)*8), stringValue); err != nil {
 				return err
 			}
 		}
@@ -159,7 +159,7 @@ func (d *SecureChannel) SerializeWithWriteBuffer(ctx context.Context, writeBuffe
 			}
 		} else {
 			stringValue := fmt.Sprintf("%v", d.thumbprint)
-			if err := writeBuffer.WriteString("thumbprint", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+			if err := writeBuffer.WriteString("thumbprint", uint32(len(stringValue)*8), stringValue); err != nil {
 				return err
 			}
 		}
@@ -188,7 +188,7 @@ func (d *SecureChannel) SerializeWithWriteBuffer(ctx context.Context, writeBuffe
 			}
 		} else {
 			stringValue := fmt.Sprintf("%v", d.certificateThumbprint)
-			if err := writeBuffer.WriteString("certificateThumbprint", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+			if err := writeBuffer.WriteString("certificateThumbprint", uint32(len(stringValue)*8), stringValue); err != nil {
 				return err
 			}
 		}
@@ -200,12 +200,12 @@ func (d *SecureChannel) SerializeWithWriteBuffer(ctx context.Context, writeBuffe
 	{
 		_value := fmt.Sprintf("%v", d.encryptionHandler)
 
-		if err := writeBuffer.WriteString("encryptionHandler", uint32(len(_value)*8), "UTF-8", _value); err != nil {
+		if err := writeBuffer.WriteString("encryptionHandler", uint32(len(_value)*8), _value); err != nil {
 			return err
 		}
 	}
 
-	if err := writeBuffer.WriteString("configuration", uint32(len(d.configuration.String())*8), "UTF-8", d.configuration.String()); err != nil {
+	if err := writeBuffer.WriteString("configuration", uint32(len(d.configuration.String())*8), d.configuration.String()); err != nil {
 		return err
 	}
 
@@ -230,7 +230,7 @@ func (d *SecureChannel) SerializeWithWriteBuffer(ctx context.Context, writeBuffe
 			}
 		} else {
 			stringValue := fmt.Sprintf("%v", d.authenticationToken)
-			if err := writeBuffer.WriteString("authenticationToken", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+			if err := writeBuffer.WriteString("authenticationToken", uint32(len(stringValue)*8), stringValue); err != nil {
 				return err
 			}
 		}
@@ -238,14 +238,14 @@ func (d *SecureChannel) SerializeWithWriteBuffer(ctx context.Context, writeBuffe
 	{
 		_value := fmt.Sprintf("%v", d.codec)
 
-		if err := writeBuffer.WriteString("codec", uint32(len(_value)*8), "UTF-8", _value); err != nil {
+		if err := writeBuffer.WriteString("codec", uint32(len(_value)*8), _value); err != nil {
 			return err
 		}
 	}
 	{
 		_value := fmt.Sprintf("%v", d.channelTransactionManager)
 
-		if err := writeBuffer.WriteString("channelTransactionManager", uint32(len(_value)*8), "UTF-8", _value); err != nil {
+		if err := writeBuffer.WriteString("channelTransactionManager", uint32(len(_value)*8), _value); err != nil {
 			return err
 		}
 	}
@@ -269,7 +269,7 @@ func (d *SecureChannel) SerializeWithWriteBuffer(ctx context.Context, writeBuffe
 		return err
 	}
 	for _, elem := range d.endpoints {
-		if err := writeBuffer.WriteString("", uint32(len(elem)*8), "UTF-8", elem); err != nil {
+		if err := writeBuffer.WriteString("", uint32(len(elem)*8), elem); err != nil {
 			return err
 		}
 	}
diff --git a/plc4go/internal/opcua/Subscriber_plc4xgen.go b/plc4go/internal/opcua/Subscriber_plc4xgen.go
index 8dabc98fb5a..0b67ed9fc6b 100644
--- a/plc4go/internal/opcua/Subscriber_plc4xgen.go
+++ b/plc4go/internal/opcua/Subscriber_plc4xgen.go
@@ -61,7 +61,7 @@ func (d *Subscriber) SerializeWithWriteBuffer(ctx context.Context, writeBuffer u
 			}
 		} else {
 			elemAsString := fmt.Sprintf("%v", elem)
-			if err := writeBuffer.WriteString(name, uint32(len(elemAsString)*8), "UTF-8", elemAsString); err != nil {
+			if err := writeBuffer.WriteString(name, uint32(len(elemAsString)*8), elemAsString); err != nil {
 				return err
 			}
 		}
@@ -76,7 +76,7 @@ func (d *Subscriber) SerializeWithWriteBuffer(ctx context.Context, writeBuffer u
 	{
 		_value := fmt.Sprintf("%v", d.connection)
 
-		if err := writeBuffer.WriteString("connection", uint32(len(_value)*8), "UTF-8", _value); err != nil {
+		if err := writeBuffer.WriteString("connection", uint32(len(_value)*8), _value); err != nil {
 			return err
 		}
 	}
diff --git a/plc4go/internal/s7/Tag.go b/plc4go/internal/s7/Tag.go
index 3407d3202ff..743248fed35 100644
--- a/plc4go/internal/s7/Tag.go
+++ b/plc4go/internal/s7/Tag.go
@@ -150,7 +150,7 @@ func (m plcTag) SerializeWithWriteBuffer(ctx context.Context, writeBuffer utils.
 		return err
 	}
 
-	if err := writeBuffer.WriteString("memoryArea", uint32(len(m.MemoryArea.String())*8), "UTF-8", m.MemoryArea.String()); err != nil {
+	if err := writeBuffer.WriteString("memoryArea", uint32(len(m.MemoryArea.String())*8), m.MemoryArea.String()); err != nil {
 		return err
 	}
 	if err := writeBuffer.WriteUint16("blockNumber", 16, m.BlockNumber); err != nil {
@@ -165,7 +165,7 @@ func (m plcTag) SerializeWithWriteBuffer(ctx context.Context, writeBuffer utils.
 	if err := writeBuffer.WriteUint16("numElements", 16, m.NumElements); err != nil {
 		return err
 	}
-	if err := writeBuffer.WriteString("dataType", uint32(len(m.Datatype.String())*8), "UTF-8", m.Datatype.String()); err != nil {
+	if err := writeBuffer.WriteString("dataType", uint32(len(m.Datatype.String())*8), m.Datatype.String()); err != nil {
 		return err
 	}
 
@@ -196,7 +196,7 @@ func (m PlcStringTag) SerializeWithWriteBuffer(ctx context.Context, writeBuffer
 		return err
 	}
 
-	if err := writeBuffer.WriteString("memoryArea", uint32(len(m.MemoryArea.String())*8), "UTF-8", m.MemoryArea.String()); err != nil {
+	if err := writeBuffer.WriteString("memoryArea", uint32(len(m.MemoryArea.String())*8), m.MemoryArea.String()); err != nil {
 		return err
 	}
 	if err := writeBuffer.WriteUint16("blockNumber", 16, m.BlockNumber); err != nil {
@@ -214,7 +214,7 @@ func (m PlcStringTag) SerializeWithWriteBuffer(ctx context.Context, writeBuffer
 	if err := writeBuffer.WriteUint16("stringLength", 16, m.stringLength); err != nil {
 		return err
 	}
-	if err := writeBuffer.WriteString("dataType", uint32(len(m.Datatype.String())*8), "UTF-8", m.Datatype.String()); err != nil {
+	if err := writeBuffer.WriteString("dataType", uint32(len(m.Datatype.String())*8), m.Datatype.String()); err != nil {
 		return err
 	}
 
diff --git a/plc4go/pkg/api/plcConnectionConnectResult_plc4xgen.go b/plc4go/pkg/api/plcConnectionConnectResult_plc4xgen.go
index 1fd1abcff5f..54de4aa346f 100644
--- a/plc4go/pkg/api/plcConnectionConnectResult_plc4xgen.go
+++ b/plc4go/pkg/api/plcConnectionConnectResult_plc4xgen.go
@@ -45,14 +45,14 @@ func (d *plcConnectionConnectResult) SerializeWithWriteBuffer(ctx context.Contex
 	{
 		_value := fmt.Sprintf("%v", d.connection)
 
-		if err := writeBuffer.WriteString("connection", uint32(len(_value)*8), "UTF-8", _value); err != nil {
+		if err := writeBuffer.WriteString("connection", uint32(len(_value)*8), _value); err != nil {
 			return err
 		}
 	}
 
 	if d.err != nil {
 		_errString := d.err.Error()
-		if err := writeBuffer.WriteString("err", uint32(len(_errString)*8), "UTF-8", _errString); err != nil {
+		if err := writeBuffer.WriteString("err", uint32(len(_errString)*8), _errString); err != nil {
 			return err
 		}
 	}
diff --git a/plc4go/pkg/api/plcDriverManger_plc4xgen.go b/plc4go/pkg/api/plcDriverManger_plc4xgen.go
index c1042deddc7..4249f0c16fb 100644
--- a/plc4go/pkg/api/plcDriverManger_plc4xgen.go
+++ b/plc4go/pkg/api/plcDriverManger_plc4xgen.go
@@ -49,7 +49,7 @@ func (d *plcDriverManger) SerializeWithWriteBuffer(ctx context.Context, writeBuf
 		name := _name
 		_value := fmt.Sprintf("%v", elem)
 
-		if err := writeBuffer.WriteString(name, uint32(len(_value)*8), "UTF-8", _value); err != nil {
+		if err := writeBuffer.WriteString(name, uint32(len(_value)*8), _value); err != nil {
 			return err
 		}
 	}
@@ -75,7 +75,7 @@ func (d *plcDriverManger) SerializeWithWriteBuffer(ctx context.Context, writeBuf
 			}
 		} else {
 			elemAsString := fmt.Sprintf("%v", elem)
-			if err := writeBuffer.WriteString(name, uint32(len(elemAsString)*8), "UTF-8", elemAsString); err != nil {
+			if err := writeBuffer.WriteString(name, uint32(len(elemAsString)*8), elemAsString); err != nil {
 				return err
 			}
 		}
diff --git a/plc4go/protocols/ads/discovery/readwrite/model/AmsString.go b/plc4go/protocols/ads/discovery/readwrite/model/AmsString.go
index c0113c049ec..8e718aed5a9 100644
--- a/plc4go/protocols/ads/discovery/readwrite/model/AmsString.go
+++ b/plc4go/protocols/ads/discovery/readwrite/model/AmsString.go
@@ -130,7 +130,7 @@ func AmsStringParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer)
 	}
 
 	// Simple Field (text)
-	_text, _textErr := readBuffer.ReadString("text", uint32((8)*((strLen)-(1))), "UTF-8")
+	_text, _textErr := readBuffer.ReadString("text", uint32((8)*((strLen)-(1))), utils.WithEncoding("UTF-8"))
 	if _textErr != nil {
 		return nil, errors.Wrap(_textErr, "Error parsing 'text' field of AmsString")
 	}
@@ -190,7 +190,7 @@ func (m *_AmsString) SerializeWithWriteBuffer(ctx context.Context, writeBuffer u
 
 	// Simple Field (text)
 	text := string(m.GetText())
-	_textErr := writeBuffer.WriteString("text", uint32((8)*((uint16(uint16(len(m.GetText())))+uint16(uint16(1)))-(1))), "UTF-8", (text))
+	_textErr := writeBuffer.WriteString("text", uint32((8)*((uint16(uint16(len(m.GetText())))+uint16(uint16(1)))-(1))), (text), utils.WithEncoding("UTF-8)"))
 	if _textErr != nil {
 		return errors.Wrap(_textErr, "Error serializing 'text' field")
 	}
diff --git a/plc4go/protocols/ads/readwrite/model/AdsDataTypeTableChildEntry.go b/plc4go/protocols/ads/readwrite/model/AdsDataTypeTableChildEntry.go
index 92b2ba5635d..ddd81b1396d 100644
--- a/plc4go/protocols/ads/readwrite/model/AdsDataTypeTableChildEntry.go
+++ b/plc4go/protocols/ads/readwrite/model/AdsDataTypeTableChildEntry.go
@@ -419,7 +419,7 @@ func AdsDataTypeTableChildEntryParseWithBuffer(ctx context.Context, readBuffer u
 	numChildren := _numChildren
 
 	// Simple Field (propertyName)
-	_propertyName, _propertyNameErr := readBuffer.ReadString("propertyName", uint32((propertyNameLength)*(8)), "UTF-8")
+	_propertyName, _propertyNameErr := readBuffer.ReadString("propertyName", uint32((propertyNameLength)*(8)), utils.WithEncoding("UTF-8"))
 	if _propertyNameErr != nil {
 		return nil, errors.Wrap(_propertyNameErr, "Error parsing 'propertyName' field of AdsDataTypeTableChildEntry")
 	}
@@ -435,7 +435,7 @@ func AdsDataTypeTableChildEntryParseWithBuffer(ctx context.Context, readBuffer u
 	}
 
 	// Simple Field (dataTypeName)
-	_dataTypeName, _dataTypeNameErr := readBuffer.ReadString("dataTypeName", uint32((dataTypeNameLength)*(8)), "UTF-8")
+	_dataTypeName, _dataTypeNameErr := readBuffer.ReadString("dataTypeName", uint32((dataTypeNameLength)*(8)), utils.WithEncoding("UTF-8"))
 	if _dataTypeNameErr != nil {
 		return nil, errors.Wrap(_dataTypeNameErr, "Error parsing 'dataTypeName' field of AdsDataTypeTableChildEntry")
 	}
@@ -451,7 +451,7 @@ func AdsDataTypeTableChildEntryParseWithBuffer(ctx context.Context, readBuffer u
 	}
 
 	// Simple Field (comment)
-	_comment, _commentErr := readBuffer.ReadString("comment", uint32((commentLength)*(8)), "UTF-8")
+	_comment, _commentErr := readBuffer.ReadString("comment", uint32((commentLength)*(8)), utils.WithEncoding("UTF-8"))
 	if _commentErr != nil {
 		return nil, errors.Wrap(_commentErr, "Error parsing 'comment' field of AdsDataTypeTableChildEntry")
 	}
@@ -661,7 +661,7 @@ func (m *_AdsDataTypeTableChildEntry) SerializeWithWriteBuffer(ctx context.Conte
 
 	// Simple Field (propertyName)
 	propertyName := string(m.GetPropertyName())
-	_propertyNameErr := writeBuffer.WriteString("propertyName", uint32((uint16(len(m.GetPropertyName())))*(8)), "UTF-8", (propertyName))
+	_propertyNameErr := writeBuffer.WriteString("propertyName", uint32((uint16(len(m.GetPropertyName())))*(8)), (propertyName), utils.WithEncoding("UTF-8)"))
 	if _propertyNameErr != nil {
 		return errors.Wrap(_propertyNameErr, "Error serializing 'propertyName' field")
 	}
@@ -674,7 +674,7 @@ func (m *_AdsDataTypeTableChildEntry) SerializeWithWriteBuffer(ctx context.Conte
 
 	// Simple Field (dataTypeName)
 	dataTypeName := string(m.GetDataTypeName())
-	_dataTypeNameErr := writeBuffer.WriteString("dataTypeName", uint32((uint16(len(m.GetDataTypeName())))*(8)), "UTF-8", (dataTypeName))
+	_dataTypeNameErr := writeBuffer.WriteString("dataTypeName", uint32((uint16(len(m.GetDataTypeName())))*(8)), (dataTypeName), utils.WithEncoding("UTF-8)"))
 	if _dataTypeNameErr != nil {
 		return errors.Wrap(_dataTypeNameErr, "Error serializing 'dataTypeName' field")
 	}
@@ -687,7 +687,7 @@ func (m *_AdsDataTypeTableChildEntry) SerializeWithWriteBuffer(ctx context.Conte
 
 	// Simple Field (comment)
 	comment := string(m.GetComment())
-	_commentErr := writeBuffer.WriteString("comment", uint32((uint16(len(m.GetComment())))*(8)), "UTF-8", (comment))
+	_commentErr := writeBuffer.WriteString("comment", uint32((uint16(len(m.GetComment())))*(8)), (comment), utils.WithEncoding("UTF-8)"))
 	if _commentErr != nil {
 		return errors.Wrap(_commentErr, "Error serializing 'comment' field")
 	}
diff --git a/plc4go/protocols/ads/readwrite/model/AdsDataTypeTableEntry.go b/plc4go/protocols/ads/readwrite/model/AdsDataTypeTableEntry.go
index ea5b1098055..a025ed66f62 100644
--- a/plc4go/protocols/ads/readwrite/model/AdsDataTypeTableEntry.go
+++ b/plc4go/protocols/ads/readwrite/model/AdsDataTypeTableEntry.go
@@ -419,7 +419,7 @@ func AdsDataTypeTableEntryParseWithBuffer(ctx context.Context, readBuffer utils.
 	numChildren := _numChildren
 
 	// Simple Field (dataTypeName)
-	_dataTypeName, _dataTypeNameErr := readBuffer.ReadString("dataTypeName", uint32((dataTypeNameLength)*(8)), "UTF-8")
+	_dataTypeName, _dataTypeNameErr := readBuffer.ReadString("dataTypeName", uint32((dataTypeNameLength)*(8)), utils.WithEncoding("UTF-8"))
 	if _dataTypeNameErr != nil {
 		return nil, errors.Wrap(_dataTypeNameErr, "Error parsing 'dataTypeName' field of AdsDataTypeTableEntry")
 	}
@@ -435,7 +435,7 @@ func AdsDataTypeTableEntryParseWithBuffer(ctx context.Context, readBuffer utils.
 	}
 
 	// Simple Field (simpleTypeName)
-	_simpleTypeName, _simpleTypeNameErr := readBuffer.ReadString("simpleTypeName", uint32((simpleTypeNameLength)*(8)), "UTF-8")
+	_simpleTypeName, _simpleTypeNameErr := readBuffer.ReadString("simpleTypeName", uint32((simpleTypeNameLength)*(8)), utils.WithEncoding("UTF-8"))
 	if _simpleTypeNameErr != nil {
 		return nil, errors.Wrap(_simpleTypeNameErr, "Error parsing 'simpleTypeName' field of AdsDataTypeTableEntry")
 	}
@@ -451,7 +451,7 @@ func AdsDataTypeTableEntryParseWithBuffer(ctx context.Context, readBuffer utils.
 	}
 
 	// Simple Field (comment)
-	_comment, _commentErr := readBuffer.ReadString("comment", uint32((commentLength)*(8)), "UTF-8")
+	_comment, _commentErr := readBuffer.ReadString("comment", uint32((commentLength)*(8)), utils.WithEncoding("UTF-8"))
 	if _commentErr != nil {
 		return nil, errors.Wrap(_commentErr, "Error parsing 'comment' field of AdsDataTypeTableEntry")
 	}
@@ -661,7 +661,7 @@ func (m *_AdsDataTypeTableEntry) SerializeWithWriteBuffer(ctx context.Context, w
 
 	// Simple Field (dataTypeName)
 	dataTypeName := string(m.GetDataTypeName())
-	_dataTypeNameErr := writeBuffer.WriteString("dataTypeName", uint32((uint16(len(m.GetDataTypeName())))*(8)), "UTF-8", (dataTypeName))
+	_dataTypeNameErr := writeBuffer.WriteString("dataTypeName", uint32((uint16(len(m.GetDataTypeName())))*(8)), (dataTypeName), utils.WithEncoding("UTF-8)"))
 	if _dataTypeNameErr != nil {
 		return errors.Wrap(_dataTypeNameErr, "Error serializing 'dataTypeName' field")
 	}
@@ -674,7 +674,7 @@ func (m *_AdsDataTypeTableEntry) SerializeWithWriteBuffer(ctx context.Context, w
 
 	// Simple Field (simpleTypeName)
 	simpleTypeName := string(m.GetSimpleTypeName())
-	_simpleTypeNameErr := writeBuffer.WriteString("simpleTypeName", uint32((uint16(len(m.GetSimpleTypeName())))*(8)), "UTF-8", (simpleTypeName))
+	_simpleTypeNameErr := writeBuffer.WriteString("simpleTypeName", uint32((uint16(len(m.GetSimpleTypeName())))*(8)), (simpleTypeName), utils.WithEncoding("UTF-8)"))
 	if _simpleTypeNameErr != nil {
 		return errors.Wrap(_simpleTypeNameErr, "Error serializing 'simpleTypeName' field")
 	}
@@ -687,7 +687,7 @@ func (m *_AdsDataTypeTableEntry) SerializeWithWriteBuffer(ctx context.Context, w
 
 	// Simple Field (comment)
 	comment := string(m.GetComment())
-	_commentErr := writeBuffer.WriteString("comment", uint32((uint16(len(m.GetComment())))*(8)), "UTF-8", (comment))
+	_commentErr := writeBuffer.WriteString("comment", uint32((uint16(len(m.GetComment())))*(8)), (comment), utils.WithEncoding("UTF-8)"))
 	if _commentErr != nil {
 		return errors.Wrap(_commentErr, "Error serializing 'comment' field")
 	}
diff --git a/plc4go/protocols/ads/readwrite/model/AdsSymbolTableEntry.go b/plc4go/protocols/ads/readwrite/model/AdsSymbolTableEntry.go
index a7f17b3bcb3..82661bb93ab 100644
--- a/plc4go/protocols/ads/readwrite/model/AdsSymbolTableEntry.go
+++ b/plc4go/protocols/ads/readwrite/model/AdsSymbolTableEntry.go
@@ -564,7 +564,7 @@ func AdsSymbolTableEntryParseWithBuffer(ctx context.Context, readBuffer utils.Re
 	}
 
 	// Simple Field (name)
-	_name, _nameErr := readBuffer.ReadString("name", uint32((nameLength)*(8)), "UTF-8")
+	_name, _nameErr := readBuffer.ReadString("name", uint32((nameLength)*(8)), utils.WithEncoding("UTF-8"))
 	if _nameErr != nil {
 		return nil, errors.Wrap(_nameErr, "Error parsing 'name' field of AdsSymbolTableEntry")
 	}
@@ -580,7 +580,7 @@ func AdsSymbolTableEntryParseWithBuffer(ctx context.Context, readBuffer utils.Re
 	}
 
 	// Simple Field (dataTypeName)
-	_dataTypeName, _dataTypeNameErr := readBuffer.ReadString("dataTypeName", uint32((dataTypeNameLength)*(8)), "UTF-8")
+	_dataTypeName, _dataTypeNameErr := readBuffer.ReadString("dataTypeName", uint32((dataTypeNameLength)*(8)), utils.WithEncoding("UTF-8"))
 	if _dataTypeNameErr != nil {
 		return nil, errors.Wrap(_dataTypeNameErr, "Error parsing 'dataTypeName' field of AdsSymbolTableEntry")
 	}
@@ -596,7 +596,7 @@ func AdsSymbolTableEntryParseWithBuffer(ctx context.Context, readBuffer utils.Re
 	}
 
 	// Simple Field (comment)
-	_comment, _commentErr := readBuffer.ReadString("comment", uint32((commentLength)*(8)), "UTF-8")
+	_comment, _commentErr := readBuffer.ReadString("comment", uint32((commentLength)*(8)), utils.WithEncoding("UTF-8"))
 	if _commentErr != nil {
 		return nil, errors.Wrap(_commentErr, "Error parsing 'comment' field of AdsSymbolTableEntry")
 	}
@@ -848,7 +848,7 @@ func (m *_AdsSymbolTableEntry) SerializeWithWriteBuffer(ctx context.Context, wri
 
 	// Simple Field (name)
 	name := string(m.GetName())
-	_nameErr := writeBuffer.WriteString("name", uint32((uint16(len(m.GetName())))*(8)), "UTF-8", (name))
+	_nameErr := writeBuffer.WriteString("name", uint32((uint16(len(m.GetName())))*(8)), (name), utils.WithEncoding("UTF-8)"))
 	if _nameErr != nil {
 		return errors.Wrap(_nameErr, "Error serializing 'name' field")
 	}
@@ -861,7 +861,7 @@ func (m *_AdsSymbolTableEntry) SerializeWithWriteBuffer(ctx context.Context, wri
 
 	// Simple Field (dataTypeName)
 	dataTypeName := string(m.GetDataTypeName())
-	_dataTypeNameErr := writeBuffer.WriteString("dataTypeName", uint32((uint16(len(m.GetDataTypeName())))*(8)), "UTF-8", (dataTypeName))
+	_dataTypeNameErr := writeBuffer.WriteString("dataTypeName", uint32((uint16(len(m.GetDataTypeName())))*(8)), (dataTypeName), utils.WithEncoding("UTF-8)"))
 	if _dataTypeNameErr != nil {
 		return errors.Wrap(_dataTypeNameErr, "Error serializing 'dataTypeName' field")
 	}
@@ -874,7 +874,7 @@ func (m *_AdsSymbolTableEntry) SerializeWithWriteBuffer(ctx context.Context, wri
 
 	// Simple Field (comment)
 	comment := string(m.GetComment())
-	_commentErr := writeBuffer.WriteString("comment", uint32((uint16(len(m.GetComment())))*(8)), "UTF-8", (comment))
+	_commentErr := writeBuffer.WriteString("comment", uint32((uint16(len(m.GetComment())))*(8)), (comment), utils.WithEncoding("UTF-8)"))
 	if _commentErr != nil {
 		return errors.Wrap(_commentErr, "Error serializing 'comment' field")
 	}
diff --git a/plc4go/protocols/ads/readwrite/model/DataItem.go b/plc4go/protocols/ads/readwrite/model/DataItem.go
index 7f4d5fcefff..aed458b76e4 100644
--- a/plc4go/protocols/ads/readwrite/model/DataItem.go
+++ b/plc4go/protocols/ads/readwrite/model/DataItem.go
@@ -183,7 +183,7 @@ func DataItemParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer, p
 		return values.NewPlcLREAL(value), nil
 	case plcValueType == PlcValueType_CHAR: // CHAR
 		// Simple Field (value)
-		value, _valueErr := readBuffer.ReadString("value", uint32(8), "Windows-1252")
+		value, _valueErr := readBuffer.ReadString("value", uint32(8), utils.WithEncoding("Windows-1252"))
 		if _valueErr != nil {
 			return nil, errors.Wrap(_valueErr, "Error parsing 'value' field")
 		}
@@ -192,7 +192,7 @@ func DataItemParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer, p
 		return values.NewPlcCHAR(value), nil
 	case plcValueType == PlcValueType_WCHAR: // WCHAR
 		// Simple Field (value)
-		value, _valueErr := readBuffer.ReadString("value", uint32(16), "UTF-16LE")
+		value, _valueErr := readBuffer.ReadString("value", uint32(16), utils.WithEncoding("UTF-16LE"))
 		if _valueErr != nil {
 			return nil, errors.Wrap(_valueErr, "Error parsing 'value' field")
 		}
@@ -201,7 +201,7 @@ func DataItemParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer, p
 		return values.NewPlcWCHAR(value), nil
 	case plcValueType == PlcValueType_STRING: // STRING
 		// Simple Field (value)
-		value, _valueErr := readBuffer.ReadString("value", uint32((stringLength)*(8)), "Windows-1252")
+		value, _valueErr := readBuffer.ReadString("value", uint32((stringLength)*(8)), utils.WithEncoding("Windows-1252"))
 		if _valueErr != nil {
 			return nil, errors.Wrap(_valueErr, "Error parsing 'value' field")
 		}
@@ -215,7 +215,7 @@ func DataItemParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer, p
 		return values.NewPlcSTRING(value), nil
 	case plcValueType == PlcValueType_WSTRING: // WSTRING
 		// Simple Field (value)
-		value, _valueErr := readBuffer.ReadString("value", uint32(((stringLength)*(8))*(2)), "UTF-16LE")
+		value, _valueErr := readBuffer.ReadString("value", uint32(((stringLength)*(8))*(2)), utils.WithEncoding("UTF-16LE"))
 		if _valueErr != nil {
 			return nil, errors.Wrap(_valueErr, "Error parsing 'value' field")
 		}
@@ -407,17 +407,17 @@ func DataItemSerializeWithWriteBuffer(ctx context.Context, writeBuffer utils.Wri
 		}
 	case plcValueType == PlcValueType_CHAR: // CHAR
 		// Simple Field (value)
-		if _err := writeBuffer.WriteString("value", uint32(8), "Windows-1252", value.GetString()); _err != nil {
+		if _err := writeBuffer.WriteString("value", uint32(8), value.GetString(), utils.WithEncoding("Windows-1252)")); _err != nil {
 			return errors.Wrap(_err, "Error serializing 'value' field")
 		}
 	case plcValueType == PlcValueType_WCHAR: // WCHAR
 		// Simple Field (value)
-		if _err := writeBuffer.WriteString("value", uint32(16), "UTF-16LE", value.GetString()); _err != nil {
+		if _err := writeBuffer.WriteString("value", uint32(16), value.GetString(), utils.WithEncoding("UTF-16LE)")); _err != nil {
 			return errors.Wrap(_err, "Error serializing 'value' field")
 		}
 	case plcValueType == PlcValueType_STRING: // STRING
 		// Simple Field (value)
-		if _err := writeBuffer.WriteString("value", uint32((stringLength)*(8)), "Windows-1252", value.GetString()); _err != nil {
+		if _err := writeBuffer.WriteString("value", uint32((stringLength)*(8)), value.GetString(), utils.WithEncoding("Windows-1252)")); _err != nil {
 			return errors.Wrap(_err, "Error serializing 'value' field")
 		}
 
@@ -427,7 +427,7 @@ func DataItemSerializeWithWriteBuffer(ctx context.Context, writeBuffer utils.Wri
 		}
 	case plcValueType == PlcValueType_WSTRING: // WSTRING
 		// Simple Field (value)
-		if _err := writeBuffer.WriteString("value", uint32(((stringLength)*(8))*(2)), "UTF-16LE", value.GetString()); _err != nil {
+		if _err := writeBuffer.WriteString("value", uint32(((stringLength)*(8))*(2)), value.GetString(), utils.WithEncoding("UTF-16LE)")); _err != nil {
 			return errors.Wrap(_err, "Error serializing 'value' field")
 		}
 
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetTagPayloadCharacterString.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetTagPayloadCharacterString.go
index 912c902b8d4..b0096c11628 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetTagPayloadCharacterString.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetTagPayloadCharacterString.go
@@ -165,7 +165,7 @@ func BACnetTagPayloadCharacterStringParseWithBuffer(ctx context.Context, readBuf
 	_ = actualLengthInBit
 
 	// Simple Field (value)
-	_value, _valueErr := readBuffer.ReadString("value", uint32(actualLengthInBit), "UTF-8")
+	_value, _valueErr := readBuffer.ReadString("value", uint32(actualLengthInBit), utils.WithEncoding("UTF-8"))
 	if _valueErr != nil {
 		return nil, errors.Wrap(_valueErr, "Error parsing 'value' field of BACnetTagPayloadCharacterString")
 	}
@@ -220,7 +220,7 @@ func (m *_BACnetTagPayloadCharacterString) SerializeWithWriteBuffer(ctx context.
 
 	// Simple Field (value)
 	value := string(m.GetValue())
-	_valueErr := writeBuffer.WriteString("value", uint32(m.GetActualLengthInBit()), "UTF-8", (value))
+	_valueErr := writeBuffer.WriteString("value", uint32(m.GetActualLengthInBit()), (value), utils.WithEncoding("UTF-8)"))
 	if _valueErr != nil {
 		return errors.Wrap(_valueErr, "Error serializing 'value' field")
 	}
diff --git a/plc4go/protocols/cbus/readwrite/model/CustomManufacturer.go b/plc4go/protocols/cbus/readwrite/model/CustomManufacturer.go
index feff5a294b4..35fa68cad23 100644
--- a/plc4go/protocols/cbus/readwrite/model/CustomManufacturer.go
+++ b/plc4go/protocols/cbus/readwrite/model/CustomManufacturer.go
@@ -118,7 +118,7 @@ func CustomManufacturerParseWithBuffer(ctx context.Context, readBuffer utils.Rea
 	_ = currentPos
 
 	// Simple Field (customString)
-	_customString, _customStringErr := readBuffer.ReadString("customString", uint32((8)*(numBytes)), "UTF-8")
+	_customString, _customStringErr := readBuffer.ReadString("customString", uint32((8)*(numBytes)), utils.WithEncoding("UTF-8"))
 	if _customStringErr != nil {
 		return nil, errors.Wrap(_customStringErr, "Error parsing 'customString' field of CustomManufacturer")
 	}
@@ -154,7 +154,7 @@ func (m *_CustomManufacturer) SerializeWithWriteBuffer(ctx context.Context, writ
 
 	// Simple Field (customString)
 	customString := string(m.GetCustomString())
-	_customStringErr := writeBuffer.WriteString("customString", uint32((8)*(m.GetNumBytes())), "UTF-8", (customString))
+	_customStringErr := writeBuffer.WriteString("customString", uint32((8)*(m.GetNumBytes())), (customString), utils.WithEncoding("UTF-8)"))
 	if _customStringErr != nil {
 		return errors.Wrap(_customStringErr, "Error serializing 'customString' field")
 	}
diff --git a/plc4go/protocols/cbus/readwrite/model/CustomTypes.go b/plc4go/protocols/cbus/readwrite/model/CustomTypes.go
index ecaaf2dd9b4..726e2ba68bb 100644
--- a/plc4go/protocols/cbus/readwrite/model/CustomTypes.go
+++ b/plc4go/protocols/cbus/readwrite/model/CustomTypes.go
@@ -118,7 +118,7 @@ func CustomTypesParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer
 	_ = currentPos
 
 	// Simple Field (customString)
-	_customString, _customStringErr := readBuffer.ReadString("customString", uint32((8)*(numBytes)), "UTF-8")
+	_customString, _customStringErr := readBuffer.ReadString("customString", uint32((8)*(numBytes)), utils.WithEncoding("UTF-8"))
 	if _customStringErr != nil {
 		return nil, errors.Wrap(_customStringErr, "Error parsing 'customString' field of CustomTypes")
 	}
@@ -154,7 +154,7 @@ func (m *_CustomTypes) SerializeWithWriteBuffer(ctx context.Context, writeBuffer
 
 	// Simple Field (customString)
 	customString := string(m.GetCustomString())
-	_customStringErr := writeBuffer.WriteString("customString", uint32((8)*(m.GetNumBytes())), "UTF-8", (customString))
+	_customStringErr := writeBuffer.WriteString("customString", uint32((8)*(m.GetNumBytes())), (customString), utils.WithEncoding("UTF-8)"))
 	if _customStringErr != nil {
 		return errors.Wrap(_customStringErr, "Error serializing 'customString' field")
 	}
diff --git a/plc4go/protocols/cbus/readwrite/model/IdentifyReplyCommandFirmwareVersion.go b/plc4go/protocols/cbus/readwrite/model/IdentifyReplyCommandFirmwareVersion.go
index 6d68762b084..d97c78784ec 100644
--- a/plc4go/protocols/cbus/readwrite/model/IdentifyReplyCommandFirmwareVersion.go
+++ b/plc4go/protocols/cbus/readwrite/model/IdentifyReplyCommandFirmwareVersion.go
@@ -142,7 +142,7 @@ func IdentifyReplyCommandFirmwareVersionParseWithBuffer(ctx context.Context, rea
 	_ = currentPos
 
 	// Simple Field (firmwareVersion)
-	_firmwareVersion, _firmwareVersionErr := readBuffer.ReadString("firmwareVersion", uint32(64), "UTF-8")
+	_firmwareVersion, _firmwareVersionErr := readBuffer.ReadString("firmwareVersion", uint32(64), utils.WithEncoding("UTF-8"))
 	if _firmwareVersionErr != nil {
 		return nil, errors.Wrap(_firmwareVersionErr, "Error parsing 'firmwareVersion' field of IdentifyReplyCommandFirmwareVersion")
 	}
@@ -183,7 +183,7 @@ func (m *_IdentifyReplyCommandFirmwareVersion) SerializeWithWriteBuffer(ctx cont
 
 		// Simple Field (firmwareVersion)
 		firmwareVersion := string(m.GetFirmwareVersion())
-		_firmwareVersionErr := writeBuffer.WriteString("firmwareVersion", uint32(64), "UTF-8", (firmwareVersion))
+		_firmwareVersionErr := writeBuffer.WriteString("firmwareVersion", uint32(64), (firmwareVersion), utils.WithEncoding("UTF-8)"))
 		if _firmwareVersionErr != nil {
 			return errors.Wrap(_firmwareVersionErr, "Error serializing 'firmwareVersion' field")
 		}
diff --git a/plc4go/protocols/cbus/readwrite/model/IdentifyReplyCommandManufacturer.go b/plc4go/protocols/cbus/readwrite/model/IdentifyReplyCommandManufacturer.go
index d9ac6c06774..2f0073831f9 100644
--- a/plc4go/protocols/cbus/readwrite/model/IdentifyReplyCommandManufacturer.go
+++ b/plc4go/protocols/cbus/readwrite/model/IdentifyReplyCommandManufacturer.go
@@ -142,7 +142,7 @@ func IdentifyReplyCommandManufacturerParseWithBuffer(ctx context.Context, readBu
 	_ = currentPos
 
 	// Simple Field (manufacturerName)
-	_manufacturerName, _manufacturerNameErr := readBuffer.ReadString("manufacturerName", uint32(64), "UTF-8")
+	_manufacturerName, _manufacturerNameErr := readBuffer.ReadString("manufacturerName", uint32(64), utils.WithEncoding("UTF-8"))
 	if _manufacturerNameErr != nil {
 		return nil, errors.Wrap(_manufacturerNameErr, "Error parsing 'manufacturerName' field of IdentifyReplyCommandManufacturer")
 	}
@@ -183,7 +183,7 @@ func (m *_IdentifyReplyCommandManufacturer) SerializeWithWriteBuffer(ctx context
 
 		// Simple Field (manufacturerName)
 		manufacturerName := string(m.GetManufacturerName())
-		_manufacturerNameErr := writeBuffer.WriteString("manufacturerName", uint32(64), "UTF-8", (manufacturerName))
+		_manufacturerNameErr := writeBuffer.WriteString("manufacturerName", uint32(64), (manufacturerName), utils.WithEncoding("UTF-8)"))
 		if _manufacturerNameErr != nil {
 			return errors.Wrap(_manufacturerNameErr, "Error serializing 'manufacturerName' field")
 		}
diff --git a/plc4go/protocols/cbus/readwrite/model/IdentifyReplyCommandNetworkVoltage.go b/plc4go/protocols/cbus/readwrite/model/IdentifyReplyCommandNetworkVoltage.go
index cc389a947b2..fdfcf9c1c57 100644
--- a/plc4go/protocols/cbus/readwrite/model/IdentifyReplyCommandNetworkVoltage.go
+++ b/plc4go/protocols/cbus/readwrite/model/IdentifyReplyCommandNetworkVoltage.go
@@ -180,7 +180,7 @@ func IdentifyReplyCommandNetworkVoltageParseWithBuffer(ctx context.Context, read
 	_ = currentPos
 
 	// Simple Field (volts)
-	_volts, _voltsErr := readBuffer.ReadString("volts", uint32(16), "UTF-8")
+	_volts, _voltsErr := readBuffer.ReadString("volts", uint32(16), utils.WithEncoding("UTF-8"))
 	if _voltsErr != nil {
 		return nil, errors.Wrap(_voltsErr, "Error parsing 'volts' field of IdentifyReplyCommandNetworkVoltage")
 	}
@@ -196,7 +196,7 @@ func IdentifyReplyCommandNetworkVoltageParseWithBuffer(ctx context.Context, read
 	}
 
 	// Simple Field (voltsDecimalPlace)
-	_voltsDecimalPlace, _voltsDecimalPlaceErr := readBuffer.ReadString("voltsDecimalPlace", uint32(16), "UTF-8")
+	_voltsDecimalPlace, _voltsDecimalPlaceErr := readBuffer.ReadString("voltsDecimalPlace", uint32(16), utils.WithEncoding("UTF-8"))
 	if _voltsDecimalPlaceErr != nil {
 		return nil, errors.Wrap(_voltsDecimalPlaceErr, "Error parsing 'voltsDecimalPlace' field of IdentifyReplyCommandNetworkVoltage")
 	}
@@ -247,7 +247,7 @@ func (m *_IdentifyReplyCommandNetworkVoltage) SerializeWithWriteBuffer(ctx conte
 
 		// Simple Field (volts)
 		volts := string(m.GetVolts())
-		_voltsErr := writeBuffer.WriteString("volts", uint32(16), "UTF-8", (volts))
+		_voltsErr := writeBuffer.WriteString("volts", uint32(16), (volts), utils.WithEncoding("UTF-8)"))
 		if _voltsErr != nil {
 			return errors.Wrap(_voltsErr, "Error serializing 'volts' field")
 		}
@@ -260,7 +260,7 @@ func (m *_IdentifyReplyCommandNetworkVoltage) SerializeWithWriteBuffer(ctx conte
 
 		// Simple Field (voltsDecimalPlace)
 		voltsDecimalPlace := string(m.GetVoltsDecimalPlace())
-		_voltsDecimalPlaceErr := writeBuffer.WriteString("voltsDecimalPlace", uint32(16), "UTF-8", (voltsDecimalPlace))
+		_voltsDecimalPlaceErr := writeBuffer.WriteString("voltsDecimalPlace", uint32(16), (voltsDecimalPlace), utils.WithEncoding("UTF-8)"))
 		if _voltsDecimalPlaceErr != nil {
 			return errors.Wrap(_voltsDecimalPlaceErr, "Error serializing 'voltsDecimalPlace' field")
 		}
diff --git a/plc4go/protocols/cbus/readwrite/model/IdentifyReplyCommandSummary.go b/plc4go/protocols/cbus/readwrite/model/IdentifyReplyCommandSummary.go
index 80148982f60..96d2ee8c31d 100644
--- a/plc4go/protocols/cbus/readwrite/model/IdentifyReplyCommandSummary.go
+++ b/plc4go/protocols/cbus/readwrite/model/IdentifyReplyCommandSummary.go
@@ -164,7 +164,7 @@ func IdentifyReplyCommandSummaryParseWithBuffer(ctx context.Context, readBuffer
 	_ = currentPos
 
 	// Simple Field (partName)
-	_partName, _partNameErr := readBuffer.ReadString("partName", uint32(48), "UTF-8")
+	_partName, _partNameErr := readBuffer.ReadString("partName", uint32(48), utils.WithEncoding("UTF-8"))
 	if _partNameErr != nil {
 		return nil, errors.Wrap(_partNameErr, "Error parsing 'partName' field of IdentifyReplyCommandSummary")
 	}
@@ -178,7 +178,7 @@ func IdentifyReplyCommandSummaryParseWithBuffer(ctx context.Context, readBuffer
 	unitServiceType := _unitServiceType
 
 	// Simple Field (version)
-	_version, _versionErr := readBuffer.ReadString("version", uint32(32), "UTF-8")
+	_version, _versionErr := readBuffer.ReadString("version", uint32(32), utils.WithEncoding("UTF-8"))
 	if _versionErr != nil {
 		return nil, errors.Wrap(_versionErr, "Error parsing 'version' field of IdentifyReplyCommandSummary")
 	}
@@ -221,7 +221,7 @@ func (m *_IdentifyReplyCommandSummary) SerializeWithWriteBuffer(ctx context.Cont
 
 		// Simple Field (partName)
 		partName := string(m.GetPartName())
-		_partNameErr := writeBuffer.WriteString("partName", uint32(48), "UTF-8", (partName))
+		_partNameErr := writeBuffer.WriteString("partName", uint32(48), (partName), utils.WithEncoding("UTF-8)"))
 		if _partNameErr != nil {
 			return errors.Wrap(_partNameErr, "Error serializing 'partName' field")
 		}
@@ -235,7 +235,7 @@ func (m *_IdentifyReplyCommandSummary) SerializeWithWriteBuffer(ctx context.Cont
 
 		// Simple Field (version)
 		version := string(m.GetVersion())
-		_versionErr := writeBuffer.WriteString("version", uint32(32), "UTF-8", (version))
+		_versionErr := writeBuffer.WriteString("version", uint32(32), (version), utils.WithEncoding("UTF-8)"))
 		if _versionErr != nil {
 			return errors.Wrap(_versionErr, "Error serializing 'version' field")
 		}
diff --git a/plc4go/protocols/cbus/readwrite/model/IdentifyReplyCommandType.go b/plc4go/protocols/cbus/readwrite/model/IdentifyReplyCommandType.go
index 2e986e3e242..d5ef99c5f57 100644
--- a/plc4go/protocols/cbus/readwrite/model/IdentifyReplyCommandType.go
+++ b/plc4go/protocols/cbus/readwrite/model/IdentifyReplyCommandType.go
@@ -142,7 +142,7 @@ func IdentifyReplyCommandTypeParseWithBuffer(ctx context.Context, readBuffer uti
 	_ = currentPos
 
 	// Simple Field (unitType)
-	_unitType, _unitTypeErr := readBuffer.ReadString("unitType", uint32(64), "UTF-8")
+	_unitType, _unitTypeErr := readBuffer.ReadString("unitType", uint32(64), utils.WithEncoding("UTF-8"))
 	if _unitTypeErr != nil {
 		return nil, errors.Wrap(_unitTypeErr, "Error parsing 'unitType' field of IdentifyReplyCommandType")
 	}
@@ -183,7 +183,7 @@ func (m *_IdentifyReplyCommandType) SerializeWithWriteBuffer(ctx context.Context
 
 		// Simple Field (unitType)
 		unitType := string(m.GetUnitType())
-		_unitTypeErr := writeBuffer.WriteString("unitType", uint32(64), "UTF-8", (unitType))
+		_unitTypeErr := writeBuffer.WriteString("unitType", uint32(64), (unitType), utils.WithEncoding("UTF-8)"))
 		if _unitTypeErr != nil {
 			return errors.Wrap(_unitTypeErr, "Error serializing 'unitType' field")
 		}
diff --git a/plc4go/protocols/cbus/readwrite/model/MediaTransportControlDataCategoryName.go b/plc4go/protocols/cbus/readwrite/model/MediaTransportControlDataCategoryName.go
index f5c8c113802..70943ee7953 100644
--- a/plc4go/protocols/cbus/readwrite/model/MediaTransportControlDataCategoryName.go
+++ b/plc4go/protocols/cbus/readwrite/model/MediaTransportControlDataCategoryName.go
@@ -141,7 +141,7 @@ func MediaTransportControlDataCategoryNameParseWithBuffer(ctx context.Context, r
 	_ = currentPos
 
 	// Simple Field (categoryName)
-	_categoryName, _categoryNameErr := readBuffer.ReadString("categoryName", uint32(((commandTypeContainer.NumBytes())-(1))*(8)), "UTF-8")
+	_categoryName, _categoryNameErr := readBuffer.ReadString("categoryName", uint32(((commandTypeContainer.NumBytes())-(1))*(8)), utils.WithEncoding("UTF-8"))
 	if _categoryNameErr != nil {
 		return nil, errors.Wrap(_categoryNameErr, "Error parsing 'categoryName' field of MediaTransportControlDataCategoryName")
 	}
@@ -180,7 +180,7 @@ func (m *_MediaTransportControlDataCategoryName) SerializeWithWriteBuffer(ctx co
 
 		// Simple Field (categoryName)
 		categoryName := string(m.GetCategoryName())
-		_categoryNameErr := writeBuffer.WriteString("categoryName", uint32(((m.GetCommandTypeContainer().NumBytes())-(1))*(8)), "UTF-8", (categoryName))
+		_categoryNameErr := writeBuffer.WriteString("categoryName", uint32(((m.GetCommandTypeContainer().NumBytes())-(1))*(8)), (categoryName), utils.WithEncoding("UTF-8)"))
 		if _categoryNameErr != nil {
 			return errors.Wrap(_categoryNameErr, "Error serializing 'categoryName' field")
 		}
diff --git a/plc4go/protocols/cbus/readwrite/model/MediaTransportControlDataSelectionName.go b/plc4go/protocols/cbus/readwrite/model/MediaTransportControlDataSelectionName.go
index 39ab3f6dafa..05492d28cfd 100644
--- a/plc4go/protocols/cbus/readwrite/model/MediaTransportControlDataSelectionName.go
+++ b/plc4go/protocols/cbus/readwrite/model/MediaTransportControlDataSelectionName.go
@@ -141,7 +141,7 @@ func MediaTransportControlDataSelectionNameParseWithBuffer(ctx context.Context,
 	_ = currentPos
 
 	// Simple Field (selectionName)
-	_selectionName, _selectionNameErr := readBuffer.ReadString("selectionName", uint32(((commandTypeContainer.NumBytes())-(1))*(8)), "UTF-8")
+	_selectionName, _selectionNameErr := readBuffer.ReadString("selectionName", uint32(((commandTypeContainer.NumBytes())-(1))*(8)), utils.WithEncoding("UTF-8"))
 	if _selectionNameErr != nil {
 		return nil, errors.Wrap(_selectionNameErr, "Error parsing 'selectionName' field of MediaTransportControlDataSelectionName")
 	}
@@ -180,7 +180,7 @@ func (m *_MediaTransportControlDataSelectionName) SerializeWithWriteBuffer(ctx c
 
 		// Simple Field (selectionName)
 		selectionName := string(m.GetSelectionName())
-		_selectionNameErr := writeBuffer.WriteString("selectionName", uint32(((m.GetCommandTypeContainer().NumBytes())-(1))*(8)), "UTF-8", (selectionName))
+		_selectionNameErr := writeBuffer.WriteString("selectionName", uint32(((m.GetCommandTypeContainer().NumBytes())-(1))*(8)), (selectionName), utils.WithEncoding("UTF-8)"))
 		if _selectionNameErr != nil {
 			return errors.Wrap(_selectionNameErr, "Error serializing 'selectionName' field")
 		}
diff --git a/plc4go/protocols/cbus/readwrite/model/MediaTransportControlDataTrackName.go b/plc4go/protocols/cbus/readwrite/model/MediaTransportControlDataTrackName.go
index 7bfadb1ab14..45f25c2af26 100644
--- a/plc4go/protocols/cbus/readwrite/model/MediaTransportControlDataTrackName.go
+++ b/plc4go/protocols/cbus/readwrite/model/MediaTransportControlDataTrackName.go
@@ -141,7 +141,7 @@ func MediaTransportControlDataTrackNameParseWithBuffer(ctx context.Context, read
 	_ = currentPos
 
 	// Simple Field (trackName)
-	_trackName, _trackNameErr := readBuffer.ReadString("trackName", uint32(((commandTypeContainer.NumBytes())-(1))*(8)), "UTF-8")
+	_trackName, _trackNameErr := readBuffer.ReadString("trackName", uint32(((commandTypeContainer.NumBytes())-(1))*(8)), utils.WithEncoding("UTF-8"))
 	if _trackNameErr != nil {
 		return nil, errors.Wrap(_trackNameErr, "Error parsing 'trackName' field of MediaTransportControlDataTrackName")
 	}
@@ -180,7 +180,7 @@ func (m *_MediaTransportControlDataTrackName) SerializeWithWriteBuffer(ctx conte
 
 		// Simple Field (trackName)
 		trackName := string(m.GetTrackName())
-		_trackNameErr := writeBuffer.WriteString("trackName", uint32(((m.GetCommandTypeContainer().NumBytes())-(1))*(8)), "UTF-8", (trackName))
+		_trackNameErr := writeBuffer.WriteString("trackName", uint32(((m.GetCommandTypeContainer().NumBytes())-(1))*(8)), (trackName), utils.WithEncoding("UTF-8)"))
 		if _trackNameErr != nil {
 			return errors.Wrap(_trackNameErr, "Error serializing 'trackName' field")
 		}
diff --git a/plc4go/protocols/cbus/readwrite/model/SecurityDataDisplayMessage.go b/plc4go/protocols/cbus/readwrite/model/SecurityDataDisplayMessage.go
index 9903c95927a..5ab5b3d1671 100644
--- a/plc4go/protocols/cbus/readwrite/model/SecurityDataDisplayMessage.go
+++ b/plc4go/protocols/cbus/readwrite/model/SecurityDataDisplayMessage.go
@@ -141,7 +141,7 @@ func SecurityDataDisplayMessageParseWithBuffer(ctx context.Context, readBuffer u
 	_ = currentPos
 
 	// Simple Field (message)
-	_message, _messageErr := readBuffer.ReadString("message", uint32(((commandTypeContainer.NumBytes())-(1))*(8)), "UTF-8")
+	_message, _messageErr := readBuffer.ReadString("message", uint32(((commandTypeContainer.NumBytes())-(1))*(8)), utils.WithEncoding("UTF-8"))
 	if _messageErr != nil {
 		return nil, errors.Wrap(_messageErr, "Error parsing 'message' field of SecurityDataDisplayMessage")
 	}
@@ -180,7 +180,7 @@ func (m *_SecurityDataDisplayMessage) SerializeWithWriteBuffer(ctx context.Conte
 
 		// Simple Field (message)
 		message := string(m.GetMessage())
-		_messageErr := writeBuffer.WriteString("message", uint32(((m.GetCommandTypeContainer().NumBytes())-(1))*(8)), "UTF-8", (message))
+		_messageErr := writeBuffer.WriteString("message", uint32(((m.GetCommandTypeContainer().NumBytes())-(1))*(8)), (message), utils.WithEncoding("UTF-8)"))
 		if _messageErr != nil {
 			return errors.Wrap(_messageErr, "Error serializing 'message' field")
 		}
diff --git a/plc4go/protocols/cbus/readwrite/model/SecurityDataZoneName.go b/plc4go/protocols/cbus/readwrite/model/SecurityDataZoneName.go
index d2785836616..c0a5b26d39e 100644
--- a/plc4go/protocols/cbus/readwrite/model/SecurityDataZoneName.go
+++ b/plc4go/protocols/cbus/readwrite/model/SecurityDataZoneName.go
@@ -159,7 +159,7 @@ func SecurityDataZoneNameParseWithBuffer(ctx context.Context, readBuffer utils.R
 	zoneNumber := _zoneNumber
 
 	// Simple Field (zoneName)
-	_zoneName, _zoneNameErr := readBuffer.ReadString("zoneName", uint32(88), "UTF-8")
+	_zoneName, _zoneNameErr := readBuffer.ReadString("zoneName", uint32(88), utils.WithEncoding("UTF-8"))
 	if _zoneNameErr != nil {
 		return nil, errors.Wrap(_zoneNameErr, "Error parsing 'zoneName' field of SecurityDataZoneName")
 	}
@@ -206,7 +206,7 @@ func (m *_SecurityDataZoneName) SerializeWithWriteBuffer(ctx context.Context, wr
 
 		// Simple Field (zoneName)
 		zoneName := string(m.GetZoneName())
-		_zoneNameErr := writeBuffer.WriteString("zoneName", uint32(88), "UTF-8", (zoneName))
+		_zoneNameErr := writeBuffer.WriteString("zoneName", uint32(88), (zoneName), utils.WithEncoding("UTF-8)"))
 		if _zoneNameErr != nil {
 			return errors.Wrap(_zoneNameErr, "Error serializing 'zoneName' field")
 		}
diff --git a/plc4go/protocols/cbus/readwrite/model/TelephonyDataDivert.go b/plc4go/protocols/cbus/readwrite/model/TelephonyDataDivert.go
index 45c213acd19..86491e7f235 100644
--- a/plc4go/protocols/cbus/readwrite/model/TelephonyDataDivert.go
+++ b/plc4go/protocols/cbus/readwrite/model/TelephonyDataDivert.go
@@ -141,7 +141,7 @@ func TelephonyDataDivertParseWithBuffer(ctx context.Context, readBuffer utils.Re
 	_ = currentPos
 
 	// Simple Field (number)
-	_number, _numberErr := readBuffer.ReadString("number", uint32(((commandTypeContainer.NumBytes())-(1))*(8)), "UTF-8")
+	_number, _numberErr := readBuffer.ReadString("number", uint32(((commandTypeContainer.NumBytes())-(1))*(8)), utils.WithEncoding("UTF-8"))
 	if _numberErr != nil {
 		return nil, errors.Wrap(_numberErr, "Error parsing 'number' field of TelephonyDataDivert")
 	}
@@ -180,7 +180,7 @@ func (m *_TelephonyDataDivert) SerializeWithWriteBuffer(ctx context.Context, wri
 
 		// Simple Field (number)
 		number := string(m.GetNumber())
-		_numberErr := writeBuffer.WriteString("number", uint32(((m.GetCommandTypeContainer().NumBytes())-(1))*(8)), "UTF-8", (number))
+		_numberErr := writeBuffer.WriteString("number", uint32(((m.GetCommandTypeContainer().NumBytes())-(1))*(8)), (number), utils.WithEncoding("UTF-8)"))
 		if _numberErr != nil {
 			return errors.Wrap(_numberErr, "Error serializing 'number' field")
 		}
diff --git a/plc4go/protocols/cbus/readwrite/model/TelephonyDataLineOffHook.go b/plc4go/protocols/cbus/readwrite/model/TelephonyDataLineOffHook.go
index 0bef961a99e..20b442e1bcf 100644
--- a/plc4go/protocols/cbus/readwrite/model/TelephonyDataLineOffHook.go
+++ b/plc4go/protocols/cbus/readwrite/model/TelephonyDataLineOffHook.go
@@ -165,7 +165,7 @@ func TelephonyDataLineOffHookParseWithBuffer(ctx context.Context, readBuffer uti
 	}
 
 	// Simple Field (number)
-	_number, _numberErr := readBuffer.ReadString("number", uint32(((commandTypeContainer.NumBytes())-(2))*(8)), "UTF-8")
+	_number, _numberErr := readBuffer.ReadString("number", uint32(((commandTypeContainer.NumBytes())-(2))*(8)), utils.WithEncoding("UTF-8"))
 	if _numberErr != nil {
 		return nil, errors.Wrap(_numberErr, "Error parsing 'number' field of TelephonyDataLineOffHook")
 	}
@@ -217,7 +217,7 @@ func (m *_TelephonyDataLineOffHook) SerializeWithWriteBuffer(ctx context.Context
 
 		// Simple Field (number)
 		number := string(m.GetNumber())
-		_numberErr := writeBuffer.WriteString("number", uint32(((m.GetCommandTypeContainer().NumBytes())-(2))*(8)), "UTF-8", (number))
+		_numberErr := writeBuffer.WriteString("number", uint32(((m.GetCommandTypeContainer().NumBytes())-(2))*(8)), (number), utils.WithEncoding("UTF-8)"))
 		if _numberErr != nil {
 			return errors.Wrap(_numberErr, "Error serializing 'number' field")
 		}
diff --git a/plc4go/protocols/cbus/readwrite/model/TelephonyDataRecallLastNumber.go b/plc4go/protocols/cbus/readwrite/model/TelephonyDataRecallLastNumber.go
index 3b6531b0117..e230248b6f9 100644
--- a/plc4go/protocols/cbus/readwrite/model/TelephonyDataRecallLastNumber.go
+++ b/plc4go/protocols/cbus/readwrite/model/TelephonyDataRecallLastNumber.go
@@ -198,7 +198,7 @@ func TelephonyDataRecallLastNumberParseWithBuffer(ctx context.Context, readBuffe
 	_ = isNumberOfLastIncomingCall
 
 	// Simple Field (number)
-	_number, _numberErr := readBuffer.ReadString("number", uint32(((commandTypeContainer.NumBytes())-(2))*(8)), "UTF-8")
+	_number, _numberErr := readBuffer.ReadString("number", uint32(((commandTypeContainer.NumBytes())-(2))*(8)), utils.WithEncoding("UTF-8"))
 	if _numberErr != nil {
 		return nil, errors.Wrap(_numberErr, "Error parsing 'number' field of TelephonyDataRecallLastNumber")
 	}
@@ -257,7 +257,7 @@ func (m *_TelephonyDataRecallLastNumber) SerializeWithWriteBuffer(ctx context.Co
 
 		// Simple Field (number)
 		number := string(m.GetNumber())
-		_numberErr := writeBuffer.WriteString("number", uint32(((m.GetCommandTypeContainer().NumBytes())-(2))*(8)), "UTF-8", (number))
+		_numberErr := writeBuffer.WriteString("number", uint32(((m.GetCommandTypeContainer().NumBytes())-(2))*(8)), (number), utils.WithEncoding("UTF-8)"))
 		if _numberErr != nil {
 			return errors.Wrap(_numberErr, "Error serializing 'number' field")
 		}
diff --git a/plc4go/protocols/cbus/readwrite/model/TelephonyDataRinging.go b/plc4go/protocols/cbus/readwrite/model/TelephonyDataRinging.go
index 68506b2e01c..3b6f19eb11a 100644
--- a/plc4go/protocols/cbus/readwrite/model/TelephonyDataRinging.go
+++ b/plc4go/protocols/cbus/readwrite/model/TelephonyDataRinging.go
@@ -163,7 +163,7 @@ func TelephonyDataRingingParseWithBuffer(ctx context.Context, readBuffer utils.R
 	}
 
 	// Simple Field (number)
-	_number, _numberErr := readBuffer.ReadString("number", uint32(((commandTypeContainer.NumBytes())-(2))*(8)), "UTF-8")
+	_number, _numberErr := readBuffer.ReadString("number", uint32(((commandTypeContainer.NumBytes())-(2))*(8)), utils.WithEncoding("UTF-8"))
 	if _numberErr != nil {
 		return nil, errors.Wrap(_numberErr, "Error parsing 'number' field of TelephonyDataRinging")
 	}
@@ -219,7 +219,7 @@ func (m *_TelephonyDataRinging) SerializeWithWriteBuffer(ctx context.Context, wr
 
 		// Simple Field (number)
 		number := string(m.GetNumber())
-		_numberErr := writeBuffer.WriteString("number", uint32(((m.GetCommandTypeContainer().NumBytes())-(2))*(8)), "UTF-8", (number))
+		_numberErr := writeBuffer.WriteString("number", uint32(((m.GetCommandTypeContainer().NumBytes())-(2))*(8)), (number), utils.WithEncoding("UTF-8)"))
 		if _numberErr != nil {
 			return errors.Wrap(_numberErr, "Error serializing 'number' field")
 		}
diff --git a/plc4go/protocols/eip/readwrite/model/AnsiExtendedSymbolSegment.go b/plc4go/protocols/eip/readwrite/model/AnsiExtendedSymbolSegment.go
index 59bf787af88..6c94b5be1cd 100644
--- a/plc4go/protocols/eip/readwrite/model/AnsiExtendedSymbolSegment.go
+++ b/plc4go/protocols/eip/readwrite/model/AnsiExtendedSymbolSegment.go
@@ -166,7 +166,7 @@ func AnsiExtendedSymbolSegmentParseWithBuffer(ctx context.Context, readBuffer ut
 	}
 
 	// Simple Field (symbol)
-	_symbol, _symbolErr := readBuffer.ReadString("symbol", uint32((dataSize)*(8)), "UTF-8")
+	_symbol, _symbolErr := readBuffer.ReadString("symbol", uint32((dataSize)*(8)), utils.WithEncoding("UTF-8"))
 	if _symbolErr != nil {
 		return nil, errors.Wrap(_symbolErr, "Error parsing 'symbol' field of AnsiExtendedSymbolSegment")
 	}
@@ -229,7 +229,7 @@ func (m *_AnsiExtendedSymbolSegment) SerializeWithWriteBuffer(ctx context.Contex
 
 		// Simple Field (symbol)
 		symbol := string(m.GetSymbol())
-		_symbolErr := writeBuffer.WriteString("symbol", uint32((uint8(len(m.GetSymbol())))*(8)), "UTF-8", (symbol))
+		_symbolErr := writeBuffer.WriteString("symbol", uint32((uint8(len(m.GetSymbol())))*(8)), (symbol), utils.WithEncoding("UTF-8)"))
 		if _symbolErr != nil {
 			return errors.Wrap(_symbolErr, "Error serializing 'symbol' field")
 		}
diff --git a/plc4go/protocols/eip/readwrite/model/CipIdentity.go b/plc4go/protocols/eip/readwrite/model/CipIdentity.go
index dcbd5e5e9fa..2a1ee7a1e93 100644
--- a/plc4go/protocols/eip/readwrite/model/CipIdentity.go
+++ b/plc4go/protocols/eip/readwrite/model/CipIdentity.go
@@ -438,7 +438,7 @@ func CipIdentityParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer
 	}
 
 	// Simple Field (productName)
-	_productName, _productNameErr := readBuffer.ReadString("productName", uint32((productNameLength)*(8)), "UTF-8")
+	_productName, _productNameErr := readBuffer.ReadString("productName", uint32((productNameLength)*(8)), utils.WithEncoding("UTF-8"))
 	if _productNameErr != nil {
 		return nil, errors.Wrap(_productNameErr, "Error parsing 'productName' field of CipIdentity")
 	}
@@ -607,7 +607,7 @@ func (m *_CipIdentity) SerializeWithWriteBuffer(ctx context.Context, writeBuffer
 
 		// Simple Field (productName)
 		productName := string(m.GetProductName())
-		_productNameErr := writeBuffer.WriteString("productName", uint32((uint8(len(m.GetProductName())))*(8)), "UTF-8", (productName))
+		_productNameErr := writeBuffer.WriteString("productName", uint32((uint8(len(m.GetProductName())))*(8)), (productName), utils.WithEncoding("UTF-8)"))
 		if _productNameErr != nil {
 			return errors.Wrap(_productNameErr, "Error serializing 'productName' field")
 		}
diff --git a/plc4go/protocols/eip/readwrite/model/PortSegmentExtended.go b/plc4go/protocols/eip/readwrite/model/PortSegmentExtended.go
index 6d810d77382..61b84fb1ae3 100644
--- a/plc4go/protocols/eip/readwrite/model/PortSegmentExtended.go
+++ b/plc4go/protocols/eip/readwrite/model/PortSegmentExtended.go
@@ -202,7 +202,7 @@ func PortSegmentExtendedParseWithBuffer(ctx context.Context, readBuffer utils.Re
 	_ = paddingByte
 
 	// Simple Field (address)
-	_address, _addressErr := readBuffer.ReadString("address", uint32(((linkAddressSize)*(8))+((paddingByte)*(8))), "UTF-8")
+	_address, _addressErr := readBuffer.ReadString("address", uint32(((linkAddressSize)*(8))+((paddingByte)*(8))), utils.WithEncoding("UTF-8"))
 	if _addressErr != nil {
 		return nil, errors.Wrap(_addressErr, "Error parsing 'address' field of PortSegmentExtended")
 	}
@@ -263,7 +263,7 @@ func (m *_PortSegmentExtended) SerializeWithWriteBuffer(ctx context.Context, wri
 
 		// Simple Field (address)
 		address := string(m.GetAddress())
-		_addressErr := writeBuffer.WriteString("address", uint32(((m.GetLinkAddressSize())*(8))+((m.GetPaddingByte())*(8))), "UTF-8", (address))
+		_addressErr := writeBuffer.WriteString("address", uint32(((m.GetLinkAddressSize())*(8))+((m.GetPaddingByte())*(8))), (address), utils.WithEncoding("UTF-8)"))
 		if _addressErr != nil {
 			return errors.Wrap(_addressErr, "Error serializing 'address' field")
 		}
diff --git a/plc4go/protocols/knxnetip/readwrite/model/KnxDatapoint.go b/plc4go/protocols/knxnetip/readwrite/model/KnxDatapoint.go
index 54a586da079..cf975d2883c 100644
--- a/plc4go/protocols/knxnetip/readwrite/model/KnxDatapoint.go
+++ b/plc4go/protocols/knxnetip/readwrite/model/KnxDatapoint.go
@@ -258,7 +258,7 @@ func KnxDatapointParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffe
 		}
 
 		// Simple Field (value)
-		value, _valueErr := readBuffer.ReadString("value", uint32(8), "UTF-8")
+		value, _valueErr := readBuffer.ReadString("value", uint32(8), utils.WithEncoding("UTF-8"))
 		if _valueErr != nil {
 			return nil, errors.Wrap(_valueErr, "Error parsing 'value' field")
 		}
@@ -272,7 +272,7 @@ func KnxDatapointParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffe
 		}
 
 		// Simple Field (value)
-		value, _valueErr := readBuffer.ReadString("value", uint32(16), "UTF-16")
+		value, _valueErr := readBuffer.ReadString("value", uint32(16), utils.WithEncoding("UTF-16"))
 		if _valueErr != nil {
 			return nil, errors.Wrap(_valueErr, "Error parsing 'value' field")
 		}
@@ -1182,7 +1182,7 @@ func KnxDatapointParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffe
 		}
 
 		// Simple Field (value)
-		value, _valueErr := readBuffer.ReadString("value", uint32(8), "ASCII")
+		value, _valueErr := readBuffer.ReadString("value", uint32(8), utils.WithEncoding("ASCII"))
 		if _valueErr != nil {
 			return nil, errors.Wrap(_valueErr, "Error parsing 'value' field")
 		}
@@ -1196,7 +1196,7 @@ func KnxDatapointParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffe
 		}
 
 		// Simple Field (value)
-		value, _valueErr := readBuffer.ReadString("value", uint32(8), "ISO-8859-1")
+		value, _valueErr := readBuffer.ReadString("value", uint32(8), utils.WithEncoding("ISO-8859-1"))
 		if _valueErr != nil {
 			return nil, errors.Wrap(_valueErr, "Error parsing 'value' field")
 		}
@@ -3637,7 +3637,7 @@ func KnxDatapointParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffe
 		}
 
 		// Simple Field (value)
-		value, _valueErr := readBuffer.ReadString("value", uint32(112), "ASCII")
+		value, _valueErr := readBuffer.ReadString("value", uint32(112), utils.WithEncoding("ASCII"))
 		if _valueErr != nil {
 			return nil, errors.Wrap(_valueErr, "Error parsing 'value' field")
 		}
@@ -3651,7 +3651,7 @@ func KnxDatapointParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffe
 		}
 
 		// Simple Field (value)
-		value, _valueErr := readBuffer.ReadString("value", uint32(112), "ISO-8859-1")
+		value, _valueErr := readBuffer.ReadString("value", uint32(112), utils.WithEncoding("ISO-8859-1"))
 		if _valueErr != nil {
 			return nil, errors.Wrap(_valueErr, "Error parsing 'value' field")
 		}
@@ -7145,7 +7145,7 @@ func KnxDatapointParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffe
 		}
 
 		// Simple Field (value)
-		value, _valueErr := readBuffer.ReadString("value", uint32(16), "ASCII")
+		value, _valueErr := readBuffer.ReadString("value", uint32(16), utils.WithEncoding("ASCII"))
 		if _valueErr != nil {
 			return nil, errors.Wrap(_valueErr, "Error parsing 'value' field")
 		}
@@ -8484,7 +8484,7 @@ func KnxDatapointSerializeWithWriteBuffer(ctx context.Context, writeBuffer utils
 		}
 
 		// Simple Field (value)
-		if _err := writeBuffer.WriteString("value", uint32(8), "UTF-8", value.GetString()); _err != nil {
+		if _err := writeBuffer.WriteString("value", uint32(8), value.GetString(), utils.WithEncoding("UTF-8)")); _err != nil {
 			return errors.Wrap(_err, "Error serializing 'value' field")
 		}
 	case datapointType == KnxDatapointType_WCHAR: // WCHAR
@@ -8494,7 +8494,7 @@ func KnxDatapointSerializeWithWriteBuffer(ctx context.Context, writeBuffer utils
 		}
 
 		// Simple Field (value)
-		if _err := writeBuffer.WriteString("value", uint32(16), "UTF-16", value.GetString()); _err != nil {
+		if _err := writeBuffer.WriteString("value", uint32(16), value.GetString(), utils.WithEncoding("UTF-16)")); _err != nil {
 			return errors.Wrap(_err, "Error serializing 'value' field")
 		}
 	case datapointType == KnxDatapointType_TIME: // TIME
@@ -9094,7 +9094,7 @@ func KnxDatapointSerializeWithWriteBuffer(ctx context.Context, writeBuffer utils
 		}
 
 		// Simple Field (value)
-		if _err := writeBuffer.WriteString("value", uint32(8), "ASCII", value.GetString()); _err != nil {
+		if _err := writeBuffer.WriteString("value", uint32(8), value.GetString(), utils.WithEncoding("ASCII)")); _err != nil {
 			return errors.Wrap(_err, "Error serializing 'value' field")
 		}
 	case datapointType == KnxDatapointType_DPT_Char_8859_1: // STRING
@@ -9104,7 +9104,7 @@ func KnxDatapointSerializeWithWriteBuffer(ctx context.Context, writeBuffer utils
 		}
 
 		// Simple Field (value)
-		if _err := writeBuffer.WriteString("value", uint32(8), "ISO-8859-1", value.GetString()); _err != nil {
+		if _err := writeBuffer.WriteString("value", uint32(8), value.GetString(), utils.WithEncoding("ISO-8859-1)")); _err != nil {
 			return errors.Wrap(_err, "Error serializing 'value' field")
 		}
 	case datapointType == KnxDatapointType_DPT_Scaling: // USINT
@@ -10829,7 +10829,7 @@ func KnxDatapointSerializeWithWriteBuffer(ctx context.Context, writeBuffer utils
 		}
 
 		// Simple Field (value)
-		if _err := writeBuffer.WriteString("value", uint32(112), "ASCII", value.GetString()); _err != nil {
+		if _err := writeBuffer.WriteString("value", uint32(112), value.GetString(), utils.WithEncoding("ASCII)")); _err != nil {
 			return errors.Wrap(_err, "Error serializing 'value' field")
 		}
 	case datapointType == KnxDatapointType_DPT_String_8859_1: // STRING
@@ -10839,7 +10839,7 @@ func KnxDatapointSerializeWithWriteBuffer(ctx context.Context, writeBuffer utils
 		}
 
 		// Simple Field (value)
-		if _err := writeBuffer.WriteString("value", uint32(112), "ISO-8859-1", value.GetString()); _err != nil {
+		if _err := writeBuffer.WriteString("value", uint32(112), value.GetString(), utils.WithEncoding("ISO-8859-1)")); _err != nil {
 			return errors.Wrap(_err, "Error serializing 'value' field")
 		}
 	case datapointType == KnxDatapointType_DPT_SceneNumber: // USINT
@@ -13109,7 +13109,7 @@ func KnxDatapointSerializeWithWriteBuffer(ctx context.Context, writeBuffer utils
 		}
 
 		// Simple Field (value)
-		if _err := writeBuffer.WriteString("value", uint32(16), "ASCII", value.GetString()); _err != nil {
+		if _err := writeBuffer.WriteString("value", uint32(16), value.GetString(), utils.WithEncoding("ASCII)")); _err != nil {
 			return errors.Wrap(_err, "Error serializing 'value' field")
 		}
 	case datapointType == KnxDatapointType_DPT_Tariff_ActiveEnergy: // Struct
diff --git a/plc4go/protocols/knxnetip/readwrite/model/KnxManufacturer.go b/plc4go/protocols/knxnetip/readwrite/model/KnxManufacturer.go
index d21a2e0a0e7..23f40dfc15d 100644
--- a/plc4go/protocols/knxnetip/readwrite/model/KnxManufacturer.go
+++ b/plc4go/protocols/knxnetip/readwrite/model/KnxManufacturer.go
@@ -729,8 +729,9 @@ const (
 	KnxManufacturer_M_VITRUM_DESIGN                                      KnxManufacturer = 683
 	KnxManufacturer_M_DETRONS                                            KnxManufacturer = 684
 	KnxManufacturer_M_ZHEJIANG_FORICK__INTELLIGENT_TECHNOLOGY_CO___LTD   KnxManufacturer = 685
-	KnxManufacturer_M_ABB___RESERVED                                     KnxManufacturer = 686
-	KnxManufacturer_M_BUSCH_JAEGER_ELEKTRO___RESERVED                    KnxManufacturer = 687
+	KnxManufacturer_M_VARNI_DIGITAL_PRIVATE_LIMITED                      KnxManufacturer = 686
+	KnxManufacturer_M_ABB___RESERVED                                     KnxManufacturer = 687
+	KnxManufacturer_M_BUSCH_JAEGER_ELEKTRO___RESERVED                    KnxManufacturer = 688
 )
 
 var KnxManufacturerValues []KnxManufacturer
@@ -1424,6 +1425,7 @@ func init() {
 		KnxManufacturer_M_VITRUM_DESIGN,
 		KnxManufacturer_M_DETRONS,
 		KnxManufacturer_M_ZHEJIANG_FORICK__INTELLIGENT_TECHNOLOGY_CO___LTD,
+		KnxManufacturer_M_VARNI_DIGITAL_PRIVATE_LIMITED,
 		KnxManufacturer_M_ABB___RESERVED,
 		KnxManufacturer_M_BUSCH_JAEGER_ELEKTRO___RESERVED,
 	}
@@ -4041,10 +4043,14 @@ func (e KnxManufacturer) Number() uint16 {
 		}
 	case 686:
 		{ /* '686' */
-			return 43954
+			return 744
 		}
 	case 687:
 		{ /* '687' */
+			return 43954
+		}
+	case 688:
+		{ /* '688' */
 			return 43959
 		}
 	case 69:
@@ -6811,10 +6817,14 @@ func (e KnxManufacturer) Name() string {
 		}
 	case 686:
 		{ /* '686' */
-			return "ABB - reserved"
+			return "Varni Digital Private Limited"
 		}
 	case 687:
 		{ /* '687' */
+			return "ABB - reserved"
+		}
+	case 688:
+		{ /* '688' */
 			return "Busch-Jaeger Elektro - reserved"
 		}
 	case 69:
@@ -8275,8 +8285,10 @@ func KnxManufacturerByValue(value uint16) (enum KnxManufacturer, ok bool) {
 	case 685:
 		return KnxManufacturer_M_ZHEJIANG_FORICK__INTELLIGENT_TECHNOLOGY_CO___LTD, true
 	case 686:
-		return KnxManufacturer_M_ABB___RESERVED, true
+		return KnxManufacturer_M_VARNI_DIGITAL_PRIVATE_LIMITED, true
 	case 687:
+		return KnxManufacturer_M_ABB___RESERVED, true
+	case 688:
 		return KnxManufacturer_M_BUSCH_JAEGER_ELEKTRO___RESERVED, true
 	case 69:
 		return KnxManufacturer_M_EELECTRON, true
@@ -9656,6 +9668,8 @@ func KnxManufacturerByName(value string) (enum KnxManufacturer, ok bool) {
 		return KnxManufacturer_M_DETRONS, true
 	case "M_ZHEJIANG_FORICK__INTELLIGENT_TECHNOLOGY_CO___LTD":
 		return KnxManufacturer_M_ZHEJIANG_FORICK__INTELLIGENT_TECHNOLOGY_CO___LTD, true
+	case "M_VARNI_DIGITAL_PRIVATE_LIMITED":
+		return KnxManufacturer_M_VARNI_DIGITAL_PRIVATE_LIMITED, true
 	case "M_ABB___RESERVED":
 		return KnxManufacturer_M_ABB___RESERVED, true
 	case "M_BUSCH_JAEGER_ELEKTRO___RESERVED":
@@ -11099,6 +11113,8 @@ func (e KnxManufacturer) PLC4XEnumName() string {
 		return "M_DETRONS"
 	case KnxManufacturer_M_ZHEJIANG_FORICK__INTELLIGENT_TECHNOLOGY_CO___LTD:
 		return "M_ZHEJIANG_FORICK__INTELLIGENT_TECHNOLOGY_CO___LTD"
+	case KnxManufacturer_M_VARNI_DIGITAL_PRIVATE_LIMITED:
+		return "M_VARNI_DIGITAL_PRIVATE_LIMITED"
 	case KnxManufacturer_M_ABB___RESERVED:
 		return "M_ABB___RESERVED"
 	case KnxManufacturer_M_BUSCH_JAEGER_ELEKTRO___RESERVED:
diff --git a/plc4go/protocols/modbus/readwrite/model/DataItem.go b/plc4go/protocols/modbus/readwrite/model/DataItem.go
index aad7a91230a..5a944cc7d71 100644
--- a/plc4go/protocols/modbus/readwrite/model/DataItem.go
+++ b/plc4go/protocols/modbus/readwrite/model/DataItem.go
@@ -415,7 +415,7 @@ func DataItemParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer, d
 		return values.NewPlcList(value), nil
 	case dataType == ModbusDataType_CHAR && numberOfValues == uint16(1): // CHAR
 		// Simple Field (value)
-		value, _valueErr := readBuffer.ReadString("value", uint32(8), "UTF-8")
+		value, _valueErr := readBuffer.ReadString("value", uint32(8), utils.WithEncoding("UTF-8"))
 		if _valueErr != nil {
 			return nil, errors.Wrap(_valueErr, "Error parsing 'value' field")
 		}
@@ -426,7 +426,7 @@ func DataItemParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer, d
 		// Array Field (value)
 		var value []api.PlcValue
 		for i := 0; i < int(numberOfValues); i++ {
-			_item, _itemErr := readBuffer.ReadString("value", uint32(8), "UTF-8")
+			_item, _itemErr := readBuffer.ReadString("value", uint32(8), utils.WithEncoding("UTF-8"))
 			if _itemErr != nil {
 				return nil, errors.Wrap(_itemErr, "Error parsing 'value' field")
 			}
@@ -437,7 +437,7 @@ func DataItemParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer, d
 		return values.NewPlcList(value), nil
 	case dataType == ModbusDataType_WCHAR && numberOfValues == uint16(1): // WCHAR
 		// Simple Field (value)
-		value, _valueErr := readBuffer.ReadString("value", uint32(16), "UTF-16")
+		value, _valueErr := readBuffer.ReadString("value", uint32(16), utils.WithEncoding("UTF-16"))
 		if _valueErr != nil {
 			return nil, errors.Wrap(_valueErr, "Error parsing 'value' field")
 		}
@@ -448,7 +448,7 @@ func DataItemParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer, d
 		// Array Field (value)
 		var value []api.PlcValue
 		for i := 0; i < int(numberOfValues); i++ {
-			_item, _itemErr := readBuffer.ReadString("value", uint32(16), "UTF-16")
+			_item, _itemErr := readBuffer.ReadString("value", uint32(16), utils.WithEncoding("UTF-16"))
 			if _itemErr != nil {
 				return nil, errors.Wrap(_itemErr, "Error parsing 'value' field")
 			}
@@ -723,26 +723,26 @@ func DataItemSerializeWithWriteBuffer(ctx context.Context, writeBuffer utils.Wri
 		}
 	case dataType == ModbusDataType_CHAR && numberOfValues == uint16(1): // CHAR
 		// Simple Field (value)
-		if _err := writeBuffer.WriteString("value", uint32(8), "UTF-8", value.GetString()); _err != nil {
+		if _err := writeBuffer.WriteString("value", uint32(8), value.GetString(), utils.WithEncoding("UTF-8)")); _err != nil {
 			return errors.Wrap(_err, "Error serializing 'value' field")
 		}
 	case dataType == ModbusDataType_CHAR: // List
 		// Array Field (value)
 		for i := uint32(0); i < uint32(m.NumberOfValues); i++ {
-			_itemErr := writeBuffer.WriteString("", uint32(8), "UTF-8", value.GetIndex(i).GetString())
+			_itemErr := writeBuffer.WriteString("", uint32(8), value.GetIndex(i).GetString(), utils.WithEncoding("UTF-8)"))
 			if _itemErr != nil {
 				return errors.Wrap(_itemErr, "Error serializing 'value' field")
 			}
 		}
 	case dataType == ModbusDataType_WCHAR && numberOfValues == uint16(1): // WCHAR
 		// Simple Field (value)
-		if _err := writeBuffer.WriteString("value", uint32(16), "UTF-16", value.GetString()); _err != nil {
+		if _err := writeBuffer.WriteString("value", uint32(16), value.GetString(), utils.WithEncoding("UTF-16)")); _err != nil {
 			return errors.Wrap(_err, "Error serializing 'value' field")
 		}
 	case dataType == ModbusDataType_WCHAR: // List
 		// Array Field (value)
 		for i := uint32(0); i < uint32(m.NumberOfValues); i++ {
-			_itemErr := writeBuffer.WriteString("", uint32(16), "UTF-16", value.GetIndex(i).GetString())
+			_itemErr := writeBuffer.WriteString("", uint32(16), value.GetIndex(i).GetString(), utils.WithEncoding("UTF-16)"))
 			if _itemErr != nil {
 				return errors.Wrap(_itemErr, "Error serializing 'value' field")
 			}
diff --git a/plc4go/protocols/opcua/readwrite/model/ChunkType.go b/plc4go/protocols/opcua/readwrite/model/ChunkType.go
index 1524f9a9fb1..b289435a669 100644
--- a/plc4go/protocols/opcua/readwrite/model/ChunkType.go
+++ b/plc4go/protocols/opcua/readwrite/model/ChunkType.go
@@ -115,7 +115,7 @@ func ChunkTypeParse(ctx context.Context, theBytes []byte) (ChunkType, error) {
 func ChunkTypeParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer) (ChunkType, error) {
 	log := zerolog.Ctx(ctx)
 	_ = log
-	val, err := readBuffer.ReadString("ChunkType", uint32(8), "UTF-8")
+	val, err := readBuffer.ReadString("ChunkType", uint32(8), utils.WithEncoding("UTF-8"))
 	if err != nil {
 		return "", errors.Wrap(err, "error reading ChunkType")
 	}
@@ -138,7 +138,7 @@ func (e ChunkType) Serialize() ([]byte, error) {
 func (e ChunkType) SerializeWithWriteBuffer(ctx context.Context, writeBuffer utils.WriteBuffer) error {
 	log := zerolog.Ctx(ctx)
 	_ = log
-	return writeBuffer.WriteString("ChunkType", uint32(8), "UTF-8", string(e), utils.WithAdditionalStringRepresentation(e.PLC4XEnumName()))
+	return writeBuffer.WriteString("ChunkType", uint32(8), string(e), utils.WithAdditionalStringRepresentation(e.PLC4XEnumName()), utils.WithEncoding("UTF-8)"))
 }
 
 // PLC4XEnumName returns the name that is used in code to identify this enum
diff --git a/plc4go/protocols/opcua/readwrite/model/MessagePDU.go b/plc4go/protocols/opcua/readwrite/model/MessagePDU.go
index a4767e6d763..0f971a3317d 100644
--- a/plc4go/protocols/opcua/readwrite/model/MessagePDU.go
+++ b/plc4go/protocols/opcua/readwrite/model/MessagePDU.go
@@ -146,7 +146,7 @@ func MessagePDUParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer,
 	_ = currentPos
 
 	// Discriminator Field (messageType) (Used as input to a switch field)
-	messageType, _messageTypeErr := readBuffer.ReadString("messageType", uint32(24), "UTF-8")
+	messageType, _messageTypeErr := readBuffer.ReadString("messageType", uint32(24), utils.WithEncoding("UTF-8"))
 	if _messageTypeErr != nil {
 		return nil, errors.Wrap(_messageTypeErr, "Error parsing 'messageType' field of MessagePDU")
 	}
@@ -228,7 +228,7 @@ func (pm *_MessagePDU) SerializeParent(ctx context.Context, writeBuffer utils.Wr
 
 	// Discriminator Field (messageType) (Used as input to a switch field)
 	messageType := string(child.GetMessageType())
-	_messageTypeErr := writeBuffer.WriteString("messageType", uint32(24), "UTF-8", (messageType))
+	_messageTypeErr := writeBuffer.WriteString("messageType", uint32(24), (messageType), utils.WithEncoding("UTF-8)"))
 
 	if _messageTypeErr != nil {
 		return errors.Wrap(_messageTypeErr, "Error serializing 'messageType' field")
diff --git a/plc4go/protocols/opcua/readwrite/model/MessageType.go b/plc4go/protocols/opcua/readwrite/model/MessageType.go
index 692d42edf7b..f3090bba01a 100644
--- a/plc4go/protocols/opcua/readwrite/model/MessageType.go
+++ b/plc4go/protocols/opcua/readwrite/model/MessageType.go
@@ -133,7 +133,7 @@ func MessageTypeParse(ctx context.Context, theBytes []byte) (MessageType, error)
 func MessageTypeParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer) (MessageType, error) {
 	log := zerolog.Ctx(ctx)
 	_ = log
-	val, err := readBuffer.ReadString("MessageType", uint32(24), "UTF-8")
+	val, err := readBuffer.ReadString("MessageType", uint32(24), utils.WithEncoding("UTF-8"))
 	if err != nil {
 		return "", errors.Wrap(err, "error reading MessageType")
 	}
@@ -156,7 +156,7 @@ func (e MessageType) Serialize() ([]byte, error) {
 func (e MessageType) SerializeWithWriteBuffer(ctx context.Context, writeBuffer utils.WriteBuffer) error {
 	log := zerolog.Ctx(ctx)
 	_ = log
-	return writeBuffer.WriteString("MessageType", uint32(24), "UTF-8", string(e), utils.WithAdditionalStringRepresentation(e.PLC4XEnumName()))
+	return writeBuffer.WriteString("MessageType", uint32(24), string(e), utils.WithAdditionalStringRepresentation(e.PLC4XEnumName()), utils.WithEncoding("UTF-8)"))
 }
 
 // PLC4XEnumName returns the name that is used in code to identify this enum
diff --git a/plc4go/protocols/opcua/readwrite/model/OpcuaDataType.go b/plc4go/protocols/opcua/readwrite/model/OpcuaDataType.go
index 5dbf97fc903..6e0e4284f47 100644
--- a/plc4go/protocols/opcua/readwrite/model/OpcuaDataType.go
+++ b/plc4go/protocols/opcua/readwrite/model/OpcuaDataType.go
@@ -355,7 +355,7 @@ func OpcuaDataTypeParse(ctx context.Context, theBytes []byte) (OpcuaDataType, er
 func OpcuaDataTypeParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer) (OpcuaDataType, error) {
 	log := zerolog.Ctx(ctx)
 	_ = log
-	val, err := readBuffer.ReadString("OpcuaDataType", uint32(112), "UTF-8")
+	val, err := readBuffer.ReadString("OpcuaDataType", uint32(112), utils.WithEncoding("UTF-8"))
 	if err != nil {
 		return "", errors.Wrap(err, "error reading OpcuaDataType")
 	}
@@ -378,7 +378,7 @@ func (e OpcuaDataType) Serialize() ([]byte, error) {
 func (e OpcuaDataType) SerializeWithWriteBuffer(ctx context.Context, writeBuffer utils.WriteBuffer) error {
 	log := zerolog.Ctx(ctx)
 	_ = log
-	return writeBuffer.WriteString("OpcuaDataType", uint32(112), "UTF-8", string(e), utils.WithAdditionalStringRepresentation(e.PLC4XEnumName()))
+	return writeBuffer.WriteString("OpcuaDataType", uint32(112), string(e), utils.WithAdditionalStringRepresentation(e.PLC4XEnumName()), utils.WithEncoding("UTF-8)"))
 }
 
 // PLC4XEnumName returns the name that is used in code to identify this enum
diff --git a/plc4go/protocols/opcua/readwrite/model/OpcuaIdentifierType.go b/plc4go/protocols/opcua/readwrite/model/OpcuaIdentifierType.go
index 0b9016ca85f..892f765dcea 100644
--- a/plc4go/protocols/opcua/readwrite/model/OpcuaIdentifierType.go
+++ b/plc4go/protocols/opcua/readwrite/model/OpcuaIdentifierType.go
@@ -121,7 +121,7 @@ func OpcuaIdentifierTypeParse(ctx context.Context, theBytes []byte) (OpcuaIdenti
 func OpcuaIdentifierTypeParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer) (OpcuaIdentifierType, error) {
 	log := zerolog.Ctx(ctx)
 	_ = log
-	val, err := readBuffer.ReadString("OpcuaIdentifierType", uint32(8), "UTF-8")
+	val, err := readBuffer.ReadString("OpcuaIdentifierType", uint32(8), utils.WithEncoding("UTF-8"))
 	if err != nil {
 		return "", errors.Wrap(err, "error reading OpcuaIdentifierType")
 	}
@@ -144,7 +144,7 @@ func (e OpcuaIdentifierType) Serialize() ([]byte, error) {
 func (e OpcuaIdentifierType) SerializeWithWriteBuffer(ctx context.Context, writeBuffer utils.WriteBuffer) error {
 	log := zerolog.Ctx(ctx)
 	_ = log
-	return writeBuffer.WriteString("OpcuaIdentifierType", uint32(8), "UTF-8", string(e), utils.WithAdditionalStringRepresentation(e.PLC4XEnumName()))
+	return writeBuffer.WriteString("OpcuaIdentifierType", uint32(8), string(e), utils.WithAdditionalStringRepresentation(e.PLC4XEnumName()), utils.WithEncoding("UTF-8)"))
 }
 
 // PLC4XEnumName returns the name that is used in code to identify this enum
diff --git a/plc4go/protocols/opcua/readwrite/model/PascalString.go b/plc4go/protocols/opcua/readwrite/model/PascalString.go
index b6f37c11ddc..17d8a682d65 100644
--- a/plc4go/protocols/opcua/readwrite/model/PascalString.go
+++ b/plc4go/protocols/opcua/readwrite/model/PascalString.go
@@ -149,7 +149,7 @@ func PascalStringParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffe
 	_ = stringLength
 
 	// Simple Field (stringValue)
-	_stringValue, _stringValueErr := readBuffer.ReadString("stringValue", uint32((stringLength)*(8)), "UTF-8")
+	_stringValue, _stringValueErr := readBuffer.ReadString("stringValue", uint32((stringLength)*(8)), utils.WithEncoding("UTF-8"))
 	if _stringValueErr != nil {
 		return nil, errors.Wrap(_stringValueErr, "Error parsing 'stringValue' field of PascalString")
 	}
@@ -197,7 +197,7 @@ func (m *_PascalString) SerializeWithWriteBuffer(ctx context.Context, writeBuffe
 
 	// Simple Field (stringValue)
 	stringValue := string(m.GetStringValue())
-	_stringValueErr := writeBuffer.WriteString("stringValue", uint32((stringLength)*(8)), "UTF-8", (stringValue))
+	_stringValueErr := writeBuffer.WriteString("stringValue", uint32((stringLength)*(8)), (stringValue), utils.WithEncoding("UTF-8)"))
 	if _stringValueErr != nil {
 		return errors.Wrap(_stringValueErr, "Error serializing 'stringValue' field")
 	}
diff --git a/plc4go/protocols/opcua/readwrite/model/XmlElement.go b/plc4go/protocols/opcua/readwrite/model/XmlElement.go
index 3547f0ed841..bb599b892d0 100644
--- a/plc4go/protocols/opcua/readwrite/model/XmlElement.go
+++ b/plc4go/protocols/opcua/readwrite/model/XmlElement.go
@@ -149,7 +149,7 @@ func XmlElementParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer)
 			arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem))
 			_ = arrayCtx
 			_ = _curItem
-			_item, _err := readBuffer.ReadString("", uint32(8), "UTF-8")
+			_item, _err := readBuffer.ReadString("", uint32(8), utils.WithEncoding("UTF-8"))
 			if _err != nil {
 				return nil, errors.Wrap(_err, "Error parsing 'value' field of XmlElement")
 			}
@@ -201,7 +201,7 @@ func (m *_XmlElement) SerializeWithWriteBuffer(ctx context.Context, writeBuffer
 	}
 	for _curItem, _element := range m.GetValue() {
 		_ = _curItem
-		_elementErr := writeBuffer.WriteString("", uint32(8), "UTF-8", _element)
+		_elementErr := writeBuffer.WriteString("", uint32(8), _element, utils.WithEncoding("UTF-8)"))
 		if _elementErr != nil {
 			return errors.Wrap(_elementErr, "Error serializing 'value' field")
 		}
diff --git a/plc4go/protocols/s7/readwrite/model/DataItem.go b/plc4go/protocols/s7/readwrite/model/DataItem.go
index 90d9a04ee53..bf81aa0279c 100644
--- a/plc4go/protocols/s7/readwrite/model/DataItem.go
+++ b/plc4go/protocols/s7/readwrite/model/DataItem.go
@@ -183,7 +183,7 @@ func DataItemParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer, d
 		return values.NewPlcLREAL(value), nil
 	case dataProtocolId == "IEC61131_CHAR": // CHAR
 		// Simple Field (value)
-		value, _valueErr := readBuffer.ReadString("value", uint32(8), "UTF-8")
+		value, _valueErr := readBuffer.ReadString("value", uint32(8), utils.WithEncoding("UTF-8"))
 		if _valueErr != nil {
 			return nil, errors.Wrap(_valueErr, "Error parsing 'value' field")
 		}
@@ -192,7 +192,7 @@ func DataItemParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer, d
 		return values.NewPlcCHAR(value), nil
 	case dataProtocolId == "IEC61131_WCHAR": // CHAR
 		// Simple Field (value)
-		value, _valueErr := readBuffer.ReadString("value", uint32(16), "UTF-16")
+		value, _valueErr := readBuffer.ReadString("value", uint32(16), utils.WithEncoding("UTF-16"))
 		if _valueErr != nil {
 			return nil, errors.Wrap(_valueErr, "Error parsing 'value' field")
 		}
@@ -504,12 +504,12 @@ func DataItemSerializeWithWriteBuffer(ctx context.Context, writeBuffer utils.Wri
 		}
 	case dataProtocolId == "IEC61131_CHAR": // CHAR
 		// Simple Field (value)
-		if _err := writeBuffer.WriteString("value", uint32(8), "UTF-8", value.GetString()); _err != nil {
+		if _err := writeBuffer.WriteString("value", uint32(8), value.GetString(), utils.WithEncoding("UTF-8)")); _err != nil {
 			return errors.Wrap(_err, "Error serializing 'value' field")
 		}
 	case dataProtocolId == "IEC61131_WCHAR": // CHAR
 		// Simple Field (value)
-		if _err := writeBuffer.WriteString("value", uint32(16), "UTF-16", value.GetString()); _err != nil {
+		if _err := writeBuffer.WriteString("value", uint32(16), value.GetString(), utils.WithEncoding("UTF-16)")); _err != nil {
 			return errors.Wrap(_err, "Error serializing 'value' field")
 		}
 	case dataProtocolId == "IEC61131_STRING": // STRING
diff --git a/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemCpuFunctionMsgSubscriptionRequest.go b/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemCpuFunctionMsgSubscriptionRequest.go
index 4157bcff91b..33b6354221f 100644
--- a/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemCpuFunctionMsgSubscriptionRequest.go
+++ b/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemCpuFunctionMsgSubscriptionRequest.go
@@ -221,7 +221,7 @@ func S7PayloadUserDataItemCpuFunctionMsgSubscriptionRequestParseWithBuffer(ctx c
 	}
 
 	// Simple Field (magicKey)
-	_magicKey, _magicKeyErr := readBuffer.ReadString("magicKey", uint32(64), "UTF-8")
+	_magicKey, _magicKeyErr := readBuffer.ReadString("magicKey", uint32(64), utils.WithEncoding("UTF-8"))
 	if _magicKeyErr != nil {
 		return nil, errors.Wrap(_magicKeyErr, "Error parsing 'magicKey' field of S7PayloadUserDataItemCpuFunctionMsgSubscriptionRequest")
 	}
@@ -325,7 +325,7 @@ func (m *_S7PayloadUserDataItemCpuFunctionMsgSubscriptionRequest) SerializeWithW
 
 		// Simple Field (magicKey)
 		magicKey := string(m.GetMagicKey())
-		_magicKeyErr := writeBuffer.WriteString("magicKey", uint32(64), "UTF-8", (magicKey))
+		_magicKeyErr := writeBuffer.WriteString("magicKey", uint32(64), (magicKey), utils.WithEncoding("UTF-8)"))
 		if _magicKeyErr != nil {
 			return errors.Wrap(_magicKeyErr, "Error serializing 'magicKey' field")
 		}
diff --git a/plc4go/protocols/s7/readwrite/model/StaticHelper.go b/plc4go/protocols/s7/readwrite/model/StaticHelper.go
index 2c2cab981e1..cc21346c0bd 100644
--- a/plc4go/protocols/s7/readwrite/model/StaticHelper.go
+++ b/plc4go/protocols/s7/readwrite/model/StaticHelper.go
@@ -142,7 +142,7 @@ func ParseS7String(ctx context.Context, io utils.ReadBuffer, stringLength int32,
 	case "UTF-16":
 		multiplier = 16
 	}
-	return io.ReadString("", uint32(stringLength*multiplier), encoding)
+	return io.ReadString("", uint32(stringLength*multiplier), utils.WithEncoding(encoding))
 }
 
 func SerializeS7String(ctx context.Context, io utils.WriteBuffer, value values.PlcValue, stringLength int32, encoding string) error {
@@ -153,7 +153,7 @@ func SerializeS7String(ctx context.Context, io utils.WriteBuffer, value values.P
 	case "UTF-16":
 		multiplier = 16
 	}
-	return io.WriteString("", uint32(stringLength*multiplier), encoding, value.GetString())
+	return io.WriteString("", uint32(stringLength*multiplier), value.GetString(), utils.WithEncoding(encoding))
 }
 
 func ParseS7Char(ctx context.Context, io utils.ReadBuffer, encoding string) (uint8, error) {
diff --git a/plc4go/protocols/simulated/readwrite/model/DataItem.go b/plc4go/protocols/simulated/readwrite/model/DataItem.go
index 985b91dada9..5ef0a46326b 100644
--- a/plc4go/protocols/simulated/readwrite/model/DataItem.go
+++ b/plc4go/protocols/simulated/readwrite/model/DataItem.go
@@ -373,7 +373,7 @@ func DataItemParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer, d
 		return values.NewPlcList(value), nil
 	case dataType == "CHAR" && numberOfValues == uint16(1): // CHAR
 		// Simple Field (value)
-		value, _valueErr := readBuffer.ReadString("value", uint32(8), "UTF-8")
+		value, _valueErr := readBuffer.ReadString("value", uint32(8), utils.WithEncoding("UTF-8"))
 		if _valueErr != nil {
 			return nil, errors.Wrap(_valueErr, "Error parsing 'value' field")
 		}
@@ -384,7 +384,7 @@ func DataItemParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer, d
 		// Array Field (value)
 		var value []api.PlcValue
 		for i := 0; i < int(numberOfValues); i++ {
-			_item, _itemErr := readBuffer.ReadString("value", uint32(8), "UTF-8")
+			_item, _itemErr := readBuffer.ReadString("value", uint32(8), utils.WithEncoding("UTF-8"))
 			if _itemErr != nil {
 				return nil, errors.Wrap(_itemErr, "Error parsing 'value' field")
 			}
@@ -395,7 +395,7 @@ func DataItemParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer, d
 		return values.NewPlcList(value), nil
 	case dataType == "WCHAR" && numberOfValues == uint16(1): // WCHAR
 		// Simple Field (value)
-		value, _valueErr := readBuffer.ReadString("value", uint32(16), "UTF-16")
+		value, _valueErr := readBuffer.ReadString("value", uint32(16), utils.WithEncoding("UTF-16"))
 		if _valueErr != nil {
 			return nil, errors.Wrap(_valueErr, "Error parsing 'value' field")
 		}
@@ -406,7 +406,7 @@ func DataItemParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer, d
 		// Array Field (value)
 		var value []api.PlcValue
 		for i := 0; i < int(numberOfValues); i++ {
-			_item, _itemErr := readBuffer.ReadString("value", uint32(16), "UTF-16")
+			_item, _itemErr := readBuffer.ReadString("value", uint32(16), utils.WithEncoding("UTF-16"))
 			if _itemErr != nil {
 				return nil, errors.Wrap(_itemErr, "Error parsing 'value' field")
 			}
@@ -417,7 +417,7 @@ func DataItemParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer, d
 		return values.NewPlcList(value), nil
 	case dataType == "STRING": // STRING
 		// Simple Field (value)
-		value, _valueErr := readBuffer.ReadString("value", uint32(255), "UTF-8")
+		value, _valueErr := readBuffer.ReadString("value", uint32(255), utils.WithEncoding("UTF-8"))
 		if _valueErr != nil {
 			return nil, errors.Wrap(_valueErr, "Error parsing 'value' field")
 		}
@@ -426,7 +426,7 @@ func DataItemParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer, d
 		return values.NewPlcSTRING(value), nil
 	case dataType == "WSTRING": // STRING
 		// Simple Field (value)
-		value, _valueErr := readBuffer.ReadString("value", uint32(255), "UTF-16")
+		value, _valueErr := readBuffer.ReadString("value", uint32(255), utils.WithEncoding("UTF-16"))
 		if _valueErr != nil {
 			return nil, errors.Wrap(_valueErr, "Error parsing 'value' field")
 		}
@@ -656,38 +656,38 @@ func DataItemSerializeWithWriteBuffer(ctx context.Context, writeBuffer utils.Wri
 		}
 	case dataType == "CHAR" && numberOfValues == uint16(1): // CHAR
 		// Simple Field (value)
-		if _err := writeBuffer.WriteString("value", uint32(8), "UTF-8", value.GetString()); _err != nil {
+		if _err := writeBuffer.WriteString("value", uint32(8), value.GetString(), utils.WithEncoding("UTF-8)")); _err != nil {
 			return errors.Wrap(_err, "Error serializing 'value' field")
 		}
 	case dataType == "CHAR": // List
 		// Array Field (value)
 		for i := uint32(0); i < uint32(m.NumberOfValues); i++ {
-			_itemErr := writeBuffer.WriteString("", uint32(8), "UTF-8", value.GetIndex(i).GetString())
+			_itemErr := writeBuffer.WriteString("", uint32(8), value.GetIndex(i).GetString(), utils.WithEncoding("UTF-8)"))
 			if _itemErr != nil {
 				return errors.Wrap(_itemErr, "Error serializing 'value' field")
 			}
 		}
 	case dataType == "WCHAR" && numberOfValues == uint16(1): // WCHAR
 		// Simple Field (value)
-		if _err := writeBuffer.WriteString("value", uint32(16), "UTF-16", value.GetString()); _err != nil {
+		if _err := writeBuffer.WriteString("value", uint32(16), value.GetString(), utils.WithEncoding("UTF-16)")); _err != nil {
 			return errors.Wrap(_err, "Error serializing 'value' field")
 		}
 	case dataType == "WCHAR": // List
 		// Array Field (value)
 		for i := uint32(0); i < uint32(m.NumberOfValues); i++ {
-			_itemErr := writeBuffer.WriteString("", uint32(16), "UTF-16", value.GetIndex(i).GetString())
+			_itemErr := writeBuffer.WriteString("", uint32(16), value.GetIndex(i).GetString(), utils.WithEncoding("UTF-16)"))
 			if _itemErr != nil {
 				return errors.Wrap(_itemErr, "Error serializing 'value' field")
 			}
 		}
 	case dataType == "STRING": // STRING
 		// Simple Field (value)
-		if _err := writeBuffer.WriteString("value", uint32(255), "UTF-8", value.GetString()); _err != nil {
+		if _err := writeBuffer.WriteString("value", uint32(255), value.GetString(), utils.WithEncoding("UTF-8)")); _err != nil {
 			return errors.Wrap(_err, "Error serializing 'value' field")
 		}
 	case dataType == "WSTRING": // STRING
 		// Simple Field (value)
-		if _err := writeBuffer.WriteString("value", uint32(255), "UTF-16", value.GetString()); _err != nil {
+		if _err := writeBuffer.WriteString("value", uint32(255), value.GetString(), utils.WithEncoding("UTF-16)")); _err != nil {
 			return errors.Wrap(_err, "Error serializing 'value' field")
 		}
 	default:
diff --git a/plc4go/spi/default/DefaultConnectionMetadata_plc4xgen.go b/plc4go/spi/default/DefaultConnectionMetadata_plc4xgen.go
index fbf2843e460..86ee9634bf6 100644
--- a/plc4go/spi/default/DefaultConnectionMetadata_plc4xgen.go
+++ b/plc4go/spi/default/DefaultConnectionMetadata_plc4xgen.go
@@ -48,7 +48,7 @@ func (d *DefaultConnectionMetadata) SerializeWithWriteBuffer(ctx context.Context
 	for _name, elem := range d.ConnectionAttributes {
 		name := _name
 
-		if err := writeBuffer.WriteString(name, uint32(len(elem)*8), "UTF-8", elem); err != nil {
+		if err := writeBuffer.WriteString(name, uint32(len(elem)*8), elem); err != nil {
 			return err
 		}
 	}
diff --git a/plc4go/spi/default/defaultCodec_plc4xgen.go b/plc4go/spi/default/defaultCodec_plc4xgen.go
index 7b4d9537180..f742efc996e 100644
--- a/plc4go/spi/default/defaultCodec_plc4xgen.go
+++ b/plc4go/spi/default/defaultCodec_plc4xgen.go
@@ -56,7 +56,7 @@ func (d *defaultCodec) SerializeWithWriteBuffer(ctx context.Context, writeBuffer
 			}
 		} else {
 			stringValue := fmt.Sprintf("%v", d.transportInstance)
-			if err := writeBuffer.WriteString("transportInstance", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+			if err := writeBuffer.WriteString("transportInstance", uint32(len(stringValue)*8), stringValue); err != nil {
 				return err
 			}
 		}
@@ -80,7 +80,7 @@ func (d *defaultCodec) SerializeWithWriteBuffer(ctx context.Context, writeBuffer
 				}
 			} else {
 				stringValue := fmt.Sprintf("%v", elem)
-				if err := writeBuffer.WriteString("value", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+				if err := writeBuffer.WriteString("value", uint32(len(stringValue)*8), stringValue); err != nil {
 					return err
 				}
 			}
@@ -91,7 +91,7 @@ func (d *defaultCodec) SerializeWithWriteBuffer(ctx context.Context, writeBuffer
 	}
 
 	_defaultIncomingMessageChannel_plx4gen_description := fmt.Sprintf("%d element(s)", len(d.defaultIncomingMessageChannel))
-	if err := writeBuffer.WriteString("defaultIncomingMessageChannel", uint32(len(_defaultIncomingMessageChannel_plx4gen_description)*8), "UTF-8", _defaultIncomingMessageChannel_plx4gen_description); err != nil {
+	if err := writeBuffer.WriteString("defaultIncomingMessageChannel", uint32(len(_defaultIncomingMessageChannel_plx4gen_description)*8), _defaultIncomingMessageChannel_plx4gen_description); err != nil {
 		return err
 	}
 
@@ -103,7 +103,7 @@ func (d *defaultCodec) SerializeWithWriteBuffer(ctx context.Context, writeBuffer
 		return err
 	}
 
-	if err := writeBuffer.WriteString("receiveTimeout", uint32(len(d.receiveTimeout.String())*8), "UTF-8", d.receiveTimeout.String()); err != nil {
+	if err := writeBuffer.WriteString("receiveTimeout", uint32(len(d.receiveTimeout.String())*8), d.receiveTimeout.String()); err != nil {
 		return err
 	}
 
diff --git a/plc4go/spi/default/defaultConnection_plc4xgen.go b/plc4go/spi/default/defaultConnection_plc4xgen.go
index 707c15110e7..91b6e64aa1a 100644
--- a/plc4go/spi/default/defaultConnection_plc4xgen.go
+++ b/plc4go/spi/default/defaultConnection_plc4xgen.go
@@ -43,7 +43,7 @@ func (d *defaultConnection) SerializeWithWriteBuffer(ctx context.Context, writeB
 		return err
 	}
 
-	if err := writeBuffer.WriteString("defaultTtl", uint32(len(d.defaultTtl.String())*8), "UTF-8", d.defaultTtl.String()); err != nil {
+	if err := writeBuffer.WriteString("defaultTtl", uint32(len(d.defaultTtl.String())*8), d.defaultTtl.String()); err != nil {
 		return err
 	}
 
@@ -64,7 +64,7 @@ func (d *defaultConnection) SerializeWithWriteBuffer(ctx context.Context, writeB
 			}
 		} else {
 			stringValue := fmt.Sprintf("%v", d.tagHandler)
-			if err := writeBuffer.WriteString("tagHandler", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+			if err := writeBuffer.WriteString("tagHandler", uint32(len(stringValue)*8), stringValue); err != nil {
 				return err
 			}
 		}
@@ -83,7 +83,7 @@ func (d *defaultConnection) SerializeWithWriteBuffer(ctx context.Context, writeB
 			}
 		} else {
 			stringValue := fmt.Sprintf("%v", d.valueHandler)
-			if err := writeBuffer.WriteString("valueHandler", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+			if err := writeBuffer.WriteString("valueHandler", uint32(len(stringValue)*8), stringValue); err != nil {
 				return err
 			}
 		}
diff --git a/plc4go/spi/default/defaultPlcConnectionCloseResult_plc4xgen.go b/plc4go/spi/default/defaultPlcConnectionCloseResult_plc4xgen.go
index 70dd07c890b..b14106029b4 100644
--- a/plc4go/spi/default/defaultPlcConnectionCloseResult_plc4xgen.go
+++ b/plc4go/spi/default/defaultPlcConnectionCloseResult_plc4xgen.go
@@ -56,7 +56,7 @@ func (d *defaultPlcConnectionCloseResult) SerializeWithWriteBuffer(ctx context.C
 			}
 		} else {
 			stringValue := fmt.Sprintf("%v", d.connection)
-			if err := writeBuffer.WriteString("connection", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+			if err := writeBuffer.WriteString("connection", uint32(len(stringValue)*8), stringValue); err != nil {
 				return err
 			}
 		}
@@ -64,7 +64,7 @@ func (d *defaultPlcConnectionCloseResult) SerializeWithWriteBuffer(ctx context.C
 
 	if d.err != nil {
 		_errString := d.err.Error()
-		if err := writeBuffer.WriteString("err", uint32(len(_errString)*8), "UTF-8", _errString); err != nil {
+		if err := writeBuffer.WriteString("err", uint32(len(_errString)*8), _errString); err != nil {
 			return err
 		}
 	}
@@ -87,7 +87,7 @@ func (d *defaultPlcConnectionCloseResult) SerializeWithWriteBuffer(ctx context.C
 				}
 			} else {
 				stringValue := fmt.Sprintf("%v", elem)
-				if err := writeBuffer.WriteString("value", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+				if err := writeBuffer.WriteString("value", uint32(len(stringValue)*8), stringValue); err != nil {
 					return err
 				}
 			}
diff --git a/plc4go/spi/default/defaultPlcConnectionConnectResult_plc4xgen.go b/plc4go/spi/default/defaultPlcConnectionConnectResult_plc4xgen.go
index 49b6cc10c90..b49b9f30dbe 100644
--- a/plc4go/spi/default/defaultPlcConnectionConnectResult_plc4xgen.go
+++ b/plc4go/spi/default/defaultPlcConnectionConnectResult_plc4xgen.go
@@ -56,7 +56,7 @@ func (d *defaultPlcConnectionConnectResult) SerializeWithWriteBuffer(ctx context
 			}
 		} else {
 			stringValue := fmt.Sprintf("%v", d.connection)
-			if err := writeBuffer.WriteString("connection", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+			if err := writeBuffer.WriteString("connection", uint32(len(stringValue)*8), stringValue); err != nil {
 				return err
 			}
 		}
@@ -64,7 +64,7 @@ func (d *defaultPlcConnectionConnectResult) SerializeWithWriteBuffer(ctx context
 
 	if d.err != nil {
 		_errString := d.err.Error()
-		if err := writeBuffer.WriteString("err", uint32(len(_errString)*8), "UTF-8", _errString); err != nil {
+		if err := writeBuffer.WriteString("err", uint32(len(_errString)*8), _errString); err != nil {
 			return err
 		}
 	}
diff --git a/plc4go/spi/default/defaultPlcConnectionPingResult_plc4xgen.go b/plc4go/spi/default/defaultPlcConnectionPingResult_plc4xgen.go
index 5b04219ff80..093051c20e7 100644
--- a/plc4go/spi/default/defaultPlcConnectionPingResult_plc4xgen.go
+++ b/plc4go/spi/default/defaultPlcConnectionPingResult_plc4xgen.go
@@ -45,7 +45,7 @@ func (d *defaultPlcConnectionPingResult) SerializeWithWriteBuffer(ctx context.Co
 
 	if d.err != nil {
 		_errString := d.err.Error()
-		if err := writeBuffer.WriteString("err", uint32(len(_errString)*8), "UTF-8", _errString); err != nil {
+		if err := writeBuffer.WriteString("err", uint32(len(_errString)*8), _errString); err != nil {
 			return err
 		}
 	}
diff --git a/plc4go/spi/interceptors/interceptedPlcReadRequestResult_plc4xgen.go b/plc4go/spi/interceptors/interceptedPlcReadRequestResult_plc4xgen.go
index 7a8939c8d1e..e3f3f479e70 100644
--- a/plc4go/spi/interceptors/interceptedPlcReadRequestResult_plc4xgen.go
+++ b/plc4go/spi/interceptors/interceptedPlcReadRequestResult_plc4xgen.go
@@ -56,7 +56,7 @@ func (d *interceptedPlcReadRequestResult) SerializeWithWriteBuffer(ctx context.C
 			}
 		} else {
 			stringValue := fmt.Sprintf("%v", d.Request)
-			if err := writeBuffer.WriteString("request", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+			if err := writeBuffer.WriteString("request", uint32(len(stringValue)*8), stringValue); err != nil {
 				return err
 			}
 		}
@@ -75,7 +75,7 @@ func (d *interceptedPlcReadRequestResult) SerializeWithWriteBuffer(ctx context.C
 			}
 		} else {
 			stringValue := fmt.Sprintf("%v", d.Response)
-			if err := writeBuffer.WriteString("response", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+			if err := writeBuffer.WriteString("response", uint32(len(stringValue)*8), stringValue); err != nil {
 				return err
 			}
 		}
@@ -83,7 +83,7 @@ func (d *interceptedPlcReadRequestResult) SerializeWithWriteBuffer(ctx context.C
 
 	if d.Err != nil {
 		_errString := d.Err.Error()
-		if err := writeBuffer.WriteString("err", uint32(len(_errString)*8), "UTF-8", _errString); err != nil {
+		if err := writeBuffer.WriteString("err", uint32(len(_errString)*8), _errString); err != nil {
 			return err
 		}
 	}
diff --git a/plc4go/spi/interceptors/interceptedPlcWriteRequestResult_plc4xgen.go b/plc4go/spi/interceptors/interceptedPlcWriteRequestResult_plc4xgen.go
index 8c560584b8b..1f52dfa65c3 100644
--- a/plc4go/spi/interceptors/interceptedPlcWriteRequestResult_plc4xgen.go
+++ b/plc4go/spi/interceptors/interceptedPlcWriteRequestResult_plc4xgen.go
@@ -56,7 +56,7 @@ func (d *interceptedPlcWriteRequestResult) SerializeWithWriteBuffer(ctx context.
 			}
 		} else {
 			stringValue := fmt.Sprintf("%v", d.Request)
-			if err := writeBuffer.WriteString("request", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+			if err := writeBuffer.WriteString("request", uint32(len(stringValue)*8), stringValue); err != nil {
 				return err
 			}
 		}
@@ -75,7 +75,7 @@ func (d *interceptedPlcWriteRequestResult) SerializeWithWriteBuffer(ctx context.
 			}
 		} else {
 			stringValue := fmt.Sprintf("%v", d.Response)
-			if err := writeBuffer.WriteString("response", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+			if err := writeBuffer.WriteString("response", uint32(len(stringValue)*8), stringValue); err != nil {
 				return err
 			}
 		}
@@ -83,7 +83,7 @@ func (d *interceptedPlcWriteRequestResult) SerializeWithWriteBuffer(ctx context.
 
 	if d.Err != nil {
 		_errString := d.Err.Error()
-		if err := writeBuffer.WriteString("err", uint32(len(_errString)*8), "UTF-8", _errString); err != nil {
+		if err := writeBuffer.WriteString("err", uint32(len(_errString)*8), _errString); err != nil {
 			return err
 		}
 	}
diff --git a/plc4go/spi/model/DefaultPlcBrowseItem_plc4xgen.go b/plc4go/spi/model/DefaultPlcBrowseItem_plc4xgen.go
index 695569c3355..9d3aca4e0fb 100644
--- a/plc4go/spi/model/DefaultPlcBrowseItem_plc4xgen.go
+++ b/plc4go/spi/model/DefaultPlcBrowseItem_plc4xgen.go
@@ -56,17 +56,17 @@ func (d *DefaultPlcBrowseItem) SerializeWithWriteBuffer(ctx context.Context, wri
 			}
 		} else {
 			stringValue := fmt.Sprintf("%v", d.Tag)
-			if err := writeBuffer.WriteString("tag", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+			if err := writeBuffer.WriteString("tag", uint32(len(stringValue)*8), stringValue); err != nil {
 				return err
 			}
 		}
 	}
 
-	if err := writeBuffer.WriteString("name", uint32(len(d.Name)*8), "UTF-8", d.Name); err != nil {
+	if err := writeBuffer.WriteString("name", uint32(len(d.Name)*8), d.Name); err != nil {
 		return err
 	}
 
-	if err := writeBuffer.WriteString("dataTypeName", uint32(len(d.DataTypeName)*8), "UTF-8", d.DataTypeName); err != nil {
+	if err := writeBuffer.WriteString("dataTypeName", uint32(len(d.DataTypeName)*8), d.DataTypeName); err != nil {
 		return err
 	}
 
@@ -100,7 +100,7 @@ func (d *DefaultPlcBrowseItem) SerializeWithWriteBuffer(ctx context.Context, wri
 			}
 		} else {
 			elemAsString := fmt.Sprintf("%v", elem)
-			if err := writeBuffer.WriteString(name, uint32(len(elemAsString)*8), "UTF-8", elemAsString); err != nil {
+			if err := writeBuffer.WriteString(name, uint32(len(elemAsString)*8), elemAsString); err != nil {
 				return err
 			}
 		}
@@ -127,7 +127,7 @@ func (d *DefaultPlcBrowseItem) SerializeWithWriteBuffer(ctx context.Context, wri
 			}
 		} else {
 			elemAsString := fmt.Sprintf("%v", elem)
-			if err := writeBuffer.WriteString(name, uint32(len(elemAsString)*8), "UTF-8", elemAsString); err != nil {
+			if err := writeBuffer.WriteString(name, uint32(len(elemAsString)*8), elemAsString); err != nil {
 				return err
 			}
 		}
diff --git a/plc4go/spi/model/DefaultPlcBrowseRequestBuilder_plc4xgen.go b/plc4go/spi/model/DefaultPlcBrowseRequestBuilder_plc4xgen.go
index fa1f0ea27bc..4cc54b50438 100644
--- a/plc4go/spi/model/DefaultPlcBrowseRequestBuilder_plc4xgen.go
+++ b/plc4go/spi/model/DefaultPlcBrowseRequestBuilder_plc4xgen.go
@@ -46,7 +46,7 @@ func (d *DefaultPlcBrowseRequestBuilder) SerializeWithWriteBuffer(ctx context.Co
 		return err
 	}
 	for _, elem := range d.queryNames {
-		if err := writeBuffer.WriteString("", uint32(len(elem)*8), "UTF-8", elem); err != nil {
+		if err := writeBuffer.WriteString("", uint32(len(elem)*8), elem); err != nil {
 			return err
 		}
 	}
@@ -59,7 +59,7 @@ func (d *DefaultPlcBrowseRequestBuilder) SerializeWithWriteBuffer(ctx context.Co
 	for _name, elem := range d.queryStrings {
 		name := _name
 
-		if err := writeBuffer.WriteString(name, uint32(len(elem)*8), "UTF-8", elem); err != nil {
+		if err := writeBuffer.WriteString(name, uint32(len(elem)*8), elem); err != nil {
 			return err
 		}
 	}
diff --git a/plc4go/spi/model/DefaultPlcBrowseRequestResult_plc4xgen.go b/plc4go/spi/model/DefaultPlcBrowseRequestResult_plc4xgen.go
index 8adb4eb74d4..4cb507d734e 100644
--- a/plc4go/spi/model/DefaultPlcBrowseRequestResult_plc4xgen.go
+++ b/plc4go/spi/model/DefaultPlcBrowseRequestResult_plc4xgen.go
@@ -56,7 +56,7 @@ func (d *DefaultPlcBrowseRequestResult) SerializeWithWriteBuffer(ctx context.Con
 			}
 		} else {
 			stringValue := fmt.Sprintf("%v", d.Request)
-			if err := writeBuffer.WriteString("request", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+			if err := writeBuffer.WriteString("request", uint32(len(stringValue)*8), stringValue); err != nil {
 				return err
 			}
 		}
@@ -75,7 +75,7 @@ func (d *DefaultPlcBrowseRequestResult) SerializeWithWriteBuffer(ctx context.Con
 			}
 		} else {
 			stringValue := fmt.Sprintf("%v", d.Response)
-			if err := writeBuffer.WriteString("response", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+			if err := writeBuffer.WriteString("response", uint32(len(stringValue)*8), stringValue); err != nil {
 				return err
 			}
 		}
@@ -83,7 +83,7 @@ func (d *DefaultPlcBrowseRequestResult) SerializeWithWriteBuffer(ctx context.Con
 
 	if d.Err != nil {
 		_errString := d.Err.Error()
-		if err := writeBuffer.WriteString("err", uint32(len(_errString)*8), "UTF-8", _errString); err != nil {
+		if err := writeBuffer.WriteString("err", uint32(len(_errString)*8), _errString); err != nil {
 			return err
 		}
 	}
diff --git a/plc4go/spi/model/DefaultPlcBrowseRequest_plc4xgen.go b/plc4go/spi/model/DefaultPlcBrowseRequest_plc4xgen.go
index 307d715789e..93531709d68 100644
--- a/plc4go/spi/model/DefaultPlcBrowseRequest_plc4xgen.go
+++ b/plc4go/spi/model/DefaultPlcBrowseRequest_plc4xgen.go
@@ -56,7 +56,7 @@ func (d *DefaultPlcBrowseRequest) SerializeWithWriteBuffer(ctx context.Context,
 			}
 		} else {
 			stringValue := fmt.Sprintf("%v", d.browser)
-			if err := writeBuffer.WriteString("browser", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+			if err := writeBuffer.WriteString("browser", uint32(len(stringValue)*8), stringValue); err != nil {
 				return err
 			}
 		}
@@ -65,7 +65,7 @@ func (d *DefaultPlcBrowseRequest) SerializeWithWriteBuffer(ctx context.Context,
 		return err
 	}
 	for _, elem := range d.queryNames {
-		if err := writeBuffer.WriteString("", uint32(len(elem)*8), "UTF-8", elem); err != nil {
+		if err := writeBuffer.WriteString("", uint32(len(elem)*8), elem); err != nil {
 			return err
 		}
 	}
@@ -91,7 +91,7 @@ func (d *DefaultPlcBrowseRequest) SerializeWithWriteBuffer(ctx context.Context,
 			}
 		} else {
 			elemAsString := fmt.Sprintf("%v", elem)
-			if err := writeBuffer.WriteString(name, uint32(len(elemAsString)*8), "UTF-8", elemAsString); err != nil {
+			if err := writeBuffer.WriteString(name, uint32(len(elemAsString)*8), elemAsString); err != nil {
 				return err
 			}
 		}
diff --git a/plc4go/spi/model/DefaultPlcBrowseResponseItem_plc4xgen.go b/plc4go/spi/model/DefaultPlcBrowseResponseItem_plc4xgen.go
index c4fcc90b32f..01155d67aeb 100644
--- a/plc4go/spi/model/DefaultPlcBrowseResponseItem_plc4xgen.go
+++ b/plc4go/spi/model/DefaultPlcBrowseResponseItem_plc4xgen.go
@@ -43,7 +43,7 @@ func (d *DefaultPlcBrowseResponseItem) SerializeWithWriteBuffer(ctx context.Cont
 		return err
 	}
 
-	if err := writeBuffer.WriteString("code", uint32(len(d.code.String())*8), "UTF-8", d.code.String()); err != nil {
+	if err := writeBuffer.WriteString("code", uint32(len(d.code.String())*8), d.code.String()); err != nil {
 		return err
 	}
 	if err := writeBuffer.PushContext("results", utils.WithRenderAsList(true)); err != nil {
@@ -65,7 +65,7 @@ func (d *DefaultPlcBrowseResponseItem) SerializeWithWriteBuffer(ctx context.Cont
 				}
 			} else {
 				stringValue := fmt.Sprintf("%v", elem)
-				if err := writeBuffer.WriteString("value", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+				if err := writeBuffer.WriteString("value", uint32(len(stringValue)*8), stringValue); err != nil {
 					return err
 				}
 			}
diff --git a/plc4go/spi/model/DefaultPlcBrowseResponse_plc4xgen.go b/plc4go/spi/model/DefaultPlcBrowseResponse_plc4xgen.go
index 9d59448e322..e5838bfb57d 100644
--- a/plc4go/spi/model/DefaultPlcBrowseResponse_plc4xgen.go
+++ b/plc4go/spi/model/DefaultPlcBrowseResponse_plc4xgen.go
@@ -56,13 +56,13 @@ func (d *DefaultPlcBrowseResponse) SerializeWithWriteBuffer(ctx context.Context,
 			}
 		} else {
 			stringValue := fmt.Sprintf("%v", d.request)
-			if err := writeBuffer.WriteString("request", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+			if err := writeBuffer.WriteString("request", uint32(len(stringValue)*8), stringValue); err != nil {
 				return err
 			}
 		}
 	}
 
-	if err := writeBuffer.WriteString("responseCode", uint32(len(d.responseCode.String())*8), "UTF-8", d.responseCode.String()); err != nil {
+	if err := writeBuffer.WriteString("responseCode", uint32(len(d.responseCode.String())*8), d.responseCode.String()); err != nil {
 		return err
 	}
 	if err := writeBuffer.PushContext("results", utils.WithRenderAsList(true)); err != nil {
@@ -84,7 +84,7 @@ func (d *DefaultPlcBrowseResponse) SerializeWithWriteBuffer(ctx context.Context,
 			}
 		} else {
 			elemAsString := fmt.Sprintf("%v", elem)
-			if err := writeBuffer.WriteString(name, uint32(len(elemAsString)*8), "UTF-8", elemAsString); err != nil {
+			if err := writeBuffer.WriteString(name, uint32(len(elemAsString)*8), elemAsString); err != nil {
 				return err
 			}
 		}
diff --git a/plc4go/spi/model/DefaultPlcConsumerRegistration_plc4xgen.go b/plc4go/spi/model/DefaultPlcConsumerRegistration_plc4xgen.go
index 9b2d0aae791..ee9c19fb7f8 100644
--- a/plc4go/spi/model/DefaultPlcConsumerRegistration_plc4xgen.go
+++ b/plc4go/spi/model/DefaultPlcConsumerRegistration_plc4xgen.go
@@ -65,7 +65,7 @@ func (d *DefaultPlcConsumerRegistration) SerializeWithWriteBuffer(ctx context.Co
 				}
 			} else {
 				stringValue := fmt.Sprintf("%v", elem)
-				if err := writeBuffer.WriteString("value", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+				if err := writeBuffer.WriteString("value", uint32(len(stringValue)*8), stringValue); err != nil {
 					return err
 				}
 			}
diff --git a/plc4go/spi/model/DefaultPlcDiscoveryItem_plc4xgen.go b/plc4go/spi/model/DefaultPlcDiscoveryItem_plc4xgen.go
index 014ec63b7f1..40f94cca3b3 100644
--- a/plc4go/spi/model/DefaultPlcDiscoveryItem_plc4xgen.go
+++ b/plc4go/spi/model/DefaultPlcDiscoveryItem_plc4xgen.go
@@ -43,11 +43,11 @@ func (d *DefaultPlcDiscoveryItem) SerializeWithWriteBuffer(ctx context.Context,
 		return err
 	}
 
-	if err := writeBuffer.WriteString("protocolCode", uint32(len(d.ProtocolCode)*8), "UTF-8", d.ProtocolCode); err != nil {
+	if err := writeBuffer.WriteString("protocolCode", uint32(len(d.ProtocolCode)*8), d.ProtocolCode); err != nil {
 		return err
 	}
 
-	if err := writeBuffer.WriteString("transportCode", uint32(len(d.TransportCode)*8), "UTF-8", d.TransportCode); err != nil {
+	if err := writeBuffer.WriteString("transportCode", uint32(len(d.TransportCode)*8), d.TransportCode); err != nil {
 		return err
 	}
 	if err := writeBuffer.PushContext("options", utils.WithRenderAsList(true)); err != nil {
@@ -57,7 +57,7 @@ func (d *DefaultPlcDiscoveryItem) SerializeWithWriteBuffer(ctx context.Context,
 		name := _name
 		_value := fmt.Sprintf("%v", elem)
 
-		if err := writeBuffer.WriteString(name, uint32(len(_value)*8), "UTF-8", _value); err != nil {
+		if err := writeBuffer.WriteString(name, uint32(len(_value)*8), _value); err != nil {
 			return err
 		}
 	}
@@ -65,7 +65,7 @@ func (d *DefaultPlcDiscoveryItem) SerializeWithWriteBuffer(ctx context.Context,
 		return err
 	}
 
-	if err := writeBuffer.WriteString("name", uint32(len(d.Name)*8), "UTF-8", d.Name); err != nil {
+	if err := writeBuffer.WriteString("name", uint32(len(d.Name)*8), d.Name); err != nil {
 		return err
 	}
 	if err := writeBuffer.PushContext("attributes", utils.WithRenderAsList(true)); err != nil {
@@ -87,7 +87,7 @@ func (d *DefaultPlcDiscoveryItem) SerializeWithWriteBuffer(ctx context.Context,
 			}
 		} else {
 			elemAsString := fmt.Sprintf("%v", elem)
-			if err := writeBuffer.WriteString(name, uint32(len(elemAsString)*8), "UTF-8", elemAsString); err != nil {
+			if err := writeBuffer.WriteString(name, uint32(len(elemAsString)*8), elemAsString); err != nil {
 				return err
 			}
 		}
diff --git a/plc4go/spi/model/DefaultPlcReadRequestBuilder_plc4xgen.go b/plc4go/spi/model/DefaultPlcReadRequestBuilder_plc4xgen.go
index a060e54860f..0d2bad924ef 100644
--- a/plc4go/spi/model/DefaultPlcReadRequestBuilder_plc4xgen.go
+++ b/plc4go/spi/model/DefaultPlcReadRequestBuilder_plc4xgen.go
@@ -46,7 +46,7 @@ func (d *DefaultPlcReadRequestBuilder) SerializeWithWriteBuffer(ctx context.Cont
 		return err
 	}
 	for _, elem := range d.tagNames {
-		if err := writeBuffer.WriteString("", uint32(len(elem)*8), "UTF-8", elem); err != nil {
+		if err := writeBuffer.WriteString("", uint32(len(elem)*8), elem); err != nil {
 			return err
 		}
 	}
@@ -59,7 +59,7 @@ func (d *DefaultPlcReadRequestBuilder) SerializeWithWriteBuffer(ctx context.Cont
 	for _name, elem := range d.tagAddresses {
 		name := _name
 
-		if err := writeBuffer.WriteString(name, uint32(len(elem)*8), "UTF-8", elem); err != nil {
+		if err := writeBuffer.WriteString(name, uint32(len(elem)*8), elem); err != nil {
 			return err
 		}
 	}
@@ -85,7 +85,7 @@ func (d *DefaultPlcReadRequestBuilder) SerializeWithWriteBuffer(ctx context.Cont
 			}
 		} else {
 			elemAsString := fmt.Sprintf("%v", elem)
-			if err := writeBuffer.WriteString(name, uint32(len(elemAsString)*8), "UTF-8", elemAsString); err != nil {
+			if err := writeBuffer.WriteString(name, uint32(len(elemAsString)*8), elemAsString); err != nil {
 				return err
 			}
 		}
diff --git a/plc4go/spi/model/DefaultPlcReadRequestResult_plc4xgen.go b/plc4go/spi/model/DefaultPlcReadRequestResult_plc4xgen.go
index b4904846e8b..5e11734f7d1 100644
--- a/plc4go/spi/model/DefaultPlcReadRequestResult_plc4xgen.go
+++ b/plc4go/spi/model/DefaultPlcReadRequestResult_plc4xgen.go
@@ -56,7 +56,7 @@ func (d *DefaultPlcReadRequestResult) SerializeWithWriteBuffer(ctx context.Conte
 			}
 		} else {
 			stringValue := fmt.Sprintf("%v", d.Request)
-			if err := writeBuffer.WriteString("request", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+			if err := writeBuffer.WriteString("request", uint32(len(stringValue)*8), stringValue); err != nil {
 				return err
 			}
 		}
@@ -75,7 +75,7 @@ func (d *DefaultPlcReadRequestResult) SerializeWithWriteBuffer(ctx context.Conte
 			}
 		} else {
 			stringValue := fmt.Sprintf("%v", d.Response)
-			if err := writeBuffer.WriteString("response", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+			if err := writeBuffer.WriteString("response", uint32(len(stringValue)*8), stringValue); err != nil {
 				return err
 			}
 		}
@@ -83,7 +83,7 @@ func (d *DefaultPlcReadRequestResult) SerializeWithWriteBuffer(ctx context.Conte
 
 	if d.Err != nil {
 		_errString := d.Err.Error()
-		if err := writeBuffer.WriteString("err", uint32(len(_errString)*8), "UTF-8", _errString); err != nil {
+		if err := writeBuffer.WriteString("err", uint32(len(_errString)*8), _errString); err != nil {
 			return err
 		}
 	}
diff --git a/plc4go/spi/model/DefaultPlcReadResponse_plc4xgen.go b/plc4go/spi/model/DefaultPlcReadResponse_plc4xgen.go
index 344b55788a2..5b1ea01def2 100644
--- a/plc4go/spi/model/DefaultPlcReadResponse_plc4xgen.go
+++ b/plc4go/spi/model/DefaultPlcReadResponse_plc4xgen.go
@@ -56,7 +56,7 @@ func (d *DefaultPlcReadResponse) SerializeWithWriteBuffer(ctx context.Context, w
 			}
 		} else {
 			stringValue := fmt.Sprintf("%v", d.request)
-			if err := writeBuffer.WriteString("request", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+			if err := writeBuffer.WriteString("request", uint32(len(stringValue)*8), stringValue); err != nil {
 				return err
 			}
 		}
@@ -80,7 +80,7 @@ func (d *DefaultPlcReadResponse) SerializeWithWriteBuffer(ctx context.Context, w
 			}
 		} else {
 			elemAsString := fmt.Sprintf("%v", elem)
-			if err := writeBuffer.WriteString(name, uint32(len(elemAsString)*8), "UTF-8", elemAsString); err != nil {
+			if err := writeBuffer.WriteString(name, uint32(len(elemAsString)*8), elemAsString); err != nil {
 				return err
 			}
 		}
diff --git a/plc4go/spi/model/DefaultPlcSubscriptionEventItem_plc4xgen.go b/plc4go/spi/model/DefaultPlcSubscriptionEventItem_plc4xgen.go
index 4a664224a46..9c8bb926832 100644
--- a/plc4go/spi/model/DefaultPlcSubscriptionEventItem_plc4xgen.go
+++ b/plc4go/spi/model/DefaultPlcSubscriptionEventItem_plc4xgen.go
@@ -43,7 +43,7 @@ func (d *DefaultPlcSubscriptionEventItem) SerializeWithWriteBuffer(ctx context.C
 		return err
 	}
 
-	if err := writeBuffer.WriteString("code", uint32(len(d.code.String())*8), "UTF-8", d.code.String()); err != nil {
+	if err := writeBuffer.WriteString("code", uint32(len(d.code.String())*8), d.code.String()); err != nil {
 		return err
 	}
 
@@ -60,17 +60,17 @@ func (d *DefaultPlcSubscriptionEventItem) SerializeWithWriteBuffer(ctx context.C
 			}
 		} else {
 			stringValue := fmt.Sprintf("%v", d.tag)
-			if err := writeBuffer.WriteString("tag", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+			if err := writeBuffer.WriteString("tag", uint32(len(stringValue)*8), stringValue); err != nil {
 				return err
 			}
 		}
 	}
 
-	if err := writeBuffer.WriteString("subscriptionType", uint32(len(d.subscriptionType.String())*8), "UTF-8", d.subscriptionType.String()); err != nil {
+	if err := writeBuffer.WriteString("subscriptionType", uint32(len(d.subscriptionType.String())*8), d.subscriptionType.String()); err != nil {
 		return err
 	}
 
-	if err := writeBuffer.WriteString("interval", uint32(len(d.interval.String())*8), "UTF-8", d.interval.String()); err != nil {
+	if err := writeBuffer.WriteString("interval", uint32(len(d.interval.String())*8), d.interval.String()); err != nil {
 		return err
 	}
 
@@ -87,7 +87,7 @@ func (d *DefaultPlcSubscriptionEventItem) SerializeWithWriteBuffer(ctx context.C
 			}
 		} else {
 			stringValue := fmt.Sprintf("%v", d.value)
-			if err := writeBuffer.WriteString("value", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+			if err := writeBuffer.WriteString("value", uint32(len(stringValue)*8), stringValue); err != nil {
 				return err
 			}
 		}
diff --git a/plc4go/spi/model/DefaultPlcSubscriptionEvent_plc4xgen.go b/plc4go/spi/model/DefaultPlcSubscriptionEvent_plc4xgen.go
index 91f666fcd45..53663765c51 100644
--- a/plc4go/spi/model/DefaultPlcSubscriptionEvent_plc4xgen.go
+++ b/plc4go/spi/model/DefaultPlcSubscriptionEvent_plc4xgen.go
@@ -61,7 +61,7 @@ func (d *DefaultPlcSubscriptionEvent) SerializeWithWriteBuffer(ctx context.Conte
 			}
 		} else {
 			elemAsString := fmt.Sprintf("%v", elem)
-			if err := writeBuffer.WriteString(name, uint32(len(elemAsString)*8), "UTF-8", elemAsString); err != nil {
+			if err := writeBuffer.WriteString(name, uint32(len(elemAsString)*8), elemAsString); err != nil {
 				return err
 			}
 		}
diff --git a/plc4go/spi/model/DefaultPlcSubscriptionHandle_plc4xgen.go b/plc4go/spi/model/DefaultPlcSubscriptionHandle_plc4xgen.go
index 922fcd3e2b6..e60b2c5afb6 100644
--- a/plc4go/spi/model/DefaultPlcSubscriptionHandle_plc4xgen.go
+++ b/plc4go/spi/model/DefaultPlcSubscriptionHandle_plc4xgen.go
@@ -43,7 +43,7 @@ func (d *DefaultPlcSubscriptionHandle) SerializeWithWriteBuffer(ctx context.Cont
 		return err
 	}
 
-	if err := writeBuffer.WriteString("uuid", uint32(len(d.uuid.String())*8), "UTF-8", d.uuid.String()); err != nil {
+	if err := writeBuffer.WriteString("uuid", uint32(len(d.uuid.String())*8), d.uuid.String()); err != nil {
 		return err
 	}
 	if err := writeBuffer.PopContext("PlcSubscriptionHandle"); err != nil {
diff --git a/plc4go/spi/model/DefaultPlcSubscriptionRequestBuilder_plc4xgen.go b/plc4go/spi/model/DefaultPlcSubscriptionRequestBuilder_plc4xgen.go
index 629d0a8fcb4..73446bf1b0f 100644
--- a/plc4go/spi/model/DefaultPlcSubscriptionRequestBuilder_plc4xgen.go
+++ b/plc4go/spi/model/DefaultPlcSubscriptionRequestBuilder_plc4xgen.go
@@ -46,7 +46,7 @@ func (d *DefaultPlcSubscriptionRequestBuilder) SerializeWithWriteBuffer(ctx cont
 		return err
 	}
 	for _, elem := range d.tagNames {
-		if err := writeBuffer.WriteString("", uint32(len(elem)*8), "UTF-8", elem); err != nil {
+		if err := writeBuffer.WriteString("", uint32(len(elem)*8), elem); err != nil {
 			return err
 		}
 	}
@@ -59,7 +59,7 @@ func (d *DefaultPlcSubscriptionRequestBuilder) SerializeWithWriteBuffer(ctx cont
 	for _name, elem := range d.tagAddresses {
 		name := _name
 
-		if err := writeBuffer.WriteString(name, uint32(len(elem)*8), "UTF-8", elem); err != nil {
+		if err := writeBuffer.WriteString(name, uint32(len(elem)*8), elem); err != nil {
 			return err
 		}
 	}
@@ -85,7 +85,7 @@ func (d *DefaultPlcSubscriptionRequestBuilder) SerializeWithWriteBuffer(ctx cont
 			}
 		} else {
 			elemAsString := fmt.Sprintf("%v", elem)
-			if err := writeBuffer.WriteString(name, uint32(len(elemAsString)*8), "UTF-8", elemAsString); err != nil {
+			if err := writeBuffer.WriteString(name, uint32(len(elemAsString)*8), elemAsString); err != nil {
 				return err
 			}
 		}
@@ -112,7 +112,7 @@ func (d *DefaultPlcSubscriptionRequestBuilder) SerializeWithWriteBuffer(ctx cont
 			}
 		} else {
 			elemAsString := fmt.Sprintf("%v", elem)
-			if err := writeBuffer.WriteString(name, uint32(len(elemAsString)*8), "UTF-8", elemAsString); err != nil {
+			if err := writeBuffer.WriteString(name, uint32(len(elemAsString)*8), elemAsString); err != nil {
 				return err
 			}
 		}
@@ -139,7 +139,7 @@ func (d *DefaultPlcSubscriptionRequestBuilder) SerializeWithWriteBuffer(ctx cont
 			}
 		} else {
 			elemAsString := fmt.Sprintf("%v", elem)
-			if err := writeBuffer.WriteString(name, uint32(len(elemAsString)*8), "UTF-8", elemAsString); err != nil {
+			if err := writeBuffer.WriteString(name, uint32(len(elemAsString)*8), elemAsString); err != nil {
 				return err
 			}
 		}
@@ -154,7 +154,7 @@ func (d *DefaultPlcSubscriptionRequestBuilder) SerializeWithWriteBuffer(ctx cont
 		name := _name
 		_value := fmt.Sprintf("%v", elem)
 
-		if err := writeBuffer.WriteString(name, uint32(len(_value)*8), "UTF-8", _value); err != nil {
+		if err := writeBuffer.WriteString(name, uint32(len(_value)*8), _value); err != nil {
 			return err
 		}
 	}
diff --git a/plc4go/spi/model/DefaultPlcSubscriptionRequestResult_plc4xgen.go b/plc4go/spi/model/DefaultPlcSubscriptionRequestResult_plc4xgen.go
index 958c29cc47a..33c347bba42 100644
--- a/plc4go/spi/model/DefaultPlcSubscriptionRequestResult_plc4xgen.go
+++ b/plc4go/spi/model/DefaultPlcSubscriptionRequestResult_plc4xgen.go
@@ -56,7 +56,7 @@ func (d *DefaultPlcSubscriptionRequestResult) SerializeWithWriteBuffer(ctx conte
 			}
 		} else {
 			stringValue := fmt.Sprintf("%v", d.Request)
-			if err := writeBuffer.WriteString("request", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+			if err := writeBuffer.WriteString("request", uint32(len(stringValue)*8), stringValue); err != nil {
 				return err
 			}
 		}
@@ -75,7 +75,7 @@ func (d *DefaultPlcSubscriptionRequestResult) SerializeWithWriteBuffer(ctx conte
 			}
 		} else {
 			stringValue := fmt.Sprintf("%v", d.Response)
-			if err := writeBuffer.WriteString("response", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+			if err := writeBuffer.WriteString("response", uint32(len(stringValue)*8), stringValue); err != nil {
 				return err
 			}
 		}
@@ -83,7 +83,7 @@ func (d *DefaultPlcSubscriptionRequestResult) SerializeWithWriteBuffer(ctx conte
 
 	if d.Err != nil {
 		_errString := d.Err.Error()
-		if err := writeBuffer.WriteString("err", uint32(len(_errString)*8), "UTF-8", _errString); err != nil {
+		if err := writeBuffer.WriteString("err", uint32(len(_errString)*8), _errString); err != nil {
 			return err
 		}
 	}
diff --git a/plc4go/spi/model/DefaultPlcSubscriptionRequest_plc4xgen.go b/plc4go/spi/model/DefaultPlcSubscriptionRequest_plc4xgen.go
index e956f3a5d01..55eeb904ce3 100644
--- a/plc4go/spi/model/DefaultPlcSubscriptionRequest_plc4xgen.go
+++ b/plc4go/spi/model/DefaultPlcSubscriptionRequest_plc4xgen.go
@@ -64,7 +64,7 @@ func (d *DefaultPlcSubscriptionRequest) SerializeWithWriteBuffer(ctx context.Con
 			}
 		} else {
 			elemAsString := fmt.Sprintf("%v", elem)
-			if err := writeBuffer.WriteString(name, uint32(len(elemAsString)*8), "UTF-8", elemAsString); err != nil {
+			if err := writeBuffer.WriteString(name, uint32(len(elemAsString)*8), elemAsString); err != nil {
 				return err
 			}
 		}
@@ -91,7 +91,7 @@ func (d *DefaultPlcSubscriptionRequest) SerializeWithWriteBuffer(ctx context.Con
 			}
 		} else {
 			elemAsString := fmt.Sprintf("%v", elem)
-			if err := writeBuffer.WriteString(name, uint32(len(elemAsString)*8), "UTF-8", elemAsString); err != nil {
+			if err := writeBuffer.WriteString(name, uint32(len(elemAsString)*8), elemAsString); err != nil {
 				return err
 			}
 		}
@@ -113,7 +113,7 @@ func (d *DefaultPlcSubscriptionRequest) SerializeWithWriteBuffer(ctx context.Con
 			}
 		} else {
 			stringValue := fmt.Sprintf("%v", d.subscriber)
-			if err := writeBuffer.WriteString("subscriber", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+			if err := writeBuffer.WriteString("subscriber", uint32(len(stringValue)*8), stringValue); err != nil {
 				return err
 			}
 		}
diff --git a/plc4go/spi/model/DefaultPlcSubscriptionResponseItem_plc4xgen.go b/plc4go/spi/model/DefaultPlcSubscriptionResponseItem_plc4xgen.go
index b887c780565..f8d49f652cb 100644
--- a/plc4go/spi/model/DefaultPlcSubscriptionResponseItem_plc4xgen.go
+++ b/plc4go/spi/model/DefaultPlcSubscriptionResponseItem_plc4xgen.go
@@ -43,7 +43,7 @@ func (d *DefaultPlcSubscriptionResponseItem) SerializeWithWriteBuffer(ctx contex
 		return err
 	}
 
-	if err := writeBuffer.WriteString("code", uint32(len(d.code.String())*8), "UTF-8", d.code.String()); err != nil {
+	if err := writeBuffer.WriteString("code", uint32(len(d.code.String())*8), d.code.String()); err != nil {
 		return err
 	}
 
@@ -60,7 +60,7 @@ func (d *DefaultPlcSubscriptionResponseItem) SerializeWithWriteBuffer(ctx contex
 			}
 		} else {
 			stringValue := fmt.Sprintf("%v", d.subscriptionHandle)
-			if err := writeBuffer.WriteString("subscriptionHandle", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+			if err := writeBuffer.WriteString("subscriptionHandle", uint32(len(stringValue)*8), stringValue); err != nil {
 				return err
 			}
 		}
diff --git a/plc4go/spi/model/DefaultPlcSubscriptionResponse_plc4xgen.go b/plc4go/spi/model/DefaultPlcSubscriptionResponse_plc4xgen.go
index 4568376a19d..e4e7d550ed3 100644
--- a/plc4go/spi/model/DefaultPlcSubscriptionResponse_plc4xgen.go
+++ b/plc4go/spi/model/DefaultPlcSubscriptionResponse_plc4xgen.go
@@ -56,7 +56,7 @@ func (d *DefaultPlcSubscriptionResponse) SerializeWithWriteBuffer(ctx context.Co
 			}
 		} else {
 			stringValue := fmt.Sprintf("%v", d.request)
-			if err := writeBuffer.WriteString("request", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+			if err := writeBuffer.WriteString("request", uint32(len(stringValue)*8), stringValue); err != nil {
 				return err
 			}
 		}
@@ -80,7 +80,7 @@ func (d *DefaultPlcSubscriptionResponse) SerializeWithWriteBuffer(ctx context.Co
 			}
 		} else {
 			elemAsString := fmt.Sprintf("%v", elem)
-			if err := writeBuffer.WriteString(name, uint32(len(elemAsString)*8), "UTF-8", elemAsString); err != nil {
+			if err := writeBuffer.WriteString(name, uint32(len(elemAsString)*8), elemAsString); err != nil {
 				return err
 			}
 		}
diff --git a/plc4go/spi/model/DefaultPlcSubscriptionTag_plc4xgen.go b/plc4go/spi/model/DefaultPlcSubscriptionTag_plc4xgen.go
index 1319b351197..a23982324b3 100644
--- a/plc4go/spi/model/DefaultPlcSubscriptionTag_plc4xgen.go
+++ b/plc4go/spi/model/DefaultPlcSubscriptionTag_plc4xgen.go
@@ -43,15 +43,15 @@ func (d *DefaultPlcSubscriptionTag) SerializeWithWriteBuffer(ctx context.Context
 		return err
 	}
 
-	if err := writeBuffer.WriteString("plcTag", uint32(len(d.plcTag.String())*8), "UTF-8", d.plcTag.String()); err != nil {
+	if err := writeBuffer.WriteString("plcTag", uint32(len(d.plcTag.String())*8), d.plcTag.String()); err != nil {
 		return err
 	}
 
-	if err := writeBuffer.WriteString("plcSubscriptionType", uint32(len(d.plcSubscriptionType.String())*8), "UTF-8", d.plcSubscriptionType.String()); err != nil {
+	if err := writeBuffer.WriteString("plcSubscriptionType", uint32(len(d.plcSubscriptionType.String())*8), d.plcSubscriptionType.String()); err != nil {
 		return err
 	}
 
-	if err := writeBuffer.WriteString("duration", uint32(len(d.duration.String())*8), "UTF-8", d.duration.String()); err != nil {
+	if err := writeBuffer.WriteString("duration", uint32(len(d.duration.String())*8), d.duration.String()); err != nil {
 		return err
 	}
 	if err := writeBuffer.PopContext("PlcSubscriptionTag"); err != nil {
diff --git a/plc4go/spi/model/DefaultPlcTagRequest_plc4xgen.go b/plc4go/spi/model/DefaultPlcTagRequest_plc4xgen.go
index 1be3d59e128..bb4d6ffddf9 100644
--- a/plc4go/spi/model/DefaultPlcTagRequest_plc4xgen.go
+++ b/plc4go/spi/model/DefaultPlcTagRequest_plc4xgen.go
@@ -61,7 +61,7 @@ func (d *DefaultPlcTagRequest) SerializeWithWriteBuffer(ctx context.Context, wri
 			}
 		} else {
 			elemAsString := fmt.Sprintf("%v", elem)
-			if err := writeBuffer.WriteString(name, uint32(len(elemAsString)*8), "UTF-8", elemAsString); err != nil {
+			if err := writeBuffer.WriteString(name, uint32(len(elemAsString)*8), elemAsString); err != nil {
 				return err
 			}
 		}
diff --git a/plc4go/spi/model/DefaultPlcUnsubscriptionRequestBuilder_plc4xgen.go b/plc4go/spi/model/DefaultPlcUnsubscriptionRequestBuilder_plc4xgen.go
index ab23d483651..85cb47b8f86 100644
--- a/plc4go/spi/model/DefaultPlcUnsubscriptionRequestBuilder_plc4xgen.go
+++ b/plc4go/spi/model/DefaultPlcUnsubscriptionRequestBuilder_plc4xgen.go
@@ -61,7 +61,7 @@ func (d *DefaultPlcUnsubscriptionRequestBuilder) SerializeWithWriteBuffer(ctx co
 				}
 			} else {
 				stringValue := fmt.Sprintf("%v", elem)
-				if err := writeBuffer.WriteString("value", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+				if err := writeBuffer.WriteString("value", uint32(len(stringValue)*8), stringValue); err != nil {
 					return err
 				}
 			}
diff --git a/plc4go/spi/model/DefaultPlcUnsubscriptionRequestResult_plc4xgen.go b/plc4go/spi/model/DefaultPlcUnsubscriptionRequestResult_plc4xgen.go
index 66a2945b674..20168201f36 100644
--- a/plc4go/spi/model/DefaultPlcUnsubscriptionRequestResult_plc4xgen.go
+++ b/plc4go/spi/model/DefaultPlcUnsubscriptionRequestResult_plc4xgen.go
@@ -56,7 +56,7 @@ func (d *DefaultPlcUnsubscriptionRequestResult) SerializeWithWriteBuffer(ctx con
 			}
 		} else {
 			stringValue := fmt.Sprintf("%v", d.Request)
-			if err := writeBuffer.WriteString("request", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+			if err := writeBuffer.WriteString("request", uint32(len(stringValue)*8), stringValue); err != nil {
 				return err
 			}
 		}
@@ -75,7 +75,7 @@ func (d *DefaultPlcUnsubscriptionRequestResult) SerializeWithWriteBuffer(ctx con
 			}
 		} else {
 			stringValue := fmt.Sprintf("%v", d.Response)
-			if err := writeBuffer.WriteString("response", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+			if err := writeBuffer.WriteString("response", uint32(len(stringValue)*8), stringValue); err != nil {
 				return err
 			}
 		}
@@ -83,7 +83,7 @@ func (d *DefaultPlcUnsubscriptionRequestResult) SerializeWithWriteBuffer(ctx con
 
 	if d.Err != nil {
 		_errString := d.Err.Error()
-		if err := writeBuffer.WriteString("err", uint32(len(_errString)*8), "UTF-8", _errString); err != nil {
+		if err := writeBuffer.WriteString("err", uint32(len(_errString)*8), _errString); err != nil {
 			return err
 		}
 	}
diff --git a/plc4go/spi/model/DefaultPlcUnsubscriptionRequest_plc4xgen.go b/plc4go/spi/model/DefaultPlcUnsubscriptionRequest_plc4xgen.go
index ca3f517cba8..94fe4739c09 100644
--- a/plc4go/spi/model/DefaultPlcUnsubscriptionRequest_plc4xgen.go
+++ b/plc4go/spi/model/DefaultPlcUnsubscriptionRequest_plc4xgen.go
@@ -61,7 +61,7 @@ func (d *DefaultPlcUnsubscriptionRequest) SerializeWithWriteBuffer(ctx context.C
 				}
 			} else {
 				stringValue := fmt.Sprintf("%v", elem)
-				if err := writeBuffer.WriteString("value", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+				if err := writeBuffer.WriteString("value", uint32(len(stringValue)*8), stringValue); err != nil {
 					return err
 				}
 			}
diff --git a/plc4go/spi/model/DefaultPlcUnsubscriptionResponse_plc4xgen.go b/plc4go/spi/model/DefaultPlcUnsubscriptionResponse_plc4xgen.go
index c3ee037df82..e2984a5cf91 100644
--- a/plc4go/spi/model/DefaultPlcUnsubscriptionResponse_plc4xgen.go
+++ b/plc4go/spi/model/DefaultPlcUnsubscriptionResponse_plc4xgen.go
@@ -43,7 +43,7 @@ func (d *DefaultPlcUnsubscriptionResponse) SerializeWithWriteBuffer(ctx context.
 		return err
 	}
 
-	if err := writeBuffer.WriteString("none", uint32(len(d.none)*8), "UTF-8", d.none); err != nil {
+	if err := writeBuffer.WriteString("none", uint32(len(d.none)*8), d.none); err != nil {
 		return err
 	}
 	if err := writeBuffer.PopContext("PlcUnsubscriptionResponse"); err != nil {
diff --git a/plc4go/spi/model/DefaultPlcWriteRequestBuilder_plc4xgen.go b/plc4go/spi/model/DefaultPlcWriteRequestBuilder_plc4xgen.go
index 4c49ea3c676..98b0606aee6 100644
--- a/plc4go/spi/model/DefaultPlcWriteRequestBuilder_plc4xgen.go
+++ b/plc4go/spi/model/DefaultPlcWriteRequestBuilder_plc4xgen.go
@@ -46,7 +46,7 @@ func (d *DefaultPlcWriteRequestBuilder) SerializeWithWriteBuffer(ctx context.Con
 		return err
 	}
 	for _, elem := range d.tagNames {
-		if err := writeBuffer.WriteString("", uint32(len(elem)*8), "UTF-8", elem); err != nil {
+		if err := writeBuffer.WriteString("", uint32(len(elem)*8), elem); err != nil {
 			return err
 		}
 	}
@@ -59,7 +59,7 @@ func (d *DefaultPlcWriteRequestBuilder) SerializeWithWriteBuffer(ctx context.Con
 	for _name, elem := range d.tagAddresses {
 		name := _name
 
-		if err := writeBuffer.WriteString(name, uint32(len(elem)*8), "UTF-8", elem); err != nil {
+		if err := writeBuffer.WriteString(name, uint32(len(elem)*8), elem); err != nil {
 			return err
 		}
 	}
@@ -85,7 +85,7 @@ func (d *DefaultPlcWriteRequestBuilder) SerializeWithWriteBuffer(ctx context.Con
 			}
 		} else {
 			elemAsString := fmt.Sprintf("%v", elem)
-			if err := writeBuffer.WriteString(name, uint32(len(elemAsString)*8), "UTF-8", elemAsString); err != nil {
+			if err := writeBuffer.WriteString(name, uint32(len(elemAsString)*8), elemAsString); err != nil {
 				return err
 			}
 		}
@@ -100,7 +100,7 @@ func (d *DefaultPlcWriteRequestBuilder) SerializeWithWriteBuffer(ctx context.Con
 		name := _name
 		_value := fmt.Sprintf("%v", elem)
 
-		if err := writeBuffer.WriteString(name, uint32(len(_value)*8), "UTF-8", _value); err != nil {
+		if err := writeBuffer.WriteString(name, uint32(len(_value)*8), _value); err != nil {
 			return err
 		}
 	}
diff --git a/plc4go/spi/model/DefaultPlcWriteRequestResult_plc4xgen.go b/plc4go/spi/model/DefaultPlcWriteRequestResult_plc4xgen.go
index 0a05980b466..dfce5dcb1b9 100644
--- a/plc4go/spi/model/DefaultPlcWriteRequestResult_plc4xgen.go
+++ b/plc4go/spi/model/DefaultPlcWriteRequestResult_plc4xgen.go
@@ -56,7 +56,7 @@ func (d *DefaultPlcWriteRequestResult) SerializeWithWriteBuffer(ctx context.Cont
 			}
 		} else {
 			stringValue := fmt.Sprintf("%v", d.Request)
-			if err := writeBuffer.WriteString("request", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+			if err := writeBuffer.WriteString("request", uint32(len(stringValue)*8), stringValue); err != nil {
 				return err
 			}
 		}
@@ -75,7 +75,7 @@ func (d *DefaultPlcWriteRequestResult) SerializeWithWriteBuffer(ctx context.Cont
 			}
 		} else {
 			stringValue := fmt.Sprintf("%v", d.Response)
-			if err := writeBuffer.WriteString("response", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+			if err := writeBuffer.WriteString("response", uint32(len(stringValue)*8), stringValue); err != nil {
 				return err
 			}
 		}
@@ -83,7 +83,7 @@ func (d *DefaultPlcWriteRequestResult) SerializeWithWriteBuffer(ctx context.Cont
 
 	if d.Err != nil {
 		_errString := d.Err.Error()
-		if err := writeBuffer.WriteString("err", uint32(len(_errString)*8), "UTF-8", _errString); err != nil {
+		if err := writeBuffer.WriteString("err", uint32(len(_errString)*8), _errString); err != nil {
 			return err
 		}
 	}
diff --git a/plc4go/spi/model/DefaultPlcWriteRequest_plc4xgen.go b/plc4go/spi/model/DefaultPlcWriteRequest_plc4xgen.go
index b1cc945790b..45afcb03c27 100644
--- a/plc4go/spi/model/DefaultPlcWriteRequest_plc4xgen.go
+++ b/plc4go/spi/model/DefaultPlcWriteRequest_plc4xgen.go
@@ -64,7 +64,7 @@ func (d *DefaultPlcWriteRequest) SerializeWithWriteBuffer(ctx context.Context, w
 			}
 		} else {
 			elemAsString := fmt.Sprintf("%v", elem)
-			if err := writeBuffer.WriteString(name, uint32(len(elemAsString)*8), "UTF-8", elemAsString); err != nil {
+			if err := writeBuffer.WriteString(name, uint32(len(elemAsString)*8), elemAsString); err != nil {
 				return err
 			}
 		}
diff --git a/plc4go/spi/model/DefaultPlcWriteResponse_plc4xgen.go b/plc4go/spi/model/DefaultPlcWriteResponse_plc4xgen.go
index 335c543df0e..0e840c1cbb3 100644
--- a/plc4go/spi/model/DefaultPlcWriteResponse_plc4xgen.go
+++ b/plc4go/spi/model/DefaultPlcWriteResponse_plc4xgen.go
@@ -56,7 +56,7 @@ func (d *DefaultPlcWriteResponse) SerializeWithWriteBuffer(ctx context.Context,
 			}
 		} else {
 			stringValue := fmt.Sprintf("%v", d.request)
-			if err := writeBuffer.WriteString("request", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+			if err := writeBuffer.WriteString("request", uint32(len(stringValue)*8), stringValue); err != nil {
 				return err
 			}
 		}
@@ -80,7 +80,7 @@ func (d *DefaultPlcWriteResponse) SerializeWithWriteBuffer(ctx context.Context,
 			}
 		} else {
 			elemAsString := fmt.Sprintf("%v", elem)
-			if err := writeBuffer.WriteString(name, uint32(len(elemAsString)*8), "UTF-8", elemAsString); err != nil {
+			if err := writeBuffer.WriteString(name, uint32(len(elemAsString)*8), elemAsString); err != nil {
 				return err
 			}
 		}
diff --git a/plc4go/spi/model/ResponseItem_plc4xgen.go b/plc4go/spi/model/ResponseItem_plc4xgen.go
index b4f4fb3700a..1bfd89ca93c 100644
--- a/plc4go/spi/model/ResponseItem_plc4xgen.go
+++ b/plc4go/spi/model/ResponseItem_plc4xgen.go
@@ -43,7 +43,7 @@ func (d *ResponseItem) SerializeWithWriteBuffer(ctx context.Context, writeBuffer
 		return err
 	}
 
-	if err := writeBuffer.WriteString("code", uint32(len(d.code.String())*8), "UTF-8", d.code.String()); err != nil {
+	if err := writeBuffer.WriteString("code", uint32(len(d.code.String())*8), d.code.String()); err != nil {
 		return err
 	}
 
@@ -60,7 +60,7 @@ func (d *ResponseItem) SerializeWithWriteBuffer(ctx context.Context, writeBuffer
 			}
 		} else {
 			stringValue := fmt.Sprintf("%v", d.value)
-			if err := writeBuffer.WriteString("value", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+			if err := writeBuffer.WriteString("value", uint32(len(stringValue)*8), stringValue); err != nil {
 				return err
 			}
 		}
diff --git a/plc4go/spi/pool/dynamicExecutor_plc4xgen.go b/plc4go/spi/pool/dynamicExecutor_plc4xgen.go
index 6f7ce184acd..5d051eb077e 100644
--- a/plc4go/spi/pool/dynamicExecutor_plc4xgen.go
+++ b/plc4go/spi/pool/dynamicExecutor_plc4xgen.go
@@ -55,7 +55,7 @@ func (d *dynamicExecutor) SerializeWithWriteBuffer(ctx context.Context, writeBuf
 	}
 
 	_interrupter_plx4gen_description := fmt.Sprintf("%d element(s)", len(d.interrupter))
-	if err := writeBuffer.WriteString("interrupter", uint32(len(_interrupter_plx4gen_description)*8), "UTF-8", _interrupter_plx4gen_description); err != nil {
+	if err := writeBuffer.WriteString("interrupter", uint32(len(_interrupter_plx4gen_description)*8), _interrupter_plx4gen_description); err != nil {
 		return err
 	}
 	if err := writeBuffer.PopContext("dynamicExecutor"); err != nil {
diff --git a/plc4go/spi/pool/executor_plc4xgen.go b/plc4go/spi/pool/executor_plc4xgen.go
index 8a914e3ac6c..682a7314b65 100644
--- a/plc4go/spi/pool/executor_plc4xgen.go
+++ b/plc4go/spi/pool/executor_plc4xgen.go
@@ -69,7 +69,7 @@ func (d *executor) SerializeWithWriteBuffer(ctx context.Context, writeBuffer uti
 				}
 			} else {
 				stringValue := fmt.Sprintf("%v", elem)
-				if err := writeBuffer.WriteString("value", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+				if err := writeBuffer.WriteString("value", uint32(len(stringValue)*8), stringValue); err != nil {
 					return err
 				}
 			}
@@ -80,7 +80,7 @@ func (d *executor) SerializeWithWriteBuffer(ctx context.Context, writeBuffer uti
 	}
 
 	_workItems_plx4gen_description := fmt.Sprintf("%d element(s)", len(d.workItems))
-	if err := writeBuffer.WriteString("workItems", uint32(len(_workItems_plx4gen_description)*8), "UTF-8", _workItems_plx4gen_description); err != nil {
+	if err := writeBuffer.WriteString("workItems", uint32(len(_workItems_plx4gen_description)*8), _workItems_plx4gen_description); err != nil {
 		return err
 	}
 
diff --git a/plc4go/spi/pool/future_plc4xgen.go b/plc4go/spi/pool/future_plc4xgen.go
index 65cb2c06222..4aa50502c4f 100644
--- a/plc4go/spi/pool/future_plc4xgen.go
+++ b/plc4go/spi/pool/future_plc4xgen.go
@@ -72,7 +72,7 @@ func (d *future) SerializeWithWriteBuffer(ctx context.Context, writeBuffer utils
 			}
 		} else {
 			stringValue := fmt.Sprintf("%v", d.err.Load())
-			if err := writeBuffer.WriteString("err", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+			if err := writeBuffer.WriteString("err", uint32(len(stringValue)*8), stringValue); err != nil {
 				return err
 			}
 		}
diff --git a/plc4go/spi/pool/workItem_plc4xgen.go b/plc4go/spi/pool/workItem_plc4xgen.go
index d32f597b02d..71760b4af8c 100644
--- a/plc4go/spi/pool/workItem_plc4xgen.go
+++ b/plc4go/spi/pool/workItem_plc4xgen.go
@@ -49,7 +49,7 @@ func (d *workItem) SerializeWithWriteBuffer(ctx context.Context, writeBuffer uti
 	{
 		_value := fmt.Sprintf("%v", d.completionFuture)
 
-		if err := writeBuffer.WriteString("completionFuture", uint32(len(_value)*8), "UTF-8", _value); err != nil {
+		if err := writeBuffer.WriteString("completionFuture", uint32(len(_value)*8), _value); err != nil {
 			return err
 		}
 	}
diff --git a/plc4go/spi/pool/worker_plc4xgen.go b/plc4go/spi/pool/worker_plc4xgen.go
index 9f132d3036e..be38b63a15c 100644
--- a/plc4go/spi/pool/worker_plc4xgen.go
+++ b/plc4go/spi/pool/worker_plc4xgen.go
@@ -60,7 +60,7 @@ func (d *worker) SerializeWithWriteBuffer(ctx context.Context, writeBuffer utils
 			}
 		} else {
 			stringValue := fmt.Sprintf("%v", d.lastReceived.Load())
-			if err := writeBuffer.WriteString("lastReceived", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+			if err := writeBuffer.WriteString("lastReceived", uint32(len(stringValue)*8), stringValue); err != nil {
 				return err
 			}
 		}
@@ -79,7 +79,7 @@ func (d *worker) SerializeWithWriteBuffer(ctx context.Context, writeBuffer utils
 	}
 
 	_interrupter_plx4gen_description := fmt.Sprintf("%d element(s)", len(d.interrupter))
-	if err := writeBuffer.WriteString("interrupter", uint32(len(_interrupter_plx4gen_description)*8), "UTF-8", _interrupter_plx4gen_description); err != nil {
+	if err := writeBuffer.WriteString("interrupter", uint32(len(_interrupter_plx4gen_description)*8), _interrupter_plx4gen_description); err != nil {
 		return err
 	}
 	if err := writeBuffer.PopContext("worker"); err != nil {
diff --git a/plc4go/spi/testutils/TestUtils_test.go b/plc4go/spi/testutils/TestUtils_test.go
index c82701df3b4..d18dff6d56c 100644
--- a/plc4go/spi/testutils/TestUtils_test.go
+++ b/plc4go/spi/testutils/TestUtils_test.go
@@ -54,7 +54,7 @@ func (A *ASerializable) Serialize() ([]byte, error) {
 }
 
 func (A *ASerializable) SerializeWithWriteBuffer(_ context.Context, writeBuffer utils.WriteBuffer) error {
-	_ = writeBuffer.WriteString("a", 8, "UTF-8", A.a)
+	_ = writeBuffer.WriteString("a", 8, A.a)
 	_ = writeBuffer.WriteInt64("b", 64, int64(A.b))
 	_ = writeBuffer.WriteFloat32("c", 32, A.c)
 	return nil
diff --git a/plc4go/spi/transactions/completedFuture_plc4xgen.go b/plc4go/spi/transactions/completedFuture_plc4xgen.go
index 34d8c9a36c0..6e289d1debc 100644
--- a/plc4go/spi/transactions/completedFuture_plc4xgen.go
+++ b/plc4go/spi/transactions/completedFuture_plc4xgen.go
@@ -45,7 +45,7 @@ func (d *completedFuture) SerializeWithWriteBuffer(ctx context.Context, writeBuf
 
 	if d.err != nil {
 		_errString := d.err.Error()
-		if err := writeBuffer.WriteString("err", uint32(len(_errString)*8), "UTF-8", _errString); err != nil {
+		if err := writeBuffer.WriteString("err", uint32(len(_errString)*8), _errString); err != nil {
 			return err
 		}
 	}
diff --git a/plc4go/spi/transactions/requestTransactionManager_plc4xgen.go b/plc4go/spi/transactions/requestTransactionManager_plc4xgen.go
index 32afc0bf1cc..996a0f4ddda 100644
--- a/plc4go/spi/transactions/requestTransactionManager_plc4xgen.go
+++ b/plc4go/spi/transactions/requestTransactionManager_plc4xgen.go
@@ -61,7 +61,7 @@ func (d *requestTransactionManager) SerializeWithWriteBuffer(ctx context.Context
 				}
 			} else {
 				stringValue := fmt.Sprintf("%v", elem)
-				if err := writeBuffer.WriteString("value", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+				if err := writeBuffer.WriteString("value", uint32(len(stringValue)*8), stringValue); err != nil {
 					return err
 				}
 			}
@@ -92,7 +92,7 @@ func (d *requestTransactionManager) SerializeWithWriteBuffer(ctx context.Context
 			}
 		} else {
 			stringValue := fmt.Sprintf("%v", d.executor)
-			if err := writeBuffer.WriteString("executor", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+			if err := writeBuffer.WriteString("executor", uint32(len(stringValue)*8), stringValue); err != nil {
 				return err
 			}
 		}
diff --git a/plc4go/spi/transactions/requestTransaction_plc4xgen.go b/plc4go/spi/transactions/requestTransaction_plc4xgen.go
index 733c59fde4f..d6296b43e36 100644
--- a/plc4go/spi/transactions/requestTransaction_plc4xgen.go
+++ b/plc4go/spi/transactions/requestTransaction_plc4xgen.go
@@ -61,7 +61,7 @@ func (d *requestTransaction) SerializeWithWriteBuffer(ctx context.Context, write
 			}
 		} else {
 			stringValue := fmt.Sprintf("%v", completionFuture)
-			if err := writeBuffer.WriteString("completionFuture", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+			if err := writeBuffer.WriteString("completionFuture", uint32(len(stringValue)*8), stringValue); err != nil {
 				return err
 			}
 		}
diff --git a/plc4go/spi/utils/Buffer_test.go b/plc4go/spi/utils/Buffer_test.go
index b89ef8ae5ed..ed7523af1ec 100644
--- a/plc4go/spi/utils/Buffer_test.go
+++ b/plc4go/spi/utils/Buffer_test.go
@@ -182,7 +182,7 @@ func Test_readerWriterArg_isWriterArgs(t *testing.T) {
 				WithReaderArgs: tt.fields.readerArg,
 				WithWriterArgs: tt.fields.writerArg,
 			}
-			assert.Equalf(t, tt.want, re.isWriterArgs(), "isWriterArgs()")
+			assert.Equalf(t, tt.want, re.isWriterArgs(), "IsWriterArgs()")
 		})
 	}
 }
diff --git a/plc4go/spi/utils/ByteOrderAware.go b/plc4go/spi/utils/ByteOrderAware.go
new file mode 100644
index 00000000000..f45f57916f2
--- /dev/null
+++ b/plc4go/spi/utils/ByteOrderAware.go
@@ -0,0 +1,29 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package utils
+
+import (
+	"encoding/binary"
+)
+
+type ByteOrderAware interface {
+	GetByteOrder() binary.ByteOrder
+	SetByteOrder(byteOrder binary.ByteOrder)
+}
diff --git a/plc4go/spi/utils/ReadBuffer.go b/plc4go/spi/utils/ReadBuffer.go
index e83052148be..7cbe3987094 100644
--- a/plc4go/spi/utils/ReadBuffer.go
+++ b/plc4go/spi/utils/ReadBuffer.go
@@ -25,6 +25,7 @@ import (
 
 type ReadBuffer interface {
 	PositionAware
+	ByteOrderAware
 	// Reset sets the position to the supplied byte position
 	Reset(pos uint16)
 	// HasMore returns true if there are bitLength bits available
@@ -46,7 +47,7 @@ type ReadBuffer interface {
 	ReadFloat32(logicalName string, bitLength uint8, readerArgs ...WithReaderArgs) (float32, error)
 	ReadFloat64(logicalName string, bitLength uint8, readerArgs ...WithReaderArgs) (float64, error)
 	ReadBigFloat(logicalName string, bitLength uint8, readerArgs ...WithReaderArgs) (*big.Float, error)
-	ReadString(logicalName string, bitLength uint32, encoding string, readerArgs ...WithReaderArgs) (string, error)
+	ReadString(logicalName string, bitLength uint32, readerArgs ...WithReaderArgs) (string, error)
 	// CloseContext signals that we expect the end of the context with the supplied logical name
 	CloseContext(logicalName string, readerArgs ...WithReaderArgs) error
 }
diff --git a/plc4go/spi/utils/ReadBufferByteBased.go b/plc4go/spi/utils/ReadBufferByteBased.go
index a4e6b575bef..f4e62d5ee85 100644
--- a/plc4go/spi/utils/ReadBufferByteBased.go
+++ b/plc4go/spi/utils/ReadBufferByteBased.go
@@ -72,6 +72,8 @@ type byteReadBuffer struct {
 	byteOrder binary.ByteOrder
 }
 
+var _ ReadBuffer = (*byteReadBuffer)(nil)
+
 //
 // Internal section
 //
@@ -377,7 +379,7 @@ func (rb *byteReadBuffer) ReadBigFloat(logicalName string, bitLength uint8, _ ..
 	return big.NewFloat(readFloat64), nil
 }
 
-func (rb *byteReadBuffer) ReadString(logicalName string, bitLength uint32, encoding string, _ ...WithReaderArgs) (string, error) {
+func (rb *byteReadBuffer) ReadString(logicalName string, bitLength uint32, _ ...WithReaderArgs) (string, error) {
 	stringBytes, err := rb.ReadByteArray(logicalName, int(bitLength/8))
 	if err != nil {
 		return "", errors.Wrap(err, "Error reading big int")
diff --git a/plc4go/spi/utils/ReadBufferByteBased_test.go b/plc4go/spi/utils/ReadBufferByteBased_test.go
index 6c08ee61fea..99e0d75dfd0 100644
--- a/plc4go/spi/utils/ReadBufferByteBased_test.go
+++ b/plc4go/spi/utils/ReadBufferByteBased_test.go
@@ -1566,7 +1566,7 @@ func TestReadBuffer_ReadString(t *testing.T) {
 				pos:       tt.fields.pos,
 				byteOrder: tt.fields.byteOrder,
 			}
-			got, err := rb.ReadString("", tt.args.bitLength, "utf-8")
+			got, err := rb.ReadString("", tt.args.bitLength)
 			if (err != nil) != tt.wantErr {
 				t.Errorf("ReadString() error = %v, wantErr %v", err, tt.wantErr)
 				return
diff --git a/plc4go/spi/utils/ReadBufferJsonBased.go b/plc4go/spi/utils/ReadBufferJsonBased.go
index f3f2e832354..11ec16868d5 100644
--- a/plc4go/spi/utils/ReadBufferJsonBased.go
+++ b/plc4go/spi/utils/ReadBufferJsonBased.go
@@ -20,6 +20,7 @@
 package utils
 
 import (
+	"encoding/binary"
 	"encoding/hex"
 	"encoding/json"
 	"fmt"
@@ -71,12 +72,21 @@ type jsonReadBuffer struct {
 	err            error
 }
 
+var _ ReadBuffer = (*jsonReadBuffer)(nil)
+
 //
 // Internal section
 //
 ///////////////////////////////////////
 ///////////////////////////////////////
 
+func (j *jsonReadBuffer) SetByteOrder(binary.ByteOrder) {
+}
+
+func (j *jsonReadBuffer) GetByteOrder() binary.ByteOrder {
+	return binary.BigEndian
+}
+
 func (j *jsonReadBuffer) GetPos() uint16 {
 	return uint16(j.pos / 8)
 }
@@ -407,7 +417,7 @@ func (j *jsonReadBuffer) ReadBigFloat(logicalName string, bitLength uint8, reade
 	}
 }
 
-func (j *jsonReadBuffer) ReadString(logicalName string, bitLength uint32, encoding string, readerArgs ...WithReaderArgs) (string, error) {
+func (j *jsonReadBuffer) ReadString(logicalName string, bitLength uint32, readerArgs ...WithReaderArgs) (string, error) {
 	if j.err != nil {
 		return "", j.err
 	}
diff --git a/plc4go/spi/utils/ReadBufferJsonBased_test.go b/plc4go/spi/utils/ReadBufferJsonBased_test.go
index 8867fb0a87b..9f28ab5058f 100644
--- a/plc4go/spi/utils/ReadBufferJsonBased_test.go
+++ b/plc4go/spi/utils/ReadBufferJsonBased_test.go
@@ -865,7 +865,6 @@ func Test_jsonReadBuffer_ReadString(t *testing.T) {
 	type args struct {
 		logicalName string
 		bitLength   uint32
-		encoding    string
 		readerArgs  []WithReaderArgs
 	}
 	tests := []struct {
@@ -900,11 +899,11 @@ func Test_jsonReadBuffer_ReadString(t *testing.T) {
 				doValidateAttr: tt.fields.doValidateAttr,
 				err:            tt.fields.err,
 			}
-			got, err := j.ReadString(tt.args.logicalName, tt.args.bitLength, tt.args.encoding, tt.args.readerArgs...)
-			if !tt.wantErr(t, err, fmt.Sprintf("ReadString(%v, %v, %v, %v)", tt.args.logicalName, tt.args.bitLength, tt.args.encoding, tt.args.readerArgs)) {
+			got, err := j.ReadString(tt.args.logicalName, tt.args.bitLength, tt.args.readerArgs...)
+			if !tt.wantErr(t, err, fmt.Sprintf("ReadString(%v, %v, %v)", tt.args.logicalName, tt.args.bitLength, tt.args.readerArgs)) {
 				return
 			}
-			assert.Equalf(t, tt.want, got, "ReadString(%v, %v, %v, %v)", tt.args.logicalName, tt.args.bitLength, tt.args.encoding, tt.args.readerArgs)
+			assert.Equalf(t, tt.want, got, "ReadString(%v, %v, %v)", tt.args.logicalName, tt.args.bitLength, tt.args.readerArgs)
 		})
 	}
 }
diff --git a/plc4go/spi/utils/ReadBufferXmlBased.go b/plc4go/spi/utils/ReadBufferXmlBased.go
index 22254d8118e..2b76f172b5c 100644
--- a/plc4go/spi/utils/ReadBufferXmlBased.go
+++ b/plc4go/spi/utils/ReadBufferXmlBased.go
@@ -20,6 +20,7 @@
 package utils
 
 import (
+	"encoding/binary"
 	"encoding/hex"
 	"encoding/xml"
 	"fmt"
@@ -64,12 +65,21 @@ type xmlReadBuffer struct {
 	doValidateList bool
 }
 
+var _ ReadBuffer = (*xmlReadBuffer)(nil)
+
 //
 // Internal section
 //
 ///////////////////////////////////////
 ///////////////////////////////////////
 
+func (x *xmlReadBuffer) SetByteOrder(binary.ByteOrder) {
+}
+
+func (x *xmlReadBuffer) GetByteOrder() binary.ByteOrder {
+	return binary.BigEndian
+}
+
 func (x *xmlReadBuffer) GetPos() uint16 {
 	return uint16(x.pos / 8)
 }
@@ -265,7 +275,7 @@ func (x *xmlReadBuffer) ReadBigFloat(logicalName string, bitLength uint8, reader
 	return &value, nil
 }
 
-func (x *xmlReadBuffer) ReadString(logicalName string, bitLength uint32, encoding string, readerArgs ...WithReaderArgs) (string, error) {
+func (x *xmlReadBuffer) ReadString(logicalName string, bitLength uint32, readerArgs ...WithReaderArgs) (string, error) {
 	var value string
 	// TODO: bitlength too short
 	err := x.decode(logicalName, rwStringKey, uint(bitLength), readerArgs, &value)
diff --git a/plc4go/spi/utils/ReadBufferXmlBased_test.go b/plc4go/spi/utils/ReadBufferXmlBased_test.go
index e69f0f8f609..5a5b9db1f47 100644
--- a/plc4go/spi/utils/ReadBufferXmlBased_test.go
+++ b/plc4go/spi/utils/ReadBufferXmlBased_test.go
@@ -825,7 +825,6 @@ func Test_xmlReadBuffer_ReadString(t *testing.T) {
 	type args struct {
 		logicalName string
 		bitLength   uint32
-		encoding    string
 		readerArgs  []WithReaderArgs
 	}
 	tests := []struct {
@@ -856,11 +855,11 @@ func Test_xmlReadBuffer_ReadString(t *testing.T) {
 				doValidateAttr: tt.fields.doValidateAttr,
 				doValidateList: tt.fields.doValidateList,
 			}
-			got, err := x.ReadString(tt.args.logicalName, tt.args.bitLength, tt.args.encoding, tt.args.readerArgs...)
-			if !tt.wantErr(t, err, fmt.Sprintf("ReadString(%v, %v, %v, %v)", tt.args.logicalName, tt.args.bitLength, tt.args.encoding, tt.args.readerArgs)) {
+			got, err := x.ReadString(tt.args.logicalName, tt.args.bitLength, tt.args.readerArgs...)
+			if !tt.wantErr(t, err, fmt.Sprintf("ReadString(%v, %v, %v)", tt.args.logicalName, tt.args.bitLength, tt.args.readerArgs)) {
 				return
 			}
-			assert.Equalf(t, tt.want, got, "ReadString(%v, %v, %v, %v)", tt.args.logicalName, tt.args.bitLength, tt.args.encoding, tt.args.readerArgs)
+			assert.Equalf(t, tt.want, got, "ReadString(%v, %v, %v)", tt.args.logicalName, tt.args.bitLength, tt.args.readerArgs)
 		})
 	}
 }
diff --git a/plc4go/spi/utils/WriteBuffer.go b/plc4go/spi/utils/WriteBuffer.go
index e9e1bf89ba6..eb8290e2ae1 100644
--- a/plc4go/spi/utils/WriteBuffer.go
+++ b/plc4go/spi/utils/WriteBuffer.go
@@ -26,6 +26,7 @@ import (
 
 type WriteBuffer interface {
 	PositionAware
+	ByteOrderAware
 	// PushContext signals opening context with the supplied logical name
 	PushContext(logicalName string, writerArgs ...WithWriterArgs) error
 	WriteBit(logicalName string, value bool, writerArgs ...WithWriterArgs) error
@@ -43,7 +44,7 @@ type WriteBuffer interface {
 	WriteFloat32(logicalName string, bitLength uint8, value float32, writerArgs ...WithWriterArgs) error
 	WriteFloat64(logicalName string, bitLength uint8, value float64, writerArgs ...WithWriterArgs) error
 	WriteBigFloat(logicalName string, bitLength uint8, value *big.Float, writerArgs ...WithWriterArgs) error
-	WriteString(logicalName string, bitLength uint32, encoding string, value string, writerArgs ...WithWriterArgs) error
+	WriteString(logicalName string, bitLength uint32, value string, writerArgs ...WithWriterArgs) error
 	WriteVirtual(ctx context.Context, logicalName string, value any, writerArgs ...WithWriterArgs) error
 	WriteSerializable(ctx context.Context, serializable Serializable) error
 	// PopContext signals work done with the context with the supplied logical name
diff --git a/plc4go/spi/utils/WriteBufferBoxBased.go b/plc4go/spi/utils/WriteBufferBoxBased.go
index b667571ec63..21fcaf1fb20 100644
--- a/plc4go/spi/utils/WriteBufferBoxBased.go
+++ b/plc4go/spi/utils/WriteBufferBoxBased.go
@@ -22,6 +22,7 @@ package utils
 import (
 	"container/list"
 	"context"
+	"encoding/binary"
 	"fmt"
 	"math/big"
 
@@ -67,12 +68,21 @@ type boxedWriteBuffer struct {
 	pos                 uint
 }
 
+var _ WriteBuffer = (*boxedWriteBuffer)(nil)
+
 //
 // Internal section
 //
 ///////////////////////////////////////
 ///////////////////////////////////////
 
+func (*boxedWriteBuffer) GetByteOrder() binary.ByteOrder {
+	return binary.BigEndian
+}
+
+func (*boxedWriteBuffer) SetByteOrder(_ binary.ByteOrder) {
+}
+
 func (b *boxedWriteBuffer) GetBox() AsciiBox {
 	back := b.Back()
 	if back == nil {
@@ -207,7 +217,7 @@ func (b *boxedWriteBuffer) WriteBigFloat(logicalName string, bitLength uint8, va
 	return nil
 }
 
-func (b *boxedWriteBuffer) WriteString(logicalName string, bitLength uint32, _ string, value string, writerArgs ...WithWriterArgs) error {
+func (b *boxedWriteBuffer) WriteString(logicalName string, bitLength uint32, value string, writerArgs ...WithWriterArgs) error {
 	additionalStringRepresentation := b.extractAdditionalStringRepresentation(UpcastWriterArgs(writerArgs...)...)
 	b.PushBack(b.asciiBoxWriter.BoxString(logicalName, fmt.Sprintf("%s%s", value, additionalStringRepresentation), 0))
 	b.move(uint(bitLength))
diff --git a/plc4go/spi/utils/WriteBufferBoxBased_test.go b/plc4go/spi/utils/WriteBufferBoxBased_test.go
index 57e8d0afca9..252cb4ec96b 100644
--- a/plc4go/spi/utils/WriteBufferBoxBased_test.go
+++ b/plc4go/spi/utils/WriteBufferBoxBased_test.go
@@ -890,7 +890,6 @@ func Test_boxedWriteBuffer_WriteString(t *testing.T) {
 	type args struct {
 		logicalName string
 		bitLength   uint32
-		in2         string
 		value       string
 		writerArgs  []WithWriterArgs
 	}
@@ -922,7 +921,7 @@ func Test_boxedWriteBuffer_WriteString(t *testing.T) {
 				asciiBoxWriterLight: tt.fields.asciiBoxWriterLight,
 				pos:                 tt.fields.pos,
 			}
-			tt.wantErr(t, b.WriteString(tt.args.logicalName, tt.args.bitLength, tt.args.in2, tt.args.value, tt.args.writerArgs...), fmt.Sprintf("WriteString(%v, %v, %v, %v, %v)", tt.args.logicalName, tt.args.bitLength, tt.args.in2, tt.args.value, tt.args.writerArgs))
+			tt.wantErr(t, b.WriteString(tt.args.logicalName, tt.args.bitLength, tt.args.value, tt.args.writerArgs...), fmt.Sprintf("WriteString(%v, %v, %v, %v)", tt.args.logicalName, tt.args.bitLength, tt.args.value, tt.args.writerArgs))
 		})
 	}
 }
diff --git a/plc4go/spi/utils/WriteBufferByteBased.go b/plc4go/spi/utils/WriteBufferByteBased.go
index 80c01e84d38..be2d1d2ff2c 100644
--- a/plc4go/spi/utils/WriteBufferByteBased.go
+++ b/plc4go/spi/utils/WriteBufferByteBased.go
@@ -82,22 +82,21 @@ func WithCustomBufferForByteBasedBuffer(buffer *bytes.Buffer) WriteBufferByteBas
 //
 
 type byteWriteBuffer struct {
+	BufferCommons
 	data      *bytes.Buffer
 	writer    *bitio.Writer
 	byteOrder binary.ByteOrder
 	pos       uint
 }
 
+var _ WriteBuffer = (*boxedWriteBuffer)(nil)
+
 //
 // Internal section
 //
 ///////////////////////////////////////
 ///////////////////////////////////////
 
-func (wb *byteWriteBuffer) PushContext(_ string, _ ...WithWriterArgs) error {
-	return nil
-}
-
 func (wb *byteWriteBuffer) SetByteOrder(byteOrder binary.ByteOrder) {
 	wb.byteOrder = byteOrder
 }
@@ -106,6 +105,10 @@ func (wb *byteWriteBuffer) GetByteOrder() binary.ByteOrder {
 	return wb.byteOrder
 }
 
+func (wb *byteWriteBuffer) PushContext(_ string, _ ...WithWriterArgs) error {
+	return nil
+}
+
 func (wb *byteWriteBuffer) GetPos() uint16 {
 	return uint16(wb.pos / 8)
 }
@@ -235,10 +238,11 @@ func (wb *byteWriteBuffer) WriteBigFloat(_ string, bitLength uint8, value *big.F
 	return errors.New("not implemented yet")
 }
 
-func (wb *byteWriteBuffer) WriteString(_ string, bitLength uint32, encoding string, value string, _ ...WithWriterArgs) error {
+func (wb *byteWriteBuffer) WriteString(_ string, bitLength uint32, value string, writerArgs ...WithWriterArgs) error {
 	wb.move(uint(bitLength))
 	// TODO: make this a writer arg
 	var nonAlphanumericRegex = regexp.MustCompile(`[^A-Z0-9]+`)
+	encoding := wb.ExtractEncoding(UpcastWriterArgs(writerArgs...)...)
 	encoding = nonAlphanumericRegex.ReplaceAllLiteralString(strings.ToUpper(encoding), "")
 	remainingBits := int64(bitLength) // we use int64 otherwise the subtraction below flips
 	// TODO: the implementation completely ignores encoding for now. Fix this
diff --git a/plc4go/spi/utils/WriteBufferByteBased_test.go b/plc4go/spi/utils/WriteBufferByteBased_test.go
index aef8f83e5da..e2cd3729f86 100644
--- a/plc4go/spi/utils/WriteBufferByteBased_test.go
+++ b/plc4go/spi/utils/WriteBufferByteBased_test.go
@@ -907,9 +907,8 @@ func Test_byteWriteBuffer_WriteString(t *testing.T) {
 	type args struct {
 		in0       string
 		bitLength uint32
-		encoding  string
 		value     string
-		in4       []WithWriterArgs
+		args      []WithWriterArgs
 	}
 	tests := []struct {
 		name    string
@@ -935,8 +934,8 @@ func Test_byteWriteBuffer_WriteString(t *testing.T) {
 			},
 			args: args{
 				bitLength: 48,
-				encoding:  "UTF8",
 				value:     "plc4x",
+				args:      []WithWriterArgs{WithEncoding("UTF8")},
 			},
 			wantErr: assert.NoError,
 		},
@@ -947,8 +946,8 @@ func Test_byteWriteBuffer_WriteString(t *testing.T) {
 			},
 			args: args{
 				bitLength: 48,
-				encoding:  "UTF16",
 				value:     "plc4x",
+				args:      []WithWriterArgs{WithEncoding("UTF16")},
 			},
 			wantErr: assert.NoError,
 		},
@@ -959,8 +958,8 @@ func Test_byteWriteBuffer_WriteString(t *testing.T) {
 			},
 			args: args{
 				bitLength: 48,
-				encoding:  "UTF16BE",
 				value:     "plc4x",
+				args:      []WithWriterArgs{WithEncoding("UTF16BE")},
 			},
 			wantErr: assert.NoError,
 		},
@@ -971,8 +970,8 @@ func Test_byteWriteBuffer_WriteString(t *testing.T) {
 			},
 			args: args{
 				bitLength: 48,
-				encoding:  "UTF16LE",
 				value:     "plc4x",
+				args:      []WithWriterArgs{WithEncoding("UTF16LE")},
 			},
 			wantErr: assert.NoError,
 		},
@@ -985,7 +984,7 @@ func Test_byteWriteBuffer_WriteString(t *testing.T) {
 				byteOrder: tt.fields.byteOrder,
 				pos:       tt.fields.pos,
 			}
-			tt.wantErr(t, wb.WriteString(tt.args.in0, tt.args.bitLength, tt.args.encoding, tt.args.value, tt.args.in4...), fmt.Sprintf("WriteString(%v, %v, %v, %v, %v)", tt.args.in0, tt.args.bitLength, tt.args.encoding, tt.args.value, tt.args.in4))
+			tt.wantErr(t, wb.WriteString(tt.args.in0, tt.args.bitLength, tt.args.value, tt.args.args...), fmt.Sprintf("WriteString(%v, %v, %v,  %v)", tt.args.in0, tt.args.bitLength, tt.args.value, tt.args.args))
 		})
 	}
 }
diff --git a/plc4go/spi/utils/WriteBufferJsonBased.go b/plc4go/spi/utils/WriteBufferJsonBased.go
index c6eca9b29d0..a426fea2ff4 100644
--- a/plc4go/spi/utils/WriteBufferJsonBased.go
+++ b/plc4go/spi/utils/WriteBufferJsonBased.go
@@ -21,6 +21,7 @@ package utils
 
 import (
 	"context"
+	"encoding/binary"
 	"encoding/json"
 	"fmt"
 	"math/big"
@@ -75,12 +76,21 @@ type listContext struct {
 	list        []any
 }
 
+var _ WriteBuffer = (*jsonWriteBuffer)(nil)
+
 //
 // Internal section
 //
 ///////////////////////////////////////
 ///////////////////////////////////////
 
+func (*jsonWriteBuffer) GetByteOrder() binary.ByteOrder {
+	return binary.BigEndian
+}
+
+func (*jsonWriteBuffer) SetByteOrder(_ binary.ByteOrder) {
+}
+
 func (j *jsonWriteBuffer) PushContext(logicalName string, writerArgs ...WithWriterArgs) error {
 	renderedAsList := j.IsToBeRenderedAsList(UpcastWriterArgs(writerArgs...)...)
 	if renderedAsList {
@@ -175,9 +185,9 @@ func (j *jsonWriteBuffer) WriteBigFloat(logicalName string, bitLength uint8, val
 	return j.encodeNode(logicalName, value, j.generateAttr(logicalName, rwFloatKey, uint(bitLength), writerArgs...))
 }
 
-func (j *jsonWriteBuffer) WriteString(logicalName string, bitLength uint32, encoding string, value string, writerArgs ...WithWriterArgs) error {
+func (j *jsonWriteBuffer) WriteString(logicalName string, bitLength uint32, value string, writerArgs ...WithWriterArgs) error {
 	attr := j.generateAttr(logicalName, rwStringKey, uint(bitLength), writerArgs...)
-	attr[fmt.Sprintf("%s__plc4x_%s", logicalName, rwEncodingKey)] = encoding
+	attr[fmt.Sprintf("%s__plc4x_%s", logicalName, rwEncodingKey)] = j.ExtractEncoding(UpcastWriterArgs(writerArgs...)...)
 	j.move(uint(bitLength))
 	return j.encodeNode(logicalName, value, attr)
 }
diff --git a/plc4go/spi/utils/WriteBufferJsonBased_test.go b/plc4go/spi/utils/WriteBufferJsonBased_test.go
index 1b5396b9c29..1961be0bbb4 100644
--- a/plc4go/spi/utils/WriteBufferJsonBased_test.go
+++ b/plc4go/spi/utils/WriteBufferJsonBased_test.go
@@ -770,7 +770,6 @@ func Test_jsonWriteBuffer_WriteString(t *testing.T) {
 	type args struct {
 		logicalName string
 		bitLength   uint32
-		encoding    string
 		value       string
 		writerArgs  []WithWriterArgs
 	}
@@ -796,7 +795,7 @@ func Test_jsonWriteBuffer_WriteString(t *testing.T) {
 				doRenderAttr:  tt.fields.doRenderAttr,
 				pos:           tt.fields.pos,
 			}
-			tt.wantErr(t, j.WriteString(tt.args.logicalName, tt.args.bitLength, tt.args.encoding, tt.args.value, tt.args.writerArgs...), fmt.Sprintf("WriteString(%v, %v, %v, %v, %v)", tt.args.logicalName, tt.args.bitLength, tt.args.encoding, tt.args.value, tt.args.writerArgs))
+			tt.wantErr(t, j.WriteString(tt.args.logicalName, tt.args.bitLength, tt.args.value, tt.args.writerArgs...), fmt.Sprintf("WriteString(%v, %v, %v, %v)", tt.args.logicalName, tt.args.bitLength, tt.args.value, tt.args.writerArgs))
 		})
 	}
 }
diff --git a/plc4go/spi/utils/WriteBufferXmlBased.go b/plc4go/spi/utils/WriteBufferXmlBased.go
index 6e8b7f5496e..5772963fdee 100644
--- a/plc4go/spi/utils/WriteBufferXmlBased.go
+++ b/plc4go/spi/utils/WriteBufferXmlBased.go
@@ -21,6 +21,7 @@ package utils
 
 import (
 	"context"
+	"encoding/binary"
 	"encoding/xml"
 	"fmt"
 	"math/big"
@@ -74,12 +75,21 @@ type xmlWriteBuffer struct {
 	pos           uint
 }
 
+var _ WriteBuffer = (*xmlWriteBuffer)(nil)
+
 //
 // Internal section
 //
 ///////////////////////////////////////
 ///////////////////////////////////////
 
+func (*xmlWriteBuffer) GetByteOrder() binary.ByteOrder {
+	return binary.BigEndian
+}
+
+func (*xmlWriteBuffer) SetByteOrder(_ binary.ByteOrder) {
+}
+
 func (x *xmlWriteBuffer) PushContext(logicalName string, writerArgs ...WithWriterArgs) error {
 	// Pre-emptive flush to avoid overflow when for a long time no context gets popped
 	if err := x.Flush(); err != nil {
@@ -188,9 +198,9 @@ var printableRange = &unicode.RangeTable{
 	},
 }
 
-func (x *xmlWriteBuffer) WriteString(logicalName string, bitLength uint32, encoding string, value string, writerArgs ...WithWriterArgs) error {
+func (x *xmlWriteBuffer) WriteString(logicalName string, bitLength uint32, value string, writerArgs ...WithWriterArgs) error {
 	attr := x.generateAttr(rwStringKey, uint(bitLength), writerArgs...)
-	attr = append(attr, xml.Attr{Name: xml.Name{Local: rwEncodingKey}, Value: encoding})
+	attr = append(attr, xml.Attr{Name: xml.Name{Local: rwEncodingKey}, Value: x.ExtractEncoding(UpcastWriterArgs(writerArgs...)...)})
 	cleanedUpString := strings.TrimFunc(value, func(r rune) bool {
 		return !unicode.In(r, printableRange)
 	})
diff --git a/plc4go/spi/utils/WriteBufferXmlBased_test.go b/plc4go/spi/utils/WriteBufferXmlBased_test.go
index d400c986b1b..15dd1d5a8d1 100644
--- a/plc4go/spi/utils/WriteBufferXmlBased_test.go
+++ b/plc4go/spi/utils/WriteBufferXmlBased_test.go
@@ -819,7 +819,6 @@ func Test_xmlWriteBuffer_WriteString(t *testing.T) {
 	type args struct {
 		logicalName string
 		bitLength   uint32
-		encoding    string
 		value       string
 		writerArgs  []WithWriterArgs
 	}
@@ -850,7 +849,7 @@ func Test_xmlWriteBuffer_WriteString(t *testing.T) {
 				doRenderAttr:  tt.fields.doRenderAttr,
 				pos:           tt.fields.pos,
 			}
-			tt.wantErr(t, x.WriteString(tt.args.logicalName, tt.args.bitLength, tt.args.encoding, tt.args.value, tt.args.writerArgs...), fmt.Sprintf("WriteString(%v, %v, %v, %v, %v)", tt.args.logicalName, tt.args.bitLength, tt.args.encoding, tt.args.value, tt.args.writerArgs))
+			tt.wantErr(t, x.WriteString(tt.args.logicalName, tt.args.bitLength, tt.args.value, tt.args.writerArgs...), fmt.Sprintf("WriteString(%v, %v, %v, %v)", tt.args.logicalName, tt.args.bitLength, tt.args.value, tt.args.writerArgs))
 		})
 	}
 }
diff --git a/plc4go/spi/utils/WriteBuffer_test.go b/plc4go/spi/utils/WriteBuffer_test.go
index c58c3a80bb0..ae177d2f36a 100644
--- a/plc4go/spi/utils/WriteBuffer_test.go
+++ b/plc4go/spi/utils/WriteBuffer_test.go
@@ -38,7 +38,7 @@ func Test_writerArg_isWriterArgs(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			wr := writerArg{}
-			assert.Equalf(t, tt.want, wr.isWriterArgs(), "isWriterArgs()")
+			assert.Equalf(t, tt.want, wr.isWriterArgs(), "IsWriterArgs()")
 		})
 	}
 }
diff --git a/plc4go/spi/utils/options.go b/plc4go/spi/utils/options.go
new file mode 100644
index 00000000000..0a025ec5e4f
--- /dev/null
+++ b/plc4go/spi/utils/options.go
@@ -0,0 +1,29 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package utils
+
+// CustomOption can be used for transporting custom readerWriterArgs. Use NewCustomOption to create one.
+type CustomOption struct {
+	readerWriterArg
+}
+
+func NewCustomOption() CustomOption {
+	return CustomOption{readerWriterArg{readerArg{}, writerArg{}}}
+}
diff --git a/plc4go/spi/values/PlcCHAR.go b/plc4go/spi/values/PlcCHAR.go
index ab7050c7bde..1129ae4cf5f 100644
--- a/plc4go/spi/values/PlcCHAR.go
+++ b/plc4go/spi/values/PlcCHAR.go
@@ -69,7 +69,7 @@ func (m PlcCHAR) Serialize() ([]byte, error) {
 }
 
 func (m PlcCHAR) SerializeWithWriteBuffer(ctx context.Context, writeBuffer utils.WriteBuffer) error {
-	return writeBuffer.WriteString("PlcCHAR", 8, "UTF-8", m.value)
+	return writeBuffer.WriteString("PlcCHAR", 8, m.value)
 }
 
 func (m PlcCHAR) String() string {
diff --git a/plc4go/spi/values/PlcDATE.go b/plc4go/spi/values/PlcDATE.go
index 75a16f5b448..6b1b5364bb4 100644
--- a/plc4go/spi/values/PlcDATE.go
+++ b/plc4go/spi/values/PlcDATE.go
@@ -106,7 +106,7 @@ func (m PlcDATE) Serialize() ([]byte, error) {
 }
 
 func (m PlcDATE) SerializeWithWriteBuffer(ctx context.Context, writeBuffer utils.WriteBuffer) error {
-	return writeBuffer.WriteString("PlcDATE", uint32(len([]rune(m.GetString()))*8), "UTF-8", m.GetString())
+	return writeBuffer.WriteString("PlcDATE", uint32(len([]rune(m.GetString()))*8), m.GetString())
 }
 
 func (m PlcDATE) String() string {
diff --git a/plc4go/spi/values/PlcDATE_AND_LTIME.go b/plc4go/spi/values/PlcDATE_AND_LTIME.go
index 6ec332080e9..4bbb17c8055 100644
--- a/plc4go/spi/values/PlcDATE_AND_LTIME.go
+++ b/plc4go/spi/values/PlcDATE_AND_LTIME.go
@@ -124,7 +124,7 @@ func (m PlcDATE_AND_LTIME) Serialize() ([]byte, error) {
 }
 
 func (m PlcDATE_AND_LTIME) SerializeWithWriteBuffer(ctx context.Context, writeBuffer utils.WriteBuffer) error {
-	return writeBuffer.WriteString("PlcDATE_AND_LTIME", uint32(len([]rune(m.GetString()))*8), "UTF-8", m.GetString())
+	return writeBuffer.WriteString("PlcDATE_AND_LTIME", uint32(len([]rune(m.GetString()))*8), m.GetString())
 }
 
 func (m PlcDATE_AND_LTIME) String() string {
diff --git a/plc4go/spi/values/PlcDATE_AND_TIME.go b/plc4go/spi/values/PlcDATE_AND_TIME.go
index 0a8bbf312c1..3e2eddae8a7 100644
--- a/plc4go/spi/values/PlcDATE_AND_TIME.go
+++ b/plc4go/spi/values/PlcDATE_AND_TIME.go
@@ -122,7 +122,7 @@ func (m PlcDATE_AND_TIME) Serialize() ([]byte, error) {
 }
 
 func (m PlcDATE_AND_TIME) SerializeWithWriteBuffer(ctx context.Context, writeBuffer utils.WriteBuffer) error {
-	return writeBuffer.WriteString("PlcDATE_AND_TIME", uint32(len([]rune(m.GetString()))*8), "UTF-8", m.GetString())
+	return writeBuffer.WriteString("PlcDATE_AND_TIME", uint32(len([]rune(m.GetString()))*8), m.GetString())
 }
 
 func (m PlcDATE_AND_TIME) String() string {
diff --git a/plc4go/spi/values/PlcLDATE.go b/plc4go/spi/values/PlcLDATE.go
index c53773fa978..d9aea97f53b 100644
--- a/plc4go/spi/values/PlcLDATE.go
+++ b/plc4go/spi/values/PlcLDATE.go
@@ -94,7 +94,7 @@ func (m PlcLDATE) Serialize() ([]byte, error) {
 }
 
 func (m PlcLDATE) SerializeWithWriteBuffer(ctx context.Context, writeBuffer utils.WriteBuffer) error {
-	return writeBuffer.WriteString("PlcLDATE", uint32(len([]rune(m.GetString()))*8), "UTF-8", m.GetString())
+	return writeBuffer.WriteString("PlcLDATE", uint32(len([]rune(m.GetString()))*8), m.GetString())
 }
 
 func (m PlcLDATE) String() string {
diff --git a/plc4go/spi/values/PlcLDATE_AND_TIME.go b/plc4go/spi/values/PlcLDATE_AND_TIME.go
index 5fdf298ba4a..c2e80a9eae8 100644
--- a/plc4go/spi/values/PlcLDATE_AND_TIME.go
+++ b/plc4go/spi/values/PlcLDATE_AND_TIME.go
@@ -93,7 +93,7 @@ func (m PlcLDATE_AND_TIME) Serialize() ([]byte, error) {
 }
 
 func (m PlcLDATE_AND_TIME) SerializeWithWriteBuffer(ctx context.Context, writeBuffer utils.WriteBuffer) error {
-	return writeBuffer.WriteString("PlcLDATE_AND_TIME", uint32(len([]rune(m.GetString()))*8), "UTF-8", m.GetString())
+	return writeBuffer.WriteString("PlcLDATE_AND_TIME", uint32(len([]rune(m.GetString()))*8), m.GetString())
 }
 
 func (m PlcLDATE_AND_TIME) String() string {
diff --git a/plc4go/spi/values/PlcLTIME.go b/plc4go/spi/values/PlcLTIME.go
index a3805b02570..27eefad7e1e 100644
--- a/plc4go/spi/values/PlcLTIME.go
+++ b/plc4go/spi/values/PlcLTIME.go
@@ -86,7 +86,7 @@ func (m PlcLTIME) Serialize() ([]byte, error) {
 }
 
 func (m PlcLTIME) SerializeWithWriteBuffer(ctx context.Context, writeBuffer utils.WriteBuffer) error {
-	return writeBuffer.WriteString("PlcLTIME", uint32(len([]rune(m.GetString()))*8), "UTF-8", m.GetString())
+	return writeBuffer.WriteString("PlcLTIME", uint32(len([]rune(m.GetString()))*8), m.GetString())
 }
 
 func (m PlcLTIME) String() string {
diff --git a/plc4go/spi/values/PlcLTIME_OF_DAY.go b/plc4go/spi/values/PlcLTIME_OF_DAY.go
index d7075e0e602..ec72f1a7847 100644
--- a/plc4go/spi/values/PlcLTIME_OF_DAY.go
+++ b/plc4go/spi/values/PlcLTIME_OF_DAY.go
@@ -99,7 +99,7 @@ func (m PlcLTIME_OF_DAY) Serialize() ([]byte, error) {
 }
 
 func (m PlcLTIME_OF_DAY) SerializeWithWriteBuffer(ctx context.Context, writeBuffer utils.WriteBuffer) error {
-	return writeBuffer.WriteString("PlcLTIME_OF_DAY", uint32(len([]rune(m.GetString()))*8), "UTF-8", m.GetString())
+	return writeBuffer.WriteString("PlcLTIME_OF_DAY", uint32(len([]rune(m.GetString()))*8), m.GetString())
 }
 
 func (m PlcLTIME_OF_DAY) String() string {
diff --git a/plc4go/spi/values/PlcSTRING.go b/plc4go/spi/values/PlcSTRING.go
index 6be3a9a530a..003b00e7783 100644
--- a/plc4go/spi/values/PlcSTRING.go
+++ b/plc4go/spi/values/PlcSTRING.go
@@ -69,7 +69,7 @@ func (m PlcSTRING) Serialize() ([]byte, error) {
 }
 
 func (m PlcSTRING) SerializeWithWriteBuffer(ctx context.Context, writeBuffer utils.WriteBuffer) error {
-	return writeBuffer.WriteString("PlcSTRING", uint32(len([]rune(m.value))*8), "UTF-8", m.value)
+	return writeBuffer.WriteString("PlcSTRING", uint32(len([]rune(m.value))*8), m.value)
 }
 
 func (m PlcSTRING) String() string {
diff --git a/plc4go/spi/values/PlcTIME.go b/plc4go/spi/values/PlcTIME.go
index fabf14e8c4e..67ab66bad04 100644
--- a/plc4go/spi/values/PlcTIME.go
+++ b/plc4go/spi/values/PlcTIME.go
@@ -86,7 +86,7 @@ func (m PlcTIME) Serialize() ([]byte, error) {
 }
 
 func (m PlcTIME) SerializeWithWriteBuffer(ctx context.Context, writeBuffer utils.WriteBuffer) error {
-	return writeBuffer.WriteString("PlcTIME", uint32(len([]rune(m.GetString()))*8), "UTF-8", m.GetString())
+	return writeBuffer.WriteString("PlcTIME", uint32(len([]rune(m.GetString()))*8), m.GetString())
 }
 
 func (m PlcTIME) String() string {
diff --git a/plc4go/spi/values/PlcTIME_OF_DAY.go b/plc4go/spi/values/PlcTIME_OF_DAY.go
index 8ec92388b73..9cbfdef2ba2 100644
--- a/plc4go/spi/values/PlcTIME_OF_DAY.go
+++ b/plc4go/spi/values/PlcTIME_OF_DAY.go
@@ -100,7 +100,7 @@ func (m PlcTIME_OF_DAY) Serialize() ([]byte, error) {
 }
 
 func (m PlcTIME_OF_DAY) SerializeWithWriteBuffer(ctx context.Context, writeBuffer utils.WriteBuffer) error {
-	return writeBuffer.WriteString("PlcTIME_OF_DAY", uint32(len([]rune(m.GetString()))*8), "UTF-8", m.GetString())
+	return writeBuffer.WriteString("PlcTIME_OF_DAY", uint32(len([]rune(m.GetString()))*8), m.GetString())
 }
 
 func (m PlcTIME_OF_DAY) String() string {
diff --git a/plc4go/spi/values/PlcWCHAR.go b/plc4go/spi/values/PlcWCHAR.go
index cdfe5b32add..c048848e593 100644
--- a/plc4go/spi/values/PlcWCHAR.go
+++ b/plc4go/spi/values/PlcWCHAR.go
@@ -69,7 +69,7 @@ func (m PlcWCHAR) Serialize() ([]byte, error) {
 }
 
 func (m PlcWCHAR) SerializeWithWriteBuffer(ctx context.Context, writeBuffer utils.WriteBuffer) error {
-	return writeBuffer.WriteString("PlcWCHAR", uint32(16), "UTF-16", m.value)
+	return writeBuffer.WriteString("PlcWCHAR", uint32(16), m.value, utils.WithEncoding("UTF-16"))
 }
 
 func (m PlcWCHAR) String() string {
diff --git a/plc4go/spi/values/PlcWSTRING.go b/plc4go/spi/values/PlcWSTRING.go
index 5003d80ebac..5ea495de6d0 100644
--- a/plc4go/spi/values/PlcWSTRING.go
+++ b/plc4go/spi/values/PlcWSTRING.go
@@ -69,7 +69,7 @@ func (m PlcWSTRING) Serialize() ([]byte, error) {
 }
 
 func (m PlcWSTRING) SerializeWithWriteBuffer(ctx context.Context, writeBuffer utils.WriteBuffer) error {
-	return writeBuffer.WriteString("PlcSTRING", uint32(len(m.value)*8), "UTF-8", m.value)
+	return writeBuffer.WriteString("PlcSTRING", uint32(len(m.value)*8), m.value)
 }
 
 func (m PlcWSTRING) String() string {
diff --git a/plc4go/spi/values/WriteBufferPlcValueBased.go b/plc4go/spi/values/WriteBufferPlcValueBased.go
index 8a485eb9b43..a785fbf3a24 100644
--- a/plc4go/spi/values/WriteBufferPlcValueBased.go
+++ b/plc4go/spi/values/WriteBufferPlcValueBased.go
@@ -21,6 +21,7 @@ package values
 
 import (
 	"context"
+	"encoding/binary"
 	"math/big"
 
 	"github.com/pkg/errors"
@@ -61,12 +62,21 @@ type plcListContext struct {
 	list        []apiValues.PlcValue
 }
 
+var _ utils.WriteBuffer = (*writeBufferPlcValueBased)(nil)
+
 //
 // Internal section
 //
 ///////////////////////////////////////
 ///////////////////////////////////////
 
+func (*writeBufferPlcValueBased) GetByteOrder() binary.ByteOrder {
+	return binary.BigEndian
+}
+
+func (*writeBufferPlcValueBased) SetByteOrder(_ binary.ByteOrder) {
+}
+
 func (p *writeBufferPlcValueBased) PushContext(logicalName string, writerArgs ...utils.WithWriterArgs) error {
 	renderedAsList := p.IsToBeRenderedAsList(utils.UpcastWriterArgs(writerArgs...)...)
 	if renderedAsList {
@@ -168,7 +178,7 @@ func (p *writeBufferPlcValueBased) WriteBigFloat(logicalName string, bitLength u
 	return p.appendValue(logicalName, NewPlcRawByteArray(encode))
 }
 
-func (p *writeBufferPlcValueBased) WriteString(logicalName string, bitLength uint32, _ string, value string, _ ...utils.WithWriterArgs) error {
+func (p *writeBufferPlcValueBased) WriteString(logicalName string, bitLength uint32, value string, _ ...utils.WithWriterArgs) error {
 	p.move(uint(bitLength))
 	return p.appendValue(logicalName, NewPlcSTRING(value))
 }
diff --git a/plc4go/spi/values/WriteBufferPlcValueBased_test.go b/plc4go/spi/values/WriteBufferPlcValueBased_test.go
index 6cac39fa893..6fab55f17a3 100644
--- a/plc4go/spi/values/WriteBufferPlcValueBased_test.go
+++ b/plc4go/spi/values/WriteBufferPlcValueBased_test.go
@@ -758,7 +758,6 @@ func Test_writeBufferPlcValueBased_WriteString(t *testing.T) {
 	type args struct {
 		logicalName string
 		bitLength   uint32
-		in2         string
 		value       string
 		in4         []utils.WithWriterArgs
 	}
@@ -781,7 +780,7 @@ func Test_writeBufferPlcValueBased_WriteString(t *testing.T) {
 				rootNode:      tt.fields.rootNode,
 				pos:           tt.fields.pos,
 			}
-			tt.wantErr(t, p.WriteString(tt.args.logicalName, tt.args.bitLength, tt.args.in2, tt.args.value, tt.args.in4...), fmt.Sprintf("WriteString(%v, %v, %v, %v, %v)", tt.args.logicalName, tt.args.bitLength, tt.args.in2, tt.args.value, tt.args.in4))
+			tt.wantErr(t, p.WriteString(tt.args.logicalName, tt.args.bitLength, tt.args.value, tt.args.in4...), fmt.Sprintf("WriteString(%v, %v, %v, %v)", tt.args.logicalName, tt.args.bitLength, tt.args.value, tt.args.in4))
 		})
 	}
 }
diff --git a/plc4go/tools/plc4xgenerator/gen.go b/plc4go/tools/plc4xgenerator/gen.go
index f3a290fd962..5c491c548c3 100644
--- a/plc4go/tools/plc4xgenerator/gen.go
+++ b/plc4go/tools/plc4xgenerator/gen.go
@@ -436,7 +436,7 @@ func (g *Generator) generate(typeName string) {
 				g.Printf("\t\t\t}\n")
 				g.Printf("\t\t} else {\n")
 				g.Printf("\t\t\telemAsString := fmt.Sprintf(\"%%v\", elem)\n")
-				g.Printf("\t\t\tif err := writeBuffer.WriteString(name, uint32(len(elemAsString)*8), \"UTF-8\", elemAsString); err != nil {\n")
+				g.Printf("\t\t\tif err := writeBuffer.WriteString(name, uint32(len(elemAsString)*8), elemAsString); err != nil {\n")
 				g.Printf("\t\t\t\treturn err\n")
 				g.Printf("\t\t\t}\n")
 				g.Printf("\t\t}\n")
@@ -639,7 +639,7 @@ var serializableFieldTemplate = `
 			}
 		} else {
 			stringValue := fmt.Sprintf("%%v", %[1]s)
-			if err := writeBuffer.WriteString(%[2]s, uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+			if err := writeBuffer.WriteString(%[2]s, uint32(len(stringValue)*8), stringValue); err != nil {
 				return err
 			}
 		}
@@ -661,7 +661,7 @@ var atomicPointerFieldTemplate = `
 			}
 		} else {
 			stringValue := fmt.Sprintf("%%v", %[2]s)
-			if err := writeBuffer.WriteString(%[3]s, uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+			if err := writeBuffer.WriteString(%[3]s, uint32(len(stringValue)*8), stringValue); err != nil {
 				return err
 			}
 		}
@@ -705,7 +705,7 @@ var boolFieldSerialize = `
 `
 
 var stringFieldSerialize = `
-	if err := writeBuffer.WriteString(%[2]s, uint32(len(%[1]s)*8), "UTF-8", %[1]s); err != nil {
+	if err := writeBuffer.WriteString(%[2]s, uint32(len(%[1]s)*8), %[1]s); err != nil {
 		return err
 	}
 `
@@ -713,7 +713,7 @@ var stringFieldSerialize = `
 var errorFieldSerialize = `
 	if %[1]s != nil {
 		_errString := %[1]s.Error()
-		if err := writeBuffer.WriteString(%[2]s, uint32(len(_errString)*8), "UTF-8", _errString); err != nil {
+		if err := writeBuffer.WriteString(%[2]s, uint32(len(_errString)*8), _errString); err != nil {
 			return err
 		}
 	}
@@ -721,7 +721,7 @@ var errorFieldSerialize = `
 
 var chanFieldSerialize = `
 	_%[3]s_plx4gen_description := fmt.Sprintf("%%d element(s)", len(%[1]s))
-    if err := writeBuffer.WriteString(%[2]s, uint32(len(_%[3]s_plx4gen_description)*8), "UTF-8", _%[3]s_plx4gen_description); err != nil {
+    if err := writeBuffer.WriteString(%[2]s, uint32(len(_%[3]s_plx4gen_description)*8), _%[3]s_plx4gen_description); err != nil {
 		return err
 	}
 `