maxValueValidator
    minValueValidator

    /** 
    * use $formGroup in angular's formBuilder to make a model driven (reactive) form. 
    *   this.form = this.formBuilder.group({
    *       pet: this.pet.$formGroup,
    *   }); 
    */
    $formGroup: FormGroup;

    /** 
    * add one or more additional validators to the control
    * @param key Name of the control (is the same as the name of the attached model property) 
    * @param validators Validator(s) to add to the control 
    */
    addValidatorToControl(controlName: string, validators: ValidatorFn | ValidatorFn[]) {
        ...
    }
}

// THIS IS GENERATED CODE. DO NOT CHANGE MANUALLY!
/* tslint:disable */

import { Validators, FormControl, FormGroup, FormArray, ValidatorFn } from '@angular/forms';
import { minValueValidator, maxValueValidator } from './validators';
import { BaseModel } from './base-model';

import { type } from './enums';
import { gender } from './enums';
import { Address } from './address.model';
import { Veterinarian } from './veterinarian.model';
import { Tag } from './tag.model';
import { NullableOrEmpty } from './nullable-or-empty.model';

export interface IPet {
    name: string;
    age?: number;
    dob?: Date;
    type: type;
    gender?: gender;
    address?: Address;
    vet?: Veterinarian;
    tags?: Array<Tag>;
    isFavorate?: boolean;
    testDate?: NullableOrEmpty<Date>;
    primitiveArray?: Array<string>;
}

export class Pet extends BaseModel implements IPet {
    name: string;
    age: number;
    dob: Date;
    type: type;
    gender: gender;
    address: Address;
    vet: Veterinarian;
    tags: Array<Tag>;
    isFavorate: boolean;
    testDate: NullableOrEmpty<Date>;
    primitiveArray: Array<string>;

    /** 
    * constructor
    * @param values Can be used to set a webapi response to this newly constructed model   
    */
    constructor(values?: any) {
        super();
        this.address = new Address();
        this.vet = new Veterinarian();
        this.tags = new Array<Tag>();
        this.testDate = new NullableOrEmpty<Date>();
        this.primitiveArray = new Array<string>();
        if (values) {
            this.setValues(values);
        }
    }

    /** 
    * set the values.
    * @param values Can be used to set a webapi response to this newly constructed model
    */
    setValues(values: any): void {
        this.name = values.name;
        this.age = values.age;
        this.dob = values.dob;
        this.type = values.type;
        this.gender = values.gender;
        this.address.setValues(values.address);
        this.vet.setValues(values.vet);
        this.fillModelArray<Tag>(this, 'tags', values.tags, Tag);
        this.isFavorate = values.isFavorate;
        this.testDate.setValues(values.testDate);
        this.fillModelArray<string>(this, 'primitiveArray', values.primitiveArray);
    }

    protected getFormGroup(): FormGroup {
        if (!this._formGroup) {
            this._formGroup = new FormGroup({
                name: new FormControl(this.name, [Validators.required, Validators.minLength(4), Validators.pattern('^[a-zA-Z0-9- ]+$'), ]),
                age: new FormControl(this.age),
                dob: new FormControl(this.dob),
                type: new FormControl(this.type, [Validators.required, ]),
                gender: new FormControl(this.gender),
                address: this.address.$formGroup,
                vet: this.vet.$formGroup,
                tags: new FormArray([]),
                isFavorate: new FormControl(this.isFavorate),
                testDate: this.testDate.$formGroup,
                primitiveArray: new FormArray([]),
            });

            // generate FormArray control elements
            this.fillFormArray<Tag>('tags', this.tags, Tag);
            this.fillFormArray<string>('primitiveArray', this.primitiveArray);
        }
        return this._formGroup;
    }
}

// THIS IS GENERATED CODE. DO NOT CHANGE MANUALLY!
/* tslint:disable */

// generate enum based on strings instead of numbers
// (see https://blog.rsuter.com/how-to-implement-an-enum-with-string-values-in-typescript/)
export enum type {
    cat = <any>"cat",
    dog = <any>"dog",
    bird = <any>"bird",
    whale = <any>"whale",
}

export enum gender {
    unknown = <any>"unknown",
    male = <any>"male",
    female = <any>"female",
}

export enum hairColor {
    red = <any>"red",
    blond = <any>"blond",
    brown = <any>"brown",
    black = <any>"black",
    white = <any>"white",
    gray = <any>"gray",
}

/**
* bundle of all enums for databinding to options, radio-buttons etc.
* usage in component:
*   import { AllEnums, minValueValidator, maxValueValidator } from '../../models/webapi';
*
*   @Component({
*       ... 
*   })
*   export class xxxComponent implements OnInit {
*       allEnums = AllEnums;
*       ...
*       ngOnInit() {
*           this.allEnums = AllEnums.instance;
*       }
*   }
*/
export class AllEnums {
    private static _instance: AllEnums = new AllEnums();
    constructor() {
        if (AllEnums._instance) {
            throw new Error("Error: Instantiation failed: Use AllEnums.instance instead of new");
        }
        AllEnums._instance = this;
    }
    static get instance(): AllEnums {
        return AllEnums._instance;
    }

    type = type;
    gender = gender;
    hairColor = hairColor;
}

{
  "type": "-------ENUM-TYPE-------",
  "cat": "kat",
  "dog": "hond",
  "bird": "vogel",
  "whale": "whale",
  "gender": "-------ENUM-TYPE-------",
  "unknown": "onbekend",
  "male": "man",
  "female": "vrouw",
  "hairColor": "-------ENUM-TYPE-------",
  "red": "rood",
  "blond": "blond",
  "brown": "bruin",
  "black": "zwart",
  "white": "wit",
  "gray": "grijs"
}