rotacloud 1.0.58 → 1.1.1

package/src/services/leave.service.ts

@@ -1,42 +1,38 @@
 import { AxiosResponse } from 'axios';
-import { ApiLeave, ApiLeaveType } from '../interfaces/index.js';
+import { Leave, LeaveType } from '../interfaces/index.js';
 import { Service, Options, RequirementsOf } from './index.js';
 
-import { Leave } from '../models/leave.model.js';
-
 import { LeaveQueryParams } from '../interfaces/query-params/leave-query-params.interface.js';
 
-import { LeaveType } from '../models/leave-type.model.js';
-
 type RequiredProps = 'users' | 'type' | 'start_date' | 'end_date';
 
 export class LeaveService extends Service {
   private apiPath = '/leave';
 
-  create(data: RequirementsOf<ApiLeave, RequiredProps>): Promise<Leave[]>;
+  create(data: RequirementsOf<Leave, RequiredProps>): Promise<Leave[]>;
   create(
-    data: RequirementsOf<ApiLeave, RequiredProps>,
-    options: { rawResponse: true } & Options
-  ): Promise<AxiosResponse<ApiLeave[], any>>;
-  create(data: RequirementsOf<ApiLeave, RequiredProps>, options: Options): Promise<Leave[]>;
-  create(data: RequirementsOf<ApiLeave, RequiredProps>, options?: Options) {
+    data: RequirementsOf<Leave, RequiredProps>,
+    options: { rawResponse: true } & Options,
+  ): Promise<AxiosResponse<Leave[], any>>;
+  create(data: RequirementsOf<Leave, RequiredProps>, options: Options): Promise<Leave[]>;
+  create(data: RequirementsOf<Leave, RequiredProps>, options?: Options) {
     return super
-      .fetch<ApiLeave[]>({ url: this.apiPath, data, method: 'POST' }, options)
-      .then((res) => Promise.resolve(options?.rawResponse ? res : [...res.data.map((leave) => new Leave(leave))]));
+      .fetch<Leave[]>({ url: this.apiPath, data, method: 'POST' }, options)
+      .then((res) => Promise.resolve(options?.rawResponse ? res : [...res.data.map((leave) => leave)]));
   }
 
   get(id: number): Promise<Leave>;
-  get(id: number, options: { rawResponse: true }): Promise<AxiosResponse<ApiLeave, any>>;
+  get(id: number, options: { rawResponse: true }): Promise<AxiosResponse<Leave, any>>;
   get(id: number, options: Options): Promise<Leave>;
   get(id: number, options?: Options) {
     return super
-      .fetch<ApiLeave>({ url: `${this.apiPath}/${id}` }, options)
-      .then((res) => Promise.resolve(options?.rawResponse ? res : new Leave(res.data)));
+      .fetch<Leave>({ url: `${this.apiPath}/${id}` }, options)
+      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
   }
 
   async *list(query: LeaveQueryParams, options?: Options) {
-    for await (const res of super.iterator<ApiLeave>({ url: this.apiPath, params: query }, options)) {
-      yield new Leave(res);
+    for await (const res of super.iterator<Leave>({ url: this.apiPath, params: query }, options)) {
+      yield res;
     }
   }
 
@@ -50,41 +46,41 @@ export class LeaveService extends Service {
   }
 
   async *listLeaveTypes(query: LeaveQueryParams, options?: Options) {
-    for await (const res of super.iterator<ApiLeaveType>({ url: this.apiPath, params: query }, options)) {
-      yield new LeaveType(res);
+    for await (const res of super.iterator<LeaveType>({ url: this.apiPath, params: query }, options)) {
+      yield res;
     }
   }
 
   listByPage(query: LeaveQueryParams, options?: Options) {
-    return super.iterator<ApiLeave>({ url: this.apiPath, params: query }, options).byPage();
+    return super.iterator<Leave>({ url: this.apiPath, params: query }, options).byPage();
   }
 
-  update(id: number, data: Partial<ApiLeave>): Promise<Leave>;
+  update(id: number, data: Partial<Leave>): Promise<Leave>;
   update(
     id: number,
-    data: Partial<ApiLeave>,
-    options: { rawResponse: true } & Options
-  ): Promise<AxiosResponse<ApiLeave, any>>;
-  update(id: number, data: Partial<ApiLeave>, options: Options): Promise<Leave>;
-  update(id: number, data: Partial<ApiLeave>, options?: Options) {
+    data: Partial<Leave>,
+    options: { rawResponse: true } & Options,
+  ): Promise<AxiosResponse<Leave, any>>;
+  update(id: number, data: Partial<Leave>, options: Options): Promise<Leave>;
+  update(id: number, data: Partial<Leave>, options?: Options) {
     return super
-      .fetch<ApiLeave>(
+      .fetch<Leave>(
         {
           url: `${this.apiPath}/${id}`,
           data,
           method: 'POST',
         },
-        options
+        options,
       )
-      .then((res) => Promise.resolve(options?.rawResponse ? res : new Leave(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<ApiLeave, any>>;
+  delete(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<Leave, any>>;
   delete(id: number, options: Options): Promise<number>;
   delete(id: number, options?: Options) {
     return super
-      .fetch<ApiLeave>({ url: `${this.apiPath}/${id}`, method: 'DELETE' })
+      .fetch<Leave>({ url: `${this.apiPath}/${id}`, method: 'DELETE' })
       .then((res) => Promise.resolve(options?.rawResponse ? res : res.status));
   }
 }

package/src/services/locations.service.ts

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

package/src/services/pins.service.ts

@@ -1,16 +1,16 @@
 import { AxiosResponse } from 'axios';
-import { ApiPin } from '../interfaces/index.js';
+import { Pin } from '../interfaces/index.js';
 import { Service, Options } from './index.js';
 
 export class PinsService extends Service {
   private apiPath = '/pins';
 
-  get(id: string): Promise<ApiPin>;
-  get(id: string, options?: { rawResponse: true } & Options): Promise<AxiosResponse<ApiPin, any>>;
-  get(id: string, options?: Options): Promise<ApiPin>;
+  get(id: string): Promise<Pin>;
+  get(id: string, options?: { rawResponse: true } & Options): Promise<AxiosResponse<Pin, any>>;
+  get(id: string, options?: Options): Promise<Pin>;
   get(id: string, options?: Options) {
     return super
-      .fetch<ApiPin>({ url: `${this.apiPath}/${id}` }, options)
+      .fetch<Pin>({ url: `${this.apiPath}/${id}` }, options)
       .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
   }
 }

package/src/services/roles.service.ts

@@ -1,9 +1,7 @@
 import { AxiosResponse } from 'axios';
-import { ApiRole } from '../interfaces/index.js';
+import { Role } from '../interfaces/index.js';
 import { Service, Options, RequirementsOf } from './index.js';
 
-import { Role } from '../models/role.model.js';
-
 import { RolesQueryParams } from '../interfaces/query-params/roles-query-params.interface.js';
 
 type RequiredProps = 'name';
@@ -11,30 +9,30 @@ type RequiredProps = 'name';
 export class RolesService extends Service {
   private apiPath = '/roles';
 
-  create(data: RequirementsOf<ApiRole, RequiredProps>): Promise<Role>;
+  create(data: RequirementsOf<Role, RequiredProps>): Promise<Role>;
   create(
-    data: RequirementsOf<ApiRole, RequiredProps>,
-    options: { rawResponse: true } & Options
-  ): Promise<AxiosResponse<ApiRole, any>>;
-  create(data: RequirementsOf<ApiRole, RequiredProps>, options: Options): Promise<Role>;
-  create(data: RequirementsOf<ApiRole, RequiredProps>, options?: Options) {
+    data: RequirementsOf<Role, RequiredProps>,
+    options: { rawResponse: true } & Options,
+  ): Promise<AxiosResponse<Role, any>>;
+  create(data: RequirementsOf<Role, RequiredProps>, options: Options): Promise<Role>;
+  create(data: RequirementsOf<Role, RequiredProps>, options?: Options) {
     return super
-      .fetch<ApiRole>({ url: this.apiPath, data, method: 'POST' })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : new Role(res.data)));
+      .fetch<Role>({ url: this.apiPath, data, method: 'POST' })
+      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
   }
 
   get(id: number): Promise<Role>;
-  get(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<ApiRole, any>>;
+  get(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<Role, any>>;
   get(id: number, options: Options): Promise<Role>;
   get(id: number, options?: Options) {
     return super
-      .fetch<ApiRole>({ url: `${this.apiPath}/${id}` }, options)
-      .then((res) => Promise.resolve(options?.rawResponse ? res : new Role(res.data)));
+      .fetch<Role>({ url: `${this.apiPath}/${id}` }, options)
+      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
   }
 
   async *list(query?: RolesQueryParams, options?: Options) {
-    for await (const res of super.iterator<ApiRole>({ url: this.apiPath, params: query }, options)) {
-      yield new Role(res);
+    for await (const res of super.iterator<Role>({ url: this.apiPath, params: query }, options)) {
+      yield res;
     }
   }
 
@@ -48,23 +46,19 @@ export class RolesService extends Service {
   }
 
   listByPage(query?: RolesQueryParams, options?: Options) {
-    return super.iterator<ApiRole>({ url: this.apiPath, params: query }, options).byPage();
+    return super.iterator<Role>({ url: this.apiPath, params: query }, options).byPage();
   }
-  update(id: number, data: Partial<ApiRole>): Promise<Role>;
-  update(
-    id: number,
-    data: Partial<ApiRole>,
-    options: { rawResponse: true } & Options
-  ): Promise<AxiosResponse<ApiRole, any>>;
-  update(id: number, data: Partial<ApiRole>, options: Options): Promise<Role>;
-  update(id: number, data: Partial<ApiRole>, options?: Options) {
+  update(id: number, data: Partial<Role>): Promise<Role>;
+  update(id: number, data: Partial<Role>, options: { rawResponse: true } & Options): Promise<AxiosResponse<Role, any>>;
+  update(id: number, data: Partial<Role>, options: Options): Promise<Role>;
+  update(id: number, data: Partial<Role>, options?: Options) {
     return super
-      .fetch<ApiRole>({
+      .fetch<Role>({
         url: `${this.apiPath}/${id}`,
         data,
         method: 'POST',
       })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : new Role(res.data)));
+      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
   }
 
   delete(id: number): Promise<number>;
@@ -72,7 +66,7 @@ export class RolesService extends Service {
   delete(id: number, options: Options): Promise<number>;
   delete(id: number, options?: Options) {
     return super
-      .fetch<ApiRole>({ url: `${this.apiPath}/${id}`, method: 'DELETE' })
+      .fetch<Role>({ url: `${this.apiPath}/${id}`, method: 'DELETE' })
       .then((res) => Promise.resolve(options?.rawResponse ? res : res.status));
   }
 }

package/src/services/settings.service.ts

@@ -1,22 +1,19 @@
 import { AxiosResponse } from 'axios';
-import { Settings } from '../models/settings.model.js';
 import { Service, Options } from './index.js';
 
-import { ApiSettings } from '../interfaces/index.js';
+import { Settings } from '../interfaces/index.js';
 
 import { SettingsQueryParams } from '../rotacloud.js';
 
-class SettingsService extends Service {
+export class SettingsService extends Service {
   private apiPath = '/settings';
 
   get(query: SettingsQueryParams): Promise<Settings>;
-  get(query: SettingsQueryParams, options: { rawResponse: true } & Options): Promise<AxiosResponse<ApiSettings, any>>;
+  get(query: SettingsQueryParams, options: { rawResponse: true } & Options): Promise<AxiosResponse<Settings, any>>;
   get(query: SettingsQueryParams, options: Options): Promise<Settings>;
   get(query: SettingsQueryParams, options?: Options) {
     return super
-      .fetch<ApiSettings>({ url: `${this.apiPath}`, params: query }, options)
-      .then((res) => Promise.resolve(options?.rawResponse ? res : new Settings(res.data)));
+      .fetch<Settings>({ url: `${this.apiPath}`, params: query }, options)
+      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
   }
 }
-
-export { SettingsService };

package/src/services/shifts.service.ts

@@ -1,9 +1,7 @@
 import { AxiosRequestConfig, AxiosResponse } from 'axios';
-import { ApiShift } from '../interfaces/index.js';
+import { Shift } from '../interfaces/index.js';
 import { Service, Options, RequirementsOf } from './index.js';
 
-import { Shift } from '../models/shift.model.js';
-
 import { ShiftsQueryParams } from '../interfaces/query-params/shifts-query-params.interface.js';
 
 type RequiredProps = 'end_time' | 'start_time' | 'location';
@@ -11,30 +9,30 @@ type RequiredProps = 'end_time' | 'start_time' | 'location';
 export class ShiftsService extends Service {
   private apiPath = '/shifts';
 
-  create(data: RequirementsOf<ApiShift, RequiredProps>): Promise<Shift>;
+  create(data: RequirementsOf<Shift, RequiredProps>): Promise<Shift>;
   create(
-    data: RequirementsOf<ApiShift, RequiredProps>,
-    options: { rawResponse: true } & Options
-  ): Promise<AxiosResponse<ApiShift, any>>;
-  create(data: RequirementsOf<ApiShift, RequiredProps>, options: Options): Promise<Shift>;
-  create(data: RequirementsOf<ApiShift, RequiredProps>, options?: Options) {
+    data: RequirementsOf<Shift, RequiredProps>,
+    options: { rawResponse: true } & Options,
+  ): Promise<AxiosResponse<Shift, any>>;
+  create(data: RequirementsOf<Shift, RequiredProps>, options: Options): Promise<Shift>;
+  create(data: RequirementsOf<Shift, RequiredProps>, options?: Options) {
     return super
-      .fetch<ApiShift>({ url: this.apiPath, data, method: 'POST' })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : new Shift(res.data)));
+      .fetch<Shift>({ url: this.apiPath, data, method: 'POST' })
+      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
   }
 
   get(id: number): Promise<Shift>;
-  get(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<ApiShift, any>>;
+  get(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<Shift, any>>;
   get(id: number, options: Options): Promise<Shift>;
   get(id: number, options?: Options) {
     return super
-      .fetch<ApiShift>({ url: `${this.apiPath}/${id}` }, options)
-      .then((res) => Promise.resolve(options?.rawResponse ? res : new Shift(res.data)));
+      .fetch<Shift>({ url: `${this.apiPath}/${id}` }, options)
+      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
   }
 
   async *list(query: ShiftsQueryParams, options?: Options) {
-    for await (const res of super.iterator<ApiShift>({ url: this.apiPath, params: query }, options)) {
-      yield new Shift(res);
+    for await (const res of super.iterator<Shift>({ url: this.apiPath, params: query }, options)) {
+      yield res;
     }
   }
 
@@ -48,40 +46,35 @@ export class ShiftsService extends Service {
   }
 
   listByPage(query: ShiftsQueryParams, options?: Options) {
-    return super.iterator<ApiShift>({ url: this.apiPath, params: query }, options).byPage();
+    return super.iterator<Shift>({ url: this.apiPath, params: query }, options).byPage();
   }
 
-  update(shift: RequirementsOf<ApiShift, 'id'>): Promise<Shift>;
-  update(
-    shift: RequirementsOf<ApiShift, 'id'>,
-    options: { rawResponse: true } & Options
-  ): Promise<AxiosResponse<ApiShift>>;
-  update(shift: RequirementsOf<ApiShift, 'id'>, options: Options): Promise<Shift>;
-  update(
-    shifts: RequirementsOf<ApiShift, 'id'>[]
-  ): Promise<{ success: Shift[]; failed: { id: number; error: string }[] }>;
-  update(shift: RequirementsOf<ApiShift, 'id'>, options: Options): Promise<Shift>;
+  update(shift: RequirementsOf<Shift, 'id'>): Promise<Shift>;
+  update(shift: RequirementsOf<Shift, 'id'>, options: { rawResponse: true } & Options): Promise<AxiosResponse<Shift>>;
+  update(shift: RequirementsOf<Shift, 'id'>, options: Options): Promise<Shift>;
+  update(shifts: RequirementsOf<Shift, 'id'>[]): Promise<{ success: Shift[]; failed: { id: number; error: string }[] }>;
+  update(shift: RequirementsOf<Shift, 'id'>, options: Options): Promise<Shift>;
   update(
-    shifts: RequirementsOf<ApiShift, 'id'>[],
-    options: { rawResponse: true } & Options
-  ): Promise<AxiosResponse<{ code: number; data?: ApiShift; error?: string }[]>>;
+    shifts: RequirementsOf<Shift, 'id'>[],
+    options: { rawResponse: true } & Options,
+  ): Promise<AxiosResponse<{ code: number; data?: Shift; error?: string }[]>>;
   update(
-    shifts: RequirementsOf<ApiShift, 'id'>[],
-    options: Options
+    shifts: RequirementsOf<Shift, 'id'>[],
+    options: Options,
   ): Promise<{ success: Shift[]; failed: { id: number; error: string }[] }>;
-  update(shifts: RequirementsOf<ApiShift, 'id'> | RequirementsOf<ApiShift, 'id'>[], options?: Options) {
+  update(shifts: RequirementsOf<Shift, 'id'> | RequirementsOf<Shift, 'id'>[], options?: Options) {
     if (!Array.isArray(shifts)) {
       return super
-        .fetch<ApiShift>({
+        .fetch<Shift>({
           url: `${this.apiPath}/${shifts.id}`,
           data: shifts,
           method: 'POST',
         })
-        .then((res) => (options?.rawResponse ? res : new Shift(res.data)));
+        .then((res) => (options?.rawResponse ? res : res.data));
     }
 
     return super
-      .fetch<{ code: number; data?: ApiShift; error?: string }[]>({
+      .fetch<{ code: number; data?: Shift; error?: string }[]>({
         url: this.apiPath,
         data: shifts,
         method: 'POST',
@@ -93,7 +86,7 @@ export class ShiftsService extends Service {
         const failed: { id: number; error: string }[] = [];
         for (let shiftIdx = 0; shiftIdx < res.data.length; shiftIdx += 1) {
           const { data, error } = res.data[shiftIdx];
-          if (data) success.push(new Shift(data));
+          if (data) success.push(data);
           if (error) failed.push({ id: shifts[shiftIdx].id, error });
         }
         return { success, failed };
@@ -108,7 +101,7 @@ export class ShiftsService extends Service {
       ? { url: this.apiPath, data: { ids }, method: 'DELETE' }
       : { url: `${this.apiPath}/${ids}`, method: 'DELETE' };
 
-    return super.fetch<ApiShift>(params).then((res) => Promise.resolve(options?.rawResponse ? res : res.status));
+    return super.fetch<Shift>(params).then((res) => Promise.resolve(options?.rawResponse ? res : res.status));
   }
 
   acknowledge(data: number[]): Promise<number>;
@@ -116,7 +109,7 @@ export class ShiftsService extends Service {
   acknowledge(data: number[], options: Options): Promise<number>;
   acknowledge(data: number[], options?: Options) {
     return super
-      .fetch<ApiShift>({ url: '/shifts_acknowledged', data, method: 'POST' })
+      .fetch<Shift>({ url: '/shifts_acknowledged', data, method: 'POST' })
       .then((res) => Promise.resolve(options?.rawResponse ? res : res.status));
   }
 
@@ -125,7 +118,7 @@ export class ShiftsService extends Service {
   publish(data: { shifts: number[] }, options: Options): Promise<number>;
   publish(data: { shifts: number[] }, options?: Options) {
     return super
-      .fetch<ApiShift>({ url: '/shifts_published', data, method: 'POST' })
+      .fetch<Shift>({ url: '/shifts_published', data, method: 'POST' })
       .then((res) => Promise.resolve(options?.rawResponse ? res : res.status));
   }
 
@@ -134,7 +127,7 @@ export class ShiftsService extends Service {
   unpublish(data: { shifts: number[] }, options: Options): Promise<number>;
   unpublish(data: { shifts: number[] }, options?: Options) {
     return super
-      .fetch<ApiShift>({ url: '/shifts_published', data, method: 'DELETE' })
+      .fetch<Shift>({ url: '/shifts_published', data, method: 'DELETE' })
       .then((res) => Promise.resolve(options?.rawResponse ? res : res.status));
   }
 }

package/src/services/terminals-active.service.ts

@@ -1,13 +1,11 @@
 import { AxiosResponse } from 'axios';
-import { ApiTerminal, ApiTerminalLocation } from '../interfaces/index.js';
+import { Terminal, TerminalLocation } from '../interfaces/index.js';
 import { Service, Options } from './index.js';
 
-import { Terminal } from '../models/terminal.model.js';
-
 interface LaunchTerminal {
   terminal: number;
   device: string;
-  location?: ApiTerminalLocation;
+  location?: TerminalLocation;
 }
 
 interface PingTerminal {
@@ -15,7 +13,7 @@ interface PingTerminal {
   device: string;
 }
 
-class TerminalsActiveService extends Service {
+export class TerminalsActiveService extends Service {
   private apiPath = '/terminals_active';
 
   launchTerminal(data: LaunchTerminal): Promise<Terminal>;
@@ -23,19 +21,19 @@ class TerminalsActiveService extends Service {
   launchTerminal(data: LaunchTerminal, options: Options): Promise<Terminal>;
   launchTerminal(data: LaunchTerminal, options?: Options) {
     return super
-      .fetch<ApiTerminal>({
+      .fetch<Terminal>({
         url: `${this.apiPath}`,
         data,
         method: 'POST',
       })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : new Terminal(res.data)));
+      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
   }
 
   pingTerminal(id: number, data: PingTerminal): Promise<number>;
   pingTerminal(
     id: number,
     data: PingTerminal,
-    options: { rawResponse: true } & Options
+    options: { rawResponse: true } & Options,
   ): Promise<AxiosResponse<any, any>>;
   pingTerminal(id: number, data: PingTerminal, options: Options): Promise<number>;
   pingTerminal(id: number, data: PingTerminal, options?: Options) {
@@ -45,8 +43,8 @@ class TerminalsActiveService extends Service {
   }
 
   async *list(options?: Options) {
-    for await (const res of super.iterator<ApiTerminal>({ url: this.apiPath }, options)) {
-      yield new Terminal(res);
+    for await (const res of super.iterator<Terminal>({ url: this.apiPath }, options)) {
+      yield res;
     }
   }
 
@@ -60,7 +58,7 @@ class TerminalsActiveService extends Service {
   }
 
   listByPage(options?: Options) {
-    return super.iterator<ApiTerminal>({ url: this.apiPath }, options).byPage();
+    return super.iterator<Terminal>({ url: this.apiPath }, options).byPage();
   }
 
   closeTerminal(id: number): Promise<number>;
@@ -72,4 +70,3 @@ class TerminalsActiveService extends Service {
       .then((res) => Promise.resolve(options?.rawResponse ? res : res.status));
   }
 }
-export { TerminalsActiveService };