Repository: moov-io/ach
Pull request #1070 (2022-08-17 08:02:23)

Remove recordType and reserved fields
This is a bit scary, but it seems that `recordType` and `reserved` fields don't really do anything. They are unexported, they are always set by each struct's corresponding `New` function, and they are effectively constants.

The existence of these fields causes issues when marshalling & unmarshalling ACH data structures. Because `recordType` is unexported, it isn't included in the JSON blob produced by marshal. Then when the blob is unmarshalled, the absence of `recordType` causes validation errors. This is addressed in a few different ways for different types:
- Functions like `NewEntryDetail` return a new struct with defaults set. The blob can be unmarshalled into that struct and the unexported defaults remain.
- The unexported function `setEntryRecordType` iterates through each of an `EntryDetail`'s addenda fields and sets each `recordTypes` (this is called by `FileFromJSON`)
- Custom `Unmarshal` functions like `batch.UnmarshalJSON` populate fields with default structs before unmarshalling.

The particular issue I'm running into is marshalling and unmarshalling `BatchHeaders`. This could be addressed by exporting `setEntryRecordType` or adding another custom Unmarshal function. But I think it would be even better if we could remove `recordType` (and `reserved`) altogether, and replace references to them with appropriate constants.


Patch:
diff --git a/addenda02.go b/addenda02.go
index dc378e9b..a3a71837 100644
--- a/addenda02.go
+++ b/addenda02.go
@@ -28,8 +28,6 @@ import (
 type Addenda02 struct {
 	// ID is a client defined string used as a reference to this record.
 	ID string `json:"id"`
-	// RecordType defines the type of record in the block. entryAddenda02 Pos 7
-	recordType string
 	// TypeCode Addenda02 type code '02'
 	TypeCode string `json:"typeCode"`
 	// ReferenceInformationOne may be used for additional reference numbers, identification numbers,
@@ -70,7 +68,6 @@ type Addenda02 struct {
 // NewAddenda02 returns a new Addenda02 with default values for none exported fields
 func NewAddenda02() *Addenda02 {
 	addenda02 := new(Addenda02)
-	addenda02.recordType = "7"
 	addenda02.TypeCode = "02"
 	return addenda02
 }
@@ -83,8 +80,7 @@ func (addenda02 *Addenda02) Parse(record string) {
 		return
 	}
 
-	// 1-1 Always "7"
-	addenda02.recordType = "7"
+	// 1-1 Always 7
 	// 2-3 Always 02
 	addenda02.TypeCode = record[1:3]
 	// 4-10 Based on the information entered (04-10) 7 alphanumeric
@@ -113,7 +109,7 @@ func (addenda02 *Addenda02) Parse(record string) {
 func (addenda02 *Addenda02) String() string {
 	var buf strings.Builder
 	buf.Grow(94)
-	buf.WriteString(addenda02.recordType)
+	buf.WriteString(entryAddendaPos)
 	buf.WriteString(addenda02.TypeCode)
 	buf.WriteString(addenda02.ReferenceInformationOneField())
 	buf.WriteString(addenda02.ReferenceInformationTwoField())
@@ -134,9 +130,6 @@ func (addenda02 *Addenda02) Validate() error {
 	if err := addenda02.fieldInclusion(); err != nil {
 		return err
 	}
-	if addenda02.recordType != "7" {
-		return fieldError("recordType", NewErrRecordType(7), addenda02.recordType)
-	}
 	if err := addenda02.isTypeCode(addenda02.TypeCode); err != nil {
 		return fieldError("TypeCode", err, addenda02.TypeCode)
 	}
@@ -187,9 +180,6 @@ func (addenda02 *Addenda02) Validate() error {
 // invalid the ACH transfer will be returned.
 
 func (addenda02 *Addenda02) fieldInclusion() error {
-	if addenda02.recordType == "" {
-		return fieldError("recordType", ErrConstructor, addenda02.recordType)
-	}
 	if addenda02.TypeCode == "" {
 		return fieldError("TypeCode", ErrConstructor, addenda02.TypeCode)
 	}
diff --git a/addenda05.go b/addenda05.go
index 4f2739d1..4dce7a6a 100644
--- a/addenda05.go
+++ b/addenda05.go
@@ -28,8 +28,6 @@ import (
 type Addenda05 struct {
 	// ID is a client defined string used as a reference to this record.
 	ID string `json:"id"`
-	// RecordType defines the type of record in the block. entryAddenda05 Pos 7
-	recordType string
 	// TypeCode Addenda05 types code '05'
 	TypeCode string `json:"typeCode"`
 	// PaymentRelatedInformation
@@ -52,7 +50,6 @@ type Addenda05 struct {
 // NewAddenda05 returns a new Addenda05 with default values for none exported fields
 func NewAddenda05() *Addenda05 {
 	addenda05 := new(Addenda05)
-	addenda05.recordType = "7"
 	addenda05.TypeCode = "05"
 	return addenda05
 }
@@ -65,8 +62,7 @@ func (addenda05 *Addenda05) Parse(record string) {
 		return
 	}
 
-	// 1-1 Always "7"
-	addenda05.recordType = "7"
+	// 1-1 Always 7
 	// 2-3 Always 05
 	addenda05.TypeCode = record[1:3]
 	// 4-83 Based on the information entered (04-83) 80 alphanumeric
@@ -82,7 +78,7 @@ func (addenda05 *Addenda05) Parse(record string) {
 func (addenda05 *Addenda05) String() string {
 	var buf strings.Builder
 	buf.Grow(94)
-	buf.WriteString(addenda05.recordType)
+	buf.WriteString(entryAddendaPos)
 	buf.WriteString(addenda05.TypeCode)
 	buf.WriteString(addenda05.PaymentRelatedInformationField())
 	buf.WriteString(addenda05.SequenceNumberField())
@@ -97,9 +93,6 @@ func (addenda05 *Addenda05) Validate() error {
 		return err
 	}
 
-	if addenda05.recordType != "7" {
-		return fieldError("recordType", NewErrRecordType(7), addenda05.recordType)
-	}
 	if err := addenda05.isTypeCode(addenda05.TypeCode); err != nil {
 		return fieldError("TypeCode", err, addenda05.TypeCode)
 	}
@@ -117,9 +110,6 @@ func (addenda05 *Addenda05) Validate() error {
 // fieldInclusion validate mandatory fields are not default values. If fields are
 // invalid the ACH transfer will be returned.
 func (addenda05 *Addenda05) fieldInclusion() error {
-	if addenda05.recordType == "" {
-		return fieldError("recordType", ErrConstructor, addenda05.recordType)
-	}
 	if addenda05.TypeCode == "" {
 		return fieldError("TypeCode", ErrConstructor, addenda05.TypeCode)
 	}
diff --git a/addenda10.go b/addenda10.go
index a01359c9..2b8dd15e 100644
--- a/addenda10.go
+++ b/addenda10.go
@@ -32,8 +32,6 @@ import (
 type Addenda10 struct {
 	// ID is a client defined string used as a reference to this record.
 	ID string `json:"id"`
-	// RecordType defines the type of record in the block.
-	recordType string
 	// TypeCode Addenda10 types code '10'
 	TypeCode string `json:"typeCode"`
 	// Transaction Type Code Describes the type of payment:
@@ -49,8 +47,6 @@ type Addenda10 struct {
 	ForeignTraceNumber string `json:"foreignTraceNumber,omitempty"`
 	// Receiving Company Name/Individual Name
 	Name string `json:"name"`
-	// reserved - Leave blank
-	reserved string
 	// EntryDetailSequenceNumber contains the ascending sequence number section of the Entry
 	// Detail or Corporate Entry Detail Record's trace number This number is
 	// the same as the last seven digits of the trace number of the related
@@ -65,7 +61,6 @@ type Addenda10 struct {
 // NewAddenda10 returns a new Addenda10 with default values for none exported fields
 func NewAddenda10() *Addenda10 {
 	addenda10 := new(Addenda10)
-	addenda10.recordType = "7"
 	addenda10.TypeCode = "10"
 	return addenda10
 }
@@ -78,8 +73,7 @@ func (addenda10 *Addenda10) Parse(record string) {
 		return
 	}
 
-	// 1-1 Always "7"
-	addenda10.recordType = "7"
+	// 1-1 Always 7
 	// 2-3 Always 10
 	addenda10.TypeCode = record[1:3]
 	// 04-06 Describes the type of payment
@@ -91,7 +85,6 @@ func (addenda10 *Addenda10) Parse(record string) {
 	// 47-81 Receiving Company Name/Individual Name
 	addenda10.Name = strings.TrimSpace(record[46:81])
 	// 82-87 reserved - Leave blank
-	addenda10.reserved = "      "
 	// 88-94 Contains the last seven digits of the number entered in the Trace Number field in the corresponding Entry Detail Record
 	addenda10.EntryDetailSequenceNumber = addenda10.parseNumField(record[87:94])
 }
@@ -100,14 +93,14 @@ func (addenda10 *Addenda10) Parse(record string) {
 func (addenda10 *Addenda10) String() string {
 	var buf strings.Builder
 	buf.Grow(94)
-	buf.WriteString(addenda10.recordType)
+	buf.WriteString(entryAddendaPos)
 	buf.WriteString(addenda10.TypeCode)
 	// TransactionTypeCode Validator
 	buf.WriteString(addenda10.TransactionTypeCode)
 	buf.WriteString(addenda10.ForeignPaymentAmountField())
 	buf.WriteString(addenda10.ForeignTraceNumberField())
 	buf.WriteString(addenda10.NameField())
-	buf.WriteString(addenda10.reservedField())
+	buf.WriteString("      ")
 	buf.WriteString(addenda10.EntryDetailSequenceNumberField())
 	return buf.String()
 }
@@ -118,9 +111,6 @@ func (addenda10 *Addenda10) Validate() error {
 	if err := addenda10.fieldInclusion(); err != nil {
 		return err
 	}
-	if addenda10.recordType != "7" {
-		return fieldError("recordType", NewErrRecordType(7), addenda10.recordType)
-	}
 	if err := addenda10.isTypeCode(addenda10.TypeCode); err != nil {
 		return fieldError("TypeCode", err, addenda10.TypeCode)
 	}
@@ -144,9 +134,6 @@ func (addenda10 *Addenda10) Validate() error {
 // fieldInclusion validate mandatory fields are not default values. If fields are
 // invalid the ACH transfer will be returned.
 func (addenda10 *Addenda10) fieldInclusion() error {
-	if addenda10.recordType == "" {
-		return fieldError("recordType", ErrConstructor, addenda10.recordType)
-	}
 	if addenda10.TypeCode == "" {
 		return fieldError("TypeCode", ErrConstructor, addenda10.TypeCode)
 	}
@@ -182,11 +169,6 @@ func (addenda10 *Addenda10) NameField() string {
 	return addenda10.alphaField(addenda10.Name, 35)
 }
 
-// reservedField gets reserved - blank space
-func (addenda10 *Addenda10) reservedField() string {
-	return addenda10.alphaField(addenda10.reserved, 6)
-}
-
 // EntryDetailSequenceNumberField returns a zero padded EntryDetailSequenceNumber string
 func (addenda10 *Addenda10) EntryDetailSequenceNumberField() string {
 	return addenda10.numericField(addenda10.EntryDetailSequenceNumber, 7)
diff --git a/addenda11.go b/addenda11.go
index 36481a40..eebe9059 100644
--- a/addenda11.go
+++ b/addenda11.go
@@ -32,16 +32,12 @@ import (
 type Addenda11 struct {
 	// ID is a client defined string used as a reference to this record.
 	ID string `json:"id"`
-	// RecordType defines the type of record in the block.
-	recordType string
 	// TypeCode Addenda11 types code '11'
 	TypeCode string `json:"typeCode"`
 	// Originator Name contains the originators name (your company name / name)
 	OriginatorName string `json:"originatorName"`
 	// Originator Street Address Contains the originators street address (your company's address / your address)
 	OriginatorStreetAddress string `json:"originatorStreetAddress"`
-	// reserved - Leave blank
-	reserved string
 	// EntryDetailSequenceNumber contains the ascending sequence number section of the Entry
 	// Detail or Corporate Entry Detail Record's trace number This number is
 	// the same as the last seven digits of the trace number of the related
@@ -56,7 +52,6 @@ type Addenda11 struct {
 // NewAddenda11 returns a new Addenda11 with default values for none exported fields
 func NewAddenda11() *Addenda11 {
 	addenda11 := new(Addenda11)
-	addenda11.recordType = "7"
 	addenda11.TypeCode = "11"
 	return addenda11
 }
@@ -69,8 +64,7 @@ func (addenda11 *Addenda11) Parse(record string) {
 		return
 	}
 
-	// 1-1 Always "7"
-	addenda11.recordType = "7"
+	// 1-1 Always 7
 	// 2-3 Always 11
 	addenda11.TypeCode = record[1:3]
 	// 4-38
@@ -78,7 +72,6 @@ func (addenda11 *Addenda11) Parse(record string) {
 	// 39-73
 	addenda11.OriginatorStreetAddress = strings.TrimSpace(record[38:73])
 	// 74-87 reserved - Leave blank
-	addenda11.reserved = "              "
 	// 88-94 Contains the last seven digits of the number entered in the Trace Number field in the corresponding Entry Detail Record
 	addenda11.EntryDetailSequenceNumber = addenda11.parseNumField(record[87:94])
 }
@@ -87,11 +80,11 @@ func (addenda11 *Addenda11) Parse(record string) {
 func (addenda11 *Addenda11) String() string {
 	var buf strings.Builder
 	buf.Grow(94)
-	buf.WriteString(addenda11.recordType)
+	buf.WriteString(entryAddendaPos)
 	buf.WriteString(addenda11.TypeCode)
 	buf.WriteString(addenda11.OriginatorNameField())
 	buf.WriteString(addenda11.OriginatorStreetAddressField())
-	buf.WriteString(addenda11.reservedField())
+	buf.WriteString("              ")
 	buf.WriteString(addenda11.EntryDetailSequenceNumberField())
 	return buf.String()
 }
@@ -102,9 +95,6 @@ func (addenda11 *Addenda11) Validate() error {
 	if err := addenda11.fieldInclusion(); err != nil {
 		return err
 	}
-	if addenda11.recordType != "7" {
-		return fieldError("recordType", NewErrRecordType(7), addenda11.recordType)
-	}
 	if err := addenda11.isTypeCode(addenda11.TypeCode); err != nil {
 		return fieldError("TypeCode", err, addenda11.TypeCode)
 	}
@@ -124,9 +114,6 @@ func (addenda11 *Addenda11) Validate() error {
 // fieldInclusion validate mandatory fields are not default values. If fields are
 // invalid the ACH transfer will be returned.
 func (addenda11 *Addenda11) fieldInclusion() error {
-	if addenda11.recordType == "" {
-		return fieldError("recordType", ErrConstructor, addenda11.recordType)
-	}
 	if addenda11.TypeCode == "" {
 		return fieldError("TypeCode", ErrConstructor, addenda11.TypeCode)
 	}
@@ -152,11 +139,6 @@ func (addenda11 *Addenda11) OriginatorStreetAddressField() string {
 	return addenda11.alphaField(addenda11.OriginatorStreetAddress, 35)
 }
 
-// reservedField gets reserved - blank space
-func (addenda11 *Addenda11) reservedField() string {
-	return addenda11.alphaField(addenda11.reserved, 14)
-}
-
 // EntryDetailSequenceNumberField returns a zero padded EntryDetailSequenceNumber string
 func (addenda11 *Addenda11) EntryDetailSequenceNumberField() string {
 	return addenda11.numericField(addenda11.EntryDetailSequenceNumber, 7)
diff --git a/addenda12.go b/addenda12.go
index b273b653..63ff2f47 100644
--- a/addenda12.go
+++ b/addenda12.go
@@ -32,8 +32,6 @@ import (
 type Addenda12 struct {
 	// ID is a client defined string used as a reference to this record.
 	ID string `json:"id"`
-	// RecordType defines the type of record in the block.
-	recordType string
 	// TypeCode Addenda12 types code '12'
 	TypeCode string `json:"typeCode"`
 	// Originator City & State / Province
@@ -45,8 +43,6 @@ type Addenda12 struct {
 	// Data elements must be separated by an asterisk (*) and must end with a backslash (\)
 	// For example: US*10036\
 	OriginatorCountryPostalCode string `json:"originatorCountryPostalCode"`
-	// reserved - Leave blank
-	reserved string
 	// EntryDetailSequenceNumber contains the ascending sequence number section of the Entry
 	// Detail or Corporate Entry Detail Record's trace number This number is
 	// the same as the last seven digits of the trace number of the related
@@ -61,7 +57,6 @@ type Addenda12 struct {
 // NewAddenda12 returns a new Addenda12 with default values for none exported fields
 func NewAddenda12() *Addenda12 {
 	addenda12 := new(Addenda12)
-	addenda12.recordType = "7"
 	addenda12.TypeCode = "12"
 	return addenda12
 }
@@ -74,8 +69,7 @@ func (addenda12 *Addenda12) Parse(record string) {
 		return
 	}
 
-	// 1-1 Always "7"
-	addenda12.recordType = "7"
+	// 1-1 Always 7
 	// 2-3 Always 12
 	addenda12.TypeCode = record[1:3]
 	// 4-38
@@ -83,7 +77,6 @@ func (addenda12 *Addenda12) Parse(record string) {
 	// 39-73
 	addenda12.OriginatorCountryPostalCode = strings.TrimSpace(record[38:73])
 	// 74-87 reserved - Leave blank
-	addenda12.reserved = "              "
 	// 88-94 Contains the last seven digits of the number entered in the Trace Number field in the corresponding Entry Detail Record
 	addenda12.EntryDetailSequenceNumber = addenda12.parseNumField(record[87:94])
 }
@@ -92,12 +85,12 @@ func (addenda12 *Addenda12) Parse(record string) {
 func (addenda12 *Addenda12) String() string {
 	var buf strings.Builder
 	buf.Grow(94)
-	buf.WriteString(addenda12.recordType)
+	buf.WriteString(entryAddendaPos)
 	buf.WriteString(addenda12.TypeCode)
 	buf.WriteString(addenda12.OriginatorCityStateProvinceField())
 	// ToDo Validator for backslash
 	buf.WriteString(addenda12.OriginatorCountryPostalCodeField())
-	buf.WriteString(addenda12.reservedField())
+	buf.WriteString("              ")
 	buf.WriteString(addenda12.EntryDetailSequenceNumberField())
 	return buf.String()
 }
@@ -108,9 +101,6 @@ func (addenda12 *Addenda12) Validate() error {
 	if err := addenda12.fieldInclusion(); err != nil {
 		return err
 	}
-	if addenda12.recordType != "7" {
-		return fieldError("recordType", NewErrRecordType(7), addenda12.recordType)
-	}
 	if err := addenda12.isTypeCode(addenda12.TypeCode); err != nil {
 		return fieldError("TypeCode", err, addenda12.TypeCode)
 	}
@@ -130,9 +120,6 @@ func (addenda12 *Addenda12) Validate() error {
 // fieldInclusion validate mandatory fields are not default values. If fields are
 // invalid the ACH transfer will be returned.
 func (addenda12 *Addenda12) fieldInclusion() error {
-	if addenda12.recordType == "" {
-		return fieldError("recordType", ErrConstructor, addenda12.recordType)
-	}
 	if addenda12.TypeCode == "" {
 		return fieldError("TypeCode", ErrConstructor, addenda12.TypeCode)
 	}
@@ -158,11 +145,6 @@ func (addenda12 *Addenda12) OriginatorCountryPostalCodeField() string {
 	return addenda12.alphaField(addenda12.OriginatorCountryPostalCode, 35)
 }
 
-// reservedField gets reserved - blank space
-func (addenda12 *Addenda12) reservedField() string {
-	return addenda12.alphaField(addenda12.reserved, 14)
-}
-
 // EntryDetailSequenceNumberField returns a zero padded EntryDetailSequenceNumber string
 func (addenda12 *Addenda12) EntryDetailSequenceNumberField() string {
 	return addenda12.numericField(addenda12.EntryDetailSequenceNumber, 7)
diff --git a/addenda13.go b/addenda13.go
index 2a51645b..bbd53cb6 100644
--- a/addenda13.go
+++ b/addenda13.go
@@ -33,8 +33,6 @@ import (
 type Addenda13 struct {
 	// ID is a client defined string used as a reference to this record.
 	ID string `json:"id"`
-	// RecordType defines the type of record in the block.
-	recordType string
 	// TypeCode Addenda13 types code '13'
 	TypeCode string `json:"typeCode"`
 	// Originating DFI Name
@@ -61,8 +59,6 @@ type Addenda13 struct {
 	// the branch of the bank that originated the entry is located. Values for other countries can
 	// be found on the International Organization for Standardization website: www.iso.org.
 	ODFIBranchCountryCode string `json:"ODFIBranchCountryCode"`
-	// reserved - Leave blank
-	reserved string
 	// EntryDetailSequenceNumber contains the ascending sequence number section of the Entry
 	// Detail or Corporate Entry Detail Record's trace number This number is
 	// the same as the last seven digits of the trace number of the related
@@ -77,7 +73,6 @@ type Addenda13 struct {
 // NewAddenda13 returns a new Addenda13 with default values for none exported fields
 func NewAddenda13() *Addenda13 {
 	addenda13 := new(Addenda13)
-	addenda13.recordType = "7"
 	addenda13.TypeCode = "13"
 	return addenda13
 }
@@ -90,8 +85,7 @@ func (addenda13 *Addenda13) Parse(record string) {
 		return
 	}
 
-	// 1-1 Always "7"
-	addenda13.recordType = "7"
+	// 1-1 Always 7
 	// 2-3 Always 13
 	addenda13.TypeCode = record[1:3]
 	// 4-38 ODFIName
@@ -103,7 +97,6 @@ func (addenda13 *Addenda13) Parse(record string) {
 	// 75-77
 	addenda13.ODFIBranchCountryCode = strings.TrimSpace(record[74:77])
 	// 78-87 reserved - Leave blank
-	addenda13.reserved = "          "
 	// 88-94 Contains the last seven digits of the number entered in the Trace Number field in the corresponding Entry Detail Record
 	addenda13.EntryDetailSequenceNumber = addenda13.parseNumField(record[87:94])
 }
@@ -112,13 +105,13 @@ func (addenda13 *Addenda13) Parse(record string) {
 func (addenda13 *Addenda13) String() string {
 	var buf strings.Builder
 	buf.Grow(94)
-	buf.WriteString(addenda13.recordType)
+	buf.WriteString(entryAddendaPos)
 	buf.WriteString(addenda13.TypeCode)
 	buf.WriteString(addenda13.ODFINameField())
 	buf.WriteString(addenda13.ODFIIDNumberQualifierField())
 	buf.WriteString(addenda13.ODFIIdentificationField())
 	buf.WriteString(addenda13.ODFIBranchCountryCodeField())
-	buf.WriteString(addenda13.reservedField())
+	buf.WriteString("          ")
 	buf.WriteString(addenda13.EntryDetailSequenceNumberField())
 	return buf.String()
 }
@@ -129,9 +122,6 @@ func (addenda13 *Addenda13) Validate() error {
 	if err := addenda13.fieldInclusion(); err != nil {
 		return err
 	}
-	if addenda13.recordType != "7" {
-		return fieldError("recordType", NewErrRecordType(7), addenda13.recordType)
-	}
 	if err := addenda13.isTypeCode(addenda13.TypeCode); err != nil {
 		return fieldError("TypeCode", err, addenda13.TypeCode)
 	}
@@ -158,9 +148,6 @@ func (addenda13 *Addenda13) Validate() error {
 // fieldInclusion validate mandatory fields are not default values. If fields are
 // invalid the ACH transfer will be returned.
 func (addenda13 *Addenda13) fieldInclusion() error {
-	if addenda13.recordType == "" {
-		return fieldError("recordType", ErrConstructor, addenda13.recordType)
-	}
 	if addenda13.TypeCode == "" {
 		return fieldError("TypeCode", ErrConstructor, addenda13.TypeCode)
 	}
@@ -202,11 +189,6 @@ func (addenda13 *Addenda13) ODFIBranchCountryCodeField() string {
 	return addenda13.alphaField(addenda13.ODFIBranchCountryCode, 3)
 }
 
-// reservedField gets reserved - blank space
-func (addenda13 *Addenda13) reservedField() string {
-	return addenda13.alphaField(addenda13.reserved, 10)
-}
-
 // EntryDetailSequenceNumberField returns a zero padded EntryDetailSequenceNumber string
 func (addenda13 *Addenda13) EntryDetailSequenceNumberField() string {
 	return addenda13.numericField(addenda13.EntryDetailSequenceNumber, 7)
diff --git a/addenda14.go b/addenda14.go
index 5f1cd5e9..740604e6 100644
--- a/addenda14.go
+++ b/addenda14.go
@@ -31,8 +31,6 @@ import (
 type Addenda14 struct {
 	// ID is a client defined string used as a reference to this record.
 	ID string `json:"id"`
-	// RecordType defines the type of record in the block.
-	recordType string
 	// TypeCode Addenda14 types code '14'
 	TypeCode string `json:"typeCode"`
 	// Receiving DFI Name
@@ -57,8 +55,6 @@ type Addenda14 struct {
 	// branch of the bank that receives the entry is located. Values for other countries can
 	// be found on the International Organization for Standardization website: www.iso.org
 	RDFIBranchCountryCode string `json:"RDFIBranchCountryCode"`
-	// reserved - Leave blank
-	reserved string
 	// EntryDetailSequenceNumber contains the ascending sequence number section of the Entry
 	// Detail or Corporate Entry Detail Record's trace number This number is
 	// the same as the last seven digits of the trace number of the related
@@ -73,7 +69,6 @@ type Addenda14 struct {
 // NewAddenda14 returns a new Addenda14 with default values for none exported fields
 func NewAddenda14() *Addenda14 {
 	addenda14 := new(Addenda14)
-	addenda14.recordType = "7"
 	addenda14.TypeCode = "14"
 	return addenda14
 }
@@ -86,8 +81,7 @@ func (addenda14 *Addenda14) Parse(record string) {
 		return
 	}
 
-	// 1-1 Always "7"
-	addenda14.recordType = "7"
+	// 1-1 Always 7
 	// 2-3 Always 14
 	addenda14.TypeCode = record[1:3]
 	// 4-38 RDFIName
@@ -99,7 +93,6 @@ func (addenda14 *Addenda14) Parse(record string) {
 	// 75-77
 	addenda14.RDFIBranchCountryCode = strings.TrimSpace(record[74:77])
 	// 78-87 reserved - Leave blank
-	addenda14.reserved = "          "
 	// 88-94 Contains the last seven digits of the number entered in the Trace Number field in the corresponding Entry Detail Record
 	addenda14.EntryDetailSequenceNumber = addenda14.parseNumField(record[87:94])
 }
@@ -108,13 +101,13 @@ func (addenda14 *Addenda14) Parse(record string) {
 func (addenda14 *Addenda14) String() string {
 	var buf strings.Builder
 	buf.Grow(94)
-	buf.WriteString(addenda14.recordType)
+	buf.WriteString(entryAddendaPos)
 	buf.WriteString(addenda14.TypeCode)
 	buf.WriteString(addenda14.RDFINameField())
 	buf.WriteString(addenda14.RDFIIDNumberQualifierField())
 	buf.WriteString(addenda14.RDFIIdentificationField())
 	buf.WriteString(addenda14.RDFIBranchCountryCodeField())
-	buf.WriteString(addenda14.reservedField())
+	buf.WriteString("          ")
 	buf.WriteString(addenda14.EntryDetailSequenceNumberField())
 	return buf.String()
 }
@@ -125,9 +118,6 @@ func (addenda14 *Addenda14) Validate() error {
 	if err := addenda14.fieldInclusion(); err != nil {
 		return err
 	}
-	if addenda14.recordType != "7" {
-		return fieldError("recordType", NewErrRecordType(7), addenda14.recordType)
-	}
 	if err := addenda14.isTypeCode(addenda14.TypeCode); err != nil {
 		return fieldError("TypeCode", err, addenda14.TypeCode)
 	}
@@ -154,9 +144,6 @@ func (addenda14 *Addenda14) Validate() error {
 // fieldInclusion validate mandatory fields are not default values. If fields are
 // invalid the ACH transfer will be returned.
 func (addenda14 *Addenda14) fieldInclusion() error {
-	if addenda14.recordType == "" {
-		return fieldError("recordType", ErrConstructor, addenda14.recordType)
-	}
 	if addenda14.TypeCode == "" {
 		return fieldError("TypeCode", ErrConstructor, addenda14.TypeCode)
 	}
@@ -198,11 +185,6 @@ func (addenda14 *Addenda14) RDFIBranchCountryCodeField() string {
 	return addenda14.alphaField(addenda14.RDFIBranchCountryCode, 3)
 }
 
-// reservedField gets reserved - blank space
-func (addenda14 *Addenda14) reservedField() string {
-	return addenda14.alphaField(addenda14.reserved, 10)
-}
-
 // EntryDetailSequenceNumberField returns a zero padded EntryDetailSequenceNumber string
 func (addenda14 *Addenda14) EntryDetailSequenceNumberField() string {
 	return addenda14.numericField(addenda14.EntryDetailSequenceNumber, 7)
diff --git a/addenda15.go b/addenda15.go
index 284daeae..4e6caad4 100644
--- a/addenda15.go
+++ b/addenda15.go
@@ -31,8 +31,6 @@ import (
 type Addenda15 struct {
 	// ID is a client defined string used as a reference to this record.
 	ID string `json:"id"`
-	// RecordType defines the type of record in the block.
-	recordType string
 	// TypeCode Addenda15 types code '15'
 	TypeCode string `json:"typeCode"`
 	// Receiver Identification Number contains the accounting number by which the Originator is known to
@@ -41,8 +39,6 @@ type Addenda15 struct {
 	ReceiverIDNumber string `json:"receiverIDNumber,omitempty"`
 	// Receiver Street Address contains the Receiver's physical address
 	ReceiverStreetAddress string `json:"receiverStreetAddress"`
-	// reserved - Leave blank
-	reserved string
 	// EntryDetailSequenceNumber contains the ascending sequence number section of the Entry
 	// Detail or Corporate Entry Detail Record's trace number This number is
 	// the same as the last seven digits of the trace number of the related
@@ -57,7 +53,6 @@ type Addenda15 struct {
 // NewAddenda15 returns a new Addenda15 with default values for none exported fields
 func NewAddenda15() *Addenda15 {
 	addenda15 := new(Addenda15)
-	addenda15.recordType = "7"
 	addenda15.TypeCode = "15"
 	return addenda15
 }
@@ -70,8 +65,7 @@ func (addenda15 *Addenda15) Parse(record string) {
 		return
 	}
 
-	// 1-1 Always "7"
-	addenda15.recordType = "7"
+	// 1-1 Always 7
 	// 2-3 Always 15
 	addenda15.TypeCode = record[1:3]
 	// 4-18
@@ -79,7 +73,6 @@ func (addenda15 *Addenda15) Parse(record string) {
 	// 19-53
 	addenda15.ReceiverStreetAddress = strings.TrimSpace(record[18:53])
 	// 54-87 reserved - Leave blank
-	addenda15.reserved = "                                  "
 	// 88-94 Contains the last seven digits of the number entered in the Trace Number field in the corresponding Entry Detail Record
 	addenda15.EntryDetailSequenceNumber = addenda15.parseNumField(record[87:94])
 }
@@ -88,11 +81,11 @@ func (addenda15 *Addenda15) Parse(record string) {
 func (addenda15 *Addenda15) String() string {
 	var buf strings.Builder
 	buf.Grow(94)
-	buf.WriteString(addenda15.recordType)
+	buf.WriteString(entryAddendaPos)
 	buf.WriteString(addenda15.TypeCode)
 	buf.WriteString(addenda15.ReceiverIDNumberField())
 	buf.WriteString(addenda15.ReceiverStreetAddressField())
-	buf.WriteString(addenda15.reservedField())
+	buf.WriteString("                                  ")
 	buf.WriteString(addenda15.EntryDetailSequenceNumberField())
 	return buf.String()
 }
@@ -103,9 +96,6 @@ func (addenda15 *Addenda15) Validate() error {
 	if err := addenda15.fieldInclusion(); err != nil {
 		return err
 	}
-	if addenda15.recordType != "7" {
-		return fieldError("recordType", NewErrRecordType(7), addenda15.recordType)
-	}
 	if err := addenda15.isTypeCode(addenda15.TypeCode); err != nil {
 		return fieldError("TypeCode", err, addenda15.TypeCode)
 	}
@@ -125,9 +115,6 @@ func (addenda15 *Addenda15) Validate() error {
 // fieldInclusion validate mandatory fields are not default values. If fields are
 // invalid the ACH transfer will be returned.
 func (addenda15 *Addenda15) fieldInclusion() error {
-	if addenda15.recordType == "" {
-		return fieldError("recordType", ErrConstructor, addenda15.recordType)
-	}
 	if addenda15.TypeCode == "" {
 		return fieldError("TypeCode", ErrConstructor, addenda15.TypeCode)
 	}
@@ -150,11 +137,6 @@ func (addenda15 *Addenda15) ReceiverStreetAddressField() string {
 	return addenda15.alphaField(addenda15.ReceiverStreetAddress, 35)
 }
 
-// reservedField gets reserved - blank space
-func (addenda15 *Addenda15) reservedField() string {
-	return addenda15.alphaField(addenda15.reserved, 34)
-}
-
 // EntryDetailSequenceNumberField returns a zero padded EntryDetailSequenceNumber string
 func (addenda15 *Addenda15) EntryDetailSequenceNumberField() string {
 	return addenda15.numericField(addenda15.EntryDetailSequenceNumber, 7)
diff --git a/addenda16.go b/addenda16.go
index ae8aa7db..75b3c1a9 100644
--- a/addenda16.go
+++ b/addenda16.go
@@ -31,8 +31,6 @@ import (
 type Addenda16 struct {
 	// ID is a client defined string used as a reference to this record.
 	ID string `json:"id"`
-	// RecordType defines the type of record in the block.
-	recordType string
 	// TypeCode Addenda16 types code '16'
 	TypeCode string `json:"typeCode"`
 	// Receiver City & State / Province
@@ -44,8 +42,6 @@ type Addenda16 struct {
 	// Data elements must be separated by an asterisk (*) and must end with a backslash (\)
 	// For example: US*10036\
 	ReceiverCountryPostalCode string `json:"receiverCountryPostalCode"`
-	// reserved - Leave blank
-	reserved string
 	// EntryDetailSequenceNumber contains the ascending sequence number section of the Entry
 	// Detail or Corporate Entry Detail Record's trace number This number is
 	// the same as the last seven digits of the trace number of the related
@@ -60,7 +56,6 @@ type Addenda16 struct {
 // NewAddenda16 returns a new Addenda16 with default values for none exported fields
 func NewAddenda16() *Addenda16 {
 	addenda16 := new(Addenda16)
-	addenda16.recordType = "7"
 	addenda16.TypeCode = "16"
 	return addenda16
 }
@@ -73,8 +68,7 @@ func (addenda16 *Addenda16) Parse(record string) {
 		return
 	}
 
-	// 1-1 Always "7"
-	addenda16.recordType = "7"
+	// 1-1 Always 7
 	// 2-3 Always 16
 	addenda16.TypeCode = record[1:3]
 	// 4-38 ReceiverCityStateProvince
@@ -82,7 +76,6 @@ func (addenda16 *Addenda16) Parse(record string) {
 	// 39-73 ReceiverCountryPostalCode
 	addenda16.ReceiverCountryPostalCode = strings.TrimSpace(record[38:73])
 	// 74-87 reserved - Leave blank
-	addenda16.reserved = "              "
 	// 88-94 Contains the last seven digits of the number entered in the Trace Number field in the corresponding Entry Detail Record
 	addenda16.EntryDetailSequenceNumber = addenda16.parseNumField(record[87:94])
 }
@@ -91,11 +84,11 @@ func (addenda16 *Addenda16) Parse(record string) {
 func (addenda16 *Addenda16) String() string {
 	var buf strings.Builder
 	buf.Grow(94)
-	buf.WriteString(addenda16.recordType)
+	buf.WriteString(entryAddendaPos)
 	buf.WriteString(addenda16.TypeCode)
 	buf.WriteString(addenda16.ReceiverCityStateProvinceField())
 	buf.WriteString(addenda16.ReceiverCountryPostalCodeField())
-	buf.WriteString(addenda16.reservedField())
+	buf.WriteString("              ")
 	buf.WriteString(addenda16.EntryDetailSequenceNumberField())
 	return buf.String()
 }
@@ -106,9 +99,6 @@ func (addenda16 *Addenda16) Validate() error {
 	if err := addenda16.fieldInclusion(); err != nil {
 		return err
 	}
-	if addenda16.recordType != "7" {
-		return fieldError("recordType", NewErrRecordType(7), addenda16.recordType)
-	}
 	if err := addenda16.isTypeCode(addenda16.TypeCode); err != nil {
 		return fieldError("TypeCode", err, addenda16.TypeCode)
 	}
@@ -128,9 +118,6 @@ func (addenda16 *Addenda16) Validate() error {
 // fieldInclusion validate mandatory fields are not default values. If fields are
 // invalid the ACH transfer will be returned.
 func (addenda16 *Addenda16) fieldInclusion() error {
-	if addenda16.recordType == "" {
-		return fieldError("recordType", ErrConstructor, addenda16.recordType)
-	}
 	if addenda16.TypeCode == "" {
 		return fieldError("TypeCode", ErrConstructor, addenda16.TypeCode)
 	}
@@ -156,11 +143,6 @@ func (addenda16 *Addenda16) ReceiverCountryPostalCodeField() string {
 	return addenda16.alphaField(addenda16.ReceiverCountryPostalCode, 35)
 }
 
-// reservedField gets reserved - blank space
-func (addenda16 *Addenda16) reservedField() string {
-	return addenda16.alphaField(addenda16.reserved, 14)
-}
-
 // EntryDetailSequenceNumberField returns a zero padded EntryDetailSequenceNumber string
 func (addenda16 *Addenda16) EntryDetailSequenceNumberField() string {
 	return addenda16.numericField(addenda16.EntryDetailSequenceNumber, 7)
diff --git a/addenda17.go b/addenda17.go
index 926b972c..795484e7 100644
--- a/addenda17.go
+++ b/addenda17.go
@@ -32,8 +32,6 @@ import (
 type Addenda17 struct {
 	// ID is a client defined string used as a reference to this record.
 	ID string `json:"id"`
-	// RecordType defines the type of record in the block. entryAddenda17 Pos 7
-	recordType string
 	// TypeCode Addenda17 types code '17'
 	TypeCode string `json:"typeCode"`
 	// PaymentRelatedInformation
@@ -56,7 +54,6 @@ type Addenda17 struct {
 // NewAddenda17 returns a new Addenda17 with default values for none exported fields
 func NewAddenda17() *Addenda17 {
 	addenda17 := new(Addenda17)
-	addenda17.recordType = "7"
 	addenda17.TypeCode = "17"
 	return addenda17
 }
@@ -69,8 +66,7 @@ func (addenda17 *Addenda17) Parse(record string) {
 		return
 	}
 
-	// 1-1 Always "7"
-	addenda17.recordType = "7"
+	// 1-1 Always 7
 	// 2-3 Always 17
 	addenda17.TypeCode = record[1:3]
 	// 4-83 Based on the information entered (04-83) 80 alphanumeric
@@ -86,7 +82,7 @@ func (addenda17 *Addenda17) Parse(record string) {
 func (addenda17 *Addenda17) String() string {
 	var buf strings.Builder
 	buf.Grow(94)
-	buf.WriteString(addenda17.recordType)
+	buf.WriteString(entryAddendaPos)
 	buf.WriteString(addenda17.TypeCode)
 	buf.WriteString(addenda17.PaymentRelatedInformationField())
 	buf.WriteString(addenda17.SequenceNumberField())
@@ -100,9 +96,6 @@ func (addenda17 *Addenda17) Validate() error {
 	if err := addenda17.fieldInclusion(); err != nil {
 		return err
 	}
-	if addenda17.recordType != "7" {
-		return fieldError("recordType", NewErrRecordType(7), addenda17.recordType)
-	}
 	if err := addenda17.isTypeCode(addenda17.TypeCode); err != nil {
 		return fieldError("TypeCode", err, addenda17.TypeCode)
 	}
@@ -120,9 +113,6 @@ func (addenda17 *Addenda17) Validate() error {
 // fieldInclusion validate mandatory fields are not default values. If fields are
 // invalid the ACH transfer will be returned.
 func (addenda17 *Addenda17) fieldInclusion() error {
-	if addenda17.recordType == "" {
-		return fieldError("recordType", ErrConstructor, addenda17.recordType)
-	}
 	if addenda17.TypeCode == "" {
 		return fieldError("TypeCode", ErrConstructor, addenda17.TypeCode)
 	}
diff --git a/addenda18.go b/addenda18.go
index a89b2017..6bbad9f5 100644
--- a/addenda18.go
+++ b/addenda18.go
@@ -33,8 +33,6 @@ import (
 type Addenda18 struct {
 	// ID is a client defined string used as a reference to this record.
 	ID string `json:"id"`
-	// RecordType defines the type of record in the block. entryAddenda18 Pos 7
-	recordType string
 	// TypeCode Addenda18 types code '18'
 	TypeCode string `json:"typeCode"`
 	// ForeignCorrespondentBankName contains the name of the Foreign Correspondent Bank
@@ -54,8 +52,6 @@ type Addenda18 struct {
 	// branch of the Foreign Correspondent Bank is located. Values can be found on the International
 	// Organization for Standardization website: www.iso.org
 	ForeignCorrespondentBankBranchCountryCode string `json:"foreignCorrespondentBankBranchCountryCode"`
-	// reserved - Leave blank
-	reserved string
 	// SequenceNumber is consecutively assigned to each Addenda18 Record following
 	// an Entry Detail Record. The first addenda18 sequence number must always
 	// be a "1".
@@ -74,7 +70,6 @@ type Addenda18 struct {
 // NewAddenda18 returns a new Addenda18 with default values for none exported fields
 func NewAddenda18() *Addenda18 {
 	addenda18 := new(Addenda18)
-	addenda18.recordType = "7"
 	addenda18.TypeCode = "18"
 	return addenda18
 }
@@ -87,8 +82,7 @@ func (addenda18 *Addenda18) Parse(record string) {
 		return
 	}
 
-	// 1-1 Always "7"
-	addenda18.recordType = "7"
+	// 1-1 Always 7
 	// 2-3 Always 18
 	addenda18.TypeCode = record[1:3]
 	// 4-83 Based on the information entered (04-38) 35 alphanumeric
@@ -103,7 +97,6 @@ func (addenda18 *Addenda18) Parse(record string) {
 	// 75-77 Based on the information entered (75-77) 3 alphanumeric
 	addenda18.ForeignCorrespondentBankBranchCountryCode = strings.TrimSpace(record[74:77])
 	// 78-83 - Blank space
-	addenda18.reserved = "      "
 	// 84-87 SequenceNumber is consecutively assigned to each Addenda18 Record following
 	// an Entry Detail Record
 	addenda18.SequenceNumber = addenda18.parseNumField(record[83:87])
@@ -115,13 +108,13 @@ func (addenda18 *Addenda18) Parse(record string) {
 func (addenda18 *Addenda18) String() string {
 	var buf strings.Builder
 	buf.Grow(94)
-	buf.WriteString(addenda18.recordType)
+	buf.WriteString(entryAddendaPos)
 	buf.WriteString(addenda18.TypeCode)
 	buf.WriteString(addenda18.ForeignCorrespondentBankNameField())
 	buf.WriteString(addenda18.ForeignCorrespondentBankIDNumberQualifierField())
 	buf.WriteString(addenda18.ForeignCorrespondentBankIDNumberField())
 	buf.WriteString(addenda18.ForeignCorrespondentBankBranchCountryCodeField())
-	buf.WriteString(addenda18.reservedField())
+	buf.WriteString("      ")
 	buf.WriteString(addenda18.SequenceNumberField())
 	buf.WriteString(addenda18.EntryDetailSequenceNumberField())
 	return buf.String()
@@ -133,9 +126,6 @@ func (addenda18 *Addenda18) Validate() error {
 	if err := addenda18.fieldInclusion(); err != nil {
 		return err
 	}
-	if addenda18.recordType != "7" {
-		return fieldError("recordType", NewErrRecordType(7), addenda18.recordType)
-	}
 	if err := addenda18.isTypeCode(addenda18.TypeCode); err != nil {
 		return fieldError("TypeCode", err, addenda18.TypeCode)
 	}
@@ -161,9 +151,6 @@ func (addenda18 *Addenda18) Validate() error {
 // fieldInclusion validate mandatory fields are not default values. If fields are
 // invalid the ACH transfer will be returned.
 func (addenda18 *Addenda18) fieldInclusion() error {
-	if addenda18.recordType == "" {
-		return fieldError("recordType", ErrConstructor, addenda18.recordType)
-	}
 	if addenda18.TypeCode == "" {
 		return fieldError("TypeCode", ErrConstructor, addenda18.TypeCode)
 	}
@@ -213,11 +200,6 @@ func (addenda18 *Addenda18) SequenceNumberField() string {
 	return addenda18.numericField(addenda18.SequenceNumber, 4)
 }
 
-// reservedField gets reserved - blank space
-func (addenda18 *Addenda18) reservedField() string {
-	return addenda18.alphaField(addenda18.reserved, 6)
-}
-
 // EntryDetailSequenceNumberField returns a zero padded EntryDetailSequenceNumber string
 func (addenda18 *Addenda18) EntryDetailSequenceNumberField() string {
 	return addenda18.numericField(addenda18.EntryDetailSequenceNumber, 7)
diff --git a/addenda98.go b/addenda98.go
index d9d96a93..f7d309c7 100644
--- a/addenda98.go
+++ b/addenda98.go
@@ -29,8 +29,6 @@ import (
 type Addenda98 struct {
 	// ID is a client defined string used as a reference to this record.
 	ID string `json:"id"`
-	// RecordType defines the type of record in the block. entryAddendaPos 7
-	recordType string
 	// TypeCode Addenda types code '98'
 	TypeCode string `json:"typeCode"`
 	// ChangeCode field contains a standard code used by an ACH Operator or RDFI to describe the reason for a change Entry.
@@ -75,8 +73,7 @@ type ChangeCode struct {
 // NewAddenda98 returns an reference to an instantiated Addenda98 with default values
 func NewAddenda98() *Addenda98 {
 	addenda98 := &Addenda98{
-		recordType: "7",
-		TypeCode:   "98",
+		TypeCode: "98",
 	}
 	return addenda98
 }
@@ -89,8 +86,7 @@ func (addenda98 *Addenda98) Parse(record string) {
 		return
 	}
 
-	// 1-1 Always "7"
-	addenda98.recordType = "7"
+	// 1-1 Always 7
 	// 2-3 Always "98"
 	addenda98.TypeCode = record[1:3]
 	// 4-6
@@ -109,7 +105,7 @@ func (addenda98 *Addenda98) Parse(record string) {
 func (addenda98 *Addenda98) String() string {
 	var buf strings.Builder
 	buf.Grow(94)
-	buf.WriteString(addenda98.recordType)
+	buf.WriteString(entryAddendaPos)
 	buf.WriteString(addenda98.TypeCode)
 	buf.WriteString(addenda98.ChangeCode)
 	buf.WriteString(addenda98.OriginalTraceField())
@@ -123,9 +119,6 @@ func (addenda98 *Addenda98) String() string {
 
 // Validate verifies NACHA rules for Addenda98
 func (addenda98 *Addenda98) Validate() error {
-	if addenda98.recordType != "7" {
-		return fieldError("recordType", NewErrRecordType(7), addenda98.recordType)
-	}
 	if addenda98.TypeCode == "" {
 		return fieldError("TypeCode", ErrConstructor, addenda98.TypeCode)
 	}
diff --git a/addenda99.go b/addenda99.go
index c5f02df8..aeefca08 100644
--- a/addenda99.go
+++ b/addenda99.go
@@ -43,8 +43,6 @@ func init() {
 type Addenda99 struct {
 	// ID is a client defined string used as a reference to this record.
 	ID string `json:"id"`
-	// RecordType defines the type of record in the block. entryAddendaPos 7
-	recordType string
 	// TypeCode Addenda types code '99'
 	TypeCode string `json:"typeCode"`
 	// ReturnCode field contains a standard code used by an ACH Operator or RDFI to describe the reason for returning an Entry.
@@ -85,8 +83,7 @@ type ReturnCode struct {
 // NewAddenda99 returns a new Addenda99 with default values for none exported fields
 func NewAddenda99() *Addenda99 {
 	Addenda99 := &Addenda99{
-		recordType: "7",
-		TypeCode:   "99",
+		TypeCode: "99",
 	}
 	return Addenda99
 }
@@ -99,8 +96,6 @@ func (Addenda99 *Addenda99) Parse(record string) {
 		return
 	}
 
-	// 1-1 Always "7"
-	Addenda99.recordType = "7"
 	// 2-3 Defines the specific explanation and format for the addenda information contained in the same record
 	Addenda99.TypeCode = record[1:3]
 	// 4-6
@@ -121,7 +116,7 @@ func (Addenda99 *Addenda99) Parse(record string) {
 func (Addenda99 *Addenda99) String() string {
 	var buf strings.Builder
 	buf.Grow(94)
-	buf.WriteString(Addenda99.recordType)
+	buf.WriteString(entryAddendaPos)
 	buf.WriteString(Addenda99.TypeCode)
 	buf.WriteString(Addenda99.ReturnCode)
 	buf.WriteString(Addenda99.OriginalTraceField())
@@ -134,9 +129,6 @@ func (Addenda99 *Addenda99) String() string {
 
 // Validate verifies NACHA rules for Addenda99
 func (Addenda99 *Addenda99) Validate() error {
-	if Addenda99.recordType != "7" {
-		return fieldError("recordType", NewErrRecordType(7), Addenda99.recordType)
-	}
 	if Addenda99.TypeCode == "" {
 		return fieldError("TypeCode", ErrConstructor, Addenda99.TypeCode)
 	}
diff --git a/addenda99_dishonored_return.go b/addenda99_dishonored_return.go
index c3c27148..5e7c093e 100644
--- a/addenda99_dishonored_return.go
+++ b/addenda99_dishonored_return.go
@@ -25,8 +25,7 @@ import (
 type Addenda99Dishonored struct {
 	// ID is a client defined string used as a reference to this record.
 	ID string `json:"id"`
-	// RecordType defines the type of record in the block. entryAddendaPos 7
-	recordType string
+
 	// TypeCode Addenda types code '99'
 	TypeCode string `json:"typeCode"`
 
@@ -65,8 +64,7 @@ type Addenda99Dishonored struct {
 // NewAddenda99Dishonored returns a new Addenda99Dishonored with default values for none exported fields
 func NewAddenda99Dishonored() *Addenda99Dishonored {
 	Addenda99Dishonored := &Addenda99Dishonored{
-		recordType: "7",
-		TypeCode:   "99",
+		TypeCode: "99",
 	}
 	return Addenda99Dishonored
 }
@@ -76,7 +74,6 @@ func (Addenda99Dishonored *Addenda99Dishonored) Parse(record string) {
 		return
 	}
 
-	Addenda99Dishonored.recordType = "7"
 	Addenda99Dishonored.TypeCode = record[1:3]
 	Addenda99Dishonored.DishonoredReturnReasonCode = record[3:6]
 	Addenda99Dishonored.OriginalEntryTraceNumber = record[6:21]
@@ -91,7 +88,7 @@ func (Addenda99Dishonored *Addenda99Dishonored) Parse(record string) {
 func (Addenda99Dishonored *Addenda99Dishonored) String() string {
 	var buf strings.Builder
 	buf.Grow(94)
-	buf.WriteString(Addenda99Dishonored.recordType)
+	buf.WriteString(entryAddendaPos)
 	buf.WriteString(Addenda99Dishonored.TypeCode)
 	buf.WriteString(Addenda99Dishonored.DishonoredReturnReasonCodeField())
 	buf.WriteString(Addenda99Dishonored.OriginalEntryTraceNumberField())
@@ -125,9 +122,6 @@ func IsDishonoredReturnCode(code string) bool {
 
 // Validate verifies NACHA rules for Addenda99Dishonored
 func (Addenda99Dishonored *Addenda99Dishonored) Validate() error {
-	if Addenda99Dishonored.recordType != "7" {
-		return fieldError("recordType", NewErrRecordType(7), Addenda99Dishonored.recordType)
-	}
 	if Addenda99Dishonored.TypeCode == "" {
 		return fieldError("TypeCode", ErrConstructor, Addenda99Dishonored.TypeCode)
 	}
diff --git a/advBatchControl.go b/advBatchControl.go
index 868a99ae..67dad4ea 100644
--- a/advBatchControl.go
+++ b/advBatchControl.go
@@ -29,8 +29,6 @@ import (
 type ADVBatchControl struct {
 	// ID is a client defined string used as a reference to this record.
 	ID string `json:"id"`
-	// RecordType defines the type of record in the block.
-	recordType string
 	// This should be the same as BatchHeader ServiceClassCode for ADV: AutomatedAccountingAdvices.
 	ServiceClassCode int `json:"serviceClassCode"`
 	// EntryAddendaCount is a tally of each Entry Detail Record and each Addenda
@@ -69,7 +67,6 @@ func (bc *ADVBatchControl) Parse(record string) {
 	}
 
 	// 1-1 Always "8"
-	bc.recordType = "8"
 	// 2-4 This is the same as the "Service code" field in previous Batch Header Record
 	bc.ServiceClassCode = bc.parseNumField(record[1:4])
 	// 5-10 Total number of Entry Detail Record in the batch
@@ -92,7 +89,6 @@ func (bc *ADVBatchControl) Parse(record string) {
 // NewADVBatchControl returns a new ADVBatchControl with default values for none exported fields
 func NewADVBatchControl() *ADVBatchControl {
 	return &ADVBatchControl{
-		recordType:       "8",
 		ServiceClassCode: AutomatedAccountingAdvices,
 		EntryHash:        1,
 		BatchNumber:      1,
@@ -103,7 +99,7 @@ func NewADVBatchControl() *ADVBatchControl {
 func (bc *ADVBatchControl) String() string {
 	var buf strings.Builder
 	buf.Grow(94)
-	buf.WriteString(bc.recordType)
+	buf.WriteString(batchControlPos)
 	buf.WriteString(fmt.Sprintf("%v", bc.ServiceClassCode))
 	buf.WriteString(bc.EntryAddendaCountField())
 	buf.WriteString(bc.EntryHashField())
@@ -121,9 +117,6 @@ func (bc *ADVBatchControl) Validate() error {
 	if err := bc.fieldInclusion(); err != nil {
 		return err
 	}
-	if bc.recordType != "8" {
-		return fieldError("recordType", NewErrRecordType(7), bc.recordType)
-	}
 	if err := bc.isServiceClass(bc.ServiceClassCode); err != nil {
 		return fieldError("ServiceClassCode", err, strconv.Itoa(bc.ServiceClassCode))
 	}
@@ -137,9 +130,6 @@ func (bc *ADVBatchControl) Validate() error {
 // fieldInclusion validate mandatory fields are not default values. If fields are
 // invalid the ACH transfer will be returned.
 func (bc *ADVBatchControl) fieldInclusion() error {
-	if bc.recordType == "" {
-		return fieldError("recordType", ErrConstructor, bc.recordType)
-	}
 	if bc.ServiceClassCode == 0 {
 		return fieldError("ServiceClassCode", ErrConstructor, strconv.Itoa(bc.ServiceClassCode))
 	}
diff --git a/advEntryDetail.go b/advEntryDetail.go
index 57026fcf..7e141e8a 100644
--- a/advEntryDetail.go
+++ b/advEntryDetail.go
@@ -31,8 +31,6 @@ import (
 type ADVEntryDetail struct {
 	// ID is a client defined string used as a reference to this record.
 	ID string `json:"id"`
-	// RecordType defines the type of record in the block. 6
-	recordType string
 	// TransactionCode representing Accounting Entries
 	// Credit for ACH debits originated - 81
 	// Debit for ACH credits originated - 82
@@ -114,8 +112,7 @@ const (
 // NewADVEntryDetail returns a new ADVEntryDetail with default values for non exported fields
 func NewADVEntryDetail() *ADVEntryDetail {
 	entry := &ADVEntryDetail{
-		recordType: "6",
-		Category:   CategoryForward,
+		Category: CategoryForward,
 	}
 	return entry
 }
@@ -131,7 +128,6 @@ func (ed *ADVEntryDetail) Parse(record string) {
 	}
 
 	// 1-1 Always "6"
-	ed.recordType = "6"
 	// 2-3 is checking credit 22 debit 27 savings credit 32 debit 37
 	ed.TransactionCode = ed.parseNumField(record[1:3])
 	// 4-11 the RDFI's routing number without the last digit.
@@ -166,7 +162,7 @@ func (ed *ADVEntryDetail) Parse(record string) {
 func (ed *ADVEntryDetail) String() string {
 	var buf strings.Builder
 	buf.Grow(94)
-	buf.WriteString(ed.recordType)
+	buf.WriteString(entryDetailPos)
 	buf.WriteString(fmt.Sprintf("%v", ed.TransactionCode))
 	buf.WriteString(ed.RDFIIdentificationField())
 	buf.WriteString(ed.CheckDigit)
@@ -190,9 +186,6 @@ func (ed *ADVEntryDetail) Validate() error {
 	if err := ed.fieldInclusion(); err != nil {
 		return err
 	}
-	if ed.recordType != "6" {
-		return fieldError("recordType", NewErrRecordType(6), ed.recordType)
-	}
 	if err := ed.isTransactionCode(ed.TransactionCode); err != nil {
 		return fieldError("TransactionCode", err, strconv.Itoa(ed.TransactionCode))
 	}
@@ -224,9 +217,6 @@ func (ed *ADVEntryDetail) Validate() error {
 // fieldInclusion validate mandatory fields are not default values. If fields are
 // invalid the ACH transfer will be returned.
 func (ed *ADVEntryDetail) fieldInclusion() error {
-	if ed.recordType == "" {
-		return fieldError("recordType", ErrConstructor, ed.recordType)
-	}
 	if ed.TransactionCode == 0 {
 		return fieldError("TransactionCode", ErrConstructor, strconv.Itoa(ed.TransactionCode))
 	}
diff --git a/advFileControl.go b/advFileControl.go
index bbc6c811..224efe03 100644
--- a/advFileControl.go
+++ b/advFileControl.go
@@ -27,8 +27,6 @@ import (
 type ADVFileControl struct {
 	// ID is a client defined string used as a reference to this record.
 	ID string `json:"id"`
-	// RecordType defines the type of record in the block. fileControlPos 9
-	recordType string
 
 	// BatchCount total number of batches (i.e., '5' records) in the file
 	BatchCount int `json:"batchCount"`
@@ -48,8 +46,6 @@ type ADVFileControl struct {
 
 	// TotalCreditEntryDollarAmountInFile contains accumulated Batch credit totals within the file.
 	TotalCreditEntryDollarAmountInFile int `json:"totalCredit"`
-	// Reserved should be blank.
-	reserved string
 	// validator is composed for data validation
 	validator
 	// converters is composed for ACH to golang Converters
@@ -65,7 +61,6 @@ func (fc *ADVFileControl) Parse(record string) {
 	}
 
 	// 1-1 Always "9"
-	fc.recordType = "9"
 	// 2-7 The total number of Batch Header Record in the file. For example: "000003
 	fc.BatchCount = fc.parseNumField(record[1:7])
 	// 8-13 e total number of blocks on the file, including the File Header and File Control records. One block is 10 lines, so it's effectively the number of lines in the file divided by 10.
@@ -80,29 +75,25 @@ func (fc *ADVFileControl) Parse(record string) {
 	// 52-71 Number of cents of credit entries within the file
 	fc.TotalCreditEntryDollarAmountInFile = fc.parseNumField(record[51:71])
 	// 72-94 Reserved Always blank (just fill with spaces)
-	fc.reserved = "                       "
 }
 
 // NewADVFileControl returns a new ADVFileControl with default values for none exported fields
 func NewADVFileControl() ADVFileControl {
-	return ADVFileControl{
-		recordType: "9",
-		reserved:   "                       ",
-	}
+	return ADVFileControl{}
 }
 
 // String writes the ADVFileControl struct to a 94 character string.
 func (fc *ADVFileControl) String() string {
 	var buf strings.Builder
 	buf.Grow(94)
-	buf.WriteString(fc.recordType)
+	buf.WriteString(fileControlPos)
 	buf.WriteString(fc.BatchCountField())
 	buf.WriteString(fc.BlockCountField())
 	buf.WriteString(fc.EntryAddendaCountField())
 	buf.WriteString(fc.EntryHashField())
 	buf.WriteString(fc.TotalDebitEntryDollarAmountInFileField())
 	buf.WriteString(fc.TotalCreditEntryDollarAmountInFileField())
-	buf.WriteString(fc.reserved)
+	buf.WriteString("                       ")
 	return buf.String()
 }
 
@@ -112,18 +103,12 @@ func (fc *ADVFileControl) Validate() error {
 	if err := fc.fieldInclusion(); err != nil {
 		return err
 	}
-	if fc.recordType != "9" {
-		return fieldError("recordType", NewErrRecordType(9), fc.recordType)
-	}
 	return nil
 }
 
 // fieldInclusion validate mandatory fields are not default values. If fields are
 // invalid the ACH transfer will be returned.
 func (fc *ADVFileControl) fieldInclusion() error {
-	if fc.recordType == "" {
-		return fieldError("recordType", ErrConstructor, fc.recordType)
-	}
 	if fc.BatchCount == 0 {
 		return fieldError("BatchCount", ErrConstructor, fc.BatchCountField())
 	}
diff --git a/batchControl.go b/batchControl.go
index 42042288..0c14819b 100644
--- a/batchControl.go
+++ b/batchControl.go
@@ -29,8 +29,6 @@ import (
 type BatchControl struct {
 	// ID is a client defined string used as a reference to this record.
 	ID string `json:"id"`
-	// RecordType defines the type of record in the block.
-	recordType string
 	// ServiceClassCode ACH Mixed Debits and Credits '200'
 	// ACH Credits Only '220'
 	// ACH Debits Only '225'
@@ -70,8 +68,6 @@ type BatchControl struct {
 	// American National Standards Institute. The remaining eleven characters
 	// of this field are blank.
 	MessageAuthenticationCode string `json:"messageAuthentication,omitempty"`
-	// Reserved for the future - Blank, 6 characters long
-	reserved string
 	// ODFIIdentification the routing number is used to identify the DFI originating entries within a given branch.
 	ODFIIdentification string `json:"ODFIIdentification"`
 	// BatchNumber this number is assigned in ascending sequence to each batch by the ODFI
@@ -94,7 +90,6 @@ func (bc *BatchControl) Parse(record string) {
 	}
 
 	// 1-1 Always "8"
-	bc.recordType = "8"
 	// 2-4 This is the same as the "Service code" field in previous Batch Header Record
 	bc.ServiceClassCode = bc.parseNumField(record[1:4])
 	// 5-10 Total number of Entry Detail Record in the batch
@@ -111,7 +106,6 @@ func (bc *BatchControl) Parse(record string) {
 	// 55-73 Seems to always be blank
 	bc.MessageAuthenticationCode = strings.TrimSpace(record[54:73])
 	// 74-79 Always blank (just fill with spaces)
-	bc.reserved = "      "
 	// 80-87 This is the same as the "ODFI identification" field in previous Batch Header Record
 	bc.ODFIIdentification = bc.parseStringField(record[79:87])
 	// 88-94 This is the same as the "Batch number" field in previous Batch Header Record
@@ -121,7 +115,6 @@ func (bc *BatchControl) Parse(record string) {
 // NewBatchControl returns a new BatchControl with default values for none exported fields
 func NewBatchControl() *BatchControl {
 	return &BatchControl{
-		recordType:       "8",
 		ServiceClassCode: MixedDebitsAndCredits,
 		EntryHash:        1,
 		BatchNumber:      1,
@@ -132,7 +125,7 @@ func NewBatchControl() *BatchControl {
 func (bc *BatchControl) String() string {
 	var buf strings.Builder
 	buf.Grow(94)
-	buf.WriteString(bc.recordType)
+	buf.WriteString(batchControlPos)
 	buf.WriteString(fmt.Sprintf("%v", bc.ServiceClassCode))
 	buf.WriteString(bc.EntryAddendaCountField())
 	buf.WriteString(bc.EntryHashField())
@@ -152,9 +145,6 @@ func (bc *BatchControl) Validate() error {
 	if err := bc.fieldInclusion(); err != nil {
 		return err
 	}
-	if bc.recordType != "8" {
-		return fieldError("recordType", NewErrRecordType(8), bc.recordType)
-	}
 	if err := bc.isServiceClass(bc.ServiceClassCode); err != nil {
 		return fieldError("ServiceClassCode", err, strconv.Itoa(bc.ServiceClassCode))
 	}
@@ -173,9 +163,6 @@ func (bc *BatchControl) Validate() error {
 // fieldInclusion validate mandatory fields are not default values. If fields are
 // invalid the ACH transfer will be returned.
 func (bc *BatchControl) fieldInclusion() error {
-	if bc.recordType == "" {
-		return fieldError("recordType", ErrConstructor, bc.recordType)
-	}
 	if bc.ServiceClassCode == 0 {
 		return fieldError("ServiceClassCode", ErrConstructor, strconv.Itoa(bc.ServiceClassCode))
 	}
diff --git a/batchHeader.go b/batchHeader.go
index 15b323b5..429b66c2 100644
--- a/batchHeader.go
+++ b/batchHeader.go
@@ -33,8 +33,6 @@ import (
 type BatchHeader struct {
 	// ID is a client defined string used as a reference to this record.
 	ID string `json:"id"`
-	// RecordType defines the type of record in the block. 5
-	recordType string
 
 	// ServiceClassCode ACH Mixed Debits and Credits '200'
 	// ACH Credits Only '220'
@@ -140,7 +138,6 @@ const (
 // NewBatchHeader returns a new BatchHeader with default values for non exported fields
 func NewBatchHeader() *BatchHeader {
 	bh := &BatchHeader{
-		recordType:           "5",
 		OriginatorStatusCode: 1, // Prepared by a financial institution
 		BatchNumber:          1,
 	}
@@ -156,7 +153,6 @@ func (bh *BatchHeader) Parse(record string) {
 	}
 
 	// 1-1 Always "5"
-	bh.recordType = "5"
 	// 2-4 MixedCreditsAnDebits (200), CreditsOnly (220), DebitsOnly (225)
 	bh.ServiceClassCode = bh.parseNumField(record[1:4])
 	// 5-20 Your company's name. This name may appear on the receivers' statements prepared by the RDFI.
@@ -196,7 +192,7 @@ func (bh *BatchHeader) Parse(record string) {
 func (bh *BatchHeader) String() string {
 	var buf strings.Builder
 	buf.Grow(94)
-	buf.WriteString(bh.recordType)
+	buf.WriteString(batchHeaderPos)
 	buf.WriteString(fmt.Sprintf("%v", bh.ServiceClassCode))
 	buf.WriteString(bh.CompanyNameField())
 	buf.WriteString(bh.CompanyDiscretionaryDataField())
@@ -251,9 +247,6 @@ func (bh *BatchHeader) Validate() error {
 	if err := bh.fieldInclusion(); err != nil {
 		return err
 	}
-	if bh.recordType != "5" {
-		return fieldError("recordType", NewErrRecordType(5), bh.recordType)
-	}
 	if bh.validateOpts == nil || bh.validateOpts.CheckTransactionCode == nil {
 		// Ensure the ServiceClassCode follows NACHA standards if we have no TransactionCode
 		// validation overrides. Custom TransactionCode's don't allow for standard validation.
@@ -291,9 +284,6 @@ func (bh *BatchHeader) Validate() error {
 // fieldInclusion validate mandatory fields are not default values. If fields are
 // invalid the ACH transfer will be returned.
 func (bh *BatchHeader) fieldInclusion() error {
-	if bh.recordType == "" {
-		return fieldError("recordType", ErrConstructor, bh.recordType)
-	}
 	if bh.ServiceClassCode == 0 {
 		return fieldError("ServiceClassCode", ErrConstructor, strconv.Itoa(bh.ServiceClassCode))
 	}
diff --git a/entryDetail.go b/entryDetail.go
index 352fe37b..f8454439 100644
--- a/entryDetail.go
+++ b/entryDetail.go
@@ -32,8 +32,6 @@ import (
 type EntryDetail struct {
 	// ID is a client defined string used as a reference to this record.
 	ID string `json:"id"`
-	// RecordType defines the type of record in the block. 6
-	recordType string
 	// TransactionCode if the receivers account is checking, savings, general ledger (GL) or loan.
 	TransactionCode int `json:"transactionCode"`
 	// RDFIIdentification is the RDFI's routing number without the last digit.
@@ -189,8 +187,7 @@ const (
 // NewEntryDetail returns a new EntryDetail with default values for non exported fields
 func NewEntryDetail() *EntryDetail {
 	entry := &EntryDetail{
-		recordType: "6",
-		Category:   CategoryForward,
+		Category: CategoryForward,
 	}
 	return entry
 }
@@ -204,7 +201,6 @@ func (ed *EntryDetail) Parse(record string) {
 	}
 
 	// 1-1 Always "6"
-	ed.recordType = "6"
 	// 2-3 is checking credit 22 debit 27 savings credit 32 debit 37
 	ed.TransactionCode = ed.parseNumField(record[1:3])
 	// 4-11 the RDFI's routing number without the last digit.
@@ -234,7 +230,7 @@ func (ed *EntryDetail) Parse(record string) {
 func (ed *EntryDetail) String() string {
 	var buf strings.Builder
 	buf.Grow(94)
-	buf.WriteString(ed.recordType)
+	buf.WriteString(entryDetailPos)
 	buf.WriteString(fmt.Sprintf("%v", ed.TransactionCode))
 	buf.WriteString(ed.RDFIIdentificationField())
 	buf.WriteString(ed.CheckDigit)
@@ -263,9 +259,6 @@ func (ed *EntryDetail) Validate() error {
 	if err := ed.fieldInclusion(); err != nil {
 		return err
 	}
-	if ed.recordType != "6" {
-		return fieldError("recordType", NewErrRecordType(6), ed.recordType)
-	}
 	if ed.validateOpts != nil && ed.validateOpts.CheckTransactionCode != nil {
 		if err := ed.validateOpts.CheckTransactionCode(ed.TransactionCode); err != nil {
 			return fieldError("TransactionCode", err, strconv.Itoa(ed.TransactionCode))
@@ -310,9 +303,6 @@ func (ed *EntryDetail) Validate() error {
 // fieldInclusion validate mandatory fields are not default values. If fields are
 // invalid the ACH transfer will be returned.
 func (ed *EntryDetail) fieldInclusion() error {
-	if ed.recordType == "" {
-		return fieldError("recordType", ErrConstructor, ed.recordType)
-	}
 	if ed.TransactionCode == 0 {
 		return fieldError("TransactionCode", ErrConstructor, strconv.Itoa(ed.TransactionCode))
 	}
diff --git a/file.go b/file.go
index 1de4172a..158815f4 100644
--- a/file.go
+++ b/file.go
@@ -239,35 +239,27 @@ type iatBatchesJSON struct {
 }
 
 func setEntryRecordType(e *EntryDetail) {
-	e.recordType = "6"
 	if e.Addenda02 != nil {
-		e.Addenda02.recordType = "7"
 		e.Addenda02.TypeCode = "02"
 	}
 	for _, a := range e.Addenda05 {
-		a.recordType = "7"
 		a.TypeCode = "05"
 	}
 	if e.Addenda98 != nil {
-		e.Addenda98.recordType = "7"
 		e.Addenda98.TypeCode = "98"
 	}
 	if e.Addenda99 != nil {
-		e.Addenda99.recordType = "7"
 		e.Addenda99.TypeCode = "99"
 	}
 	if e.Addenda99Dishonored != nil {
-		e.Addenda99Dishonored.recordType = "7"
 		e.Addenda99Dishonored.TypeCode = "99"
 	}
 	if e.Addenda99Contested != nil {
-		e.Addenda99Contested.recordType = "7"
 		e.Addenda99Contested.TypeCode = "99"
 	}
 }
 
 func setADVEntryRecordType(e *ADVEntryDetail) {
-	e.recordType = "6"
 	if e.Addenda99 == nil {
 		e.Category = CategoryForward
 	}
@@ -275,49 +267,37 @@ func setADVEntryRecordType(e *ADVEntryDetail) {
 
 func setIATEntryRecordType(e *IATEntryDetail) {
 	// these values need to be inferred from the json field names
-	e.recordType = "6"
 	if e.Addenda10 != nil {
-		e.Addenda10.recordType = "7"
 		e.Addenda10.TypeCode = "10"
 	}
 	if e.Addenda11 != nil {
-		e.Addenda11.recordType = "7"
 		e.Addenda11.TypeCode = "11"
 	}
 	if e.Addenda12 != nil {
-		e.Addenda12.recordType = "7"
 		e.Addenda12.TypeCode = "12"
 	}
 	if e.Addenda13 != nil {
-		e.Addenda13.recordType = "7"
 		e.Addenda13.TypeCode = "13"
 	}
 	if e.Addenda14 != nil {
-		e.Addenda14.recordType = "7"
 		e.Addenda14.TypeCode = "14"
 	}
 	if e.Addenda15 != nil {
-		e.Addenda15.recordType = "7"
 		e.Addenda15.TypeCode = "15"
 	}
 	if e.Addenda16 != nil {
-		e.Addenda16.recordType = "7"
 		e.Addenda16.TypeCode = "16"
 	}
 	for _, a := range e.Addenda17 {
-		a.recordType = "7"
 		a.TypeCode = "17"
 	}
 	for _, a := range e.Addenda18 {
-		a.recordType = "7"
 		a.TypeCode = "18"
 	}
 	if e.Addenda98 != nil {
-		e.Addenda98.recordType = "7"
 		e.Addenda98.TypeCode = "98"
 	}
 	if e.Addenda99 != nil {
-		e.Addenda99.recordType = "7"
 		e.Addenda99.TypeCode = "99"
 	}
 }
@@ -346,7 +326,6 @@ func (f *File) setBatchesFromJSON(bs []byte) error {
 		}
 		batch := *batches.Batches[i]
 		batch.SetID(batch.Header.ID)
-		batch.Header.recordType = batchHeaderPos
 		batch.SetValidation(f.validateOpts)
 
 		for _, e := range batch.Entries {
@@ -377,7 +356,6 @@ func (f *File) setBatchesFromJSON(bs []byte) error {
 
 		iatBatch := iatBatches.IATBatches[i]
 		iatBatch.ID = iatBatch.Header.ID
-		iatBatch.Header.recordType = "5"
 		for _, e := range iatBatch.Entries {
 			setIATEntryRecordType(e)
 		}
diff --git a/fileControl.go b/fileControl.go
index bbf06f3c..79818ecf 100644
--- a/fileControl.go
+++ b/fileControl.go
@@ -27,8 +27,6 @@ import (
 type FileControl struct {
 	// ID is a client defined string used as a reference to this record.
 	ID string `json:"id"`
-	// RecordType defines the type of record in the block. fileControlPos 9
-	recordType string
 	// BatchCount total number of batches (i.e., '5' records) in the file
 	BatchCount int `json:"batchCount"`
 	// BlockCount total number of records in the file (include all headers and trailer) divided
@@ -43,8 +41,6 @@ type FileControl struct {
 	TotalDebitEntryDollarAmountInFile int `json:"totalDebit"`
 	// TotalCreditEntryDollarAmountInFile contains accumulated Batch credit totals within the file.
 	TotalCreditEntryDollarAmountInFile int `json:"totalCredit"`
-	// Reserved should be blank.
-	reserved string
 	// validator is composed for data validation
 	validator
 	// converters is composed for ACH to golang Converters
@@ -60,7 +56,6 @@ func (fc *FileControl) Parse(record string) {
 	}
 
 	// 1-1 Always "9"
-	fc.recordType = "9"
 	// 2-7 The total number of Batch Header Record in the file. For example: "000003
 	fc.BatchCount = fc.parseNumField(record[1:7])
 	// 8-13 e total number of blocks on the file, including the File Header and File Control records. One block is 10 lines, so it's effectively the number of lines in the file divided by 10.
@@ -75,29 +70,25 @@ func (fc *FileControl) Parse(record string) {
 	// 44-55 Number of cents of credit entries within the file
 	fc.TotalCreditEntryDollarAmountInFile = fc.parseNumField(record[43:55])
 	// 56-94 Reserved Always blank (just fill with spaces)
-	fc.reserved = "                                       "
 }
 
 // NewFileControl returns a new FileControl with default values for none exported fields
 func NewFileControl() FileControl {
-	return FileControl{
-		recordType: "9",
-		reserved:   "                                       ",
-	}
+	return FileControl{}
 }
 
 // String writes the FileControl struct to a 94 character string.
 func (fc *FileControl) String() string {
 	var buf strings.Builder
 	buf.Grow(94)
-	buf.WriteString(fc.recordType)
+	buf.WriteString(fileControlPos)
 	buf.WriteString(fc.BatchCountField())
 	buf.WriteString(fc.BlockCountField())
 	buf.WriteString(fc.EntryAddendaCountField())
 	buf.WriteString(fc.EntryHashField())
 	buf.WriteString(fc.TotalDebitEntryDollarAmountInFileField())
 	buf.WriteString(fc.TotalCreditEntryDollarAmountInFileField())
-	buf.WriteString(fc.reserved)
+	buf.WriteString("                                       ")
 	return buf.String()
 }
 
@@ -107,18 +98,12 @@ func (fc *FileControl) Validate() error {
 	if err := fc.fieldInclusion(); err != nil {
 		return err
 	}
-	if fc.recordType != "9" {
-		return fieldError("recordType", NewErrRecordType(9), fc.recordType)
-	}
 	return nil
 }
 
 // fieldInclusion validate mandatory fields are not default values. If fields are
 // invalid the ACH transfer will be returned.
 func (fc *FileControl) fieldInclusion() error {
-	if fc.recordType == "" {
-		return fieldError("recordType", ErrConstructor, fc.recordType)
-	}
 	if fc.BlockCount == 0 {
 		return fieldError("BlockCount", ErrConstructor, fc.BlockCountField())
 	}
diff --git a/fileHeader.go b/fileHeader.go
index e4b43054..5949007b 100644
--- a/fileHeader.go
+++ b/fileHeader.go
@@ -32,8 +32,6 @@ import (
 type FileHeader struct {
 	// ID is a client defined string used as a reference to this record.
 	ID string `json:"id"`
-	// RecordType defines the type of record in the block. headerPos
-	recordType string
 	// PriorityCode consists of the numerals 01
 	priorityCode string
 
@@ -107,7 +105,6 @@ type FileHeader struct {
 // NewFileHeader returns a new FileHeader with default values for none exported fields
 func NewFileHeader() FileHeader {
 	fh := FileHeader{
-		recordType:     "1",
 		priorityCode:   "01",
 		FileIDModifier: "A",
 		recordSize:     "094",
@@ -126,7 +123,6 @@ func (fh *FileHeader) Parse(record string) {
 	}
 
 	// (character position 1-1) Always "1"
-	fh.recordType = "1"
 	// (2-3) Always "01"
 	fh.priorityCode = "01"
 	// (4-13) A blank space followed by your ODFI's routing number. For example: " 121140399"
@@ -166,7 +162,7 @@ func trimRoutingNumberLeadingZero(s string) string {
 func (fh *FileHeader) String() string {
 	var buf strings.Builder
 	buf.Grow(94)
-	buf.WriteString(fh.recordType)
+	buf.WriteString(fileHeaderPos)
 	buf.WriteString(fh.priorityCode)
 	buf.WriteString(fh.ImmediateDestinationField())
 	buf.WriteString(fh.ImmediateOriginField())
@@ -207,9 +203,6 @@ func (fh *FileHeader) ValidateWith(opts *ValidateOpts) error {
 	if err := fh.fieldInclusion(); err != nil {
 		return err
 	}
-	if fh.recordType != "1" {
-		return fieldError("recordType", NewErrRecordType(1), fh.recordType)
-	}
 	if err := fh.isUpperAlphanumeric(fh.FileIDModifier); err != nil {
 		return fieldError("FileIDModifier", err, fh.FileIDModifier)
 	}
@@ -265,9 +258,6 @@ func (fh *FileHeader) ValidateWith(opts *ValidateOpts) error {
 // fieldInclusion validate mandatory fields are not default values. If fields are
 // invalid the ACH transfer will be returned.
 func (fh *FileHeader) fieldInclusion() error {
-	if fh.recordType == "" {
-		return fieldError("recordType", ErrConstructor, fh.recordType)
-	}
 	if fh.ImmediateDestination == "" {
 		return fieldError("ImmediateDestination", ErrConstructor, fh.ImmediateDestinationField())
 	}
diff --git a/iatBatchHeader.go b/iatBatchHeader.go
index cf6a6252..54918a82 100644
--- a/iatBatchHeader.go
+++ b/iatBatchHeader.go
@@ -45,9 +45,6 @@ type IATBatchHeader struct {
 	// ID is a client defined string used as a reference to this record.
 	ID string `json:"id"`
 
-	// RecordType defines the type of record in the block. 5
-	recordType string
-
 	// ServiceClassCode ACH Mixed Debits and Credits '200'
 	// ACH Credits Only '220'
 	// ACH Debits Only '225'
@@ -180,7 +177,6 @@ const (
 // NewIATBatchHeader returns a new BatchHeader with default values for non exported fields
 func NewIATBatchHeader() *IATBatchHeader {
 	iatBh := &IATBatchHeader{
-		recordType:           "5",
 		OriginatorStatusCode: 0, //Prepared by an Originator
 		BatchNumber:          1,
 	}
@@ -196,7 +192,6 @@ func (iatBh *IATBatchHeader) Parse(record string) {
 	}
 
 	// 1-1 Always "5"
-	iatBh.recordType = "5"
 	// 2-4 MixedCreditsAnDebits (220), CReditsOnly 9220), DebitsOnly (225)"
 	iatBh.ServiceClassCode = iatBh.parseNumField(record[1:4])
 	// 05-20  Blank except for corrected IAT entries
@@ -251,7 +246,7 @@ func (iatBh *IATBatchHeader) Parse(record string) {
 func (iatBh *IATBatchHeader) String() string {
 	var buf strings.Builder
 	buf.Grow(94)
-	buf.WriteString(iatBh.recordType)
+	buf.WriteString(batchHeaderPos)
 	buf.WriteString(fmt.Sprintf("%v", iatBh.ServiceClassCode))
 	buf.WriteString(iatBh.IATIndicatorField())
 	buf.WriteString(iatBh.ForeignExchangeIndicatorField())
@@ -277,9 +272,6 @@ func (iatBh *IATBatchHeader) Validate() error {
 	if err := iatBh.fieldInclusion(); err != nil {
 		return err
 	}
-	if iatBh.recordType != "5" {
-		return fieldError("recordType", NewErrRecordType(5), iatBh.recordType)
-	}
 	if err := iatBh.isServiceClass(iatBh.ServiceClassCode); err != nil {
 		return fieldError("ServiceClassCode", err, strconv.Itoa(iatBh.ServiceClassCode))
 	}
@@ -313,9 +305,6 @@ func (iatBh *IATBatchHeader) Validate() error {
 // fieldInclusion validate mandatory fields are not default values. If fields are
 // invalid the ACH transfer will be returned.
 func (iatBh *IATBatchHeader) fieldInclusion() error {
-	if iatBh.recordType == "" {
-		return fieldError("recordType", ErrFieldInclusion, iatBh.recordType)
-	}
 	if iatBh.ServiceClassCode == 0 {
 		return fieldError("ServiceClassCode", ErrFieldInclusion, strconv.Itoa(iatBh.ServiceClassCode))
 	}
diff --git a/iatEntryDetail.go b/iatEntryDetail.go
index 6eb49ef1..ca4cc3b9 100644
--- a/iatEntryDetail.go
+++ b/iatEntryDetail.go
@@ -31,8 +31,6 @@ import (
 type IATEntryDetail struct {
 	// ID is a client defined string used as a reference to this record.
 	ID string `json:"id"`
-	// RecordType defines the type of record in the block. 6
-	recordType string
 	// TransactionCode if the receivers account is:
 	// Credit (deposit) to checking account '22'
 	// Prenote for credit to checking account '23'
@@ -50,15 +48,11 @@ type IATEntryDetail struct {
 	CheckDigit string `json:"checkDigit"`
 	// AddendaRecords is the number of Addenda Records
 	AddendaRecords int `json:"addendaRecords"`
-	// reserved - Leave blank
-	reserved string
 	// Amount Number of cents you are debiting/crediting this account
 	Amount int `json:"amount"`
 	// DFIAccountNumber is the receiver's bank account number you are crediting/debiting.
 	// It important to note that this is an alphanumeric field, so its space padded, no zero padded
 	DFIAccountNumber string `json:"DFIAccountNumber"`
-	// reservedTwo - Leave blank
-	reservedTwo string
 	// OFACScreeningIndicator - Leave blank
 	OFACScreeningIndicator string `json:"OFACScreeningIndicator"`
 	// SecondaryOFACScreeningIndicator - Leave blank
@@ -138,7 +132,6 @@ type IATEntryDetail struct {
 // NewIATEntryDetail returns a new IATEntryDetail with default values for non exported fields
 func NewIATEntryDetail() *IATEntryDetail {
 	iatEd := &IATEntryDetail{
-		recordType:             "6",
 		Category:               CategoryForward,
 		AddendaRecordIndicator: 1,
 	}
@@ -154,7 +147,6 @@ func (iatEd *IATEntryDetail) Parse(record string) {
 	}
 
 	// 1-1 Always "6"
-	iatEd.recordType = "6"
 	// 2-3 is checking credit 22 debit 27 savings credit 32 debit 37
 	iatEd.TransactionCode = iatEd.parseNumField(record[1:3])
 	// 4-11 the RDFI's routing number without the last digit.
@@ -164,13 +156,11 @@ func (iatEd *IATEntryDetail) Parse(record string) {
 	// 13-16 Number of addenda records
 	iatEd.AddendaRecords = iatEd.parseNumField(record[12:16])
 	// 17-29 reserved - Leave blank
-	iatEd.reserved = "             "
 	// 30-39 Number of cents you are debiting/crediting this account
 	iatEd.Amount = iatEd.parseNumField(record[29:39])
 	// 40-74 The foreign receiver's account number you are crediting/debiting
 	iatEd.DFIAccountNumber = record[39:74]
-	// 75-76 reserved2 Leave blank
-	iatEd.reservedTwo = "  "
+	// 75-76 reserved Leave blank
 	// 77 OFACScreeningIndicator
 	iatEd.OFACScreeningIndicator = " "
 	// 78-78 Secondary SecondaryOFACScreeningIndicator
@@ -187,15 +177,15 @@ func (iatEd *IATEntryDetail) Parse(record string) {
 func (iatEd *IATEntryDetail) String() string {
 	var buf strings.Builder
 	buf.Grow(94)
-	buf.WriteString(iatEd.recordType)
+	buf.WriteString(entryDetailPos)
 	buf.WriteString(fmt.Sprintf("%v", iatEd.TransactionCode))
 	buf.WriteString(iatEd.RDFIIdentificationField())
 	buf.WriteString(iatEd.CheckDigit)
 	buf.WriteString(iatEd.AddendaRecordsField())
-	buf.WriteString(iatEd.reservedField())
+	buf.WriteString("             ")
 	buf.WriteString(iatEd.AmountField())
 	buf.WriteString(iatEd.DFIAccountNumberField())
-	buf.WriteString(iatEd.reservedTwoField())
+	buf.WriteString("  ")
 	buf.WriteString(iatEd.OFACScreeningIndicatorField())
 	buf.WriteString(iatEd.SecondaryOFACScreeningIndicatorField())
 	buf.WriteString(fmt.Sprintf("%v", iatEd.AddendaRecordIndicator))
@@ -209,9 +199,6 @@ func (iatEd *IATEntryDetail) Validate() error {
 	if err := iatEd.fieldInclusion(); err != nil {
 		return err
 	}
-	if iatEd.recordType != "6" {
-		return fieldError("recordType", NewErrRecordType(6), iatEd.recordType)
-	}
 	if err := iatEd.isTransactionCode(iatEd.TransactionCode); err != nil {
 		return fieldError("TransactionCode", err, strconv.Itoa(iatEd.TransactionCode))
 	}
@@ -234,9 +221,6 @@ func (iatEd *IATEntryDetail) Validate() error {
 // fieldInclusion validate mandatory fields are not default values. If fields are
 // invalid the ACH transfer will be returned.
 func (iatEd *IATEntryDetail) fieldInclusion() error {
-	if iatEd.recordType == "" {
-		return fieldError("recordType", ErrConstructor, iatEd.recordType)
-	}
 	if iatEd.TransactionCode == 0 {
 		return fieldError("TransactionCode", ErrConstructor, strconv.Itoa(iatEd.TransactionCode))
 	}
@@ -281,10 +265,6 @@ func (iatEd *IATEntryDetail) AddendaRecordsField() string {
 	return iatEd.numericField(iatEd.AddendaRecords, 4)
 }
 
-func (iatEd *IATEntryDetail) reservedField() string {
-	return iatEd.alphaField(iatEd.reserved, 13)
-}
-
 // AmountField returns a zero padded string of amount
 func (iatEd *IATEntryDetail) AmountField() string {
 	return iatEd.numericField(iatEd.Amount, 10)
@@ -295,11 +275,6 @@ func (iatEd *IATEntryDetail) DFIAccountNumberField() string {
 	return iatEd.alphaField(iatEd.DFIAccountNumber, 35)
 }
 
-// reservedTwoField gets the reservedTwo
-func (iatEd *IATEntryDetail) reservedTwoField() string {
-	return iatEd.alphaField(iatEd.reservedTwo, 2)
-}
-
 // OFACScreeningIndicatorField gets the OFACScreeningIndicator
 func (iatEd *IATEntryDetail) OFACScreeningIndicatorField() string {
 	return iatEd.alphaField(iatEd.OFACScreeningIndicator, 1)


Test patch:
diff --git a/addenda02_test.go b/addenda02_test.go
index f370a9e3..5c28843e 100644
--- a/addenda02_test.go
+++ b/addenda02_test.go
@@ -47,29 +47,6 @@ func TestMockAddenda02(t *testing.T) {
 	}
 }
 
-// testAddenda02ValidRecordType validates Addenda02 recordType
-func testAddenda02ValidRecordType(t testing.TB) {
-	addenda02 := mockAddenda02()
-	addenda02.recordType = "63"
-	err := addenda02.Validate()
-	if !base.Match(err, NewErrRecordType(7)) {
-		t.Errorf("%T: %s", err, err)
-	}
-}
-
-// TestAddenda02ValidRecordType tests validating Addenda02 recordType
-func TestAddenda02ValidRecordType(t *testing.T) {
-	testAddenda02ValidRecordType(t)
-}
-
-// BenchmarkAddenda02ValidRecordType benchmarks validating Addenda02 recordType
-func BenchmarkAddenda02ValidRecordType(b *testing.B) {
-	b.ReportAllocs()
-	for i := 0; i < b.N; i++ {
-		testAddenda02ValidRecordType(b)
-	}
-}
-
 // testAddenda02ValidTypeCode validates Addenda02 TypeCode
 func testAddenda02ValidTypeCode(t testing.TB) {
 	addenda02 := mockAddenda02()
@@ -116,29 +93,6 @@ func BenchmarkAddenda02TypeCode02(b *testing.B) {
 	}
 }
 
-// testAddenda02FieldInclusionRecordType validates recordType fieldInclusion
-func testAddenda02FieldInclusionRecordType(t testing.TB) {
-	addenda02 := mockAddenda02()
-	addenda02.recordType = ""
-	err := addenda02.Validate()
-	if !base.Match(err, ErrConstructor) {
-		t.Errorf("%T: %s", err, err)
-	}
-}
-
-// TestAddenda02FieldInclusionRecordType tests validating recordType fieldInclusion
-func TestAddenda02FieldInclusionRecordType(t *testing.T) {
-	testAddenda02FieldInclusionRecordType(t)
-}
-
-// BenchmarkAddenda02FieldInclusionRecordType benchmarks validating recordType fieldInclusion
-func BenchmarkAddenda02FieldInclusionRecordType(b *testing.B) {
-	b.ReportAllocs()
-	for i := 0; i < b.N; i++ {
-		testAddenda02FieldInclusionRecordType(b)
-	}
-}
-
 // testAddenda02FieldInclusionTypeCode validates TypeCode fieldInclusion
 func testAddenda02FieldInclusionTypeCode(t testing.TB) {
 	addenda02 := mockAddenda02()
diff --git a/addenda05_test.go b/addenda05_test.go
index 99de0bf7..e1f44549 100644
--- a/addenda05_test.go
+++ b/addenda05_test.go
@@ -64,9 +64,6 @@ func testParseAddenda05(t testing.TB) {
 
 	record := r.currentBatch.GetEntries()[0].Addenda05[0]
 
-	if record.recordType != "7" {
-		t.Errorf("RecordType Expected '7' got: %v", record.recordType)
-	}
 	if record.TypeCode != "05" {
 		t.Errorf("TypeCode Expected 05 got: %v", record.TypeCode)
 	}
@@ -118,24 +115,6 @@ func BenchmarkAddenda05String(b *testing.B) {
 	}
 }
 
-func TestValidateAddenda05RecordType(t *testing.T) {
-	addenda05 := mockAddenda05()
-	addenda05.recordType = "63"
-	err := addenda05.Validate()
-	if !base.Match(err, NewErrRecordType(7)) {
-		t.Errorf("%T: %s", err, err)
-	}
-}
-
-func TestValidateAddenda05TypeCode(t *testing.T) {
-	addenda05 := mockAddenda05()
-	addenda05.TypeCode = "23"
-	err := addenda05.Validate()
-	if !base.Match(err, ErrAddendaTypeCode) {
-		t.Errorf("%T: %s", err, err)
-	}
-}
-
 func TestAddenda05FieldInclusion(t *testing.T) {
 	addenda05 := mockAddenda05()
 	addenda05.EntryDetailSequenceNumber = 0
@@ -154,15 +133,6 @@ func TestAddenda05FieldInclusionSequenceNumber(t *testing.T) {
 	}
 }
 
-func TestAddenda05FieldInclusionRecordType(t *testing.T) {
-	addenda05 := mockAddenda05()
-	addenda05.recordType = ""
-	err := addenda05.Validate()
-	if !base.Match(err, ErrConstructor) {
-		t.Errorf("%T: %s", err, err)
-	}
-}
-
 func TestAddenda05PaymentRelatedInformationAlphaNumeric(t *testing.T) {
 	addenda05 := mockAddenda05()
 	addenda05.PaymentRelatedInformation = "®©"
diff --git a/addenda10_test.go b/addenda10_test.go
index a7876f6a..4d8f9c62 100644
--- a/addenda10_test.go
+++ b/addenda10_test.go
@@ -48,9 +48,6 @@ func testAddenda10Parse(t testing.TB) {
 	line := "710ANN000000000000100000928383-23938          BEK Enterprises                          0000001"
 	addenda10.Parse(line)
 	// walk the Addenda10 struct
-	if addenda10.recordType != "7" {
-		t.Errorf("expected %v got %v", "7", addenda10.recordType)
-	}
 	if addenda10.TypeCode != "10" {
 		t.Errorf("expected %v got %v", "10", addenda10.TypeCode)
 	}
@@ -66,9 +63,6 @@ func testAddenda10Parse(t testing.TB) {
 	if addenda10.Name != "BEK Enterprises" {
 		t.Errorf("expected: %s got: %s", "BEK Enterprises", addenda10.Name)
 	}
-	if addenda10.reserved != "      " {
-		t.Errorf("expected: %v got: %v", "      ", addenda10.reserved)
-	}
 	if addenda10.EntryDetailSequenceNumber != 0000001 {
 		t.Errorf("expected: %v got: %v", 0000001, addenda10.EntryDetailSequenceNumber)
 	}
@@ -87,29 +81,6 @@ func BenchmarkAddenda10Parse(b *testing.B) {
 	}
 }
 
-// testAddenda10ValidRecordType validates Addenda10 recordType
-func testAddenda10ValidRecordType(t testing.TB) {
-	addenda10 := mockAddenda10()
-	addenda10.recordType = "63"
-	err := addenda10.Validate()
-	if !base.Match(err, NewErrRecordType(7)) {
-		t.Errorf("%T: %s", err, err)
-	}
-}
-
-// TestAddenda10ValidRecordType tests validating Addenda10 recordType
-func TestAddenda10ValidRecordType(t *testing.T) {
-	testAddenda10ValidRecordType(t)
-}
-
-// BenchmarkAddenda10ValidRecordType benchmarks validating Addenda10 recordType
-func BenchmarkAddenda10ValidRecordType(b *testing.B) {
-	b.ReportAllocs()
-	for i := 0; i < b.N; i++ {
-		testAddenda10ValidRecordType(b)
-	}
-}
-
 // testAddenda10ValidTypeCode validates Addenda10 TypeCode
 func testAddenda10ValidTypeCode(t testing.TB) {
 	addenda10 := mockAddenda10()
@@ -225,29 +196,6 @@ func BenchmarkNameAlphaNumeric(b *testing.B) {
 	}
 }
 
-// testAddenda10FieldInclusionRecordType validates recordType fieldInclusion
-func testAddenda10FieldInclusionRecordType(t testing.TB) {
-	addenda10 := mockAddenda10()
-	addenda10.recordType = ""
-	err := addenda10.Validate()
-	if !base.Match(err, ErrConstructor) {
-		t.Errorf("%T: %s", err, err)
-	}
-}
-
-// TestAddenda10FieldInclusionRecordType tests validating recordType fieldInclusion
-func TestAddenda10FieldInclusionRecordType(t *testing.T) {
-	testAddenda10FieldInclusionRecordType(t)
-}
-
-// BenchmarkAddenda10FieldInclusionRecordType benchmarks validating recordType fieldInclusion
-func BenchmarkAddenda10FieldInclusionRecordType(b *testing.B) {
-	b.ReportAllocs()
-	for i := 0; i < b.N; i++ {
-		testAddenda10FieldInclusionRecordType(b)
-	}
-}
-
 // testAddenda10FieldInclusionTypeCode validates TypeCode fieldInclusion
 func testAddenda10FieldInclusionTypeCode(t testing.TB) {
 	addenda10 := mockAddenda10()
diff --git a/addenda11_test.go b/addenda11_test.go
index 40b1172c..4ac4234a 100644
--- a/addenda11_test.go
+++ b/addenda11_test.go
@@ -46,9 +46,6 @@ func testAddenda11Parse(t testing.TB) {
 	line := "711BEK Solutions                      15 West Place Street                             0000001"
 	Addenda11.Parse(line)
 	// walk the Addenda11 struct
-	if Addenda11.recordType != "7" {
-		t.Errorf("expected %v got %v", "7", Addenda11.recordType)
-	}
 	if Addenda11.TypeCode != "11" {
 		t.Errorf("expected %v got %v", "11", Addenda11.TypeCode)
 	}
@@ -58,9 +55,6 @@ func testAddenda11Parse(t testing.TB) {
 	if Addenda11.OriginatorStreetAddress != "15 West Place Street" {
 		t.Errorf("expected: %v got: %v", "15 West Place Street", Addenda11.OriginatorStreetAddress)
 	}
-	if Addenda11.reserved != "              " {
-		t.Errorf("expected: %v got: %v", "              ", Addenda11.reserved)
-	}
 	if Addenda11.EntryDetailSequenceNumber != 0000001 {
 		t.Errorf("expected: %v got: %v", 0000001, Addenda11.EntryDetailSequenceNumber)
 	}
@@ -79,29 +73,6 @@ func BenchmarkAddenda11Parse(b *testing.B) {
 	}
 }
 
-// testAddenda11ValidRecordType validates Addenda11 recordType
-func testAddenda11ValidRecordType(t testing.TB) {
-	addenda11 := mockAddenda11()
-	addenda11.recordType = "63"
-	err := addenda11.Validate()
-	if !base.Match(err, NewErrRecordType(7)) {
-		t.Errorf("%T: %s", err, err)
-	}
-}
-
-// TestAddenda11ValidRecordType tests validating Addenda11 recordType
-func TestAddenda11ValidRecordType(t *testing.T) {
-	testAddenda11ValidRecordType(t)
-}
-
-// BenchmarkAddenda11ValidRecordType benchmarks validating Addenda11 recordType
-func BenchmarkAddenda11ValidRecordType(b *testing.B) {
-	b.ReportAllocs()
-	for i := 0; i < b.N; i++ {
-		testAddenda11ValidRecordType(b)
-	}
-}
-
 // testAddenda11ValidTypeCode validates Addenda11 TypeCode
 func testAddenda11ValidTypeCode(t testing.TB) {
 	addenda11 := mockAddenda11()
@@ -194,29 +165,6 @@ func BenchmarkOriginatorStreetAddressAlphaNumeric(b *testing.B) {
 	}
 }
 
-// testAddenda11FieldInclusionRecordType validates recordType fieldInclusion
-func testAddenda11FieldInclusionRecordType(t testing.TB) {
-	addenda11 := mockAddenda11()
-	addenda11.recordType = ""
-	err := addenda11.Validate()
-	if !base.Match(err, ErrConstructor) {
-		t.Errorf("%T: %s", err, err)
-	}
-}
-
-// TestAddenda11FieldInclusionRecordType tests validating recordType fieldInclusion
-func TestAddenda11FieldInclusionRecordType(t *testing.T) {
-	testAddenda11FieldInclusionRecordType(t)
-}
-
-// BenchmarkAddenda11FieldInclusionRecordType benchmarks validating recordType fieldInclusion
-func BenchmarkAddenda11FieldInclusionRecordType(b *testing.B) {
-	b.ReportAllocs()
-	for i := 0; i < b.N; i++ {
-		testAddenda11FieldInclusionRecordType(b)
-	}
-}
-
 // testAddenda11FieldInclusionTypeCode validates TypeCode fieldInclusion
 func testAddenda11FieldInclusionTypeCode(t testing.TB) {
 	addenda11 := mockAddenda11()
diff --git a/addenda12_test.go b/addenda12_test.go
index 10767a52..4f99dcbe 100644
--- a/addenda12_test.go
+++ b/addenda12_test.go
@@ -46,9 +46,6 @@ func testAddenda12Parse(t testing.TB) {
 	line := "712" + "JacobsTown*PA\\                     " + "US*19305\\                                        " + "0000001"
 	Addenda12.Parse(line)
 	// walk the Addenda12 struct
-	if Addenda12.recordType != "7" {
-		t.Errorf("expected %v got %v", "7", Addenda12.recordType)
-	}
 	if Addenda12.TypeCode != "12" {
 		t.Errorf("expected %v got %v", "12", Addenda12.TypeCode)
 	}
@@ -58,9 +55,6 @@ func testAddenda12Parse(t testing.TB) {
 	if Addenda12.OriginatorCountryPostalCode != "US*19305\\" {
 		t.Errorf("expected: %v got: %v", "US*19305\\", Addenda12.OriginatorCountryPostalCode)
 	}
-	if Addenda12.reserved != "              " {
-		t.Errorf("expected: %v got: %v", "              ", Addenda12.reserved)
-	}
 	if Addenda12.EntryDetailSequenceNumber != 0000001 {
 		t.Errorf("expected: %v got: %v", 0000001, Addenda12.EntryDetailSequenceNumber)
 	}
@@ -79,29 +73,6 @@ func BenchmarkAddenda12Parse(b *testing.B) {
 	}
 }
 
-// testAddenda12ValidRecordType validates Addenda12 recordType
-func testAddenda12ValidRecordType(t testing.TB) {
-	addenda12 := mockAddenda12()
-	addenda12.recordType = "63"
-	err := addenda12.Validate()
-	if !base.Match(err, NewErrRecordType(7)) {
-		t.Errorf("%T: %s", err, err)
-	}
-}
-
-// TestAddenda12ValidRecordType tests validating Addenda12 recordType
-func TestAddenda12ValidRecordType(t *testing.T) {
-	testAddenda12ValidRecordType(t)
-}
-
-// BenchmarkAddenda12ValidRecordType benchmarks validating Addenda12 recordType
-func BenchmarkAddenda12ValidRecordType(b *testing.B) {
-	b.ReportAllocs()
-	for i := 0; i < b.N; i++ {
-		testAddenda12ValidRecordType(b)
-	}
-}
-
 // testAddenda12ValidTypeCode validates Addenda12 TypeCode
 func testAddenda12ValidTypeCode(t testing.TB) {
 	addenda12 := mockAddenda12()
@@ -194,29 +165,6 @@ func BenchmarkOriginatorCountryPostalCodeAlphaNumeric(b *testing.B) {
 	}
 }
 
-// testAddenda12FieldInclusionRecordType validates recordType fieldInclusion
-func testAddenda12FieldInclusionRecordType(t testing.TB) {
-	addenda12 := mockAddenda12()
-	addenda12.recordType = ""
-	err := addenda12.Validate()
-	if !base.Match(err, ErrConstructor) {
-		t.Errorf("%T: %s", err, err)
-	}
-}
-
-// TestAddenda12FieldInclusionRecordType tests validating recordType fieldInclusion
-func TestAddenda12FieldInclusionRecordType(t *testing.T) {
-	testAddenda12FieldInclusionRecordType(t)
-}
-
-// BenchmarkAddenda12FieldInclusionRecordType benchmarks validating recordType fieldInclusion
-func BenchmarkAddenda12FieldInclusionRecordType(b *testing.B) {
-	b.ReportAllocs()
-	for i := 0; i < b.N; i++ {
-		testAddenda12FieldInclusionRecordType(b)
-	}
-}
-
 // testAddenda12FieldInclusionTypeCode validates TypeCode fieldInclusion
 func testAddenda12FieldInclusionTypeCode(t testing.TB) {
 	addenda12 := mockAddenda12()
diff --git a/addenda13_test.go b/addenda13_test.go
index 09438566..d5c0d0b4 100644
--- a/addenda13_test.go
+++ b/addenda13_test.go
@@ -40,9 +40,6 @@ func testAddenda13Parse(t testing.TB) {
 	line := "713Wells Fargo                        01121042882                         US           0000001"
 	Addenda13.Parse(line)
 	// walk the Addenda13 struct
-	if Addenda13.recordType != "7" {
-		t.Errorf("expected %v got %v", "7", Addenda13.recordType)
-	}
 	if Addenda13.TypeCode != "13" {
 		t.Errorf("expected %v got %v", "13", Addenda13.TypeCode)
 	}
@@ -58,9 +55,6 @@ func testAddenda13Parse(t testing.TB) {
 	if Addenda13.ODFIBranchCountryCode != "US" {
 		t.Errorf("expected: %s got: %s", "US", Addenda13.ODFIBranchCountryCode)
 	}
-	if Addenda13.reserved != "          " {
-		t.Errorf("expected: %v got: %v", "          ", Addenda13.reserved)
-	}
 	if Addenda13.EntryDetailSequenceNumber != 0000001 {
 		t.Errorf("expected: %v got: %v", 0000001, Addenda13.EntryDetailSequenceNumber)
 	}
@@ -87,29 +81,6 @@ func TestMockAddenda13(t *testing.T) {
 	}
 }
 
-// testAddenda13ValidRecordType validates Addenda13 recordType
-func testAddenda13ValidRecordType(t testing.TB) {
-	addenda13 := mockAddenda13()
-	addenda13.recordType = "63"
-	err := addenda13.Validate()
-	if !base.Match(err, NewErrRecordType(7)) {
-		t.Errorf("%T: %s", err, err)
-	}
-}
-
-// TestAddenda13ValidRecordType tests validating Addenda13 recordType
-func TestAddenda13ValidRecordType(t *testing.T) {
-	testAddenda13ValidRecordType(t)
-}
-
-// BenchmarkAddenda13ValidRecordType benchmarks validating Addenda13 recordType
-func BenchmarkAddenda13ValidRecordType(b *testing.B) {
-	b.ReportAllocs()
-	for i := 0; i < b.N; i++ {
-		testAddenda13ValidRecordType(b)
-	}
-}
-
 // testAddenda13ValidTypeCode validates Addenda13 TypeCode
 func testAddenda13ValidTypeCode(t testing.TB) {
 	addenda13 := mockAddenda13()
@@ -248,29 +219,6 @@ func BenchmarkODFIBranchCountryCodeAlphaNumeric(b *testing.B) {
 	}
 }
 
-// testAddenda13FieldInclusionRecordType validates recordType fieldInclusion
-func testAddenda13FieldInclusionRecordType(t testing.TB) {
-	addenda13 := mockAddenda13()
-	addenda13.recordType = ""
-	err := addenda13.Validate()
-	if !base.Match(err, ErrConstructor) {
-		t.Errorf("%T: %s", err, err)
-	}
-}
-
-// TestAddenda13FieldInclusionRecordType tests validating recordType fieldInclusion
-func TestAddenda13FieldInclusionRecordType(t *testing.T) {
-	testAddenda13FieldInclusionRecordType(t)
-}
-
-// BenchmarkAddenda13FieldInclusionRecordType benchmarks validating recordType fieldInclusion
-func BenchmarkAddenda13FieldInclusionRecordType(b *testing.B) {
-	b.ReportAllocs()
-	for i := 0; i < b.N; i++ {
-		testAddenda13FieldInclusionRecordType(b)
-	}
-}
-
 // testAddenda13FieldInclusionTypeCode validates TypeCode fieldInclusion
 func testAddenda13FieldInclusionTypeCode(t testing.TB) {
 	addenda13 := mockAddenda13()
diff --git a/addenda14_test.go b/addenda14_test.go
index b73b199b..73521d16 100644
--- a/addenda14_test.go
+++ b/addenda14_test.go
@@ -48,9 +48,6 @@ func testAddenda14Parse(t testing.TB) {
 	line := "714Citadel Bank                       01231380104                         US           0000001"
 	Addenda14.Parse(line)
 	// walk the Addenda14 struct
-	if Addenda14.recordType != "7" {
-		t.Errorf("expected %v got %v", "7", Addenda14.recordType)
-	}
 	if Addenda14.TypeCode != "14" {
 		t.Errorf("expected %v got %v", "14", Addenda14.TypeCode)
 	}
@@ -66,9 +63,6 @@ func testAddenda14Parse(t testing.TB) {
 	if Addenda14.RDFIBranchCountryCode != "US" {
 		t.Errorf("expected: %s got: %s", "US", Addenda14.RDFIBranchCountryCode)
 	}
-	if Addenda14.reserved != "          " {
-		t.Errorf("expected: %v got: %v", "          ", Addenda14.reserved)
-	}
 	if Addenda14.EntryDetailSequenceNumber != 0000001 {
 		t.Errorf("expected: %v got: %v", 0000001, Addenda14.EntryDetailSequenceNumber)
 	}
@@ -87,29 +81,6 @@ func BenchmarkAddenda14Parse(b *testing.B) {
 	}
 }
 
-// testAddenda14ValidRecordType validates Addenda14 recordType
-func testAddenda14ValidRecordType(t testing.TB) {
-	addenda14 := mockAddenda14()
-	addenda14.recordType = "63"
-	err := addenda14.Validate()
-	if !base.Match(err, NewErrRecordType(7)) {
-		t.Errorf("%T: %s", err, err)
-	}
-}
-
-// TestAddenda14ValidRecordType tests validating Addenda14 recordType
-func TestAddenda14ValidRecordType(t *testing.T) {
-	testAddenda14ValidRecordType(t)
-}
-
-// BenchmarkAddenda14ValidRecordType benchmarks validating Addenda14 recordType
-func BenchmarkAddenda14ValidRecordType(b *testing.B) {
-	b.ReportAllocs()
-	for i := 0; i < b.N; i++ {
-		testAddenda14ValidRecordType(b)
-	}
-}
-
 // testAddenda14ValidTypeCode validates Addenda14 TypeCode
 func testAddenda14ValidTypeCode(t testing.TB) {
 	addenda14 := mockAddenda14()
@@ -248,29 +219,6 @@ func BenchmarkRDFIBranchCountryCodeAlphaNumeric(b *testing.B) {
 	}
 }
 
-// testAddenda14FieldInclusionRecordType validates recordType fieldInclusion
-func testAddenda14FieldInclusionRecordType(t testing.TB) {
-	addenda14 := mockAddenda14()
-	addenda14.recordType = ""
-	err := addenda14.Validate()
-	if !base.Match(err, ErrConstructor) {
-		t.Errorf("%T: %s", err, err)
-	}
-}
-
-// TestAddenda14FieldInclusionRecordType tests validating recordType fieldInclusion
-func TestAddenda14FieldInclusionRecordType(t *testing.T) {
-	testAddenda14FieldInclusionRecordType(t)
-}
-
-// BenchmarkAddenda14FieldInclusionRecordType benchmarks validating recordType fieldInclusion
-func BenchmarkAddenda14FieldInclusionRecordType(b *testing.B) {
-	b.ReportAllocs()
-	for i := 0; i < b.N; i++ {
-		testAddenda14FieldInclusionRecordType(b)
-	}
-}
-
 // testAddenda14FieldInclusionTypeCode validates TypeCode fieldInclusion
 func testAddenda14FieldInclusionTypeCode(t testing.TB) {
 	addenda14 := mockAddenda14()
diff --git a/addenda15_test.go b/addenda15_test.go
index a84fed25..24cab9c4 100644
--- a/addenda15_test.go
+++ b/addenda15_test.go
@@ -46,9 +46,6 @@ func testAddenda15Parse(t testing.TB) {
 	line := "7159874654932139872121 Front Street                                                    0000001"
 	Addenda15.Parse(line)
 	// walk the Addenda15 struct
-	if Addenda15.recordType != "7" {
-		t.Errorf("expected %v got %v", "7", Addenda15.recordType)
-	}
 	if Addenda15.TypeCode != "15" {
 		t.Errorf("expected %v got %v", "15", Addenda15.TypeCode)
 	}
@@ -58,9 +55,6 @@ func testAddenda15Parse(t testing.TB) {
 	if Addenda15.ReceiverStreetAddress != "2121 Front Street" {
 		t.Errorf("expected: %v got: %v", "2121 Front Street", Addenda15.ReceiverStreetAddress)
 	}
-	if Addenda15.reserved != "                                  " {
-		t.Errorf("expected: %v got: %v", "                                  ", Addenda15.reserved)
-	}
 	if Addenda15.EntryDetailSequenceNumber != 0000001 {
 		t.Errorf("expected: %v got: %v", 0000001, Addenda15.EntryDetailSequenceNumber)
 	}
@@ -79,29 +73,6 @@ func BenchmarkAddenda15Parse(b *testing.B) {
 	}
 }
 
-// testAddenda15ValidRecordType validates Addenda15 recordType
-func testAddenda15ValidRecordType(t testing.TB) {
-	addenda15 := mockAddenda15()
-	addenda15.recordType = "63"
-	err := addenda15.Validate()
-	if !base.Match(err, NewErrRecordType(7)) {
-		t.Errorf("%T: %s", err, err)
-	}
-}
-
-// TestAddenda15ValidRecordType tests validating Addenda15 recordType
-func TestAddenda15ValidRecordType(t *testing.T) {
-	testAddenda15ValidRecordType(t)
-}
-
-// BenchmarkAddenda15ValidRecordType benchmarks validating Addenda15 recordType
-func BenchmarkAddenda15ValidRecordType(b *testing.B) {
-	b.ReportAllocs()
-	for i := 0; i < b.N; i++ {
-		testAddenda15ValidRecordType(b)
-	}
-}
-
 // testAddenda15ValidTypeCode validates Addenda15 TypeCode
 func testAddenda15ValidTypeCode(t testing.TB) {
 	addenda15 := mockAddenda15()
@@ -194,29 +165,6 @@ func BenchmarkReceiverStreetAddressAlphaNumeric(b *testing.B) {
 	}
 }
 
-// testAddenda15FieldInclusionRecordType validates recordType fieldInclusion
-func testAddenda15FieldInclusionRecordType(t testing.TB) {
-	addenda15 := mockAddenda15()
-	addenda15.recordType = ""
-	err := addenda15.Validate()
-	if !base.Match(err, ErrConstructor) {
-		t.Errorf("%T: %s", err, err)
-	}
-}
-
-// TestAddenda15FieldInclusionRecordType tests validating recordType fieldInclusion
-func TestAddenda15FieldInclusionRecordType(t *testing.T) {
-	testAddenda15FieldInclusionRecordType(t)
-}
-
-// BenchmarkAddenda15FieldInclusionRecordType benchmarks validating recordType fieldInclusion
-func BenchmarkAddenda15FieldInclusionRecordType(b *testing.B) {
-	b.ReportAllocs()
-	for i := 0; i < b.N; i++ {
-		testAddenda15FieldInclusionRecordType(b)
-	}
-}
-
 // testAddenda15FieldInclusionTypeCode validates TypeCode fieldInclusion
 func testAddenda15FieldInclusionTypeCode(t testing.TB) {
 	addenda15 := mockAddenda15()
diff --git a/addenda16_test.go b/addenda16_test.go
index 31e19253..946c69b6 100644
--- a/addenda16_test.go
+++ b/addenda16_test.go
@@ -46,9 +46,6 @@ func testAddenda16Parse(t testing.TB) {
 	line := "716LetterTown*AB\\                     CA*80014\\                                        0000001"
 	Addenda16.Parse(line)
 	// walk the Addenda16 struct
-	if Addenda16.recordType != "7" {
-		t.Errorf("expected %v got %v", "7", Addenda16.recordType)
-	}
 	if Addenda16.TypeCode != "16" {
 		t.Errorf("expected %v got %v", "16", Addenda16.TypeCode)
 	}
@@ -58,9 +55,6 @@ func testAddenda16Parse(t testing.TB) {
 	if Addenda16.ReceiverCountryPostalCode != "CA*80014\\" {
 		t.Errorf("expected: %v got: %v", "CA*80014\\", Addenda16.ReceiverCountryPostalCode)
 	}
-	if Addenda16.reserved != "              " {
-		t.Errorf("expected: %v got: %v", "              ", Addenda16.reserved)
-	}
 	if Addenda16.EntryDetailSequenceNumber != 0000001 {
 		t.Errorf("expected: %v got: %v", 0000001, Addenda16.EntryDetailSequenceNumber)
 	}
@@ -79,29 +73,6 @@ func BenchmarkAddenda16Parse(b *testing.B) {
 	}
 }
 
-// testAddenda16ValidRecordType validates Addenda16 recordType
-func testAddenda16ValidRecordType(t testing.TB) {
-	addenda16 := mockAddenda16()
-	addenda16.recordType = "63"
-	err := addenda16.Validate()
-	if !base.Match(err, NewErrRecordType(7)) {
-		t.Errorf("%T: %s", err, err)
-	}
-}
-
-// TestAddenda16ValidRecordType tests validating Addenda16 recordType
-func TestAddenda16ValidRecordType(t *testing.T) {
-	testAddenda16ValidRecordType(t)
-}
-
-// BenchmarkAddenda16ValidRecordType benchmarks validating Addenda16 recordType
-func BenchmarkAddenda16ValidRecordType(b *testing.B) {
-	b.ReportAllocs()
-	for i := 0; i < b.N; i++ {
-		testAddenda16ValidRecordType(b)
-	}
-}
-
 // testAddenda16ValidTypeCode validates Addenda16 TypeCode
 func testAddenda16ValidTypeCode(t testing.TB) {
 	addenda16 := mockAddenda16()
@@ -194,29 +165,6 @@ func BenchmarkReceiverCountryPostalCodeAlphaNumeric(b *testing.B) {
 	}
 }
 
-// testAddenda16FieldInclusionRecordType validates recordType fieldInclusion
-func testAddenda16FieldInclusionRecordType(t testing.TB) {
-	addenda16 := mockAddenda16()
-	addenda16.recordType = ""
-	err := addenda16.Validate()
-	if !base.Match(err, ErrConstructor) {
-		t.Errorf("%T: %s", err, err)
-	}
-}
-
-// TestAddenda16FieldInclusionRecordType tests validating recordType fieldInclusion
-func TestAddenda16FieldInclusionRecordType(t *testing.T) {
-	testAddenda16FieldInclusionRecordType(t)
-}
-
-// BenchmarkAddenda16FieldInclusionRecordType benchmarks validating recordType fieldInclusion
-func BenchmarkAddenda16FieldInclusionRecordType(b *testing.B) {
-	b.ReportAllocs()
-	for i := 0; i < b.N; i++ {
-		testAddenda16FieldInclusionRecordType(b)
-	}
-}
-
 // testAddenda16FieldInclusionTypeCode validates TypeCode fieldInclusion
 func testAddenda16FieldInclusionTypeCode(t testing.TB) {
 	addenda16 := mockAddenda16()
diff --git a/addenda17_test.go b/addenda17_test.go
index d3a7a564..682d7e0f 100644
--- a/addenda17_test.go
+++ b/addenda17_test.go
@@ -47,9 +47,6 @@ func testAddenda17Parse(t testing.TB) {
 	line := "717This is an international payment                                                00010000001"
 	Addenda17.Parse(line)
 	// walk the Addenda17 struct
-	if Addenda17.recordType != "7" {
-		t.Errorf("expected %v got %v", "7", Addenda17.recordType)
-	}
 	if Addenda17.TypeCode != "17" {
 		t.Errorf("expected %v got %v", "17", Addenda17.TypeCode)
 	}
@@ -112,15 +109,6 @@ func BenchmarkAddenda17String(b *testing.B) {
 	}
 }
 
-func TestValidateAddenda17RecordType(t *testing.T) {
-	addenda17 := mockAddenda17()
-	addenda17.recordType = "63"
-	err := addenda17.Validate()
-	if !base.Match(err, NewErrRecordType(7)) {
-		t.Errorf("%T: %s", err, err)
-	}
-}
-
 func TestAddenda17FieldInclusionTypeCode(t *testing.T) {
 	addenda17 := mockAddenda17()
 	addenda17.TypeCode = ""
@@ -148,15 +136,6 @@ func TestAddenda17FieldInclusionSequenceNumber(t *testing.T) {
 	}
 }
 
-func TestAddenda17FieldInclusionRecordType(t *testing.T) {
-	addenda17 := mockAddenda17()
-	addenda17.recordType = ""
-	err := addenda17.Validate()
-	if !base.Match(err, ErrConstructor) {
-		t.Errorf("%T: %s", err, err)
-	}
-}
-
 // testAddenda17PaymentRelatedInformationAlphaNumeric validates PaymentRelatedInformation is alphanumeric
 func testAddenda17PaymentRelatedInformationAlphaNumeric(t testing.TB) {
 	addenda17 := mockAddenda17()
diff --git a/addenda18_test.go b/addenda18_test.go
index 630643a0..17906cbe 100644
--- a/addenda18_test.go
+++ b/addenda18_test.go
@@ -119,9 +119,6 @@ func testAddenda18Parse(t testing.TB) {
 	line := "718Bank of Germany                    01987987987654654                   DE       00010000001"
 	Addenda18.Parse(line)
 	// walk the Addenda18 struct
-	if Addenda18.recordType != "7" {
-		t.Errorf("expected %v got %v", "7", Addenda18.recordType)
-	}
 	if Addenda18.TypeCode != "18" {
 		t.Errorf("expected %v got %v", "18", Addenda18.TypeCode)
 	}
@@ -137,9 +134,6 @@ func testAddenda18Parse(t testing.TB) {
 	if Addenda18.ForeignCorrespondentBankBranchCountryCode != "DE" {
 		t.Errorf("expected: %s got: %s", "DE", Addenda18.ForeignCorrespondentBankBranchCountryCode)
 	}
-	if Addenda18.reserved != "      " {
-		t.Errorf("expected: %v got: %v", "      ", Addenda18.reserved)
-	}
 	if Addenda18.EntryDetailSequenceNumber != 0000001 {
 		t.Errorf("expected: %v got: %v", 0000001, Addenda18.EntryDetailSequenceNumber)
 	}
@@ -182,15 +176,6 @@ func BenchmarkAddenda18String(b *testing.B) {
 	}
 }
 
-func TestValidateAddenda18RecordType(t *testing.T) {
-	addenda18 := mockAddenda18()
-	addenda18.recordType = "63"
-	err := addenda18.Validate()
-	if !base.Match(err, NewErrRecordType(7)) {
-		t.Errorf("%T: %s", err, err)
-	}
-}
-
 func TestAddenda18FieldInclusionTypeCode(t *testing.T) {
 	addenda18 := mockAddenda18()
 	addenda18.TypeCode = ""
@@ -218,15 +203,6 @@ func TestAddenda18FieldInclusionSequenceNumber(t *testing.T) {
 	}
 }
 
-func TestAddenda18FieldInclusionRecordType(t *testing.T) {
-	addenda18 := mockAddenda18()
-	addenda18.recordType = ""
-	err := addenda18.Validate()
-	if !base.Match(err, ErrConstructor) {
-		t.Errorf("%T: %s", err, err)
-	}
-}
-
 func TestAddenda18FieldInclusionFCBankName(t *testing.T) {
 	addenda18 := mockAddenda18()
 	addenda18.ForeignCorrespondentBankName = ""
diff --git a/addenda98_test.go b/addenda98_test.go
index da98857d..2f13fb84 100644
--- a/addenda98_test.go
+++ b/addenda98_test.go
@@ -61,9 +61,6 @@ func testAddenda98Parse(t testing.TB) {
 	line := "798C01099912340000015      091012981918171614                                  091012980000088"
 	addenda98.Parse(line)
 	// walk the Addenda98 struct
-	if addenda98.recordType != "7" {
-		t.Errorf("expected %v got %v", "7", addenda98.recordType)
-	}
 	if addenda98.TypeCode != "98" {
 		t.Errorf("expected %v got %v", "98", addenda98.TypeCode)
 	}
@@ -116,25 +113,6 @@ func BenchmarkAddenda98String(b *testing.B) {
 	}
 }
 
-func testAddenda98ValidRecordType(t testing.TB) {
-	addenda98 := mockAddenda98()
-	addenda98.recordType = "63"
-	err := addenda98.Validate()
-	if !base.Match(err, NewErrRecordType(7)) {
-		t.Errorf("%T: %s", err, err)
-	}
-}
-func TestAddenda98ValidRecordType(t *testing.T) {
-	testAddenda98ValidRecordType(t)
-}
-
-func BenchmarkAddenda98ValidRecordType(b *testing.B) {
-	b.ReportAllocs()
-	for i := 0; i < b.N; i++ {
-		testAddenda98ValidRecordType(b)
-	}
-}
-
 func testAddenda98ValidTypeCode(t testing.TB) {
 	addenda98 := mockAddenda98()
 	addenda98.TypeCode = "05"
diff --git a/addenda99_contested_return.go b/addenda99_contested_return.go
index e59bddb5..a4522f6d 100644
--- a/addenda99_contested_return.go
+++ b/addenda99_contested_return.go
@@ -25,8 +25,6 @@ import (
 type Addenda99Contested struct {
 	// ID is a client defined string used as a reference to this record.
 	ID string `json:"id"`
-	// RecordType defines the type of record in the block. entryAddendaPos 7
-	recordType string
 
 	// TypeCode Addenda types code '99'
 	TypeCode string `json:"typeCode"`
@@ -78,8 +76,7 @@ type Addenda99Contested struct {
 // NewAddenda99Contested returns a new Addenda99Contested with default values for none exported fields
 func NewAddenda99Contested() *Addenda99Contested {
 	Addenda99Contested := &Addenda99Contested{
-		recordType: "7",
-		TypeCode:   "99",
+		TypeCode: "99",
 	}
 	return Addenda99Contested
 }
@@ -89,7 +86,6 @@ func (Addenda99Contested *Addenda99Contested) Parse(record string) {
 		return
 	}
 
-	Addenda99Contested.recordType = "7"
 	Addenda99Contested.TypeCode = record[1:3]
 	Addenda99Contested.ContestedReturnCode = record[3:6]
 	Addenda99Contested.OriginalEntryTraceNumber = record[6:21]
@@ -109,7 +105,7 @@ func (Addenda99Contested *Addenda99Contested) String() string {
 	var buf strings.Builder
 	buf.Grow(94)
 
-	buf.WriteString(Addenda99Contested.recordType)
+	buf.WriteString(entryAddendaPos)
 	buf.WriteString(Addenda99Contested.TypeCode)
 	buf.WriteString(Addenda99Contested.ContestedReturnCodeField())
 	buf.WriteString(Addenda99Contested.OriginalEntryTraceNumberField())
@@ -139,9 +135,6 @@ func (Addenda99Contested *Addenda99Contested) SetValidation(opts *ValidateOpts)
 
 // Validate verifies NACHA rules for Addenda99Contested
 func (Addenda99Contested *Addenda99Contested) Validate() error {
-	if Addenda99Contested.recordType != "7" {
-		return fieldError("recordType", NewErrRecordType(7), Addenda99Contested.recordType)
-	}
 	if Addenda99Contested.TypeCode == "" {
 		return fieldError("TypeCode", ErrConstructor, Addenda99Contested.TypeCode)
 	}
diff --git a/addenda99_test.go b/addenda99_test.go
index e1bd0457..1a388406 100644
--- a/addenda99_test.go
+++ b/addenda99_test.go
@@ -40,9 +40,6 @@ func testAddenda99Parse(t testing.TB) {
 	line := "799R07099912340000015      09101298Authorization revoked                       091012980000066"
 	addenda99.Parse(line)
 	// walk the Addenda99 struct
-	if addenda99.recordType != "7" {
-		t.Errorf("expected %v got %v", "7", addenda99.recordType)
-	}
 	if addenda99.TypeCode != "99" {
 		t.Errorf("expected %v got %v", "99", addenda99.TypeCode)
 	}
@@ -291,25 +288,6 @@ func BenchmarkAddenda99TraceNumberField(b *testing.B) {
 	}
 }
 
-func testAddenda99ValidRecordType(t testing.TB) {
-	addenda99 := mockAddenda99()
-	addenda99.recordType = "63"
-	err := addenda99.Validate()
-	if !base.Match(err, NewErrRecordType(7)) {
-		t.Errorf("%T: %s", err, err)
-	}
-}
-func TestAddenda99ValidRecordType(t *testing.T) {
-	testAddenda99ValidRecordType(t)
-}
-
-func BenchmarkAddenda99ValidRecordType(b *testing.B) {
-	b.ReportAllocs()
-	for i := 0; i < b.N; i++ {
-		testAddenda99ValidRecordType(b)
-	}
-}
-
 // testAddenda99TypeCode99 TypeCode is 99
 func testAddenda99TypeCode99(t testing.TB) {
 	addenda99 := mockAddenda99()
diff --git a/advBatchControl_test.go b/advBatchControl_test.go
index f75b5d84..6c84cdd6 100644
--- a/advBatchControl_test.go
+++ b/advBatchControl_test.go
@@ -80,9 +80,6 @@ func testParseADVBatchControl(t testing.TB) {
 	}
 	record := r.currentBatch.GetADVControl()
 
-	if record.recordType != "8" {
-		t.Errorf("RecordType Expected '8' got: %v", record.recordType)
-	}
 	if record.ServiceClassCode != AutomatedAccountingAdvices {
 		t.Errorf("ServiceClassCode Expected '280' got: %v", record.ServiceClassCode)
 	}
@@ -158,29 +155,6 @@ func BenchmarkADVBCString(b *testing.B) {
 	}
 }
 
-// testValidateADVBCRecordType ensure error if recordType is not 8
-func testValidateADVBCRecordType(t testing.TB) {
-	bc := mockADVBatchControl()
-	bc.recordType = "2"
-	err := bc.Validate()
-	if !base.Match(err, NewErrRecordType(7)) {
-		t.Errorf("%T: %s", err, err)
-	}
-}
-
-// TestValidateADVBCRecordType tests ensuring an error if recordType is not 8
-func TestValidateADVBCRecordType(t *testing.T) {
-	testValidateADVBCRecordType(t)
-}
-
-// BenchmarkValidateADVBCRecordType benchmarks ensuring an error if recordType is not 8
-func BenchmarkValidateADVBCRecordType(b *testing.B) {
-	b.ReportAllocs()
-	for i := 0; i < b.N; i++ {
-		testValidateBCRecordType(b)
-	}
-}
-
 // testADVisServiceClassErr verifies service class code
 func testADVBCisServiceClassErr(t testing.TB) {
 	bc := mockADVBatchControl()
@@ -250,29 +224,6 @@ func BenchmarkADVACHOperatorDataAlphaNumeric(b *testing.B) {
 	}
 }
 
-// testADVBCFieldInclusionRecordType verifies Record Type is included
-func testADVBCFieldInclusionRecordType(t testing.TB) {
-	bc := mockADVBatchControl()
-	bc.recordType = ""
-	err := bc.Validate()
-	if !base.Match(err, ErrConstructor) {
-		t.Errorf("%T: %s", err, err)
-	}
-}
-
-// TestADVBCFieldInclusionRecordType tests verifying Record Type is included
-func TestADVBCFieldInclusionRecordType(t *testing.T) {
-	testADVBCFieldInclusionRecordType(t)
-}
-
-// BenchmarkADVBCFieldInclusionRecordType benchmarks verifying Record Type is included
-func BenchmarkADVBCFieldInclusionRecordType(b *testing.B) {
-	b.ReportAllocs()
-	for i := 0; i < b.N; i++ {
-		testADVBCFieldInclusionRecordType(b)
-	}
-}
-
 // testADVBCFieldInclusionServiceClassCode verifies Service Class Code is included
 func testADVBCFieldInclusionServiceClassCode(t testing.TB) {
 	bc := mockADVBatchControl()
diff --git a/advEntryDetail_test.go b/advEntryDetail_test.go
index 7ba130b8..99c26788 100644
--- a/advEntryDetail_test.go
+++ b/advEntryDetail_test.go
@@ -138,16 +138,6 @@ func BenchmarkADVEDString(b *testing.B) {
 	}
 }
 
-// TestValidateADVEDRecordType validates error if recordType is not 6
-func TestValidateADVEDRecordType(t *testing.T) {
-	ed := mockADVEntryDetail()
-	ed.recordType = "2"
-	err := ed.Validate()
-	if !base.Match(err, NewErrRecordType(6)) {
-		t.Errorf("%T: %s", err, err)
-	}
-}
-
 // TestValidateADVEDTransactionCode validates error if transaction code is not valid
 func TestValidateADVEDTransactionCode(t *testing.T) {
 	ed := mockADVEntryDetail()
@@ -218,16 +208,6 @@ func TestADVEDisCheckDigit(t *testing.T) {
 	}
 }
 
-// TestADVEDFieldInclusionRecordType validates recordType field inclusion
-func TestADVEDFieldInclusionRecordType(t *testing.T) {
-	entry := mockADVEntryDetail()
-	entry.recordType = ""
-	err := entry.Validate()
-	if !base.Match(err, ErrConstructor) {
-		t.Errorf("%T: %s", err, err)
-	}
-}
-
 // TestADVEDFieldInclusionTransactionCode validates TransactionCode field inclusion
 func TestADVEDFieldInclusionTransactionCode(t *testing.T) {
 	entry := mockADVEntryDetail()
diff --git a/advFileControl_test.go b/advFileControl_test.go
index db153c9a..1088b796 100644
--- a/advFileControl_test.go
+++ b/advFileControl_test.go
@@ -81,9 +81,6 @@ func testParseADVFileControl(t testing.TB) {
 	}
 	record := r.File.ADVControl
 
-	if record.recordType != "9" {
-		t.Errorf("RecordType Expected '9' got: %v", record.recordType)
-	}
 	if record.BatchCountField() != "000001" {
 		t.Errorf("BatchCount Expected '000001' got: %v", record.BatchCountField())
 	}
@@ -102,9 +99,6 @@ func testParseADVFileControl(t testing.TB) {
 	if record.TotalCreditEntryDollarAmountInFileField() != "00000000000000000000" {
 		t.Errorf("TotalCreditEntryDollarAmountInFile Expected '00000000000000000000' got: %v", record.TotalCreditEntryDollarAmountInFileField())
 	}
-	if record.reserved != "                       " {
-		t.Errorf("Reserved Expected '                       ' got: %v", record.reserved)
-	}
 }
 
 // TestParseADVFileControl tests parsing a known file control record string
@@ -151,30 +145,6 @@ func BenchmarkADVFCString(b *testing.B) {
 	}
 }
 
-// testValidateADVFCRecordType validates error if recordType is not 9
-func testValidateADVFCRecordType(t testing.TB) {
-	fc := mockADVFileControl()
-	fc.recordType = "2"
-
-	err := fc.Validate()
-	if !base.Match(err, NewErrRecordType(9)) {
-		t.Errorf("%T: %s", err, err)
-	}
-}
-
-// TestValidateADVFCRecordType tests validating error if recordType is not 9
-func TestValidateADVFCRecordType(t *testing.T) {
-	testValidateADVFCRecordType(t)
-}
-
-// BenchmarkValidateADVFCRecordType benchmarks validating error if recordType is not 9
-func BenchmarkValidateADVFCRecordType(b *testing.B) {
-	b.ReportAllocs()
-	for i := 0; i < b.N; i++ {
-		testValidateADVFCRecordType(b)
-	}
-}
-
 // testADVFCFieldInclusion validates file control field inclusion
 func testADVFCFieldInclusion(t testing.TB) {
 	fc := mockADVFileControl()
@@ -198,29 +168,6 @@ func BenchmarkADVFCFieldInclusion(b *testing.B) {
 	}
 }
 
-// testADVFCFieldInclusionRecordType validates file control record type field inclusion
-func testADVFCFieldInclusionRecordType(t testing.TB) {
-	fc := mockADVFileControl()
-	fc.recordType = ""
-	err := fc.Validate()
-	if !base.Match(err, ErrConstructor) {
-		t.Errorf("%T: %s", err, err)
-	}
-}
-
-// TestADVFCFieldInclusionRecordType tests validating file control record type field inclusion
-func TestADVFCFieldInclusionRecordType(t *testing.T) {
-	testADVFCFieldInclusionRecordType(t)
-}
-
-// BenchmarkADVFCFieldInclusionRecordType benchmarks tests validating file control record type field inclusion
-func BenchmarkADVFCFieldInclusionRecordType(b *testing.B) {
-	b.ReportAllocs()
-	for i := 0; i < b.N; i++ {
-		testADVFCFieldInclusionRecordType(b)
-	}
-}
-
 // testADVFCFieldInclusionBlockCount validates file control block count field inclusion
 func testADVFCFieldInclusionBlockCount(t testing.TB) {
 	fc := mockADVFileControl()
diff --git a/batchARC_test.go b/batchARC_test.go
index 2b2869ba..48ebce7e 100644
--- a/batchARC_test.go
+++ b/batchARC_test.go
@@ -348,9 +348,9 @@ func BenchmarkBatchARCAddendaCount(b *testing.B) {
 // testBatchARCInvalidBuild validates an invalid batch build
 func testBatchARCInvalidBuild(t testing.TB) {
 	mockBatch := mockBatchARC()
-	mockBatch.GetHeader().recordType = "3"
+	mockBatch.GetHeader().ServiceClassCode = 3
 	err := mockBatch.Create()
-	if !base.Match(err, NewErrRecordType(5)) {
+	if !base.Match(err, ErrServiceClass) {
 		t.Errorf("%T: %s", err, err)
 	}
 }
diff --git a/batchATX_test.go b/batchATX_test.go
index 26014155..ee6d83bd 100644
--- a/batchATX_test.go
+++ b/batchATX_test.go
@@ -214,25 +214,25 @@ func TestBatchATXInvalidAddend02(t *testing.T) {
 	}
 }
 
-// testBatchATXInvalidAddenda validates Addendum must be Addenda05 with record type 7
+// testBatchATXInvalidAddenda validates Addendum must be Addenda05 with type code 05
 func testBatchATXInvalidAddenda(t testing.TB) {
 	mockBatch := NewBatchATX(mockBatchATXHeader())
 	mockBatch.AddEntry(mockATXEntryDetail())
 	addenda05 := mockAddenda05()
-	addenda05.recordType = "63"
+	addenda05.TypeCode = "63"
 	mockBatch.GetEntries()[0].AddAddenda05(addenda05)
 	err := mockBatch.Create()
-	if !base.Match(err, NewErrRecordType(7)) {
+	if !base.Match(err, ErrAddendaTypeCode) {
 		t.Errorf("%T: %s", err, err)
 	}
 }
 
-// TestBatchATXInvalidAddenda tests validating Addendum must be Addenda05 with record type 7
+// TestBatchATXInvalidAddenda tests validating Addendum must be Addenda05 with type code 05
 func TestBatchATXInvalidAddenda(t *testing.T) {
 	testBatchATXInvalidAddenda(t)
 }
 
-// BenchmarkBatchATXInvalidAddenda benchmarks validating Addendum must be Addenda05 with record type 7
+// BenchmarkBatchATXInvalidAddenda benchmarks validating Addendum must be Addenda05 with type code 05
 func BenchmarkBatchATXInvalidAddenda(b *testing.B) {
 	b.ReportAllocs()
 	for i := 0; i < b.N; i++ {
@@ -243,9 +243,9 @@ func BenchmarkBatchATXInvalidAddenda(b *testing.B) {
 // testBatchATXInvalidBuild validates an invalid batch build
 func testBatchATXInvalidBuild(t testing.TB) {
 	mockBatch := mockBatchATX()
-	mockBatch.GetHeader().recordType = "3"
+	mockBatch.GetHeader().ServiceClassCode = 3
 	err := mockBatch.Create()
-	if !base.Match(err, NewErrRecordType(5)) {
+	if !base.Match(err, ErrServiceClass) {
 		t.Errorf("%T: %s", err, err)
 	}
 }
diff --git a/batchBOC_test.go b/batchBOC_test.go
index bc6e8f2d..6c805fa1 100644
--- a/batchBOC_test.go
+++ b/batchBOC_test.go
@@ -348,9 +348,9 @@ func BenchmarkBatchBOCAddenda05(b *testing.B) {
 // testBatchBOCInvalidBuild validates an invalid batch build
 func testBatchBOCInvalidBuild(t testing.TB) {
 	mockBatch := mockBatchBOC()
-	mockBatch.GetHeader().recordType = "3"
+	mockBatch.GetHeader().ServiceClassCode = 3
 	err := mockBatch.Create()
-	if !base.Match(err, NewErrRecordType(5)) {
+	if !base.Match(err, ErrServiceClass) {
 		t.Errorf("%T: %s", err, err)
 	}
 }
diff --git a/batchCIE_test.go b/batchCIE_test.go
index 00381f0a..5e2b414a 100644
--- a/batchCIE_test.go
+++ b/batchCIE_test.go
@@ -314,26 +314,26 @@ func BenchmarkBatchCIEInvalidAddendum(b *testing.B) {
 	}
 }
 
-// testBatchCIEInvalidAddenda validates Addendum must be Addenda05 with record type 7
+// testBatchCIEInvalidAddenda validates Addendum must be Addenda05 with type code 05
 func testBatchCIEInvalidAddenda(t testing.TB) {
 	mockBatch := NewBatchCIE(mockBatchCIEHeader())
 	mockBatch.AddEntry(mockCIEEntryDetail())
 	addenda05 := mockAddenda05()
-	addenda05.recordType = "63"
+	addenda05.TypeCode = "63"
 	mockBatch.GetEntries()[0].AddAddenda05(addenda05)
 	mockBatch.Entries[0].AddendaRecordIndicator = 1
 	err := mockBatch.Create()
-	if !base.Match(err, NewErrRecordType(7)) {
+	if !base.Match(err, ErrAddendaTypeCode) {
 		t.Errorf("%T: %s", err, err)
 	}
 }
 
-// TestBatchCIEInvalidAddenda tests validating Addendum must be Addenda05 with record type 7
+// TestBatchCIEInvalidAddenda tests validating Addendum must be Addenda05 with type code 05
 func TestBatchCIEInvalidAddenda(t *testing.T) {
 	testBatchCIEInvalidAddenda(t)
 }
 
-// BenchmarkBatchCIEInvalidAddenda benchmarks validating Addendum must be Addenda05 with record type 7
+// BenchmarkBatchCIEInvalidAddenda benchmarks validating Addendum must be Addenda05 with type code 05
 func BenchmarkBatchCIEInvalidAddenda(b *testing.B) {
 	b.ReportAllocs()
 	for i := 0; i < b.N; i++ {
@@ -344,9 +344,9 @@ func BenchmarkBatchCIEInvalidAddenda(b *testing.B) {
 // testBatchCIEInvalidBuild validates an invalid batch build
 func testBatchCIEInvalidBuild(t testing.TB) {
 	mockBatch := mockBatchCIE()
-	mockBatch.GetHeader().recordType = "3"
+	mockBatch.GetHeader().ServiceClassCode = 3
 	err := mockBatch.Create()
-	if !base.Match(err, NewErrRecordType(5)) {
+	if !base.Match(err, ErrServiceClass) {
 		t.Errorf("%T: %s", err, err)
 	}
 }
diff --git a/batchCOR_test.go b/batchCOR_test.go
index 9f7fd6d5..8bb663f3 100644
--- a/batchCOR_test.go
+++ b/batchCOR_test.go
@@ -388,12 +388,12 @@ func TestBatchCORTestBatchCORInvalidAddenda98(t *testing.T) {
 	mockBatch.AddEntry(mockCOREntryDetail())
 	mockBatch.GetEntries()[0].Category = CategoryNOC
 	addenda98 := mockAddenda98()
-	addenda98.recordType = "03"
+	addenda98.TypeCode = "63"
 	mockBatch.GetEntries()[0].Addenda98 = addenda98
 
 	mockBatch.Entries[0].AddendaRecordIndicator = 1
 	err := mockBatch.Create()
-	if !base.Match(err, NewErrRecordType(7)) {
+	if !base.Match(err, ErrAddendaTypeCode) {
 		t.Errorf("%T: %s", err, err)
 	}
 }
diff --git a/batchCTX_test.go b/batchCTX_test.go
index 1eed4c04..f19d850a 100644
--- a/batchCTX_test.go
+++ b/batchCTX_test.go
@@ -199,16 +199,16 @@ func BenchmarkBatchCTXAddendaCountZero(b *testing.B) {
 	}
 }
 
-// testBatchCTXInvalidAddenda validates Addendum must be Addenda05 with record type 7
+// testBatchCTXInvalidAddenda validates Addendum must be Addenda05 with type code 05
 func testBatchCTXInvalidAddenda(t testing.TB) {
 	mockBatch := NewBatchCTX(mockBatchCTXHeader())
 	mockBatch.AddEntry(mockCTXEntryDetail())
 	addenda05 := mockAddenda05()
-	addenda05.recordType = "63"
+	addenda05.TypeCode = "63"
 	mockBatch.GetEntries()[0].AddAddenda05(addenda05)
 	mockBatch.Entries[0].AddendaRecordIndicator = 1
 	err := mockBatch.Create()
-	if !base.Match(err, NewErrRecordType(7)) {
+	if !base.Match(err, ErrAddendaTypeCode) {
 		t.Errorf("%T: %s", err, err)
 	}
 }
@@ -229,9 +229,9 @@ func BenchmarkBatchCTXInvalidAddenda(b *testing.B) {
 // testBatchCTXInvalidBuild validates an invalid batch build
 func testBatchCTXInvalidBuild(t testing.TB) {
 	mockBatch := mockBatchCTX()
-	mockBatch.GetHeader().recordType = "3"
+	mockBatch.GetHeader().ServiceClassCode = 3
 	err := mockBatch.Create()
-	if !base.Match(err, NewErrRecordType(5)) {
+	if !base.Match(err, ErrServiceClass) {
 		t.Errorf("%T: %s", err, err)
 	}
 }
diff --git a/batchControl_test.go b/batchControl_test.go
index cdc0b6e8..80df23ed 100644
--- a/batchControl_test.go
+++ b/batchControl_test.go
@@ -79,9 +79,6 @@ func testParseBatchControl(t testing.TB) {
 	}
 	record := r.currentBatch.GetControl()
 
-	if record.recordType != "8" {
-		t.Errorf("RecordType Expected '8' got: %v", record.recordType)
-	}
 	if record.ServiceClassCode != DebitsOnly {
 		t.Errorf("ServiceClassCode Expected '225' got: %v", record.ServiceClassCode)
 	}
@@ -103,9 +100,6 @@ func testParseBatchControl(t testing.TB) {
 	if record.MessageAuthenticationCodeField() != "                   " {
 		t.Errorf("MessageAuthenticationCode Expected '                   ' got: %v", record.MessageAuthenticationCodeField())
 	}
-	if record.reserved != "      " {
-		t.Errorf("Reserved Expected '      ' got: %v", record.reserved)
-	}
 	if record.ODFIIdentificationField() != "07640125" {
 		t.Errorf("OdfiIdentification Expected '07640125' got: %v", record.ODFIIdentificationField())
 	}
@@ -162,29 +156,6 @@ func BenchmarkBCString(b *testing.B) {
 	}
 }
 
-// testValidateBCRecordType ensure error if recordType is not 8
-func testValidateBCRecordType(t testing.TB) {
-	bc := mockBatchControl()
-	bc.recordType = "2"
-	err := bc.Validate()
-	if !base.Match(err, NewErrRecordType(7)) {
-		t.Errorf("%T: %s", err, err)
-	}
-}
-
-// TestValidateBCRecordType tests ensuring an error if recordType is not 8
-func TestValidateBCRecordType(t *testing.T) {
-	testValidateBCRecordType(t)
-}
-
-// BenchmarkValidateBCRecordType benchmarks ensuring an error if recordType is not 8
-func BenchmarkValidateBCRecordType(b *testing.B) {
-	b.ReportAllocs()
-	for i := 0; i < b.N; i++ {
-		testValidateBCRecordType(b)
-	}
-}
-
 // testBCisServiceClassErr verifies service class code
 func testBCisServiceClassErr(t testing.TB) {
 	bc := mockBatchControl()
@@ -277,29 +248,6 @@ func BenchmarkBCMessageAuthenticationCodeAlphaNumeric(b *testing.B) {
 	}
 }
 
-// testBCFieldInclusionRecordType verifies Record Type is included
-func testBCFieldInclusionRecordType(t testing.TB) {
-	bc := mockBatchControl()
-	bc.recordType = ""
-	err := bc.Validate()
-	if !base.Match(err, ErrConstructor) {
-		t.Errorf("%T: %s", err, err)
-	}
-}
-
-// TestBCFieldInclusionRecordType tests verifying Record Type is included
-func TestBCFieldInclusionRecordType(t *testing.T) {
-	testBCFieldInclusionRecordType(t)
-}
-
-// BenchmarkBCFieldInclusionRecordType benchmarks verifying Record Type is included
-func BenchmarkBCFieldInclusionRecordType(b *testing.B) {
-	b.ReportAllocs()
-	for i := 0; i < b.N; i++ {
-		testBCFieldInclusionRecordType(b)
-	}
-}
-
 // testBCFieldInclusionServiceClassCode verifies Service Class Code is included
 func testBCFieldInclusionServiceClassCode(t testing.TB) {
 	bc := mockBatchControl()
diff --git a/batchHeader_test.go b/batchHeader_test.go
index 4ef4757a..97a3395f 100644
--- a/batchHeader_test.go
+++ b/batchHeader_test.go
@@ -85,9 +85,6 @@ func testParseBatchHeader(t testing.TB) {
 	}
 	record := r.currentBatch.GetHeader()
 
-	if record.recordType != "5" {
-		t.Errorf("RecordType Expected '5' got: %v", record.recordType)
-	}
 	if record.ServiceClassCode != DebitsOnly {
 		t.Errorf("ServiceClassCode Expected '225' got: %v", record.ServiceClassCode)
 	}
@@ -167,29 +164,6 @@ func BenchmarkBHString(b *testing.B) {
 	}
 }
 
-// testValidateBHRecordType validates error if recordType is not 5
-func testValidateBHRecordType(t testing.TB) {
-	bh := mockBatchHeader()
-	bh.recordType = "2"
-	err := bh.Validate()
-	if !base.Match(err, NewErrRecordType(5)) {
-		t.Errorf("%T: %s", err, err)
-	}
-}
-
-// TestValidateBHRecordType tests validating error if recordType is not 5
-func TestValidateBHRecordType(t *testing.T) {
-	testValidateBHRecordType(t)
-}
-
-// BenchmarkValidateBHRecordType benchmarks validating error if recordType is not 5
-func BenchmarkValidateBHRecordType(b *testing.B) {
-	b.ReportAllocs()
-	for i := 0; i < b.N; i++ {
-		testValidateBHRecordType(b)
-	}
-}
-
 // testInvalidServiceCode validates error if service code is not valid
 func testInvalidServiceCode(t testing.TB) {
 	bh := mockBatchHeader()
@@ -375,29 +349,6 @@ func BenchmarkBatchCompanyEntryDescriptionAlphaNumeric(b *testing.B) {
 	}
 }
 
-// testBHFieldInclusionRecordType validates record type field inclusion
-func testBHFieldInclusionRecordType(t testing.TB) {
-	bh := mockBatchHeader()
-	bh.recordType = ""
-	err := bh.Validate()
-	if !base.Match(err, ErrConstructor) {
-		t.Errorf("%T: %s", err, err)
-	}
-}
-
-// TestBHFieldInclusionRecordType tests validating record type field inclusion
-func TestBHFieldInclusionRecordType(t *testing.T) {
-	testBHFieldInclusionRecordType(t)
-}
-
-// BenchmarkBHFieldInclusionRecordType benchmarks validating record type field inclusion
-func BenchmarkBHFieldInclusionRecordType(b *testing.B) {
-	b.ReportAllocs()
-	for i := 0; i < b.N; i++ {
-		testBHFieldInclusionRecordType(b)
-	}
-}
-
 // testBHFieldInclusionCompanyName validates company name field inclusion
 func testBHFieldInclusionCompanyName(t testing.TB) {
 	bh := mockBatchHeader()
diff --git a/batchPOP_test.go b/batchPOP_test.go
index 11e39e3b..066b8e0e 100644
--- a/batchPOP_test.go
+++ b/batchPOP_test.go
@@ -427,9 +427,9 @@ func BenchmarkBatchPOPAddendaCount(b *testing.B) {
 // testBatchPOPInvalidBuild validates an invalid batch build
 func testBatchPOPInvalidBuild(t testing.TB) {
 	mockBatch := mockBatchPOP()
-	mockBatch.GetHeader().recordType = "3"
+	mockBatch.GetHeader().ServiceClassCode = 3
 	err := mockBatch.Create()
-	if !base.Match(err, NewErrRecordType(5)) {
+	if !base.Match(err, ErrServiceClass) {
 		t.Errorf("%T: %s", err, err)
 	}
 }
diff --git a/batchPOS_test.go b/batchPOS_test.go
index 750756a8..e2517711 100644
--- a/batchPOS_test.go
+++ b/batchPOS_test.go
@@ -367,11 +367,11 @@ func testBatchPOSInvalidAddenda(t testing.TB) {
 	mockBatch := NewBatchPOS(mockBatchPOSHeader())
 	mockBatch.AddEntry(mockPOSEntryDetail())
 	addenda02 := mockAddenda02()
-	addenda02.recordType = "63"
+	addenda02.TypeCode = "63"
 	mockBatch.GetEntries()[0].Addenda02 = addenda02
 	mockBatch.Entries[0].AddendaRecordIndicator = 1
 	err := mockBatch.Create()
-	if !base.Match(err, NewErrRecordType(7)) {
+	if !base.Match(err, ErrAddendaTypeCode) {
 		t.Errorf("%T: %s", err, err)
 	}
 }
@@ -392,9 +392,9 @@ func BenchmarkBatchPOSInvalidAddenda(b *testing.B) {
 // testBatchPOSInvalidBuild validates an invalid batch build
 func testBatchPOSInvalidBuild(t testing.TB) {
 	mockBatch := mockBatchPOS()
-	mockBatch.GetHeader().recordType = "3"
+	mockBatch.GetHeader().ServiceClassCode = 3
 	err := mockBatch.Create()
-	if !base.Match(err, NewErrRecordType(5)) {
+	if !base.Match(err, ErrServiceClass) {
 		t.Errorf("%T: %s", err, err)
 	}
 }
diff --git a/batchRCK_test.go b/batchRCK_test.go
index 45273feb..2af62570 100644
--- a/batchRCK_test.go
+++ b/batchRCK_test.go
@@ -397,9 +397,9 @@ func BenchmarkBatchRCKParseCheckSerialNumber(b *testing.B) {
 // testBatchRCKInvalidBuild validates an invalid batch build
 func testBatchRCKInvalidBuild(t testing.TB) {
 	mockBatch := mockBatchRCK()
-	mockBatch.GetHeader().recordType = "3"
+	mockBatch.GetHeader().ServiceClassCode = 3
 	err := mockBatch.Create()
-	if !base.Match(err, NewErrRecordType(5)) {
+	if !base.Match(err, ErrServiceClass) {
 		t.Errorf("%T: %s", err, err)
 	}
 }
diff --git a/batchSHR_test.go b/batchSHR_test.go
index 67ad1ecb..b6956d2a 100644
--- a/batchSHR_test.go
+++ b/batchSHR_test.go
@@ -353,11 +353,11 @@ func testBatchSHRInvalidAddenda(t testing.TB) {
 	mockBatch := NewBatchSHR(mockBatchSHRHeader())
 	mockBatch.AddEntry(mockSHREntryDetail())
 	addenda02 := mockAddenda02()
-	addenda02.recordType = "63"
+	addenda02.TypeCode = "63"
 	mockBatch.GetEntries()[0].Addenda02 = addenda02
 	mockBatch.Entries[0].AddendaRecordIndicator = 1
 	err := mockBatch.Create()
-	if !base.Match(err, NewErrRecordType(7)) {
+	if !base.Match(err, ErrAddendaTypeCode) {
 		t.Errorf("%T: %s", err, err)
 	}
 }
@@ -378,9 +378,9 @@ func BenchmarkBatchSHRInvalidAddenda(b *testing.B) {
 // testBatchSHRInvalidBuild validates an invalid batch build
 func testBatchSHRInvalidBuild(t testing.TB) {
 	mockBatch := mockBatchSHR()
-	mockBatch.GetHeader().recordType = "3"
+	mockBatch.GetHeader().ServiceClassCode = 3
 	err := mockBatch.Create()
-	if !base.Match(err, NewErrRecordType(5)) {
+	if !base.Match(err, ErrServiceClass) {
 		t.Errorf("%T: %s", err, err)
 	}
 }
diff --git a/batchTRC_test.go b/batchTRC_test.go
index caec9b51..a9235031 100644
--- a/batchTRC_test.go
+++ b/batchTRC_test.go
@@ -329,9 +329,9 @@ func BenchmarkBatchTRCAddendaCount(b *testing.B) {
 // testBatchTRCInvalidBuild validates an invalid batch build
 func testBatchTRCInvalidBuild(t testing.TB) {
 	mockBatch := mockBatchTRC()
-	mockBatch.GetHeader().recordType = "3"
+	mockBatch.GetHeader().ServiceClassCode = 3
 	err := mockBatch.Create()
-	if !base.Match(err, NewErrRecordType(5)) {
+	if !base.Match(err, ErrServiceClass) {
 		t.Errorf("%T: %s", err, err)
 	}
 }
diff --git a/batchTRX_test.go b/batchTRX_test.go
index 92b67049..daad92c8 100644
--- a/batchTRX_test.go
+++ b/batchTRX_test.go
@@ -258,16 +258,16 @@ func BenchmarkBatchTRXInvalidAddendum(b *testing.B) {
 	}
 }
 
-// testBatchTRXInvalidAddenda validates Addendum must be Addenda05 with record type 7
+// testBatchTRXInvalidAddenda validates Addendum must be Addenda05 with type code 05
 func testBatchTRXInvalidAddenda(t testing.TB) {
 	mockBatch := NewBatchTRX(mockBatchTRXHeader())
 	mockBatch.AddEntry(mockTRXEntryDetail())
 	addenda05 := mockAddenda05()
-	addenda05.recordType = "63"
+	addenda05.TypeCode = "63"
 	mockBatch.GetEntries()[0].AddAddenda05(addenda05)
 	mockBatch.Entries[0].AddendaRecordIndicator = 1
 	err := mockBatch.Create()
-	if !base.Match(err, NewErrRecordType(7)) {
+	if !base.Match(err, ErrAddendaTypeCode) {
 		t.Errorf("%T: %s", err, err)
 	}
 }
@@ -288,9 +288,9 @@ func BenchmarkBatchTRXInvalidAddenda(b *testing.B) {
 // testBatchTRXInvalidBuild validates an invalid batch build
 func testBatchTRXInvalidBuild(t testing.TB) {
 	mockBatch := mockBatchTRX()
-	mockBatch.GetHeader().recordType = "3"
+	mockBatch.GetHeader().ServiceClassCode = 3
 	err := mockBatch.Create()
-	if !base.Match(err, NewErrRecordType(5)) {
+	if !base.Match(err, ErrServiceClass) {
 		t.Errorf("%T: %s", err, err)
 	}
 }
diff --git a/batchXCK_test.go b/batchXCK_test.go
index ea4c7748..1fb20d58 100644
--- a/batchXCK_test.go
+++ b/batchXCK_test.go
@@ -329,9 +329,9 @@ func BenchmarkBatchXCKAddendaCount(b *testing.B) {
 // testBatchXCKInvalidBuild validates an invalid batch build
 func testBatchXCKInvalidBuild(t testing.TB) {
 	mockBatch := mockBatchXCK()
-	mockBatch.GetHeader().recordType = "3"
+	mockBatch.GetHeader().ServiceClassCode = 3
 	err := mockBatch.Create()
-	if !base.Match(err, NewErrRecordType(5)) {
+	if !base.Match(err, ErrServiceClass) {
 		t.Errorf("%T: %s", err, err)
 	}
 }
diff --git a/entryDetail_test.go b/entryDetail_test.go
index 45aed451..6e51f882 100644
--- a/entryDetail_test.go
+++ b/entryDetail_test.go
@@ -92,9 +92,6 @@ func testParseEntryDetail(t testing.TB) {
 	}
 	record := r.currentBatch.GetEntries()[0]
 
-	if record.recordType != "6" {
-		t.Errorf("RecordType Expected '6' got: %v", record.recordType)
-	}
 	if record.TransactionCode != CheckingDebit {
 		t.Errorf("TransactionCode Expected '27' got: %v", record.TransactionCode)
 	}
@@ -174,29 +171,6 @@ func BenchmarkEDString(b *testing.B) {
 	}
 }
 
-// testValidateEDRecordType validates error if recordType is not 6
-func testValidateEDRecordType(t testing.TB) {
-	ed := mockEntryDetail()
-	ed.recordType = "2"
-	err := ed.Validate()
-	if !base.Match(err, NewErrRecordType(6)) {
-		t.Errorf("%T: %s", err, err)
-	}
-}
-
-// TestValidateEDRecordType tests validating error if recordType is not 6
-func TestValidateEDRecordType(t *testing.T) {
-	testValidateEDRecordType(t)
-}
-
-// BenchmarkValidateEDRecordType benchmarks validating error if recordType is not 6
-func BenchmarkValidateEDRecordType(b *testing.B) {
-	b.ReportAllocs()
-	for i := 0; i < b.N; i++ {
-		testValidateEDRecordType(b)
-	}
-}
-
 // testValidateEDTransactionCode validates error if transaction code is not valid
 func testValidateEDTransactionCode(t testing.TB) {
 	ed := mockEntryDetail()
@@ -391,29 +365,6 @@ func BenchmarkEDSetRDFI(b *testing.B) {
 	}
 }
 
-// testEDFieldInclusionRecordType validates record type field inclusion
-func testEDFieldInclusionRecordType(t testing.TB) {
-	entry := mockEntryDetail()
-	entry.recordType = ""
-	err := entry.Validate()
-	if !base.Match(err, ErrConstructor) {
-		t.Errorf("%T: %s", err, err)
-	}
-}
-
-// TestEDFieldInclusionRecordType tests validating record type field inclusion
-func TestEDFieldInclusionRecordType(t *testing.T) {
-	testEDFieldInclusionRecordType(t)
-}
-
-// BenchmarkEDFieldInclusionRecordType benchmarks validating record type field inclusion
-func BenchmarkEDFieldInclusionRecordType(b *testing.B) {
-	b.ReportAllocs()
-	for i := 0; i < b.N; i++ {
-		testEDFieldInclusionRecordType(b)
-	}
-}
-
 // testEDFieldInclusionTransactionCode validates transaction code field inclusion
 func testEDFieldInclusionTransactionCode(t testing.TB) {
 	entry := mockEntryDetail()
diff --git a/examples/testdata/contested-return.ach b/examples/testdata/contested-return.ach
index 1f0dbd56..d53bd05f 100644
--- a/examples/testdata/contested-return.ach
+++ b/examples/testdata/contested-return.ach
@@ -1,4 +1,4 @@
-101 231380104 1210428822203311019A094101Federal Reserve Bank   My Bank Name                   
+101 231380104 1210428822208172357A094101Federal Reserve Bank   My Bank Name                   
 5220ACME Corporation                    121042882 PPDPAYROLL         000000   1121042880000001
 622121042882123456789        0100000000ABC##jvkdjfuiwnWade Arnold             1121042880000001
 799R07099912340000015      09101298Authorization Revoked                       000000000000000
diff --git a/examples/testdata/dishonored-return.ach b/examples/testdata/dishonored-return.ach
index 44d99231..39c2826c 100644
--- a/examples/testdata/dishonored-return.ach
+++ b/examples/testdata/dishonored-return.ach
@@ -1,4 +1,4 @@
-101 231380104 1210428822203310948A094101Federal Reserve Bank   My Bank Name                   
+101 231380104 1210428822208172357A094101Federal Reserve Bank   My Bank Name                   
 5225Payee Name                          231380104 POSACH POS         000000   1231380100000001
 627121042882744-5678-99      000002500045689033       Wade Arnold           011231380100000001
 799R68059999990000301      12391871   12391871000000117901Untimely Return      059999990000001
diff --git a/fileControl_test.go b/fileControl_test.go
index 70079eb3..b5cc4d2d 100644
--- a/fileControl_test.go
+++ b/fileControl_test.go
@@ -79,9 +79,6 @@ func testParseFileControl(t testing.TB) {
 	}
 	record := r.File.Control
 
-	if record.recordType != "9" {
-		t.Errorf("RecordType Expected '9' got: %v", record.recordType)
-	}
 	if record.BatchCountField() != "000001" {
 		t.Errorf("BatchCount Expected '000001' got: %v", record.BatchCountField())
 	}
@@ -100,9 +97,6 @@ func testParseFileControl(t testing.TB) {
 	if record.TotalCreditEntryDollarAmountInFileField() != "000000000000" {
 		t.Errorf("TotalCreditEntryDollarAmountInFile Expected '000000000000' got: %v", record.TotalCreditEntryDollarAmountInFileField())
 	}
-	if record.reserved != "                                       " {
-		t.Errorf("Reserved Expected '                                       ' got: %v", record.reserved)
-	}
 }
 
 // TestParseFileControl tests parsing a known file control record string
@@ -146,30 +140,6 @@ func BenchmarkFCString(b *testing.B) {
 	}
 }
 
-// testValidateFCRecordType validates error if recordType is not 9
-func testValidateFCRecordType(t testing.TB) {
-	fc := mockFileControl()
-	fc.recordType = "2"
-
-	err := fc.Validate()
-	if !base.Match(err, NewErrRecordType(9)) {
-		t.Errorf("%T: %s", err, err)
-	}
-}
-
-// TestValidateFCRecordType tests validating error if recordType is not 9
-func TestValidateFCRecordType(t *testing.T) {
-	testValidateFCRecordType(t)
-}
-
-// BenchmarkValidateFCRecordType benchmarks validating error if recordType is not 9
-func BenchmarkValidateFCRecordType(b *testing.B) {
-	b.ReportAllocs()
-	for i := 0; i < b.N; i++ {
-		testValidateFCRecordType(b)
-	}
-}
-
 // testFCFieldInclusion validates file control field inclusion
 func testFCFieldInclusion(t testing.TB) {
 	fc := mockFileControl()
@@ -193,29 +163,6 @@ func BenchmarkFCFieldInclusion(b *testing.B) {
 	}
 }
 
-// testFCFieldInclusionRecordType validates file control record type field inclusion
-func testFCFieldInclusionRecordType(t testing.TB) {
-	fc := mockFileControl()
-	fc.recordType = ""
-	err := fc.Validate()
-	if !base.Match(err, ErrConstructor) {
-		t.Errorf("%T: %s", err, err)
-	}
-}
-
-// TestFCFieldInclusionRecordType tests validating file control record type field inclusion
-func TestFCFieldInclusionRecordType(t *testing.T) {
-	testFCFieldInclusionRecordType(t)
-}
-
-// BenchmarkFCFieldInclusionRecordType benchmarks tests validating file control record type field inclusion
-func BenchmarkFCFieldInclusionRecordType(b *testing.B) {
-	b.ReportAllocs()
-	for i := 0; i < b.N; i++ {
-		testFCFieldInclusionRecordType(b)
-	}
-}
-
 // testFCFieldInclusionBlockCount validates file control block count field inclusion
 func testFCFieldInclusionBlockCount(t testing.TB) {
 	fc := mockFileControl()
diff --git a/fileHeader_test.go b/fileHeader_test.go
index 88eade83..31e61faf 100644
--- a/fileHeader_test.go
+++ b/fileHeader_test.go
@@ -184,9 +184,6 @@ func parseFileHeader(t testing.TB) {
 	}
 	record := r.File.Header
 
-	if record.recordType != "1" {
-		t.Errorf("RecordType Expected 1 got: %v", record.recordType)
-	}
 	if record.priorityCode != "01" {
 		t.Errorf("PriorityCode Expected 01 got: %v", record.priorityCode)
 	}
@@ -265,29 +262,6 @@ func BenchmarkFHString(b *testing.B) {
 	}
 }
 
-// testValidateFHRecordType validates error if record type is not 1
-func testValidateFHRecordType(t testing.TB) {
-	fh := mockFileHeader()
-	fh.recordType = "2"
-	err := fh.Validate()
-	if !base.Match(err, NewErrRecordType(1)) {
-		t.Errorf("%T: %s", err, err)
-	}
-}
-
-// TestValidateFHRecordType tests validating error if record type is not 1
-func TestValidateFHRecordType(t *testing.T) {
-	testValidateFHRecordType(t)
-}
-
-// BenchmarkValidateFHRecordType benchmarks validating error if record type is not 1
-func BenchmarkValidateFHRecordType(b *testing.B) {
-	b.ReportAllocs()
-	for i := 0; i < b.N; i++ {
-		testValidateFHRecordType(b)
-	}
-}
-
 // testValidateIDModifier validates ID modifier is upper alphanumeric
 func testValidateIDModifier(t testing.TB) {
 	fh := mockFileHeader()
@@ -507,29 +481,6 @@ func BenchmarkImmediateReferenceCodeAlphaNumeric(b *testing.B) {
 	}
 }
 
-// testFHFieldInclusionRecordType validates field inclusion
-func testFHFieldInclusionRecordType(t testing.TB) {
-	fh := mockFileHeader()
-	fh.recordType = ""
-	err := fh.Validate()
-	if !base.Match(err, ErrConstructor) {
-		t.Errorf("%T: %s", err, err)
-	}
-}
-
-// TestFHFieldInclusionRecordType tests validating field inclusion
-func TestFHFieldInclusionRecordType(t *testing.T) {
-	testFHFieldInclusionRecordType(t)
-}
-
-// BenchmarkFHFieldInclusionRecordType benchmarks validating field inclusion
-func BenchmarkFHFieldInclusionRecordType(b *testing.B) {
-	b.ReportAllocs()
-	for i := 0; i < b.N; i++ {
-		testFHFieldInclusionRecordType(b)
-	}
-}
-
 // testFHFieldInclusionImmediateDestination validates immediate destination field inclusion
 func testFHFieldInclusionImmediateDestination(t testing.TB) {
 	fh := mockFileHeader()
diff --git a/file_test.go b/file_test.go
index 88bb1d02..8b14a09c 100644
--- a/file_test.go
+++ b/file_test.go
@@ -106,7 +106,7 @@ func TestFileEmptyError(t *testing.T) {
 	}
 	err := file.Validate()
 	msg := err.Error()
-	if !strings.HasPrefix(msg, "recordType") || !strings.Contains(msg, "is a mandatory field") {
+	if !strings.HasPrefix(msg, "ImmediateDestination") || !strings.Contains(msg, "is a mandatory field") {
 		t.Errorf("got %q", err)
 	}
 }
@@ -913,9 +913,9 @@ func TestFileADVBlockCount10(t *testing.T) {
 func TestFileADVControlValidate(t *testing.T) {
 	file := mockFileADV()
 
-	file.ADVControl.recordType = "22"
+	file.ADVControl.TotalDebitEntryDollarAmountInFile = -100
 	err := file.Validate()
-	if !base.Match(err, NewErrRecordType(9)) {
+	if !base.Match(err, NewErrFileCalculatedControlEquality("TotalDebitEntryDollarAmountInFile", 0, 0)) {
 		t.Errorf("%T: %s", err, err)
 	}
 }
@@ -924,9 +924,9 @@ func TestFileADVControlValidate(t *testing.T) {
 func TestFileControlValidate(t *testing.T) {
 	file := mockFilePPD()
 
-	file.Control.recordType = "22"
+	file.Control.TotalDebitEntryDollarAmountInFile = 22
 	err := file.Validate()
-	if !base.Match(err, NewErrRecordType(9)) {
+	if !base.Match(err, NewErrFileCalculatedControlEquality("TotalDebitEntryDollarAmountInFile", 0, 22)) {
 		t.Errorf("%T: %s", err, err)
 	}
 }
diff --git a/iatBatchHeader_test.go b/iatBatchHeader_test.go
index f16d4256..bdca78b0 100644
--- a/iatBatchHeader_test.go
+++ b/iatBatchHeader_test.go
@@ -134,9 +134,6 @@ func testParseIATBatchHeader(t testing.TB) {
 	}
 	record := r.IATCurrentBatch.GetHeader()
 
-	if record.recordType != "5" {
-		t.Errorf("RecordType Expected '5' got: %v", record.recordType)
-	}
 	if record.ServiceClassCode != CreditsOnly {
 		t.Errorf("ServiceClassCode Expected '220' got: %v", record.ServiceClassCode)
 	}
@@ -254,29 +251,6 @@ func BenchmarkIATBHFVString(b *testing.B) {
 	}
 }
 
-// testValidateIATBHRecordType validates error if IATBatchHeader recordType is invalid
-func testValidateIATBHRecordType(t testing.TB) {
-	bh := mockIATBatchHeaderFF()
-	bh.recordType = "2"
-	err := bh.Validate()
-	if !base.Match(err, NewErrRecordType(5)) {
-		t.Errorf("%T: %s", err, err)
-	}
-}
-
-// TestValidateIATBHRecordType tests validating error if IATBatchHeader recordType is invalid
-func TestValidateIATBHRecordType(t *testing.T) {
-	testValidateIATBHRecordType(t)
-}
-
-// BenchmarkValidateIATBHRecordType benchmarks validating error if IATBatchHeader recordType is invalid
-func BenchmarkValidateIATBHRecordType(b *testing.B) {
-	b.ReportAllocs()
-	for i := 0; i < b.N; i++ {
-		testValidateIATBHRecordType(b)
-	}
-}
-
 // testValidateIATBHServiceClassCode validates error if IATBatchHeader
 // ServiceClassCode is invalid
 func testValidateIATBHServiceClassCode(t testing.TB) {
@@ -540,29 +514,6 @@ func BenchmarkValidateIATBHOriginatorStatusCode(b *testing.B) {
 
 //FieldInclusion
 
-// testIATBHRecordType validates IATBatchHeader recordType fieldInclusion
-func testIATBHRecordType(t testing.TB) {
-	bh := mockIATBatchHeaderFF()
-	bh.recordType = ""
-	err := bh.Validate()
-	if !base.Match(err, ErrFieldInclusion) {
-		t.Errorf("%T: %s", err, err)
-	}
-}
-
-// TestIATBHRecordType tests validating IATBatchHeader recordType fieldInclusion
-func TestIATBHRecordType(t *testing.T) {
-	testIATBHRecordType(t)
-}
-
-// BenchmarkIATBHRecordType benchmarks validating IATBatchHeader recordType fieldInclusion
-func BenchmarkIATBHRecordType(b *testing.B) {
-	b.ReportAllocs()
-	for i := 0; i < b.N; i++ {
-		testIATBHRecordType(b)
-	}
-}
-
 // testIATBHServiceClassCode validates IATBatchHeader ServiceClassCode fieldInclusion
 func testIATBHServiceClassCode(t testing.TB) {
 	bh := mockIATBatchHeaderFF()
diff --git a/iatBatch_test.go b/iatBatch_test.go
index d025db79..bf4d5b06 100644
--- a/iatBatch_test.go
+++ b/iatBatch_test.go
@@ -670,7 +670,7 @@ func BenchmarkIATBatchDebitIsBatchAmount(b *testing.B) {
 func testIATBatchFieldInclusion(t testing.TB) {
 	mockBatch := mockIATBatch(t)
 	mockBatch2 := mockIATBatch(t)
-	mockBatch2.Header.recordType = "4"
+	mockBatch2.Header.ServiceClassCode = 4
 
 	err := mockBatch.verify()
 	// no errors expected
@@ -678,11 +678,11 @@ func testIATBatchFieldInclusion(t testing.TB) {
 		t.Errorf("%T: %s", err, err)
 	}
 	err = mockBatch2.verify()
-	if !base.Match(err, NewErrRecordType(5)) {
+	if !base.Match(err, ErrServiceClass) {
 		t.Errorf("%T: %s", err, err)
 	}
 	err = mockBatch2.build()
-	if !base.Match(err, NewErrRecordType(5)) {
+	if !base.Match(err, ErrServiceClass) {
 		t.Errorf("%T: %s", err, err)
 	}
 }
@@ -954,10 +954,10 @@ func BenchmarkIATBatchCategory(b *testing.B) {
 // testIATBatchValidateEntry validates EntryDetail
 func testIATBatchValidateEntry(t testing.TB) {
 	mockBatch := mockIATBatch(t)
-	mockBatch.GetEntries()[0].recordType = "5"
+	mockBatch.GetEntries()[0].TransactionCode = 5
 
 	err := mockBatch.verify()
-	if !base.Match(err, NewErrRecordType(6)) {
+	if !base.Match(err, ErrTransactionCode) {
 		t.Errorf("%T: %s", err, err)
 	}
 }
@@ -1170,10 +1170,10 @@ func BenchmarkIATBatchValidateAddenda17(b *testing.B) {
 func testIATBatchCreate(t testing.TB) {
 	file := NewFile().SetHeader(mockFileHeader())
 	mockBatch := mockIATBatch(t)
-	mockBatch.GetHeader().recordType = "7"
+	mockBatch.GetHeader().ServiceClassCode = 7
 
 	err := mockBatch.Create()
-	if !base.Match(err, NewErrRecordType(5)) {
+	if !base.Match(err, ErrServiceClass) {
 		t.Errorf("%T: %s", err, err)
 	}
 
@@ -1782,7 +1782,7 @@ func TestIATBatchAddenda98RecordType(t *testing.T) {
 	mockBatch.GetEntries()[0].TransactionCode = CheckingReturnNOCCredit
 	mockBatch.GetEntries()[0].AddendaRecords = 2
 	addenda98 := mockAddenda98()
-	addenda98.recordType = "00"
+	addenda98.TypeCode = "00"
 	mockBatch.GetEntries()[0].Addenda98 = addenda98
 	mockBatch.GetEntries()[0].Category = CategoryNOC
 
@@ -1791,7 +1791,7 @@ func TestIATBatchAddenda98RecordType(t *testing.T) {
 	}
 
 	err := mockBatch.Validate()
-	if !base.Match(err, NewErrRecordType(7)) {
+	if !base.Match(err, ErrAddendaTypeCode) {
 		t.Errorf("%T: %s", err, err)
 	}
 }
@@ -1802,7 +1802,7 @@ func TestIATBatchAddenda99RecordType(t *testing.T) {
 	mockBatch.SetHeader(mockIATReturnBatchHeaderFF())
 	mockBatch.GetEntries()[0].AddendaRecords = 1
 	addenda99 := mockAddenda99()
-	addenda99.recordType = "00"
+	addenda99.TypeCode = "00"
 	mockBatch.GetEntries()[0].Addenda99 = addenda99
 	mockBatch.GetEntries()[0].Category = CategoryReturn
 
@@ -1811,7 +1811,7 @@ func TestIATBatchAddenda99RecordType(t *testing.T) {
 	}
 
 	err := mockBatch.Validate()
-	if !base.Match(err, NewErrRecordType(7)) {
+	if !base.Match(err, ErrAddendaTypeCode) {
 		t.Errorf("%T: %s", err, err)
 	}
 }
@@ -1821,7 +1821,7 @@ func TestIATBatchAddenda18RecordType(t *testing.T) {
 	mockBatch := mockIATBatch(t)
 	mockBatch.SetHeader(mockIATReturnBatchHeaderFF())
 	addenda18 := mockAddenda18()
-	addenda18.recordType = "00"
+	addenda18.TypeCode = "00"
 	mockBatch.GetEntries()[0].AddAddenda18(addenda18)
 
 	if err := mockBatch.build(); err != nil {
@@ -1829,7 +1829,7 @@ func TestIATBatchAddenda18RecordType(t *testing.T) {
 	}
 
 	err := mockBatch.Validate()
-	if !base.Match(err, NewErrRecordType(7)) {
+	if !base.Match(err, ErrAddendaTypeCode) {
 		t.Errorf("%T: %s", err, err)
 	}
 }
diff --git a/iatEntryDetail_test.go b/iatEntryDetail_test.go
index dbf24653..0c71de5f 100644
--- a/iatEntryDetail_test.go
+++ b/iatEntryDetail_test.go
@@ -102,9 +102,6 @@ func testParseIATEntryDetail(t testing.TB) {
 	}
 	record := r.IATCurrentBatch.GetEntries()[0]
 
-	if record.recordType != "6" {
-		t.Errorf("RecordType Expected '6' got: %v", record.recordType)
-	}
 	if record.TransactionCode != CheckingCredit {
 		t.Errorf("TransactionCode Expected '22' got: %v", record.TransactionCode)
 	}
@@ -178,29 +175,6 @@ func BenchmarkIATEDString(b *testing.B) {
 	}
 }
 
-// testIATEDInvalidRecordType validates error for IATEntryDetail invalid recordType
-func testIATEDInvalidRecordType(t testing.TB) {
-	iatEd := mockIATEntryDetail()
-	iatEd.recordType = "2"
-	err := iatEd.Validate()
-	if !base.Match(err, NewErrRecordType(6)) {
-		t.Errorf("%T: %s", err, err)
-	}
-}
-
-// TestIATEDInvalidRecordType  tests validating error for IATEntryDetail invalid recordType
-func TestIATEDInvalidRecordType(t *testing.T) {
-	testIATEDInvalidRecordType(t)
-}
-
-// BenchmarkIATEDRecordType benchmarks validating error for IATEntryDetail invalid recordType
-func BenchmarkIATEDInvalidRecordType(b *testing.B) {
-	b.ReportAllocs()
-	for i := 0; i < b.N; i++ {
-		testIATEDInvalidRecordType(b)
-	}
-}
-
 // testIATEDInvalidTransactionCode validates error for IATEntryDetail invalid TransactionCode
 func testIATEDInvalidTransactionCode(t testing.TB) {
 	iatEd := mockIATEntryDetail()
@@ -318,29 +292,6 @@ func BenchmarkValidateEDIATCheckDigit(b *testing.B) {
 	}
 }
 
-// testIATEDRecordType validates IATEntryDetail recordType fieldInclusion
-func testIATEDRecordType(t testing.TB) {
-	iatEd := mockIATEntryDetail()
-	iatEd.recordType = ""
-	err := iatEd.Validate()
-	if !base.Match(err, ErrConstructor) {
-		t.Errorf("%T: %s", err, err)
-	}
-}
-
-// TestIATEDRecordType tests validating IATEntryDetail recordType fieldInclusion
-func TestIATEDRecordType(t *testing.T) {
-	testIATEDRecordType(t)
-}
-
-// BenchmarkIATEDRecordType benchmarks validating IATEntryDetail recordType fieldInclusion
-func BenchmarkIATEDRecordType(b *testing.B) {
-	b.ReportAllocs()
-	for i := 0; i < b.N; i++ {
-		testIATEDRecordType(b)
-	}
-}
-
 // testIATEDTransactionCode validates IATEntryDetail TransactionCode fieldInclusion
 func testIATEDTransactionCode(t testing.TB) {
 	iatEd := mockIATEntryDetail()
diff --git a/writer_test.go b/writer_test.go
index adbd9e3f..8a30b80a 100644
--- a/writer_test.go
+++ b/writer_test.go
@@ -727,7 +727,7 @@ func TestWriteWithCustomLineEnding(t *testing.T) {
 
 func TestWriteBypassValidation(t *testing.T) {
 	file := mockFilePPD()
-	file.Header.recordType = "" // make the file fail Nacha validation
+	file.Header.FileCreationDate = "abc" // make the file fail Nacha validation
 
 	writer := NewWriter(&bytes.Buffer{})
 	writer.BypassValidation = true