rotacloud 1.0.58 → 1.1.1

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

@@ -1,5 +1,4 @@
 import { Service } from './index.js';
-import { Shift } from '../models/shift.model.js';
 export class ShiftsService extends Service {
     constructor() {
         super(...arguments);
@@ -8,16 +7,16 @@ export class ShiftsService extends Service {
     create(data, options) {
         return super
             .fetch({ url: this.apiPath, data, method: 'POST' })
-            .then((res) => Promise.resolve(options?.rawResponse ? res : new Shift(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 Shift(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 Shift(res);
+            yield res;
         }
     }
     async listAll(query, options) {
@@ -38,7 +37,7 @@ export class ShiftsService extends Service {
                 data: shifts,
                 method: 'POST',
             })
-                .then((res) => (options?.rawResponse ? res : new Shift(res.data)));
+                .then((res) => (options?.rawResponse ? res : res.data));
         }
         return super
             .fetch({
@@ -54,7 +53,7 @@ export class ShiftsService extends Service {
             for (let shiftIdx = 0; shiftIdx < res.data.length; shiftIdx += 1) {
                 const { data, error } = res.data[shiftIdx];
                 if (data)
-                    success.push(new Shift(data));
+                    success.push(data);
                 if (error)
                     failed.push({ id: shifts[shiftIdx].id, error });
             }

package/dist/mjs/services/terminals-active.service.d.ts

@@ -1,17 +1,16 @@
 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 {
     action: string;
     device: string;
 }
-declare class TerminalsActiveService extends Service {
+export declare class TerminalsActiveService extends Service {
     private apiPath;
     launchTerminal(data: LaunchTerminal): Promise<Terminal>;
     launchTerminal(data: LaunchTerminal, options: {
@@ -25,11 +24,11 @@ declare class TerminalsActiveService extends Service {
     pingTerminal(id: number, data: PingTerminal, options: Options): Promise<number>;
     list(options?: Options): AsyncGenerator<Terminal, void, unknown>;
     listAll(options?: Options): Promise<Terminal[]>;
-    listByPage(options?: Options): AsyncGenerator<AxiosResponse<ApiTerminal[], any>, any, unknown>;
+    listByPage(options?: Options): AsyncGenerator<AxiosResponse<Terminal[], any>, any, unknown>;
     closeTerminal(id: number): Promise<number>;
     closeTerminal(id: number, options: {
         rawResponse: true;
     } & Options): Promise<AxiosResponse<any, any>>;
     closeTerminal(id: number, options: Options): Promise<number>;
 }
-export { TerminalsActiveService };
+export {};

package/dist/mjs/services/terminals-active.service.js

@@ -1,6 +1,5 @@
 import { Service } from './index.js';
-import { Terminal } from '../models/terminal.model.js';
-class TerminalsActiveService extends Service {
+export class TerminalsActiveService extends Service {
     constructor() {
         super(...arguments);
         this.apiPath = '/terminals_active';
@@ -12,7 +11,7 @@ class TerminalsActiveService extends Service {
             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, data, options) {
         return super
@@ -21,7 +20,7 @@ class TerminalsActiveService extends Service {
     }
     async *list(options) {
         for await (const res of super.iterator({ url: this.apiPath }, options)) {
-            yield new Terminal(res);
+            yield res;
         }
     }
     async listAll(options) {
@@ -40,4 +39,3 @@ class TerminalsActiveService extends Service {
             .then((res) => Promise.resolve(options?.rawResponse ? res : res.status));
     }
 }
-export { TerminalsActiveService };

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

@@ -1,25 +1,24 @@
 import { AxiosResponse } from 'axios';
-import { ApiTerminal } from '../interfaces/index.js';
+import { Terminal } from '../interfaces/index.js';
 import { Service, Options, RequirementsOf } from './index.js';
-import { Terminal } from '../models/terminal.model.js';
 type RequiredProps = 'name' | 'timezone';
-declare class TerminalsService extends Service {
+export declare class TerminalsService extends Service {
     private apiPath;
-    create(data: RequirementsOf<ApiTerminal, RequiredProps>): Promise<Terminal>;
-    create(data: RequirementsOf<ApiTerminal, RequiredProps>, options: {
+    create(data: RequirementsOf<Terminal, RequiredProps>): Promise<Terminal>;
+    create(data: RequirementsOf<Terminal, RequiredProps>, options: {
         rawResponse: true;
-    } & Options): Promise<AxiosResponse<ApiTerminal, any>>;
-    create(data: RequirementsOf<ApiTerminal, RequiredProps>, options: Options): Promise<Terminal>;
+    } & Options): Promise<AxiosResponse<Terminal, any>>;
+    create(data: RequirementsOf<Terminal, RequiredProps>, options: Options): Promise<Terminal>;
     get(id: number): Promise<Terminal>;
     get(id: number, options: {
         rawResponse: true;
-    } & Options): Promise<AxiosResponse<ApiTerminal, any>>;
+    } & Options): Promise<AxiosResponse<Terminal, any>>;
     get(id: number, options: Options): Promise<Terminal>;
-    update(id: number, data: Partial<ApiTerminal>): Promise<Terminal>;
-    update(id: number, data: Partial<ApiTerminal>, options: {
+    update(id: number, data: Partial<Terminal>): Promise<Terminal>;
+    update(id: number, data: Partial<Terminal>, options: {
         rawResponse: true;
-    } & Options): Promise<AxiosResponse<ApiTerminal, any>>;
-    update(id: number, data: Partial<ApiTerminal>, options: Options): Promise<Terminal>;
+    } & Options): Promise<AxiosResponse<Terminal, any>>;
+    update(id: number, data: Partial<Terminal>, options: Options): Promise<Terminal>;
     closeTerminal(id: number): Promise<number>;
     closeTerminal(id: number, options: {
         rawResponse: true;
@@ -27,6 +26,6 @@ declare class TerminalsService extends Service {
     closeTerminal(id: number, options: Options): Promise<number>;
     list(options?: Options): AsyncGenerator<Terminal, void, unknown>;
     listAll(options?: Options): Promise<Terminal[]>;
-    listByPage(options?: Options): AsyncGenerator<AxiosResponse<ApiTerminal[], any>, any, unknown>;
+    listByPage(options?: Options): AsyncGenerator<AxiosResponse<Terminal[], any>, any, unknown>;
 }
-export { TerminalsService };
+export {};

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

@@ -1,6 +1,5 @@
 import { Service } from './index.js';
-import { Terminal } from '../models/terminal.model.js';
-class TerminalsService extends Service {
+export class TerminalsService extends Service {
     constructor() {
         super(...arguments);
         this.apiPath = '/terminals';
@@ -8,12 +7,12 @@ class TerminalsService extends Service {
     create(data, options) {
         return super
             .fetch({ 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));
     }
     get(id, options) {
         return super
             .fetch({ url: `${this.apiPath}/${id}` }, options)
-            .then((res) => Promise.resolve(options?.rawResponse ? res : new Terminal(res.data)));
+            .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
     }
     update(id, data, options) {
         return super
@@ -22,7 +21,7 @@ class TerminalsService extends Service {
             data,
             method: 'POST',
         })
-            .then((res) => Promise.resolve(options?.rawResponse ? res : new Terminal(res.data)));
+            .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
     }
     closeTerminal(id, options) {
         return super
@@ -31,7 +30,7 @@ class TerminalsService extends Service {
     }
     async *list(options) {
         for await (const res of super.iterator({ url: this.apiPath }, options)) {
-            yield new Terminal(res);
+            yield res;
         }
     }
     async listAll(options) {
@@ -45,4 +44,3 @@ class TerminalsService extends Service {
         return super.iterator({ url: this.apiPath }, options).byPage();
     }
 }
-export { TerminalsService };

package/dist/mjs/services/toil-accruals.service.d.ts

@@ -1,16 +1,15 @@
 import { AxiosResponse } from 'axios';
 import { Options, RequirementsOf, Service } from './service';
 import { ToilAccrualsQueryParams } from '../interfaces/query-params/toil-accruals-query-params.interface';
-import { ToilAccrual } from '../models/toil-accrual.model';
-import { ApiToilAccrual } from '../interfaces/toil-accrual.interface';
+import { ToilAccrual } from '../interfaces/toil-accrual.interface';
 type RequiredProps = 'duration_hours' | 'leave_year' | 'user_id';
 export declare class ToilAccrualsService extends Service {
     private apiPath;
-    create(data: RequirementsOf<ApiToilAccrual, RequiredProps>): Promise<ToilAccrual>;
-    create(data: RequirementsOf<ApiToilAccrual, RequiredProps>, options: {
+    create(data: RequirementsOf<ToilAccrual, RequiredProps>): Promise<ToilAccrual>;
+    create(data: RequirementsOf<ToilAccrual, RequiredProps>, options: {
         rawResponse: true;
-    } & Options): Promise<AxiosResponse<ApiToilAccrual, any>>;
-    create(data: RequirementsOf<ApiToilAccrual, RequiredProps>, options: Options): Promise<ToilAccrual>;
+    } & Options): Promise<AxiosResponse<ToilAccrual, any>>;
+    create(data: RequirementsOf<ToilAccrual, RequiredProps>, options: Options): Promise<ToilAccrual>;
     get(id: number): Promise<ToilAccrual>;
     get(id: number, options: {
         rawResponse: true;
@@ -18,7 +17,7 @@ export declare class ToilAccrualsService extends Service {
     get(id: number, options: Options): Promise<ToilAccrual>;
     list(query: ToilAccrualsQueryParams, options?: Options): AsyncGenerator<ToilAccrual, void, unknown>;
     listAll(query: ToilAccrualsQueryParams, options?: Options): Promise<ToilAccrual[]>;
-    listByPage(query: ToilAccrualsQueryParams, options?: Options): AsyncGenerator<AxiosResponse<ApiToilAccrual[], any>, any, unknown>;
+    listByPage(query: ToilAccrualsQueryParams, options?: Options): AsyncGenerator<AxiosResponse<ToilAccrual[], any>, any, unknown>;
     delete(id: number): Promise<number>;
     delete(id: number, options: {
         rawResponse: true;

package/dist/mjs/services/toil-accruals.service.js

@@ -1,5 +1,4 @@
 import { Service } from './service';
-import { ToilAccrual } from '../models/toil-accrual.model';
 export class ToilAccrualsService extends Service {
     constructor() {
         super(...arguments);
@@ -8,16 +7,16 @@ export class ToilAccrualsService extends Service {
     create(data, options) {
         return super
             .fetch({ url: this.apiPath, data, method: 'POST' })
-            .then((res) => Promise.resolve(options?.rawResponse ? res : new ToilAccrual(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 ToilAccrual(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 ToilAccrual(res);
+            yield res;
         }
     }
     async listAll(query, options) {

package/dist/mjs/services/toil-allowance.service.d.ts

@@ -1,10 +1,9 @@
 import { Options, Service } from './service';
 import { ToilAllowanceQueryParams } from '../interfaces/query-params/toil-allowance-query-params.interface';
-import { ApiToilAllowance } from '../interfaces/toil-allowance.interface';
-import { ToilAllowance } from '../models/toil-allowance.model';
+import { ToilAllowance } from '../interfaces/toil-allowance.interface';
 export declare class ToilAllowanceService extends Service {
     private apiPath;
     list(year: number, query: ToilAllowanceQueryParams, options?: Options): AsyncGenerator<ToilAllowance, void, unknown>;
     listAll(year: number, query: ToilAllowanceQueryParams, options?: Options): Promise<ToilAllowance[]>;
-    listByPage(year: number, query: ToilAllowanceQueryParams, options?: Options): AsyncGenerator<import("axios").AxiosResponse<ApiToilAllowance[][], any>, any, unknown>;
+    listByPage(year: number, query: ToilAllowanceQueryParams, options?: Options): AsyncGenerator<import("axios").AxiosResponse<ToilAllowance[][], any>, any, unknown>;
 }

package/dist/mjs/services/toil-allowance.service.js

@@ -1,5 +1,4 @@
 import { Service } from './service';
-import { ToilAllowance } from '../models/toil-allowance.model';
 export class ToilAllowanceService extends Service {
     constructor() {
         super(...arguments);
@@ -7,7 +6,7 @@ export class ToilAllowanceService extends Service {
     }
     async *list(year, query, options) {
         for await (const res of super.iterator({ url: `${this.apiPath}/${year}`, params: query }, options)) {
-            yield new ToilAllowance(res);
+            yield res;
         }
     }
     async listAll(year, query, options) {

package/dist/mjs/services/users-clock-in.service.d.ts

@@ -1,62 +1,54 @@
 import { AxiosResponse } from 'axios';
-import { ApiUserBreak, ApiUserClockedIn, ApiUserClockedOut, ApiTerminalLocation } from '../interfaces/index.js';
+import { UserBreak, UserClockedIn, UserClockedOut, TerminalLocation } from '../interfaces/index.js';
 import { Service, Options, RequirementsOf } from './index.js';
-import { UserClockedIn, UserClockedOut } from '../models/index.js';
 interface UserClockIn {
     method: string;
     shift: number;
     terminal: number;
     user: number;
     photo?: string;
-    location: ApiTerminalLocation;
+    location: TerminalLocation;
 }
 interface UserClockOut extends Omit<UserClockIn, 'user' | 'shift'> {
 }
-interface UserBreak {
+interface UserBreakRequest {
     method: string;
     action: string;
     terminal: number;
     photo?: string;
-    location: ApiTerminalLocation;
-}
-declare class UserBreak {
-    start_time: number;
-    start_location: ApiTerminalLocation;
-    end_time: number | null;
-    end_location: ApiTerminalLocation | null;
-    constructor(apiUserBreak: ApiUserBreak);
+    location: TerminalLocation;
 }
 type RequiredPropsClockIn = 'method';
 type RequiredPropsBreak = 'method' | 'action';
-declare class UsersClockInService extends Service {
+export declare class UsersClockInService extends Service {
     private apiPath;
     getClockedInUser(id: number): Promise<UserClockedIn>;
     getClockedInUser(id: number, options: {
         rawResponse: true;
-    } & Options): Promise<AxiosResponse<ApiUserClockedIn, any>>;
+    } & Options): Promise<AxiosResponse<UserClockedIn, any>>;
     getClockedInUser(id: number, options: Options): Promise<UserClockedIn>;
     list(options?: Options): AsyncGenerator<UserClockedIn, void, unknown>;
     listAll(options?: Options): Promise<UserClockedIn[]>;
-    listByPage(options?: Options): AsyncGenerator<AxiosResponse<ApiUserClockedIn[], any>, any, unknown>;
+    listByPage(options?: Options): AsyncGenerator<AxiosResponse<UserClockedIn[], any>, any, unknown>;
     clockIn(data: RequirementsOf<UserClockIn, RequiredPropsClockIn>): Promise<UserClockedIn>;
     clockIn(data: RequirementsOf<UserClockIn, RequiredPropsClockIn>, options: {
         rawResponse: true;
-    } & Options): Promise<AxiosResponse<ApiUserClockedIn, any>>;
+    } & Options): Promise<AxiosResponse<UserClockedIn, any>>;
     clockIn(data: RequirementsOf<UserClockIn, RequiredPropsClockIn>, options: Options): Promise<UserClockedIn>;
     clockOut(id: number, data: UserClockOut): Promise<UserClockedOut>;
     clockOut(id: number, data: UserClockOut, options: {
         rawResponse: true;
-    } & Options): Promise<AxiosResponse<ApiUserClockedOut, any>>;
+    } & Options): Promise<AxiosResponse<UserClockedOut, any>>;
     clockOut(id: number, data: UserClockOut, options: Options): Promise<UserClockedOut>;
-    startBreak(id: number, data: RequirementsOf<UserBreak, RequiredPropsBreak>): Promise<UserBreak>;
-    startBreak(id: number, data: RequirementsOf<UserBreak, RequiredPropsBreak>, options: {
+    startBreak(id: number, data: RequirementsOf<UserBreakRequest, RequiredPropsBreak>): Promise<UserBreak>;
+    startBreak(id: number, data: RequirementsOf<UserBreakRequest, RequiredPropsBreak>, options: {
         rawResponse: true;
-    } & Options): Promise<AxiosResponse<ApiUserBreak, any>>;
-    startBreak(id: number, data: RequirementsOf<UserBreak, RequiredPropsBreak>, options: Options): Promise<UserBreak>;
-    endBreak(id: number, data: RequirementsOf<UserBreak, RequiredPropsBreak>): Promise<UserBreak>;
-    endBreak(id: number, data: RequirementsOf<UserBreak, RequiredPropsBreak>, options: {
+    } & Options): Promise<AxiosResponse<UserBreak, any>>;
+    startBreak(id: number, data: RequirementsOf<UserBreakRequest, RequiredPropsBreak>, options: Options): Promise<UserBreak>;
+    endBreak(id: number, data: RequirementsOf<UserBreakRequest, RequiredPropsBreak>): Promise<UserBreak>;
+    endBreak(id: number, data: RequirementsOf<UserBreakRequest, RequiredPropsBreak>, options: {
         rawResponse: true;
-    } & Options): Promise<AxiosResponse<ApiUserBreak, any>>;
-    endBreak(id: number, data: RequirementsOf<UserBreak, RequiredPropsBreak>, options: Options): Promise<UserBreak>;
+    } & Options): Promise<AxiosResponse<UserBreak, any>>;
+    endBreak(id: number, data: RequirementsOf<UserBreakRequest, RequiredPropsBreak>, options: Options): Promise<UserBreak>;
 }
-export { UsersClockInService };
+export {};

package/dist/mjs/services/users-clock-in.service.js

@@ -1,14 +1,5 @@
 import { Service } from './index.js';
-import { UserClockedIn, UserClockedOut } from '../models/index.js';
-class UserBreak {
-    constructor(apiUserBreak) {
-        this.start_time = apiUserBreak.start_time;
-        this.start_location = apiUserBreak.start_location;
-        this.end_time = apiUserBreak.end_time ?? null;
-        this.end_location = apiUserBreak.end_location ?? null;
-    }
-}
-class UsersClockInService extends Service {
+export class UsersClockInService extends Service {
     constructor() {
         super(...arguments);
         this.apiPath = '/users_clocked_in';
@@ -16,11 +7,11 @@ class UsersClockInService extends Service {
     getClockedInUser(id, options) {
         return super
             .fetch({ url: `${this.apiPath}/${id}` }, options)
-            .then((res) => Promise.resolve(options?.rawResponse ? res : new UserClockedIn(res.data)));
+            .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
     }
     async *list(options) {
         for await (const res of super.iterator({ url: this.apiPath }, options)) {
-            yield new UserClockedIn(res);
+            yield res;
         }
     }
     async listAll(options) {
@@ -36,22 +27,21 @@ class UsersClockInService extends Service {
     clockIn(data, options) {
         return super
             .fetch({ url: this.apiPath, data, method: 'POST' })
-            .then((res) => Promise.resolve(options?.rawResponse ? res : new UserClockedIn(res.data)));
+            .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
     }
     clockOut(id, data, options) {
         return super
             .fetch({ url: `${this.apiPath}/${id}`, data, method: 'DELETE' })
-            .then((res) => Promise.resolve(options?.rawResponse ? res : new UserClockedOut(res.data)));
+            .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
     }
     startBreak(id, data, options) {
         return super
             .fetch({ url: `${this.apiPath}/${id}`, data, method: 'POST' })
-            .then((res) => Promise.resolve(options?.rawResponse ? res : new UserBreak(res.data)));
+            .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
     }
     endBreak(id, data, options) {
         return super
             .fetch({ url: `${this.apiPath}/${id}`, data, method: 'POST' })
-            .then((res) => Promise.resolve(options?.rawResponse ? res : new UserBreak(res.data)));
+            .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
     }
 }
-export { UsersClockInService };

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

@@ -1,33 +1,32 @@
 import { AxiosResponse } from 'axios';
-import { ApiUser } from '../interfaces/index.js';
+import { User } from '../interfaces/index.js';
 import { Service, Options, RequirementsOf } from './index.js';
-import { User } from '../models/user.model.js';
 import { UsersQueryParams } from '../interfaces/query-params/users-query-params.interface.js';
 type RequiredProps = 'first_name' | 'last_name';
-declare class UsersService extends Service {
+export declare class UsersService extends Service {
     private apiPath;
-    create(data: RequirementsOf<ApiUser, RequiredProps>): Promise<User>;
-    create(data: RequirementsOf<ApiUser, RequiredProps>, options: {
+    create(data: RequirementsOf<User, RequiredProps>): Promise<User>;
+    create(data: RequirementsOf<User, RequiredProps>, options: {
         rawResponse: true;
-    } & Options): Promise<AxiosResponse<ApiUser, any>>;
-    create(data: RequirementsOf<ApiUser, RequiredProps>, options: Options): Promise<User>;
+    } & Options): Promise<AxiosResponse<User, any>>;
+    create(data: RequirementsOf<User, RequiredProps>, options: Options): Promise<User>;
     get(id: number): Promise<User>;
     get(id: number, options: {
         rawResponse: true;
-    } & Options): Promise<AxiosResponse<ApiUser, any>>;
+    } & Options): Promise<AxiosResponse<User, any>>;
     get(id: number, options: Options): Promise<User>;
     list(query: UsersQueryParams, options?: Options): AsyncGenerator<User, void, unknown>;
     listAll(query: UsersQueryParams, options?: Options): Promise<User[]>;
-    listByPage(query: UsersQueryParams, options?: Options): AsyncGenerator<AxiosResponse<ApiUser[], any>, any, unknown>;
-    update(id: number, data: Partial<ApiUser>): Promise<User>;
-    update(id: number, data: Partial<ApiUser>, options: {
+    listByPage(query: UsersQueryParams, options?: Options): AsyncGenerator<AxiosResponse<User[], any>, any, unknown>;
+    update(id: number, data: Partial<User>): Promise<User>;
+    update(id: number, data: Partial<User>, options: {
         rawResponse: true;
-    } & Options): Promise<AxiosResponse<ApiUser, any>>;
-    update(id: number, data: Partial<ApiUser>, options: Options): Promise<User>;
+    } & Options): Promise<AxiosResponse<User, any>>;
+    update(id: number, data: Partial<User>, options: Options): Promise<User>;
     delete(id: number): Promise<number>;
     delete(id: number, options: {
         rawResponse: true;
     } & Options): Promise<AxiosResponse<any, any>>;
     delete(id: number, options: Options): Promise<number>;
 }
-export { UsersService };
+export {};

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

@@ -1,6 +1,5 @@
 import { Service } from './index.js';
-import { User } from '../models/user.model.js';
-class UsersService extends Service {
+export class UsersService extends Service {
     constructor() {
         super(...arguments);
         this.apiPath = '/users';
@@ -8,16 +7,16 @@ class UsersService extends Service {
     create(data, options) {
         return super
             .fetch({ url: this.apiPath, data, method: 'POST' })
-            .then((res) => Promise.resolve(options?.rawResponse ? res : new User(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 User(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 User(res);
+            yield res;
         }
     }
     async listAll(query, options) {
@@ -37,7 +36,7 @@ class UsersService extends Service {
             data,
             method: 'POST',
         })
-            .then((res) => Promise.resolve(options?.rawResponse ? res : new User(res.data)));
+            .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
     }
     delete(id, options) {
         return super
@@ -45,4 +44,3 @@ class UsersService extends Service {
             .then((res) => Promise.resolve(options?.rawResponse ? res : res.status));
     }
 }
-export { UsersService };

package/dist/mjs/version.js

@@ -1 +1 @@
-export const Version = { version: '1.0.58' };
+export const Version = { version: '1.1.1' };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rotacloud",
-  "version": "1.0.58",
+  "version": "1.1.1",
   "description": "The RotaCloud SDK for the RotaCloud API",
   "engines": {
     "node": ">=16.10.0"

package/src/interfaces/account-service.interface.ts

@@ -1,4 +1,4 @@
-export interface ApiAccountService {
+export interface AccountService {
   active: boolean;
   billed: boolean;
   hidden: boolean;

package/src/interfaces/account-services.interface.ts

@@ -1,7 +1,7 @@
-import { ApiAccountService } from './index.js';
+import { AccountService } from './index.js';
 
-export interface ApiAccountServices {
-  time_attendance: ApiAccountService;
-  sms: ApiAccountService;
-  pro: ApiAccountService;
+export interface AccountServices {
+  time_attendance: AccountService;
+  sms: AccountService;
+  pro: AccountService;
 }

package/src/interfaces/account.interface.ts

@@ -1,6 +1,6 @@
-import { ApiAccountServices } from './index.js';
+import { AccountServices } from './index.js';
 
-export interface ApiAccount {
+export interface Account {
   id: number;
   name: string;
   level: string;
@@ -16,7 +16,7 @@ export interface ApiAccount {
   county: string | null;
   postcode: string | null;
   country: number;
-  services: ApiAccountServices[];
+  services: AccountServices[];
   total_price: number;
   pricing: object;
   expires_in: number;

package/src/interfaces/attendance.interface.ts

@@ -1,12 +1,12 @@
-import { ApiShift } from './index.js';
+import { Shift } from './index.js';
 
-export interface ApiAttendanceLocation {
+export interface AttendanceLocation {
   lat: number;
   lng: number;
   accuracy: number;
 }
 
-export interface ApiAttendance {
+export interface Attendance {
   id: number;
   deleted: boolean;
   approved: boolean;
@@ -21,11 +21,11 @@ export interface ApiAttendance {
   hours_auto: number;
   hours_is_auto: boolean;
   notes: string | null;
-  shift: ApiShift | null;
+  shift: Shift | null;
   in_method: string;
   out_method: string;
-  in_location: ApiAttendanceLocation;
-  out_location: ApiAttendanceLocation;
+  in_location: AttendanceLocation;
+  out_location: AttendanceLocation;
   in_device: number;
   out_device: number;
   in_terminal: null;

package/src/interfaces/auth.interface.ts

@@ -1,9 +1,9 @@
-export interface ApiAuthAccount {
+export interface AuthAccount {
   id: number;
   name: string;
 }
 
-export interface ApiAuth {
+export interface Auth {
   two_factor_enabled: boolean;
-  accounts: ApiAuthAccount[];
+  accounts: AuthAccount[];
 }