Q:

JSON object with nested objects, all needing to be casted to classes in Typescript/Angular 5

Have done quite a bit of research on this but my situation seems to be a tad more complex than other examples i've seen on stack.  I hope my explanation is clear enough to follow! 
The API response I am working with is structured as an array of Customers.  Each Customer has methods of its own as well as multiple nested objects.  For the purposes of this question I'll focus on the Addons nested object (so Customer. Addons).  Addons has some methods as well as an array of objects (addons).  Each array item is an Addon object.  So...I need to cast each level as the prototype of the associated Class.  
This seems to work fine for Customer: 
Object.setPrototypeOf(customer, Customer.prototype)

I am stuck on Addons even though I am using the same approach:
Object.setPrototypeOf(customer.addOns, Addons.prototype)

And for the array of addons (type Addon) I am iterating through like so.  THIS seems to be working fine as well:
_.each(customer.addOns, (addon: Addon) => {
    Object.setPrototypeOf(addon, Addon.prototype)
})

When I console.log this stuff, I can see that the Customer object is getting recognized as Customer.  I can see that array items are correctly getting recognized as type Addon, but the Addons object, that middle layer, seems to be a plain object. 
This image captures what I mean.  Parent object of type Customer, child named addons with an array of items all of type Addon:

Here is my Addons class.  It extends a generic class whose sole job is to have an array with some basic CRUD methods.  The getSubtotal method is just returning a hard coded number for now (for testing) but will ultimately iterate through the associated array in its super and add numbers.  
export class Addons extends PluralOfType<Addon> {

    constructor() {}

    ...

    getSubTotal(): number {
        // eventually will return _.reduce(super.arr, ...) etc
        return 10
    }

}

Here is a segment from the PluralOfType generic:
class PluralOfType<T> {

    public arr: T[] = [];

    getAll(): T[] { return this.arr };

    ...

}

In my other typescript files, if I do this:
console.log(customer.addOns)

I will get the array of addons, each of type Addon.  If I do this:
console.log(customer.addOns.getSubtotal())

I will get 10, which is correct.  If I do this, which is a method on addOns superclass: 
console.log(customer.addOns.getAll())

I get undefined.  Moreover, because arr is public in the superclass, unsure why I can't just call customer.addOns.arr.  
Clearly I am missing something here.  Hopefully it's a simple fix!  Appreciate any help.  

A:

Given some class object, class A {m(){}}, setting the prototype of an object, say o, to A.prototype does not construct A and then merge the resulting value's members into o. It just changes o's prototype.  In other words it sets up delegation of member lookup such that, if o does not have a requested member, say m, then A.prototype will be considered and A.prototype.m will be reolved.  
So, for
class PluralOfType {
  arr = [];
  getAll() {return this.arr;}
}

and 
class AddOns extends PluralOfType {
  getSubTotal() {return 10;}
}

if we write
const o = {};
Object.setPrototypeOf(o, AddOns.prototype);
console.log(o.getAll());

will print undefined because this is o in the expression this.arr.  
We would then  likely be tempted to write 
const addOnsArray = customer.addOns.slice();
Object.setPrototypeOf(customer.addOns, AddOns.prototype);
Object.assign(customer.addOns, new AddOns());

But that will make arr an empty array which isn't what we actually want.  
An unsound and dirty fix for the specific problem is to write
const addOnsArray = customer.addOns.slice();
Object.setPrototypeOf(customer.addOns, AddOns.prototype);
customer.addOns.arr = addOnsArray;

This in not general enough to be useful.  
The entire approach dramatically increases the odds of introducing very serious and difficult to find bugs.  It makes the system confusing. 
I'm not just talking about arrays, I mean all of it. 
You should scrap your entire approach.  Don't change the prototypes of any values returned by JSON.parse at all. 
You probably do not realize how hard you are making your task nor how much the people who inherit your project will hate you. 
My recommendation is that you not use classes to define the functionality.  If you really want to have methods in your objects add them to the objects directly.  However, it would be simpler to keep the functionality outside the objects either as free standing functions or as methods in services.  These would receive the object as an argument.  Sometimes it does make sense to have functions and data together but this does not work well with serialization. 