rotacloud 1.0.58 → 1.1.0

package/src/services/availability.service.ts

@@ -2,61 +2,56 @@ import { AxiosResponse } from 'axios';
 import { Service, Options } from './index.js';
 
 import { AvailabilityQueryParams } from '../interfaces/query-params/availability-query-params.interface.js';
-import { Availability } from '../models/availability.model.js';
-import { ApiAvailability } from '../interfaces/availability.interface.js';
+import { Availability } from '../interfaces/availability.interface.js';
 
 export class AvailabilityService extends Service {
   private apiPath = '/availability';
 
-  update(data: ApiAvailability): Promise<Availability>;
-  update(data: ApiAvailability, options: { rawResponse: true } & Options): Promise<AxiosResponse<ApiAvailability>>;
-  update(data: ApiAvailability, options?: Options): Promise<Availability | AxiosResponse<ApiAvailability>>;
-  update(data: ApiAvailability, options?: Options) {
+  update(data: Availability): Promise<Availability>;
+  update(data: Availability, options: { rawResponse: true } & Options): Promise<AxiosResponse<Availability>>;
+  update(data: Availability, options?: Options): Promise<Availability | AxiosResponse<Availability>>;
+  update(data: Availability, options?: Options) {
     return super
-      .fetch<ApiAvailability>({
+      .fetch<Availability>({
         url: this.apiPath,
         data,
         method: 'POST',
       })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : new Availability(res.data)));
+      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
   }
 
   /** Alias of {@link AvailabilityService["update"]} */
-  create(data: ApiAvailability): Promise<Availability>;
-  create(data: ApiAvailability, options: { rawResponse: true } & Options): Promise<AxiosResponse<ApiAvailability>>;
-  create(data: ApiAvailability, options?: Options): Promise<Availability | AxiosResponse<ApiAvailability>>;
-  create(data: ApiAvailability, options?: Options) {
+  create(data: Availability): Promise<Availability>;
+  create(data: Availability, options: { rawResponse: true } & Options): Promise<AxiosResponse<Availability>>;
+  create(data: Availability, options?: Options): Promise<Availability | AxiosResponse<Availability>>;
+  create(data: Availability, options?: Options) {
     return this.update(data, options);
   }
 
   delete(user: number, dates: string[]): Promise<Availability>;
-  delete(
-    user: number,
-    dates: string[],
-    options: { rawResponse: true } & Options
-  ): Promise<AxiosResponse<ApiAvailability>>;
-  delete(user: number, dates: string[], options?: Options): Promise<Availability | AxiosResponse<ApiAvailability>>;
+  delete(user: number, dates: string[], options: { rawResponse: true } & Options): Promise<AxiosResponse<Availability>>;
+  delete(user: number, dates: string[], options?: Options): Promise<Availability | AxiosResponse<Availability>>;
   delete(user: number, dates: string[], options?: Options) {
     return this.update(
       {
         user,
         dates: dates.map((date) => ({
-            date,
-            available: [],
-            unavailable: [],
-          })),
+          date,
+          available: [],
+          unavailable: [],
+        })),
       },
-      options
+      options,
     );
   }
 
   async *list(query: AvailabilityQueryParams, options?: Options) {
-    for await (const res of super.iterator<ApiAvailability>({ url: this.apiPath, params: query }, options)) {
-      yield new Availability(res);
+    for await (const res of super.iterator<Availability>({ url: this.apiPath, params: query }, options)) {
+      yield res;
     }
   }
 
   listByPage(query: AvailabilityQueryParams, options?: Options) {
-    return super.iterator<ApiAvailability>({ url: this.apiPath, params: query }, options).byPage();
+    return super.iterator<Availability>({ url: this.apiPath, params: query }, options).byPage();
   }
 }

package/src/services/daily-budgets.service.ts

@@ -1,16 +1,15 @@
 import { AxiosResponse } from 'axios';
-import { ApiDailyBudgets } from '../interfaces/daily-budgets.interface.js';
+import { DailyBudgets } from '../interfaces/daily-budgets.interface.js';
 import { Service, Options } from './index.js';
 
-import { DailyBudgets } from '../models/daily-budgets.model.js';
 import { DailyBudgetsQueryParams } from '../interfaces/query-params/daily-budgets-query-params.interface.js';
 
 export class DailyBudgetsService extends Service {
   private apiPath = '/daily_budgets';
 
   async *list(query: DailyBudgetsQueryParams, options?: Options) {
-    for await (const res of super.iterator<ApiDailyBudgets>({ url: this.apiPath, params: query }, options)) {
-      yield new DailyBudgets(res);
+    for await (const res of super.iterator<DailyBudgets>({ url: this.apiPath, params: query }, options)) {
+      yield res;
     }
   }
 
@@ -24,18 +23,18 @@ export class DailyBudgetsService extends Service {
   }
 
   listByPage(query: DailyBudgetsQueryParams, options?: Options) {
-    return super.iterator<ApiDailyBudgets>({ url: this.apiPath, params: query }, options).byPage();
+    return super.iterator<DailyBudgets>({ url: this.apiPath, params: query }, options).byPage();
   }
 
-  update(data: Partial<ApiDailyBudgets>[]): Promise<number>;
+  update(data: Partial<DailyBudgets>[]): Promise<number>;
   update(
-    data: Partial<ApiDailyBudgets>[],
-    options: { rawResponse: true } & Options
-  ): Promise<AxiosResponse<ApiDailyBudgets, any>>;
-  update(data: Partial<ApiDailyBudgets>[], options: Options): Promise<number>;
-  update(data: Partial<ApiDailyBudgets>[], options?: Options) {
+    data: Partial<DailyBudgets>[],
+    options: { rawResponse: true } & Options,
+  ): Promise<AxiosResponse<DailyBudgets, any>>;
+  update(data: Partial<DailyBudgets>[], options: Options): Promise<number>;
+  update(data: Partial<DailyBudgets>[], options?: Options) {
     return super
-      .fetch<ApiDailyBudgets>({
+      .fetch<DailyBudgets>({
         url: `${this.apiPath}`,
         data,
         method: 'POST',

package/src/services/daily-revenue.service.ts

@@ -1,16 +1,15 @@
 import { AxiosResponse } from 'axios';
-import { ApiDailyRevenue } from '../interfaces/daily-revenue.interface.js';
+import { DailyRevenue } from '../interfaces/daily-revenue.interface.js';
 import { Service, Options } from './index.js';
 
-import { DailyRevenue } from '../models/daily-revenue.model.js';
 import { DailyRevenueQueryParams } from '../interfaces/query-params/daily-revenue-query-params.interface.js';
 
 export class DailyRevenueService extends Service {
   private apiPath = '/daily_revenue';
 
   async *list(query: DailyRevenueQueryParams, options?: Options) {
-    for await (const res of super.iterator<ApiDailyRevenue>({ url: this.apiPath, params: query }, options)) {
-      yield new DailyRevenue(res);
+    for await (const res of super.iterator<DailyRevenue>({ url: this.apiPath, params: query }, options)) {
+      yield res;
     }
   }
 
@@ -24,18 +23,18 @@ export class DailyRevenueService extends Service {
   }
 
   listByPage(query: DailyRevenueQueryParams, options?: Options) {
-    return super.iterator<ApiDailyRevenue>({ url: this.apiPath, params: query }, options).byPage();
+    return super.iterator<DailyRevenue>({ url: this.apiPath, params: query }, options).byPage();
   }
 
-  update(data: Partial<ApiDailyRevenue>[]): Promise<number>;
+  update(data: Partial<DailyRevenue>[]): Promise<number>;
   update(
-    data: Partial<ApiDailyRevenue>[],
-    options: { rawResponse: true } & Options
-  ): Promise<AxiosResponse<ApiDailyRevenue, any>>;
-  update(data: Partial<ApiDailyRevenue>[], options: Options): Promise<number>;
-  update(data: Partial<ApiDailyRevenue>[], options?: Options) {
+    data: Partial<DailyRevenue>[],
+    options: { rawResponse: true } & Options,
+  ): Promise<AxiosResponse<DailyRevenue, any>>;
+  update(data: Partial<DailyRevenue>[], options: Options): Promise<number>;
+  update(data: Partial<DailyRevenue>[], options?: Options) {
     return super
-      .fetch<ApiDailyRevenue>({
+      .fetch<DailyRevenue>({
         url: `${this.apiPath}`,
         data,
         method: 'POST',

package/src/services/day-notes.service.ts

@@ -1,34 +1,33 @@
 import { AxiosResponse } from 'axios';
-import { ApiDayNote } from '../interfaces/index.js';
+import { DayNote } from '../interfaces/index.js';
 import { Service, Options } from './index.js';
 
-import { DayNote } from '../models/day-note.model.js';
 import { DayNotesQueryParams } from '../interfaces/query-params/day-notes-query-params.interface';
 
 export class DayNotesService extends Service {
   private apiPath = '/day_notes';
 
-  create(data: ApiDayNote): Promise<DayNote>;
-  create(data: ApiDayNote, options: { rawResponse: true } & Options): Promise<AxiosResponse<ApiDayNote, any>>;
-  create(data: ApiDayNote, options: Options): Promise<DayNote>;
-  create(data: ApiDayNote, options?: Options) {
+  create(data: DayNote): Promise<DayNote>;
+  create(data: DayNote, options: { rawResponse: true } & Options): Promise<AxiosResponse<DayNote, any>>;
+  create(data: DayNote, options: Options): Promise<DayNote>;
+  create(data: DayNote, options?: Options) {
     return super
-      .fetch<ApiDayNote>({ url: this.apiPath, data, method: 'POST' })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : new DayNote(res.data)));
+      .fetch<DayNote>({ url: this.apiPath, data, method: 'POST' })
+      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
   }
 
   get(id: number): Promise<DayNote>;
-  get(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<ApiDayNote, any>>;
+  get(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<DayNote, any>>;
   get(id: number, options: Options): Promise<DayNote>;
   get(id: number, options?: Options) {
     return super
-      .fetch<ApiDayNote>({ url: `${this.apiPath}/${id}` }, options)
-      .then((res) => Promise.resolve(options?.rawResponse ? res : new DayNote(res.data)));
+      .fetch<DayNote>({ url: `${this.apiPath}/${id}` }, options)
+      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
   }
 
   async *list(query: DayNotesQueryParams, options?: Options) {
-    for await (const res of super.iterator<ApiDayNote>({ url: this.apiPath, params: query }, options)) {
-      yield new DayNote(res);
+    for await (const res of super.iterator<DayNote>({ url: this.apiPath, params: query }, options)) {
+      yield res;
     }
   }
 
@@ -42,24 +41,24 @@ export class DayNotesService extends Service {
   }
 
   listByPage(query: DayNotesQueryParams, options?: Options) {
-    return super.iterator<ApiDayNote>({ url: this.apiPath, params: query }, options).byPage();
+    return super.iterator<DayNote>({ url: this.apiPath, params: query }, options).byPage();
   }
 
-  update(id: number, data: Partial<ApiDayNote>): Promise<DayNote>;
+  update(id: number, data: Partial<DayNote>): Promise<DayNote>;
   update(
     id: number,
-    data: Partial<ApiDayNote>,
-    options: { rawResponse: true } & Options
-  ): Promise<AxiosResponse<ApiDayNote, any>>;
-  update(id: number, data: Partial<ApiDayNote>, options: Options): Promise<DayNote>;
-  update(id: number, data: Partial<ApiDayNote>, options?: Options) {
+    data: Partial<DayNote>,
+    options: { rawResponse: true } & Options,
+  ): Promise<AxiosResponse<DayNote, any>>;
+  update(id: number, data: Partial<DayNote>, options: Options): Promise<DayNote>;
+  update(id: number, data: Partial<DayNote>, options?: Options) {
     return super
-      .fetch<ApiDayNote>({
+      .fetch<DayNote>({
         url: `${this.apiPath}/${id}`,
         data,
         method: 'POST',
       })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : new DayNote(res.data)));
+      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
   }
 
   delete(id: number): Promise<number>;
@@ -67,7 +66,7 @@ export class DayNotesService extends Service {
   delete(id: number, options: Options): Promise<number>;
   delete(id: number, options?: Options) {
     return super
-      .fetch<ApiDayNote>({ url: `${this.apiPath}/${id}`, method: 'DELETE' })
+      .fetch<DayNote>({ url: `${this.apiPath}/${id}`, method: 'DELETE' })
       .then((res) => Promise.resolve(options?.rawResponse ? res : res.status));
   }
 }

package/src/services/days-off.service.ts

@@ -1,19 +1,18 @@
 import { AxiosResponse } from 'axios';
-import { ApiDaysOff } from '../interfaces/index.js';
+import { DaysOff } from '../interfaces/index.js';
 import { Service, Options } from './index.js';
 
-import { DaysOff } from '../models/days-off.model.js';
 import { DaysOffQueryParams } from '../interfaces/query-params/days-off-query-params.interface.js';
 
-export class DaysOffService extends Service<ApiDaysOff> {
+export class DaysOffService extends Service<DaysOff> {
   private apiPath = '/days_off';
 
   create(dates: string[], users: number[]): Promise<number>;
   create(
     dates: string[],
     users: number[],
-    options: { rawResponse: true } & Options
-  ): Promise<AxiosResponse<ApiDaysOff, any>>;
+    options: { rawResponse: true } & Options,
+  ): Promise<AxiosResponse<DaysOff, any>>;
   create(dates: string[], users: number[], options: Options): Promise<number>;
   create(dates: string[], users: number[], options?: Options) {
     return super
@@ -30,7 +29,7 @@ export class DaysOffService extends Service<ApiDaysOff> {
 
   async *list(query: DaysOffQueryParams, options?: Options) {
     for await (const res of super.iterator({ url: this.apiPath, params: query }, options)) {
-      yield new DaysOff(res);
+      yield res;
     }
   }
 

package/src/services/groups.service.ts

@@ -1,8 +1,7 @@
 import { AxiosResponse } from 'axios';
-import { ApiGroup } from '../interfaces/index.js';
+import { Group } from '../interfaces/index.js';
 import { Service, Options, RequirementsOf } from './index.js';
 
-import { Group } from '../models/group.model.js';
 import { GroupsQueryParams } from '../interfaces/query-params/groups-query-params.interface.js';
 
 type RequiredProps = 'name';
@@ -10,30 +9,30 @@ type RequiredProps = 'name';
 export class GroupsService extends Service {
   private apiPath = '/groups';
 
-  create(data: RequirementsOf<ApiGroup, RequiredProps>): Promise<Group>;
+  create(data: RequirementsOf<Group, RequiredProps>): Promise<Group>;
   create(
-    data: RequirementsOf<ApiGroup, RequiredProps>,
-    options: { rawResponse: true } & Options
-  ): Promise<AxiosResponse<ApiGroup, any>>;
-  create(data: RequirementsOf<ApiGroup, RequiredProps>, options: Options): Promise<Group>;
-  create(data: RequirementsOf<ApiGroup, RequiredProps>, options?: Options) {
+    data: RequirementsOf<Group, RequiredProps>,
+    options: { rawResponse: true } & Options,
+  ): Promise<AxiosResponse<Group, any>>;
+  create(data: RequirementsOf<Group, RequiredProps>, options: Options): Promise<Group>;
+  create(data: RequirementsOf<Group, RequiredProps>, options?: Options) {
     return super
-      .fetch<ApiGroup>({ url: this.apiPath, data, method: 'POST' })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : new Group(res.data)));
+      .fetch<Group>({ url: this.apiPath, data, method: 'POST' })
+      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
   }
 
   get(id: number): Promise<Group>;
-  get(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<ApiGroup, any>>;
+  get(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<Group, any>>;
   get(id: number, options: Options): Promise<Group>;
   get(id: number, options?: Options) {
     return super
-      .fetch<ApiGroup>({ url: `${this.apiPath}/${id}` }, options)
-      .then((res) => Promise.resolve(options?.rawResponse ? res : new Group(res.data)));
+      .fetch<Group>({ url: `${this.apiPath}/${id}` }, options)
+      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
   }
 
   async *list(query?: GroupsQueryParams, options?: Options) {
-    for await (const res of super.iterator<ApiGroup>({ url: this.apiPath, params: query }, options)) {
-      yield new Group(res);
+    for await (const res of super.iterator<Group>({ url: this.apiPath, params: query }, options)) {
+      yield res;
     }
   }
 
@@ -47,24 +46,24 @@ export class GroupsService extends Service {
   }
 
   listByPage(query?: GroupsQueryParams, options?: Options) {
-    return super.iterator<ApiGroup>({ url: this.apiPath, params: query }, options).byPage();
+    return super.iterator<Group>({ url: this.apiPath, params: query }, options).byPage();
   }
 
-  update(id: number, data: Partial<ApiGroup>): Promise<Group>;
+  update(id: number, data: Partial<Group>): Promise<Group>;
   update(
     id: number,
-    data: Partial<ApiGroup>,
-    options: { rawResponse: true } & Options
-  ): Promise<AxiosResponse<ApiGroup, any>>;
-  update(id: number, data: Partial<ApiGroup>, options: Options): Promise<Group>;
-  update(id: number, data: Partial<ApiGroup>, options?: Options) {
+    data: Partial<Group>,
+    options: { rawResponse: true } & Options,
+  ): Promise<AxiosResponse<Group, any>>;
+  update(id: number, data: Partial<Group>, options: Options): Promise<Group>;
+  update(id: number, data: Partial<Group>, options?: Options) {
     return super
-      .fetch<ApiGroup>({
+      .fetch<Group>({
         url: `${this.apiPath}/${id}`,
         data,
         method: 'POST',
       })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : new Group(res.data)));
+      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
   }
 
   delete(id: number): Promise<number>;
@@ -72,7 +71,7 @@ export class GroupsService extends Service {
   delete(id: number, options: Options): Promise<number>;
   delete(id: number, options?: Options) {
     return super
-      .fetch<ApiGroup>({ url: `${this.apiPath}/${id}`, method: 'DELETE' })
+      .fetch<Group>({ url: `${this.apiPath}/${id}`, method: 'DELETE' })
       .then((res) => Promise.resolve(options?.rawResponse ? res : res.status));
   }
 }

package/src/services/leave-embargoes.service.ts

@@ -1,8 +1,7 @@
 import { AxiosResponse } from 'axios';
-import { ApiLeaveEmbargo } from '../interfaces/index.js';
+import { LeaveEmbargo } from '../interfaces/index.js';
 import { Service, Options, RequirementsOf } from './index.js';
 
-import { LeaveEmbargo } from '../models/leave-embargo.model.js';
 import { LeaveEmbargoesQueryParams } from '../rotacloud.js';
 
 type RequiredProps = 'start_date' | 'end_date' | 'users';
@@ -10,30 +9,30 @@ type RequiredProps = 'start_date' | 'end_date' | 'users';
 export class LeaveEmbargoesService extends Service {
   private apiPath = '/leave_embargoes';
 
-  create(data: RequirementsOf<ApiLeaveEmbargo, RequiredProps>): Promise<LeaveEmbargo>;
+  create(data: RequirementsOf<LeaveEmbargo, RequiredProps>): Promise<LeaveEmbargo>;
   create(
-    data: RequirementsOf<ApiLeaveEmbargo, RequiredProps>,
-    options: { rawResponse: true } & Options
-  ): Promise<AxiosResponse<ApiLeaveEmbargo, any>>;
-  create(data: RequirementsOf<ApiLeaveEmbargo, RequiredProps>, options: Options): Promise<LeaveEmbargo>;
-  create(data: RequirementsOf<ApiLeaveEmbargo, RequiredProps>, options?: Options) {
+    data: RequirementsOf<LeaveEmbargo, RequiredProps>,
+    options: { rawResponse: true } & Options,
+  ): Promise<AxiosResponse<LeaveEmbargo, any>>;
+  create(data: RequirementsOf<LeaveEmbargo, RequiredProps>, options: Options): Promise<LeaveEmbargo>;
+  create(data: RequirementsOf<LeaveEmbargo, RequiredProps>, options?: Options) {
     return super
-      .fetch<ApiLeaveEmbargo>({ url: this.apiPath, data, method: 'POST' })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : new LeaveEmbargo(res.data)));
+      .fetch<LeaveEmbargo>({ url: this.apiPath, data, method: 'POST' })
+      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
   }
 
   get(id: number): Promise<LeaveEmbargo>;
-  get(id: number, options: { rawResponse: true }): Promise<AxiosResponse<ApiLeaveEmbargo, any>>;
+  get(id: number, options: { rawResponse: true }): Promise<AxiosResponse<LeaveEmbargo, any>>;
   get(id: number, options: Options): Promise<LeaveEmbargo>;
   get(id: number, options?: Options) {
     return super
-      .fetch<ApiLeaveEmbargo>({ url: `${this.apiPath}/${id}` }, options)
-      .then((res) => Promise.resolve(options?.rawResponse ? res : new LeaveEmbargo(res.data)));
+      .fetch<LeaveEmbargo>({ url: `${this.apiPath}/${id}` }, options)
+      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
   }
 
   async *list(query: LeaveEmbargoesQueryParams, options?: Options) {
-    for await (const res of super.iterator<ApiLeaveEmbargo>({ url: this.apiPath, params: query }, options)) {
-      yield new LeaveEmbargo(res);
+    for await (const res of super.iterator<LeaveEmbargo>({ url: this.apiPath, params: query }, options)) {
+      yield res;
     }
   }
 
@@ -47,24 +46,24 @@ export class LeaveEmbargoesService extends Service {
   }
 
   listByPage(query: LeaveEmbargoesQueryParams, options?: Options) {
-    return super.iterator<ApiLeaveEmbargo>({ url: this.apiPath, params: query }, options).byPage();
+    return super.iterator<LeaveEmbargo>({ url: this.apiPath, params: query }, options).byPage();
   }
 
-  update(id: number, data: Partial<ApiLeaveEmbargo>): Promise<LeaveEmbargo>;
+  update(id: number, data: Partial<LeaveEmbargo>): Promise<LeaveEmbargo>;
   update(
     id: number,
-    data: Partial<ApiLeaveEmbargo>,
-    options: { rawResponse: true } & Options
-  ): Promise<AxiosResponse<ApiLeaveEmbargo, any>>;
-  update(id: number, data: Partial<ApiLeaveEmbargo>, options: Options): Promise<LeaveEmbargo>;
-  update(id: number, data: Partial<ApiLeaveEmbargo>, options?: Options) {
+    data: Partial<LeaveEmbargo>,
+    options: { rawResponse: true } & Options,
+  ): Promise<AxiosResponse<LeaveEmbargo, any>>;
+  update(id: number, data: Partial<LeaveEmbargo>, options: Options): Promise<LeaveEmbargo>;
+  update(id: number, data: Partial<LeaveEmbargo>, options?: Options) {
     return super
-      .fetch<ApiLeaveEmbargo>({
+      .fetch<LeaveEmbargo>({
         url: `${this.apiPath}/${id}`,
         data,
         method: 'POST',
       })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : new LeaveEmbargo(res.data)));
+      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
   }
 
   delete(id: number): Promise<number>;
@@ -72,7 +71,7 @@ export class LeaveEmbargoesService extends Service {
   delete(id: number, options: Options): Promise<number>;
   delete(id: number, options?: Options) {
     return super
-      .fetch<ApiLeaveEmbargo>({ url: `${this.apiPath}/${id}`, method: 'DELETE' })
+      .fetch<LeaveEmbargo>({ url: `${this.apiPath}/${id}`, method: 'DELETE' })
       .then((res) => Promise.resolve(options?.rawResponse ? res : res.status));
   }
 }

package/src/services/leave-request.service.ts

@@ -1,47 +1,45 @@
 import { AxiosResponse } from 'axios';
-import { ApiLeaveRequest } from '../interfaces/index.js';
+import { LeaveRequest } from '../interfaces/index.js';
 import { Service, Options, RequirementsOf } from './index.js';
 
 import { LeaveRequestsQueryParams } from '../interfaces/query-params/leave-requests-query-params.interface.js';
 
-import { LeaveRequest } from '../models/leave-request.model.js';
-
 type RequiredProps = 'start_date' | 'end_date' | 'type' | 'user';
 
 export class LeaveRequestService extends Service {
   private apiPath = '/leave_requests';
 
-  create(data: RequirementsOf<ApiLeaveRequest, RequiredProps>): Promise<LeaveRequest>;
+  create(data: RequirementsOf<LeaveRequest, RequiredProps>): Promise<LeaveRequest>;
   create(
-    data: RequirementsOf<ApiLeaveRequest, RequiredProps>,
-    options: { rawResponse: true } & Options
-  ): Promise<AxiosResponse<ApiLeaveRequest, any>>;
-  create(data: RequirementsOf<ApiLeaveRequest, RequiredProps>, options: Options): Promise<LeaveRequest>;
-  create(data: RequirementsOf<ApiLeaveRequest, RequiredProps>, options?: Options) {
+    data: RequirementsOf<LeaveRequest, RequiredProps>,
+    options: { rawResponse: true } & Options,
+  ): Promise<AxiosResponse<LeaveRequest, any>>;
+  create(data: RequirementsOf<LeaveRequest, RequiredProps>, options: Options): Promise<LeaveRequest>;
+  create(data: RequirementsOf<LeaveRequest, RequiredProps>, options?: Options) {
     return super
-      .fetch<ApiLeaveRequest>(
+      .fetch<LeaveRequest>(
         {
           url: this.apiPath,
           data,
           method: 'POST',
         },
-        options
+        options,
       )
-      .then((res) => Promise.resolve(options?.rawResponse ? res : new LeaveRequest(res.data)));
+      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
   }
 
   get(id: number): Promise<LeaveRequest>;
-  get(id: number, options: { rawResponse: true }): Promise<AxiosResponse<ApiLeaveRequest, any>>;
+  get(id: number, options: { rawResponse: true }): Promise<AxiosResponse<LeaveRequest, any>>;
   get(id: number, options: Options): Promise<LeaveRequest>;
   get(id: number, options?: Options) {
     return super
-      .fetch<ApiLeaveRequest>({ url: `${this.apiPath}/${id}` }, options)
-      .then((res) => Promise.resolve(options?.rawResponse ? res : new LeaveRequest(res.data)));
+      .fetch<LeaveRequest>({ url: `${this.apiPath}/${id}` }, options)
+      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
   }
 
   async *list(query?: LeaveRequestsQueryParams, options?: Options) {
-    for await (const res of super.iterator<ApiLeaveRequest>({ url: this.apiPath, params: query }, options)) {
-      yield new LeaveRequest(res);
+    for await (const res of super.iterator<LeaveRequest>({ url: this.apiPath, params: query }, options)) {
+      yield res;
     }
   }
 
@@ -55,32 +53,32 @@ export class LeaveRequestService extends Service {
   }
 
   listByPage(query?: LeaveRequestsQueryParams, options?: Options) {
-    return super.iterator<ApiLeaveRequest>({ url: `${this.apiPath}`, params: query }, options).byPage();
+    return super.iterator<LeaveRequest>({ url: `${this.apiPath}`, params: query }, options).byPage();
   }
 
-  update(id: number, data: Partial<ApiLeaveRequest>): Promise<LeaveRequest>;
+  update(id: number, data: Partial<LeaveRequest>): Promise<LeaveRequest>;
   update(
     id: number,
-    data: Partial<ApiLeaveRequest>,
-    options: { rawResponse: true } & Options
-  ): Promise<AxiosResponse<ApiLeaveRequest, any>>;
-  update(id: number, data: Partial<ApiLeaveRequest>, options: Options): Promise<LeaveRequest>;
-  update(id: number, data: Partial<ApiLeaveRequest>, options?: Options) {
+    data: Partial<LeaveRequest>,
+    options: { rawResponse: true } & Options,
+  ): Promise<AxiosResponse<LeaveRequest, any>>;
+  update(id: number, data: Partial<LeaveRequest>, options: Options): Promise<LeaveRequest>;
+  update(id: number, data: Partial<LeaveRequest>, options?: Options) {
     return super
-      .fetch<ApiLeaveRequest>({
+      .fetch<LeaveRequest>({
         url: `${this.apiPath}/${id}`,
         data,
         method: 'POST',
       })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : new LeaveRequest(res.data)));
+      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
   }
 
   delete(id: number): Promise<number>;
-  delete(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<ApiLeaveRequest, any>>;
+  delete(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<LeaveRequest, any>>;
   delete(id: number, options: Options): Promise<number>;
   delete(id: number, options?: Options) {
     return super
-      .fetch<ApiLeaveRequest>({ url: `${this.apiPath}/${id}`, method: 'DELETE' })
+      .fetch<LeaveRequest>({ url: `${this.apiPath}/${id}`, method: 'DELETE' })
       .then((res) => Promise.resolve(options?.rawResponse ? res : res.status));
   }
 }

package/src/services/leave-types.service.ts

@@ -1,20 +1,16 @@
 import { AxiosResponse } from 'axios';
-import { ApiLeaveType } from '../interfaces/index.js';
+import { LeaveType } from '../interfaces/index.js';
 import { Service, Options } from './index.js';
 
-import { LeaveType } from '../models/index.js';
-
 export class LeaveTypesService extends Service {
   private apiPath = '/leave_types';
 
   get(): Promise<LeaveType[]>;
-  get(options: { rawResponse: true }): Promise<AxiosResponse<ApiLeaveType[]>>;
+  get(options: { rawResponse: true }): Promise<AxiosResponse<LeaveType[]>>;
   get(options: Options): Promise<LeaveType[]>;
   get(options?: Options) {
     return super
-      .fetch<ApiLeaveType[]>({ url: this.apiPath }, options)
-      .then((res) =>
-        Promise.resolve(options?.rawResponse ? res : res.data.map((leaveType) => new LeaveType(leaveType)))
-      );
+      .fetch<LeaveType[]>({ url: this.apiPath }, options)
+      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data.map((leaveType) => leaveType)));
   }
 }