rotacloud 1.0.58 → 1.1.0

package/dist/mjs/services/groups.service.d.ts

@@ -1,29 +1,28 @@
 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';
 export declare class GroupsService extends Service {
     private apiPath;
-    create(data: RequirementsOf<ApiGroup, RequiredProps>): Promise<Group>;
-    create(data: RequirementsOf<ApiGroup, RequiredProps>, options: {
+    create(data: RequirementsOf<Group, RequiredProps>): Promise<Group>;
+    create(data: RequirementsOf<Group, RequiredProps>, options: {
         rawResponse: true;
-    } & Options): Promise<AxiosResponse<ApiGroup, any>>;
-    create(data: RequirementsOf<ApiGroup, RequiredProps>, options: Options): Promise<Group>;
+    } & Options): Promise<AxiosResponse<Group, any>>;
+    create(data: RequirementsOf<Group, RequiredProps>, options: Options): Promise<Group>;
     get(id: number): Promise<Group>;
     get(id: number, options: {
         rawResponse: true;
-    } & Options): Promise<AxiosResponse<ApiGroup, any>>;
+    } & Options): Promise<AxiosResponse<Group, any>>;
     get(id: number, options: Options): Promise<Group>;
     list(query?: GroupsQueryParams, options?: Options): AsyncGenerator<Group, void, unknown>;
     listAll(query?: GroupsQueryParams, options?: Options): Promise<Group[]>;
-    listByPage(query?: GroupsQueryParams, options?: Options): AsyncGenerator<AxiosResponse<ApiGroup[], any>, any, unknown>;
-    update(id: number, data: Partial<ApiGroup>): Promise<Group>;
-    update(id: number, data: Partial<ApiGroup>, options: {
+    listByPage(query?: GroupsQueryParams, options?: Options): AsyncGenerator<AxiosResponse<Group[], any>, any, unknown>;
+    update(id: number, data: Partial<Group>): Promise<Group>;
+    update(id: number, data: Partial<Group>, options: {
         rawResponse: true;
-    } & Options): Promise<AxiosResponse<ApiGroup, any>>;
-    update(id: number, data: Partial<ApiGroup>, options: Options): Promise<Group>;
+    } & Options): Promise<AxiosResponse<Group, any>>;
+    update(id: number, data: Partial<Group>, options: Options): Promise<Group>;
     delete(id: number): Promise<number>;
     delete(id: number, options: {
         rawResponse: true;

package/dist/mjs/services/groups.service.js

@@ -1,5 +1,4 @@
 import { Service } from './index.js';
-import { Group } from '../models/group.model.js';
 export class GroupsService extends Service {
     constructor() {
         super(...arguments);
@@ -8,16 +7,16 @@ export class GroupsService extends Service {
     create(data, options) {
         return super
             .fetch({ url: this.apiPath, data, method: 'POST' })
-            .then((res) => Promise.resolve(options?.rawResponse ? res : new Group(res.data)));
+            .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
     }
     get(id, options) {
         return super
             .fetch({ url: `${this.apiPath}/${id}` }, options)
-            .then((res) => Promise.resolve(options?.rawResponse ? res : new Group(res.data)));
+            .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
     }
     async *list(query, options) {
         for await (const res of super.iterator({ url: this.apiPath, params: query }, options)) {
-            yield new Group(res);
+            yield res;
         }
     }
     async listAll(query, options) {
@@ -37,7 +36,7 @@ export class GroupsService extends Service {
             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, options) {
         return super

package/dist/mjs/services/leave-embargoes.service.d.ts

@@ -1,29 +1,28 @@
 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';
 export declare class LeaveEmbargoesService extends Service {
     private apiPath;
-    create(data: RequirementsOf<ApiLeaveEmbargo, RequiredProps>): Promise<LeaveEmbargo>;
-    create(data: RequirementsOf<ApiLeaveEmbargo, RequiredProps>, options: {
+    create(data: RequirementsOf<LeaveEmbargo, RequiredProps>): Promise<LeaveEmbargo>;
+    create(data: RequirementsOf<LeaveEmbargo, RequiredProps>, options: {
         rawResponse: true;
-    } & Options): Promise<AxiosResponse<ApiLeaveEmbargo, any>>;
-    create(data: RequirementsOf<ApiLeaveEmbargo, RequiredProps>, options: Options): Promise<LeaveEmbargo>;
+    } & Options): Promise<AxiosResponse<LeaveEmbargo, any>>;
+    create(data: RequirementsOf<LeaveEmbargo, RequiredProps>, options: Options): Promise<LeaveEmbargo>;
     get(id: number): Promise<LeaveEmbargo>;
     get(id: number, options: {
         rawResponse: true;
-    }): Promise<AxiosResponse<ApiLeaveEmbargo, any>>;
+    }): Promise<AxiosResponse<LeaveEmbargo, any>>;
     get(id: number, options: Options): Promise<LeaveEmbargo>;
     list(query: LeaveEmbargoesQueryParams, options?: Options): AsyncGenerator<LeaveEmbargo, void, unknown>;
     listAll(query: LeaveEmbargoesQueryParams, options?: Options): Promise<LeaveEmbargo[]>;
-    listByPage(query: LeaveEmbargoesQueryParams, options?: Options): AsyncGenerator<AxiosResponse<ApiLeaveEmbargo[], any>, any, unknown>;
-    update(id: number, data: Partial<ApiLeaveEmbargo>): Promise<LeaveEmbargo>;
-    update(id: number, data: Partial<ApiLeaveEmbargo>, options: {
+    listByPage(query: LeaveEmbargoesQueryParams, options?: Options): AsyncGenerator<AxiosResponse<LeaveEmbargo[], any>, any, unknown>;
+    update(id: number, data: Partial<LeaveEmbargo>): Promise<LeaveEmbargo>;
+    update(id: number, data: Partial<LeaveEmbargo>, options: {
         rawResponse: true;
-    } & Options): Promise<AxiosResponse<ApiLeaveEmbargo, any>>;
-    update(id: number, data: Partial<ApiLeaveEmbargo>, options: Options): Promise<LeaveEmbargo>;
+    } & Options): Promise<AxiosResponse<LeaveEmbargo, any>>;
+    update(id: number, data: Partial<LeaveEmbargo>, options: Options): Promise<LeaveEmbargo>;
     delete(id: number): Promise<number>;
     delete(id: number, options: {
         rawResponse: true;

package/dist/mjs/services/leave-embargoes.service.js

@@ -1,5 +1,4 @@
 import { Service } from './index.js';
-import { LeaveEmbargo } from '../models/leave-embargo.model.js';
 export class LeaveEmbargoesService extends Service {
     constructor() {
         super(...arguments);
@@ -8,16 +7,16 @@ export class LeaveEmbargoesService extends Service {
     create(data, options) {
         return super
             .fetch({ url: this.apiPath, data, method: 'POST' })
-            .then((res) => Promise.resolve(options?.rawResponse ? res : new LeaveEmbargo(res.data)));
+            .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
     }
     get(id, options) {
         return super
             .fetch({ url: `${this.apiPath}/${id}` }, options)
-            .then((res) => Promise.resolve(options?.rawResponse ? res : new LeaveEmbargo(res.data)));
+            .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
     }
     async *list(query, options) {
         for await (const res of super.iterator({ url: this.apiPath, params: query }, options)) {
-            yield new LeaveEmbargo(res);
+            yield res;
         }
     }
     async listAll(query, options) {
@@ -37,7 +36,7 @@ export class LeaveEmbargoesService extends Service {
             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, options) {
         return super

package/dist/mjs/services/leave-request.service.d.ts

@@ -1,33 +1,32 @@
 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 declare class LeaveRequestService extends Service {
     private apiPath;
-    create(data: RequirementsOf<ApiLeaveRequest, RequiredProps>): Promise<LeaveRequest>;
-    create(data: RequirementsOf<ApiLeaveRequest, RequiredProps>, options: {
+    create(data: RequirementsOf<LeaveRequest, RequiredProps>): Promise<LeaveRequest>;
+    create(data: RequirementsOf<LeaveRequest, RequiredProps>, options: {
         rawResponse: true;
-    } & Options): Promise<AxiosResponse<ApiLeaveRequest, any>>;
-    create(data: RequirementsOf<ApiLeaveRequest, RequiredProps>, options: Options): Promise<LeaveRequest>;
+    } & Options): Promise<AxiosResponse<LeaveRequest, any>>;
+    create(data: RequirementsOf<LeaveRequest, RequiredProps>, options: Options): Promise<LeaveRequest>;
     get(id: number): Promise<LeaveRequest>;
     get(id: number, options: {
         rawResponse: true;
-    }): Promise<AxiosResponse<ApiLeaveRequest, any>>;
+    }): Promise<AxiosResponse<LeaveRequest, any>>;
     get(id: number, options: Options): Promise<LeaveRequest>;
     list(query?: LeaveRequestsQueryParams, options?: Options): AsyncGenerator<LeaveRequest, void, unknown>;
     listAll(query?: LeaveRequestsQueryParams, options?: Options): Promise<LeaveRequest[]>;
-    listByPage(query?: LeaveRequestsQueryParams, options?: Options): AsyncGenerator<AxiosResponse<ApiLeaveRequest[], any>, any, unknown>;
-    update(id: number, data: Partial<ApiLeaveRequest>): Promise<LeaveRequest>;
-    update(id: number, data: Partial<ApiLeaveRequest>, options: {
+    listByPage(query?: LeaveRequestsQueryParams, options?: Options): AsyncGenerator<AxiosResponse<LeaveRequest[], any>, any, unknown>;
+    update(id: number, data: Partial<LeaveRequest>): Promise<LeaveRequest>;
+    update(id: number, data: Partial<LeaveRequest>, options: {
         rawResponse: true;
-    } & Options): Promise<AxiosResponse<ApiLeaveRequest, any>>;
-    update(id: number, data: Partial<ApiLeaveRequest>, options: Options): Promise<LeaveRequest>;
+    } & Options): Promise<AxiosResponse<LeaveRequest, any>>;
+    update(id: number, data: Partial<LeaveRequest>, options: Options): Promise<LeaveRequest>;
     delete(id: number): Promise<number>;
     delete(id: number, options: {
         rawResponse: true;
-    } & Options): Promise<AxiosResponse<ApiLeaveRequest, any>>;
+    } & Options): Promise<AxiosResponse<LeaveRequest, any>>;
     delete(id: number, options: Options): Promise<number>;
 }
 export {};

package/dist/mjs/services/leave-request.service.js

@@ -1,5 +1,4 @@
 import { Service } from './index.js';
-import { LeaveRequest } from '../models/leave-request.model.js';
 export class LeaveRequestService extends Service {
     constructor() {
         super(...arguments);
@@ -12,16 +11,16 @@ export class LeaveRequestService extends Service {
             data,
             method: 'POST',
         }, options)
-            .then((res) => Promise.resolve(options?.rawResponse ? res : new LeaveRequest(res.data)));
+            .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
     }
     get(id, options) {
         return super
             .fetch({ url: `${this.apiPath}/${id}` }, options)
-            .then((res) => Promise.resolve(options?.rawResponse ? res : new LeaveRequest(res.data)));
+            .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
     }
     async *list(query, options) {
         for await (const res of super.iterator({ url: this.apiPath, params: query }, options)) {
-            yield new LeaveRequest(res);
+            yield res;
         }
     }
     async listAll(query, options) {
@@ -41,7 +40,7 @@ export class LeaveRequestService extends Service {
             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, options) {
         return super

package/dist/mjs/services/leave-types.service.d.ts

@@ -1,12 +1,11 @@
 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 declare class LeaveTypesService extends Service {
     private apiPath;
     get(): Promise<LeaveType[]>;
     get(options: {
         rawResponse: true;
-    }): Promise<AxiosResponse<ApiLeaveType[]>>;
+    }): Promise<AxiosResponse<LeaveType[]>>;
     get(options: Options): Promise<LeaveType[]>;
 }

package/dist/mjs/services/leave-types.service.js

@@ -1,5 +1,4 @@
 import { Service } from './index.js';
-import { LeaveType } from '../models/index.js';
 export class LeaveTypesService extends Service {
     constructor() {
         super(...arguments);
@@ -8,6 +7,6 @@ export class LeaveTypesService extends Service {
     get(options) {
         return super
             .fetch({ url: this.apiPath }, options)
-            .then((res) => Promise.resolve(options?.rawResponse ? res : res.data.map((leaveType) => new LeaveType(leaveType))));
+            .then((res) => Promise.resolve(options?.rawResponse ? res : res.data.map((leaveType) => leaveType)));
     }
 }

package/dist/mjs/services/leave.service.d.ts

@@ -1,35 +1,33 @@
 import { AxiosResponse } from 'axios';
-import { ApiLeave } 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 declare class LeaveService extends Service {
     private apiPath;
-    create(data: RequirementsOf<ApiLeave, RequiredProps>): Promise<Leave[]>;
-    create(data: RequirementsOf<ApiLeave, RequiredProps>, options: {
+    create(data: RequirementsOf<Leave, RequiredProps>): Promise<Leave[]>;
+    create(data: RequirementsOf<Leave, RequiredProps>, options: {
         rawResponse: true;
-    } & Options): Promise<AxiosResponse<ApiLeave[], any>>;
-    create(data: RequirementsOf<ApiLeave, RequiredProps>, options: Options): Promise<Leave[]>;
+    } & Options): Promise<AxiosResponse<Leave[], any>>;
+    create(data: RequirementsOf<Leave, RequiredProps>, options: Options): Promise<Leave[]>;
     get(id: number): Promise<Leave>;
     get(id: number, options: {
         rawResponse: true;
-    }): Promise<AxiosResponse<ApiLeave, any>>;
+    }): Promise<AxiosResponse<Leave, any>>;
     get(id: number, options: Options): Promise<Leave>;
     list(query: LeaveQueryParams, options?: Options): AsyncGenerator<Leave, void, unknown>;
     listAll(query: LeaveQueryParams, options?: Options): Promise<Leave[]>;
     listLeaveTypes(query: LeaveQueryParams, options?: Options): AsyncGenerator<LeaveType, void, unknown>;
-    listByPage(query: LeaveQueryParams, options?: Options): AsyncGenerator<AxiosResponse<ApiLeave[], any>, any, unknown>;
-    update(id: number, data: Partial<ApiLeave>): Promise<Leave>;
-    update(id: number, data: Partial<ApiLeave>, options: {
+    listByPage(query: LeaveQueryParams, options?: Options): AsyncGenerator<AxiosResponse<Leave[], any>, any, unknown>;
+    update(id: number, data: Partial<Leave>): Promise<Leave>;
+    update(id: number, data: Partial<Leave>, options: {
         rawResponse: true;
-    } & Options): Promise<AxiosResponse<ApiLeave, any>>;
-    update(id: number, data: Partial<ApiLeave>, options: Options): Promise<Leave>;
+    } & Options): Promise<AxiosResponse<Leave, any>>;
+    update(id: number, data: Partial<Leave>, options: Options): Promise<Leave>;
     delete(id: number): Promise<number>;
     delete(id: number, options: {
         rawResponse: true;
-    } & Options): Promise<AxiosResponse<ApiLeave, any>>;
+    } & Options): Promise<AxiosResponse<Leave, any>>;
     delete(id: number, options: Options): Promise<number>;
 }
 export {};

package/dist/mjs/services/leave.service.js

@@ -1,6 +1,4 @@
 import { Service } from './index.js';
-import { Leave } from '../models/leave.model.js';
-import { LeaveType } from '../models/leave-type.model.js';
 export class LeaveService extends Service {
     constructor() {
         super(...arguments);
@@ -9,16 +7,16 @@ export class LeaveService extends Service {
     create(data, options) {
         return super
             .fetch({ url: this.apiPath, data, method: 'POST' }, options)
-            .then((res) => Promise.resolve(options?.rawResponse ? res : [...res.data.map((leave) => new Leave(leave))]));
+            .then((res) => Promise.resolve(options?.rawResponse ? res : [...res.data.map((leave) => leave)]));
     }
     get(id, options) {
         return super
             .fetch({ url: `${this.apiPath}/${id}` }, options)
-            .then((res) => Promise.resolve(options?.rawResponse ? res : new Leave(res.data)));
+            .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
     }
     async *list(query, options) {
         for await (const res of super.iterator({ url: this.apiPath, params: query }, options)) {
-            yield new Leave(res);
+            yield res;
         }
     }
     async listAll(query, options) {
@@ -30,7 +28,7 @@ export class LeaveService extends Service {
     }
     async *listLeaveTypes(query, options) {
         for await (const res of super.iterator({ url: this.apiPath, params: query }, options)) {
-            yield new LeaveType(res);
+            yield res;
         }
     }
     listByPage(query, options) {
@@ -43,7 +41,7 @@ export class LeaveService extends Service {
             data,
             method: 'POST',
         }, options)
-            .then((res) => Promise.resolve(options?.rawResponse ? res : new Leave(res.data)));
+            .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
     }
     delete(id, options) {
         return super

package/dist/mjs/services/locations.service.d.ts

@@ -1,29 +1,28 @@
 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';
 export declare class LocationsService extends Service {
     private apiPath;
-    create(data: RequirementsOf<ApiLocation, RequiredProps>): Promise<Location>;
-    create(data: RequirementsOf<ApiLocation, RequiredProps>, options: {
+    create(data: RequirementsOf<Location, RequiredProps>): Promise<Location>;
+    create(data: RequirementsOf<Location, RequiredProps>, options: {
         rawResponse: true;
-    } & Options): Promise<AxiosResponse<ApiLocation, any>>;
-    create(data: RequirementsOf<ApiLocation, RequiredProps>, options: Options): Promise<Location>;
+    } & Options): Promise<AxiosResponse<Location, any>>;
+    create(data: RequirementsOf<Location, RequiredProps>, options: Options): Promise<Location>;
     get(id: number): Promise<Location>;
     get(id: number, options: {
         rawResponse: true;
-    } & Options): Promise<AxiosResponse<ApiLocation, any>>;
+    } & Options): Promise<AxiosResponse<Location, any>>;
     get(id: number, options: Options): Promise<Location>;
     list(query?: LocationsQueryParams, options?: Options): AsyncGenerator<Location, void, unknown>;
     listAll(query?: LocationsQueryParams, options?: Options): Promise<Location[]>;
-    listByPage(query?: LocationsQueryParams, options?: Options): AsyncGenerator<AxiosResponse<ApiLocation[], any>, any, unknown>;
-    update(id: number, data: Partial<ApiLocation>): Promise<Location>;
-    update(id: number, data: Partial<ApiLocation>, options: {
+    listByPage(query?: LocationsQueryParams, options?: Options): AsyncGenerator<AxiosResponse<Location[], any>, any, unknown>;
+    update(id: number, data: Partial<Location>): Promise<Location>;
+    update(id: number, data: Partial<Location>, options: {
         rawResponse: true;
-    } & Options): Promise<AxiosResponse<ApiLocation, any>>;
-    update(id: number, data: Partial<ApiLocation>, options: Options): Promise<Location>;
+    } & Options): Promise<AxiosResponse<Location, any>>;
+    update(id: number, data: Partial<Location>, options: Options): Promise<Location>;
     delete(id: number): Promise<number>;
     delete(id: number, options: {
         rawResponse: true;

package/dist/mjs/services/locations.service.js

@@ -1,5 +1,4 @@
 import { Service } from './index.js';
-import { Location } from '../models/location.model.js';
 export class LocationsService extends Service {
     constructor() {
         super(...arguments);
@@ -8,16 +7,16 @@ export class LocationsService extends Service {
     create(data, options) {
         return super
             .fetch({ url: `${this.apiPath}`, data, method: 'POST' })
-            .then((res) => Promise.resolve(options?.rawResponse ? res : new Location(res.data)));
+            .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
     }
     get(id, options) {
         return super
             .fetch({ url: `${this.apiPath}/${id}` }, options)
-            .then((res) => Promise.resolve(options?.rawResponse ? res : new Location(res.data)));
+            .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
     }
     async *list(query, options) {
         for await (const res of super.iterator({ url: this.apiPath, params: query }, options)) {
-            yield new Location(res);
+            yield res;
         }
     }
     async listAll(query, options) {
@@ -37,7 +36,7 @@ export class LocationsService extends Service {
             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, options) {
         return super

package/dist/mjs/services/pins.service.d.ts

@@ -1,11 +1,11 @@
 import { AxiosResponse } from 'axios';
-import { ApiPin } from '../interfaces/index.js';
+import { Pin } from '../interfaces/index.js';
 import { Service, Options } from './index.js';
 export declare class PinsService extends Service {
     private apiPath;
-    get(id: string): Promise<ApiPin>;
+    get(id: string): Promise<Pin>;
     get(id: string, options?: {
         rawResponse: true;
-    } & Options): Promise<AxiosResponse<ApiPin, any>>;
-    get(id: string, options?: Options): Promise<ApiPin>;
+    } & Options): Promise<AxiosResponse<Pin, any>>;
+    get(id: string, options?: Options): Promise<Pin>;
 }

package/dist/mjs/services/roles.service.d.ts

@@ -1,29 +1,28 @@
 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';
 export declare class RolesService extends Service {
     private apiPath;
-    create(data: RequirementsOf<ApiRole, RequiredProps>): Promise<Role>;
-    create(data: RequirementsOf<ApiRole, RequiredProps>, options: {
+    create(data: RequirementsOf<Role, RequiredProps>): Promise<Role>;
+    create(data: RequirementsOf<Role, RequiredProps>, options: {
         rawResponse: true;
-    } & Options): Promise<AxiosResponse<ApiRole, any>>;
-    create(data: RequirementsOf<ApiRole, RequiredProps>, options: Options): Promise<Role>;
+    } & Options): Promise<AxiosResponse<Role, any>>;
+    create(data: RequirementsOf<Role, RequiredProps>, options: Options): Promise<Role>;
     get(id: number): Promise<Role>;
     get(id: number, options: {
         rawResponse: true;
-    } & Options): Promise<AxiosResponse<ApiRole, any>>;
+    } & Options): Promise<AxiosResponse<Role, any>>;
     get(id: number, options: Options): Promise<Role>;
     list(query?: RolesQueryParams, options?: Options): AsyncGenerator<Role, void, unknown>;
     listAll(query?: RolesQueryParams, options?: Options): Promise<Role[]>;
-    listByPage(query?: RolesQueryParams, options?: Options): AsyncGenerator<AxiosResponse<ApiRole[], any>, any, unknown>;
-    update(id: number, data: Partial<ApiRole>): Promise<Role>;
-    update(id: number, data: Partial<ApiRole>, options: {
+    listByPage(query?: RolesQueryParams, options?: Options): AsyncGenerator<AxiosResponse<Role[], any>, any, unknown>;
+    update(id: number, data: Partial<Role>): Promise<Role>;
+    update(id: number, data: Partial<Role>, options: {
         rawResponse: true;
-    } & Options): Promise<AxiosResponse<ApiRole, any>>;
-    update(id: number, data: Partial<ApiRole>, options: Options): Promise<Role>;
+    } & Options): Promise<AxiosResponse<Role, any>>;
+    update(id: number, data: Partial<Role>, options: Options): Promise<Role>;
     delete(id: number): Promise<number>;
     delete(id: number, options: {
         rawResponse: true;

package/dist/mjs/services/roles.service.js

@@ -1,5 +1,4 @@
 import { Service } from './index.js';
-import { Role } from '../models/role.model.js';
 export class RolesService extends Service {
     constructor() {
         super(...arguments);
@@ -8,16 +7,16 @@ export class RolesService extends Service {
     create(data, options) {
         return super
             .fetch({ url: this.apiPath, data, method: 'POST' })
-            .then((res) => Promise.resolve(options?.rawResponse ? res : new Role(res.data)));
+            .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
     }
     get(id, options) {
         return super
             .fetch({ url: `${this.apiPath}/${id}` }, options)
-            .then((res) => Promise.resolve(options?.rawResponse ? res : new Role(res.data)));
+            .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
     }
     async *list(query, options) {
         for await (const res of super.iterator({ url: this.apiPath, params: query }, options)) {
-            yield new Role(res);
+            yield res;
         }
     }
     async listAll(query, options) {
@@ -37,7 +36,7 @@ export class RolesService extends Service {
             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, options) {
         return super

package/dist/mjs/services/settings.service.d.ts

@@ -1,14 +1,12 @@
 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';
-declare class SettingsService extends Service {
+export declare class SettingsService extends Service {
     private apiPath;
     get(query: SettingsQueryParams): Promise<Settings>;
     get(query: SettingsQueryParams, options: {
         rawResponse: true;
-    } & Options): Promise<AxiosResponse<ApiSettings, any>>;
+    } & Options): Promise<AxiosResponse<Settings, any>>;
     get(query: SettingsQueryParams, options: Options): Promise<Settings>;
 }
-export { SettingsService };

package/dist/mjs/services/settings.service.js

@@ -1,6 +1,5 @@
-import { Settings } from '../models/settings.model.js';
 import { Service } from './index.js';
-class SettingsService extends Service {
+export class SettingsService extends Service {
     constructor() {
         super(...arguments);
         this.apiPath = '/settings';
@@ -8,7 +7,6 @@ class SettingsService extends Service {
     get(query, options) {
         return super
             .fetch({ url: `${this.apiPath}`, params: query }, options)
-            .then((res) => Promise.resolve(options?.rawResponse ? res : new Settings(res.data)));
+            .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
     }
 }
-export { SettingsService };

package/dist/mjs/services/shifts.service.d.ts

@@ -1,45 +1,44 @@
 import { 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';
 export declare class ShiftsService extends Service {
     private apiPath;
-    create(data: RequirementsOf<ApiShift, RequiredProps>): Promise<Shift>;
-    create(data: RequirementsOf<ApiShift, RequiredProps>, options: {
+    create(data: RequirementsOf<Shift, RequiredProps>): Promise<Shift>;
+    create(data: RequirementsOf<Shift, RequiredProps>, options: {
         rawResponse: true;
-    } & Options): Promise<AxiosResponse<ApiShift, any>>;
-    create(data: RequirementsOf<ApiShift, RequiredProps>, options: Options): Promise<Shift>;
+    } & Options): Promise<AxiosResponse<Shift, any>>;
+    create(data: RequirementsOf<Shift, RequiredProps>, options: Options): Promise<Shift>;
     get(id: number): Promise<Shift>;
     get(id: number, options: {
         rawResponse: true;
-    } & Options): Promise<AxiosResponse<ApiShift, any>>;
+    } & Options): Promise<AxiosResponse<Shift, any>>;
     get(id: number, options: Options): Promise<Shift>;
     list(query: ShiftsQueryParams, options?: Options): AsyncGenerator<Shift, void, unknown>;
     listAll(query: ShiftsQueryParams, options?: Options): Promise<Shift[]>;
-    listByPage(query: ShiftsQueryParams, options?: Options): AsyncGenerator<AxiosResponse<ApiShift[], any>, any, unknown>;
-    update(shift: RequirementsOf<ApiShift, 'id'>): Promise<Shift>;
-    update(shift: RequirementsOf<ApiShift, 'id'>, options: {
+    listByPage(query: ShiftsQueryParams, options?: Options): AsyncGenerator<AxiosResponse<Shift[], any>, any, unknown>;
+    update(shift: RequirementsOf<Shift, 'id'>): Promise<Shift>;
+    update(shift: RequirementsOf<Shift, 'id'>, options: {
         rawResponse: true;
-    } & Options): Promise<AxiosResponse<ApiShift>>;
-    update(shift: RequirementsOf<ApiShift, 'id'>, options: Options): Promise<Shift>;
-    update(shifts: RequirementsOf<ApiShift, 'id'>[]): Promise<{
+    } & 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<ApiShift, 'id'>, options: Options): Promise<Shift>;
-    update(shifts: RequirementsOf<ApiShift, 'id'>[], options: {
+    update(shift: RequirementsOf<Shift, 'id'>, options: Options): Promise<Shift>;
+    update(shifts: RequirementsOf<Shift, 'id'>[], options: {
         rawResponse: true;
     } & Options): Promise<AxiosResponse<{
         code: number;
-        data?: ApiShift;
+        data?: Shift;
         error?: string;
     }[]>>;
-    update(shifts: RequirementsOf<ApiShift, 'id'>[], options: Options): Promise<{
+    update(shifts: RequirementsOf<Shift, 'id'>[], options: Options): Promise<{
         success: Shift[];
         failed: {
             id: number;