// open a file for reading or pass any io.Reader NewReader()
f, err := os.Open("name-of-your-ach-file.ach")
if err != nil {
	log.Panicf("Can not open local file: %s: \n", err)
}
r := ach.NewReader(f)
achFile, err := r.Read()
if err != nil {
	fmt.Printf("Issue reading file: %+v \n", err)
}
// ensure we have a validated file structure
if achFile.Validate(); err != nil {
	fmt.Printf("Could not validate entire read file: %v", err)
}
// Check if any Notifications Of Change exist in the file 
if len(achFile.NotificationOfChange) > 0 {
	for _, batch := range achFile.NotificationOfChange {
		a98 := batch.GetEntries()[0].Addendum[0].(*Addenda98)
		println(a98.CorrectedData)
	} 
} 
// Check if any Return Entries exist in the file 
if len(achFile.ReturnEntries) > 0 {
	for _, batch := range achFile.ReturnEntries {
		aReturn := batch.GetEntries()[0].Addendum[0].(*Addenda99)
		println(aReturn.ReturnCode)
	} 
}

   fh := ach.NewFileHeader()
   fh.ImmediateDestination = "9876543210" // A blank space followed by your ODFI's transit/routing number
   fh.ImmediateOrigin = "1234567890"      // Organization or Company FED ID usually 1 and FEIN/SSN. Assigned by your ODFI
   fh.FileCreationDate = time.Now()     // Todays Date
   fh.ImmediateDestinationName = "Federal Reserve Bank"
   fh.ImmediateOriginName = "My Bank Name")

   file := ach.NewFile()
   file.SetHeader(fh)

func mockBatchPPDHeader() *BatchHeader {
   bh := NewBatchHeader()
   bh.ServiceClassCode = 220
   bh.StandardEntryClassCode = "PPD"
   bh.CompanyName = "ACME Corporation"
   bh.CompanyIdentification = "123456789"
   bh.CompanyEntryDescription = "PAYROLL"
   bh.EffectiveEntryDate = time.Now()
   bh.ODFIIdentification = "6200001"
   return bh
}

mockBatch := NewBatch(mockBatchPPDHeader())

func mockBatchPPDHeader() *BatchHeader {
   bh := NewBatchHeader()
   bh.ServiceClassCode = 220
   bh.StandardEntryClassCode = "PPD"
   bh.CompanyName = "ACME Corporation"
   bh.CompanyIdentification = "123456789"
   bh.CompanyEntryDescription = "PAYROLL"
   bh.EffectiveEntryDate = time.Now()
   bh.ODFIIdentification = "6200001"
   return bh
}

mockBatch, _ := ach.NewBatch(mockBatchPPDHeader())

entry := ach.NewEntryDetail()
entry.TransactionCode = 22
entry.SetRDFI("009101298")
entry.DFIAccountNumber = "123456789"
entry.Amount = 100000000
entry.IndividualName = "Wade Arnold"
entry.SetTraceNumber(bh.ODFIIdentification, 1)
entry.IdentificationNumber = "ABC##jvkdjfuiwn"
entry.Category = ach.CategoryForward

addenda := NewAddenda05()
addenda.PaymentRelatedInformation = "Bonus pay for amazing work on #OSS"

entry.AddAddenda(addenda)

batch.AddEntry(entry)

if err := batch.Create(); err != nil {
   fmt.Printf("%T: %s", err, err)
}

file.AddBatch(batch)

func mockBatchWEBHeader() *BatchHeader {
	bh := NewBatchHeader()
	bh.ServiceClassCode = 220
	bh.StandardEntryClassCode = "WEB"
	bh.CompanyName = "Your Company, inc"
	bh.CompanyIdentification = "123456789"
	bh.CompanyEntryDescription = "Online Order"
	bh.ODFIIdentification = "6200001"
	return bh
}

batch2, _ := ach.NewBatch(mockBatchWEBHeader())

entry2 := ach.NewEntryDetail()
entry2.TransactionCode = 22
entry2.SetRDFI(102001017)
entry2.DFIAccountNumber = "5343121"
entry2.Amount = 799
entry2.IndividualName = "Wade Arnold"
entry2.SetTraceNumber(bh.ODFIIdentification, 1)
entry2.IdentificationNumber = "#123456"
entry.DiscretionaryData = "R"
entry2.Category = ach.CategoryForward


addenda2 := NewAddenda05()
addenda2.PaymentRelatedInformation = "Monthly Membership Subscription"

entry2.AddAddenda(addenda2)

batch2.AddEntry(entry2)
if err := batch2.Create(); err != nil {
	fmt.Printf("%T: %s", err, err)
}
file.AddBatch(batch2)

if err := file.Create(); err != nil {
   fmt.Printf("%T: %s", err, err)
}

w := ach.NewWriter(os.Stdout)
if err := w.Write(file); err != nil {
   fmt.Printf("%T: %s", err, err)
}
w.Flush()
}

type BatchMTE struct {
	batch
}

func NewBatchMTE(bh *BatchHeader) *BatchMTE {
	batch := new(BatchMTE)
	batch.setControl(NewBatchControl)
	batch.SetHeader(bh)
	return batch
}

// Validate checks valid NACHA batch rules. Assumes properly parsed records.
func (batch *BatchMTE) Validate() error {
	// basic verification of the batch before we validate specific rules.
	if err := batch.verify(); err != nil {
		return err
	}
	// Add configuration based validation for this type.
	// ... batch.isAddendaCount(1)
	// Add type specific validation.
	// ...
	return nil
}

// Create takes Batch Header and Entries and builds a valid batch
func (batch *BatchMTE) Create() error {
	// generates sequence numbers and batch control
	if err := batch.build(); err != nil {
		return err
	}
	// Additional steps specific to batch type
	// ...

	if err := batch.Validate(); err != nil {
		return err
	}
	return nil
}

//...
case "MTE":
		return NewBatchMTE(bh), nil
//...