How to use the class-transformer.Type function in class-transformer

createTitle: translate('Add new group'),
    viewTitle: translate('Group #{{id}}'),
    updateTitle: translate('Update group #{{id}}'),
    deleteTitle: translate('Delete group #{{id}}'),
    deleteMessage: translate('Do you really want to delete group?'),
    selectTitle: translate('Select group')
  };
  // need for deep update if local change in any place
  static nested = {
    permissions: Permission
  };
  id: number = undefined;
  @IsNotEmpty()
  name: string = undefined;
  title: string = undefined;
  @Type(serializeModel(Permission))
  permissions: Permission[] = [];
  get permissionsAsString() {
    if (this.permissions) {
      const permissionsLength = this.permissions.length;
      if (permissionsLength > 14) {
        return (
          this.permissions.filter((item, index) => index < 7).join(', ') +
          (permissionsLength > 7 ? `... +${permissionsLength - 7}` : '')
        );
      }
      return this.permissions.join(', ');
    } else {
      return '';
    }
  }
  toString() {

description: translate('Description'),
    status: translate('Status'),
    openAt: translate('Open at'),
    closeAt: translate('Close at'),
    createdAt: translate('Created at'),
    updatedAt: translate('Updated at'),
    range: translate('Range'),
    createTitle: translate('Add new task'),
    viewTitle: translate('Task #{{id}}'),
    updateTitle: translate('Update task #{{id}}'),
    deleteTitle: translate('Delete task #{{id}}'),
    deleteMessage: translate('Do you really want to delete task?')
  };
  id: number = undefined;
  @IsNotEmpty()
  @Type(serializeModel(Project))
  @Transform(transformStringToObject, { toPlainOnly: true })
  project: Project = undefined;
  @IsNotEmpty()
  title: string = undefined;
  description: string = undefined;
  @IsNotEmpty()
  @Type(serializeModel(Status))
  @Transform(transformStringToObject, { toPlainOnly: true })
  status: Status = undefined;
  @Transform(transformStringToDate, { toClassOnly: true })
  @Transform(transformDateToString, { toPlainOnly: true })
  openAt: Date = undefined;
  @Transform(transformStringToDate, { toClassOnly: true })
  @Transform(transformDateToString, { toPlainOnly: true })
  closeAt: Date = undefined;
  @Transform(transformStringToDate, { toClassOnly: true })

export class Department {
  static strings = {
    id: 'Id',
    name: 'Name',
    company: 'Company'
  };

  id: number;

  @IsNotEmpty()
  name: string;

  @ValidateNested()
  @IsOptional()
  @Type(serializeModel(Company))
  company: Company;

  toString() {
    return this.name;
  }

  constructor(data?: any) {
    plainToClassFromExist(this, data);
  }
}

groups: [ProjectPanelStepsEnum.Step1]
  })
  name?: string = undefined;

  @IsNotEmpty({ always: true })
  description?: string = undefined;

  @ValidateNested({
    groups: [ProjectPanelStepsEnum.Step2]
  })
  @Validate(ObjectMustBeNotEmpty, [1, 3], {
    groups: [ProjectPanelStepsEnum.Step2],
    message: 'Tasks not initialized or min length = 1 and max length = 3, and all initialized tasks must be not empty'
  })
  @IsOptional()
  @Type(serializeModel(Task))
  tasks?: Task[] = [];

  toString() {
    return `Project #${this.id} ${this.name}`;
  }
}

firstName: string = undefined;
  lastName: string = undefined;
  @IsNotEmpty()
  @IsEmail(undefined)
  email: string = undefined;
  isSuperuser = false;
  isStaff = false;
  isActive = false;
  @Transform(transformStringToDate, { toClassOnly: true })
  @Transform(transformDateToString, { toPlainOnly: true })
  lastLogin: Date = undefined;
  @Transform(transformStringToDate, { toClassOnly: true })
  @Transform(transformDateToString, { toPlainOnly: true })
  dateJoined: Date = undefined;
  @IsOptional()
  @Type(serializeModel(Group))
  groups: Group[] = [];
  @Transform(transformStringToDate, { toClassOnly: true })
  @Transform(transformDateToString, { toPlainOnly: true })
  dateOfBirth: Date = undefined;
  get permissionNames() {
    const permissions = [];
    if (this.groups) {
      this.groups.forEach(group => group.permissions.forEach(permission => permissions.push(permission.name)));
    }
    return permissions;
  }
  toString() {
    return `${this.firstName} ${this.lastName} (${this.username})`.trim();
  }
  get fullName() {
    return `${this.firstName} ${this.lastName}`.trim();

import { Type } from 'class-transformer';
import { User } from '../../../models/user';
import { serializeModel } from '../../../utils/custom-transforms';

export class UserTokenDto {
  token: string;
  @Type(serializeModel(User))
  user: User;
}

id: number;

  @IsNotEmpty()
  username: string;
  password: string;

  @IsEmail()
  @IsNotEmpty()
  email: string;
  isSuperuser: boolean;
  isStaff: boolean;

  @ValidateNested()
  @IsOptional()
  @Type(serializeModel(Department))
  department: Department = new Department();

  @Transform(transformStringToDate, { toClassOnly: true })
  @Transform(transformDateToString, { toPlainOnly: true })
  dateOfBirth: string;

  toString() {
    return this.username;
  }

  constructor(data?: any) {
    plainToClassFromExist(this, data);
  }
}

import { Type } from 'class-transformer';
import { User } from '../../../models/user';
import { serializeModel } from '../../../utils/custom-transforms';

export class UserDto {
  @Type(serializeModel(User))
  user: User;
}

return function(object, propertyName) {
    if (!(typeFunction instanceof Function)) {
      typeFunction = getDesignTypeFunction(object, propertyName);
    } 
    if (typeFunction) {
      class_transformer_1.Type(typeFunction)(object, propertyName);
    }
  };
}

static createGetManyDto(dto: any, resourceName: string): any {
    class GetManyResponseDto implements GetManyDefaultResponse {
      @ApiProperty({ type: dto, isArray: true })
      @Type(() => dto)
      data: any[];

      @ApiProperty({ type: 'number' })
      count: number;

      @ApiProperty({ type: 'number' })
      total: number;

      @ApiProperty({ type: 'number' })
      page: number;

      @ApiProperty({ type: 'number' })
      pageCount: number;
    }

    Object.defineProperty(GetManyResponseDto, 'name', {