rotacloud 1.0.6 → 1.0.9

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

@@ -0,0 +1,37 @@
+import { AxiosResponse } from 'axios';
+import { ApiLeaveEmbargo } from '../interfaces/index.js';
+import { Service, Options, RequirementsOf } from './index.js';
+import { LeaveEmbargo } from '../models/leave-embargo.model.js';
+import { UsersQueryParams } from '../interfaces/query-params/users-query-params.interface.js';
+import { InternalQueryParams } from '../interfaces/query-params/internal-query-params.inteface.js';
+declare type RequiredProps = 'start_date' | 'end_date' | 'users';
+declare class LeaveEmbargoesService extends Service {
+    private apiPath;
+    create(data: RequirementsOf<ApiLeaveEmbargo, RequiredProps>): Promise<LeaveEmbargo>;
+    create(data: RequirementsOf<ApiLeaveEmbargo, RequiredProps>, options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<ApiLeaveEmbargo, any>>;
+    create(data: RequirementsOf<ApiLeaveEmbargo, RequiredProps>, options: Options<InternalQueryParams>): Promise<LeaveEmbargo>;
+    get(id: number): Promise<LeaveEmbargo>;
+    get(id: number, options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<ApiLeaveEmbargo, any>>;
+    get(id: number, options: Options<InternalQueryParams>): Promise<LeaveEmbargo>;
+    list(options?: Options<UsersQueryParams & InternalQueryParams>): AsyncGenerator<LeaveEmbargo, void, unknown>;
+    listByPage(options?: Options<UsersQueryParams & InternalQueryParams>): AsyncGenerator<AxiosResponse<ApiLeaveEmbargo[], any>, any, unknown>;
+    update(id: number, data: Partial<ApiLeaveEmbargo>): Promise<LeaveEmbargo>;
+    update(id: number, data: Partial<ApiLeaveEmbargo>, options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<ApiLeaveEmbargo, any>>;
+    update(id: number, data: Partial<ApiLeaveEmbargo>, options: Options<InternalQueryParams>): Promise<LeaveEmbargo>;
+    delete(id: number): Promise<number>;
+    delete(id: number, options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<any, any>>;
+    delete(id: number, options: Options<InternalQueryParams>): Promise<number>;
+}
+export { LeaveEmbargoesService };

package/dist/{services → mjs/services}/leave-embargoes.service.js

@@ -3,7 +3,7 @@ import { LeaveEmbargo } from '../models/leave-embargo.model.js';
 import { ErrorResponse } from '../models/error-response.model.js';
 class LeaveEmbargoesService extends Service {
     constructor() {
-        super();
+        super(...arguments);
         this.apiPath = '/leave_embargoes';
     }
     create(data, options) {

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

@@ -0,0 +1,37 @@
+import { AxiosResponse } from 'axios';
+import { ApiLeaveRequest } from '../interfaces/index.js';
+import { Service, Options, RequirementsOf } from './index.js';
+import { LeaveQueryParams } from '../interfaces/query-params/leave-query-params.interface.js';
+import { InternalQueryParams } from '../interfaces/query-params/internal-query-params.inteface.js';
+import { LeaveRequest } from '../models/leave-request.model.js';
+declare type RequiredProps = 'start_date' | 'end_date' | 'type' | 'user';
+declare class LeaveRequestService extends Service {
+    private apiPath;
+    create(data: RequirementsOf<ApiLeaveRequest, RequiredProps>): Promise<LeaveRequest>;
+    create(data: RequirementsOf<ApiLeaveRequest, RequiredProps>, options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<ApiLeaveRequest, any>>;
+    create(data: RequirementsOf<ApiLeaveRequest, RequiredProps>, options: Options<InternalQueryParams>): Promise<LeaveRequest>;
+    get(id: number): Promise<LeaveRequest>;
+    get(id: number, options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<ApiLeaveRequest, any>>;
+    get(id: number, options: Options<InternalQueryParams>): Promise<LeaveRequest>;
+    list(options?: Options<LeaveQueryParams & InternalQueryParams>): AsyncGenerator<LeaveRequest, void, unknown>;
+    listByPage(options?: Options<LeaveQueryParams & InternalQueryParams>): AsyncGenerator<AxiosResponse<ApiLeaveRequest[], any>, any, unknown>;
+    update(id: number, data: Partial<ApiLeaveRequest>): Promise<LeaveRequest>;
+    update(id: number, data: Partial<ApiLeaveRequest>, options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<ApiLeaveRequest, any>>;
+    update(id: number, data: Partial<ApiLeaveRequest>, options: Options<InternalQueryParams>): Promise<LeaveRequest>;
+    delete(id: number): Promise<number>;
+    delete(id: number, options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<ApiLeaveRequest, any>>;
+    delete(id: number, options: Options<InternalQueryParams>): Promise<number>;
+}
+export { LeaveRequestService };

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

@@ -0,0 +1,39 @@
+import { AxiosResponse } from 'axios';
+import { ApiLeave } 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 { InternalQueryParams } from '../interfaces/query-params/internal-query-params.inteface.js';
+import { LeaveType } from '../models/leave-type.model.js';
+declare type RequiredProps = 'users' | 'type' | 'start_date' | 'end_date';
+declare class LeaveService extends Service {
+    private apiPath;
+    create(data: RequirementsOf<ApiLeave, RequiredProps>): Promise<Leave[]>;
+    create(data: RequirementsOf<ApiLeave, RequiredProps>, options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<ApiLeave[], any>>;
+    create(data: RequirementsOf<ApiLeave, RequiredProps>, options: Options<InternalQueryParams>): Promise<Leave[]>;
+    get(id: number): Promise<Leave>;
+    get(id: number, options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<ApiLeave, any>>;
+    get(id: number, options: Options<InternalQueryParams>): Promise<Leave>;
+    list(options?: Options<LeaveQueryParams & InternalQueryParams>): AsyncGenerator<Leave, void, unknown>;
+    listLeaveTypes(options?: Options<InternalQueryParams>): AsyncGenerator<LeaveType, void, unknown>;
+    listByPage(options?: Options<LeaveQueryParams & InternalQueryParams>): AsyncGenerator<AxiosResponse<ApiLeave[], any>, any, unknown>;
+    update(id: number, data: Partial<ApiLeave>): Promise<Leave>;
+    update(id: number, data: Partial<ApiLeave>, options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<ApiLeave, any>>;
+    update(id: number, data: Partial<ApiLeave>, options: Options<InternalQueryParams>): Promise<Leave>;
+    delete(id: number): Promise<number>;
+    delete(id: number, options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<ApiLeave, any>>;
+    delete(id: number, options: Options<InternalQueryParams>): Promise<number>;
+}
+export { LeaveService };

package/dist/{services → mjs/services}/leave.service.js

@@ -4,7 +4,7 @@ import { ErrorResponse } from '../models/error-response.model.js';
 import { LeaveType } from '../models/leave-type.model.js';
 class LeaveService extends Service {
     constructor() {
-        super();
+        super(...arguments);
         this.apiPath = '/leave';
     }
     create(data, options) {

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

@@ -0,0 +1,37 @@
+import { AxiosResponse } from 'axios';
+import { ApiLocation } 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';
+import { InternalQueryParams } from '../interfaces/query-params/internal-query-params.inteface.js';
+declare type RequiredProps = 'name';
+declare class LocationsService extends Service {
+    private apiPath;
+    create(data: RequirementsOf<ApiLocation, RequiredProps>): Promise<Location>;
+    create(data: RequirementsOf<ApiLocation, RequiredProps>, options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<ApiLocation, any>>;
+    create(data: RequirementsOf<ApiLocation, RequiredProps>, options: Options<InternalQueryParams>): Promise<ApiLocation>;
+    get(id: number): Promise<Location>;
+    get(id: number, options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<ApiLocation, any>>;
+    get(id: number, options: Options<InternalQueryParams>): Promise<ApiLocation>;
+    list(options?: Options<LocationsQueryParams & InternalQueryParams>): AsyncGenerator<Location, void, unknown>;
+    listByPage(options?: Options<LocationsQueryParams & InternalQueryParams>): AsyncGenerator<AxiosResponse<ApiLocation[], any>, any, unknown>;
+    update(id: number, data: Partial<ApiLocation>): Promise<Location>;
+    update(id: number, data: Partial<ApiLocation>, options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<ApiLocation, any>>;
+    update(id: number, data: Partial<ApiLocation>, options: Options<InternalQueryParams>): Promise<ApiLocation>;
+    delete(id: number): Promise<number>;
+    delete(id: number, options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<any, any>>;
+    delete(id: number, options: Options<InternalQueryParams>): Promise<number>;
+}
+export { LocationsService };

package/dist/{services → mjs/services}/locations.service.js

@@ -3,7 +3,7 @@ import { Location } from '../models/location.model.js';
 import { ErrorResponse } from '../models/error-response.model.js';
 class LocationsService extends Service {
     constructor() {
-        super();
+        super(...arguments);
         this.apiPath = '/locations';
     }
     create(data, options) {

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

@@ -0,0 +1,37 @@
+import { AxiosResponse } from 'axios';
+import { ApiRole } 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';
+import { InternalQueryParams } from '../interfaces/query-params/internal-query-params.inteface.js';
+declare type RequiredProps = 'name';
+declare class RolesService extends Service {
+    private apiPath;
+    create(data: RequirementsOf<ApiRole, RequiredProps>): Promise<Role>;
+    create(data: RequirementsOf<ApiRole, RequiredProps>, options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<ApiRole, any>>;
+    create(data: RequirementsOf<ApiRole, RequiredProps>, options: Options<InternalQueryParams>): Promise<Role>;
+    get(id: number): Promise<Role>;
+    get(id: number, options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<ApiRole, any>>;
+    get(id: number, options: Options<InternalQueryParams>): Promise<Role>;
+    list(options?: Options<RolesQueryParams & InternalQueryParams>): AsyncGenerator<Role, void, unknown>;
+    listByPage(options?: Options<RolesQueryParams & InternalQueryParams>): AsyncGenerator<AxiosResponse<ApiRole[], any>, any, unknown>;
+    update(id: number, data: Partial<ApiRole>): Promise<Role>;
+    update(id: number, data: Partial<ApiRole>, options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<ApiRole, any>>;
+    update(id: number, data: Partial<ApiRole>, options: Options<InternalQueryParams>): Promise<Role>;
+    delete(id: number): Promise<number>;
+    delete(id: number, options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<any, any>>;
+    delete(id: number, options: Options<InternalQueryParams>): Promise<number>;
+}
+export { RolesService };

package/dist/{services → mjs/services}/roles.service.js

@@ -3,7 +3,7 @@ import { Role } from '../models/role.model.js';
 import { ErrorResponse } from '../models/error-response.model.js';
 class RolesService extends Service {
     constructor() {
-        super();
+        super(...arguments);
         this.apiPath = '/roles';
     }
     create(data, options) {

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

@@ -0,0 +1,20 @@
+import { AxiosRequestConfig, AxiosResponse } from 'axios';
+export declare type RequirementsOf<T, K extends keyof T> = Required<Pick<T, K>> & Partial<T>;
+export interface Options<T> {
+    rawResponse?: boolean;
+    params?: T;
+}
+export declare abstract class Service<ApiResponse = any> {
+    isLeaveRequest(endpoint?: string): boolean;
+    private buildQueryStr;
+    private getPagingObject;
+    fetch<T = ApiResponse>(httpOptions: AxiosRequestConfig, options?: any): Promise<AxiosResponse<T>>;
+    private listFetch;
+    private listResponses;
+    iterator<T = ApiResponse>(reqObject: any, options?: any): {
+        [Symbol.asyncIterator](): {
+            next(): Promise<IteratorResult<T, void>>;
+        };
+        byPage: () => AsyncGenerator<AxiosResponse<T[], any>, any, unknown>;
+    };
+}

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

@@ -0,0 +1,55 @@
+import { AxiosResponse } from 'axios';
+import { ApiShift } 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';
+import { InternalQueryParams } from '../interfaces/query-params/internal-query-params.inteface.js';
+declare type RequiredProps = 'end_time' | 'start_time' | 'location';
+declare class ShiftsService extends Service {
+    private apiPath;
+    create(data: RequirementsOf<ApiShift, RequiredProps>): Promise<Shift>;
+    create(data: RequirementsOf<ApiShift, RequiredProps>, options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<ApiShift, any>>;
+    create(data: RequirementsOf<ApiShift, RequiredProps>, options: Options<InternalQueryParams>): Promise<Shift>;
+    get(id: number): Promise<Shift>;
+    get(id: number, options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<ApiShift, any>>;
+    get(id: number, options: Options<InternalQueryParams>): Promise<Shift>;
+    list(options?: Options<ShiftsQueryParams & InternalQueryParams>): AsyncGenerator<Shift, void, unknown>;
+    listByPage(options?: Options<ShiftsQueryParams & InternalQueryParams>): AsyncGenerator<AxiosResponse<ApiShift[], any>, any, unknown>;
+    update(id: number, data: Partial<ApiShift>): Promise<Shift>;
+    update(id: number, data: Partial<ApiShift>, options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<ApiShift, any>>;
+    update(id: number, data: Partial<ApiShift>, options: Options<InternalQueryParams>): Promise<Shift>;
+    delete(id: number): Promise<number>;
+    delete(id: number, options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<any, any>>;
+    delete(id: number, options: Options<InternalQueryParams>): Promise<number>;
+    acknowledge(data: number[]): Promise<number>;
+    acknowledge(data: number[], options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<any, any>>;
+    acknowledge(data: number[], options: Options<InternalQueryParams>): Promise<number>;
+    publish(data: number[]): Promise<number>;
+    publish(data: number[], options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<any, any>>;
+    publish(data: number[], options: Options<InternalQueryParams>): Promise<number>;
+    unpublish(data: number[]): Promise<number>;
+    unpublish(data: number[], options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<any, any>>;
+    unpublish(data: number[], options: Options<InternalQueryParams>): Promise<number>;
+}
+export { ShiftsService };

package/dist/{services → mjs/services}/shifts.service.js

@@ -3,7 +3,7 @@ import { Shift } from '../models/shift.model.js';
 import { ErrorResponse } from '../models/error-response.model.js';
 class ShiftsService extends Service {
     constructor() {
-        super();
+        super(...arguments);
         this.apiPath = '/shifts';
     }
     create(data, options) {

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

@@ -0,0 +1,37 @@
+import { AxiosResponse } from 'axios';
+import { ApiUser } 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';
+import { InternalQueryParams } from '../interfaces/query-params/internal-query-params.inteface.js';
+declare type RequiredProps = 'first_name' | 'last_name';
+declare class UsersService extends Service {
+    private apiPath;
+    create(data: RequirementsOf<ApiUser, RequiredProps>): Promise<User>;
+    create(data: RequirementsOf<ApiUser, RequiredProps>, options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<ApiUser, any>>;
+    create(data: RequirementsOf<ApiUser, RequiredProps>, options: Options<InternalQueryParams>): Promise<User>;
+    get(id: number): Promise<User>;
+    get(id: number, options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<ApiUser, any>>;
+    get(id: number, options: Options<InternalQueryParams>): Promise<User>;
+    list(options?: Options<UsersQueryParams & InternalQueryParams>): AsyncGenerator<User, void, unknown>;
+    listByPage(options?: Options<UsersQueryParams & InternalQueryParams>): AsyncGenerator<AxiosResponse<ApiUser[], any>, any, unknown>;
+    update(id: number, data: Partial<ApiUser>): Promise<User>;
+    update(id: number, data: Partial<ApiUser>, options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<ApiUser, any>>;
+    update(id: number, data: Partial<ApiUser>, options: Options<InternalQueryParams>): Promise<User>;
+    delete(id: number): Promise<number>;
+    delete(id: number, options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<any, any>>;
+    delete(id: number, options: Options<InternalQueryParams>): Promise<number>;
+}
+export { UsersService };

package/dist/{services → mjs/services}/users.service.js

@@ -3,7 +3,7 @@ import { User } from '../models/user.model.js';
 import { ErrorResponse } from '../models/error-response.model.js';
 class UsersService extends Service {
     constructor() {
-        super();
+        super(...arguments);
         this.apiPath = '/users';
     }
     create(data, options) {

package/dist/mjs/version.d.ts

@@ -0,0 +1,3 @@
+export declare const Version: {
+    version: string;
+};

package/dist/mjs/version.js

@@ -0,0 +1 @@
+export const Version = { version: "1.0.9" };

package/fixup

@@ -0,0 +1,11 @@
+cat >dist/cjs/package.json <<!EOF
+{
+    "type": "commonjs"
+}
+!EOF
+
+cat >dist/mjs/package.json <<!EOF
+{
+    "type": "module"
+}
+!EOF

package/package.json

@@ -1,15 +1,21 @@
 {
   "name": "rotacloud",
-  "version": "1.0.6",
+  "version": "1.0.9",
   "description": "The RotaCloud SDK for the RotaCloud API",
   "engines": {
     "node": ">=14.17.0"
   },
-  "main": "dist/rotacloud.js",
-  "type": "module",
+  "main": "dist/cjs/rotacloud.js",
+  "module": "dist/mjs/rotacloud.js",
+  "exports": {
+    ".": {
+      "require": "./dist/cjs/rotacloud.js",
+      "import": "./dist/mjs/rotacloud.js"
+    }
+  },
   "scripts": {
     "version:output": "echo 'export const Version = { version: \"'$npm_package_version'\" }' > ./src/version.ts",
-    "build": "rm -rf ./dist && tsc",
+    "build": "rm -rf dist/* && tsc -p tsconfig.json && tsc -p tsconfig-cjs.json && ./fixup",
     "watch": "rm -rf ./dist && tsc --watch",
     "lint": "eslint src --ext .ts",
     "test": "echo \"Error: no test specified\" && exit 1"

package/src/interfaces/leave.interface.ts

@@ -3,15 +3,15 @@ import { ApiLeaveDate } from './index.js';
 export interface ApiLeave {
   id: number;
   deleted: boolean;
-  deleted_at: number;
-  deleted_by: number;
+  deleted_at: number | null;
+  deleted_by: number | null;
   type: number;
   user: number;
   admin: number;
   status: string;
   requested: boolean;
-  user_message: string;
-  admin_message: string;
+  user_message: string | null;
+  admin_message: string | null;
   start_date: string;
   start_am_pm: string;
   end_date: string;

package/src/models/group.model.ts

@@ -3,9 +3,11 @@ import { ApiGroup } from '../interfaces/index.js';
 export class Group {
   public id: number;
   public name: string;
+  public users: number[];
 
   constructor(group: ApiGroup) {
     this.id = group.id;
     this.name = group.name;
+    this.users = group.users;
   }
 }

package/src/models/leave.model.ts

@@ -2,10 +2,50 @@ import { ApiLeave, ApiLeaveDate } from '../interfaces/index.js';
 
 export class Leave {
   public id: number;
+  public type: number;
+  public user: number;
+  public start_date: string;
+  public end_date: string;
   public dates: ApiLeaveDate[];
+  public paid: boolean;
+  public status: string;
+  public requested: boolean;
+  public admin_message: string | null;
+  public user_message: string | null;
+  public deleted: boolean;
+  public deleted_at: number | null;
+  public deleted_by: number | null;
+  public admin: number;
+  public start_am_pm: string;
+  public end_am_pm: string;
+  public hours: { [key: string]: number };
+  public hours_method: string;
+  public hours_set: boolean;
+  public requested_at: number;
+  public replied_at: number;
 
   constructor(leave: ApiLeave) {
     this.id = leave.id;
+    this.type = leave.type;
     this.dates = leave.dates;
+    this.user = leave.user;
+    this.start_date = leave.start_date;
+    this.end_date = leave.end_date;
+    this.paid = leave.paid;
+    this.status = leave.status;
+    this.requested = leave.requested;
+    this.admin_message = leave.admin_message;
+    this.user_message = leave.user_message;
+    this.deleted = leave.deleted;
+    this.deleted_at = leave.deleted_at;
+    this.deleted_by = leave.deleted_by;
+    this.admin = leave.admin;
+    this.start_am_pm = leave.start_am_pm;
+    this.end_am_pm = leave.end_am_pm;
+    this.hours = leave.hours;
+    this.hours_method = leave.hours_method;
+    this.hours_set = leave.hours_set;
+    this.requested_at = leave.requested_at;
+    this.replied_at = leave.replied_at;
   }
 }

package/src/models/location.model.ts

@@ -9,9 +9,11 @@ export class LatLngObject {
 export class Location {
   public id: number;
   public name: string;
+  public users: number[];
 
   constructor(locaiton: ApiLocation) {
     this.id = locaiton.id;
     this.name = locaiton.name;
+    this.users = locaiton.users;
   }
 }

package/src/models/role.model.ts

@@ -4,8 +4,11 @@ export class Role {
   public id: number;
   public name: string;
   public colour: string;
+  public users: number[];
+
   constructor(role: ApiRole) {
     this.id = role.id;
     this.name = role.name;
+    this.users = role.users;
   }
 }

package/src/rotacloud.ts

@@ -1,6 +1,8 @@
 import {
   AccountsService,
   AttendanceService,
+  DaysOffService,
+  GroupsService,
   LeaveEmbargoesService,
   LeaveRequestService,
   LeaveService,
@@ -10,7 +12,6 @@ import {
   UsersService,
 } from './services/index.js';
 import { SDKConfig } from './interfaces/index.js';
-import { DaysOffService } from './services/days-off.service.js';
 
 export class RotaCloud {
   public static config: SDKConfig;
@@ -19,6 +20,7 @@ export class RotaCloud {
   public accounts = new AccountsService();
   public attendance = new AttendanceService();
   public daysOff = new DaysOffService();
+  public group = new GroupsService();
   public leaveEmbargoes = new LeaveEmbargoesService();
   public leaveRequests = new LeaveRequestService();
   public leave = new LeaveService();

package/src/services/accounts.service.ts

@@ -7,10 +7,6 @@ import { InternalQueryParams } from '../interfaces/query-params/internal-query-p
 class AccountsService extends Service {
   private apiPath = '/accounts';
 
-  constructor() {
-    super();
-  }
-
   async *list(options?: Options<InternalQueryParams>) {
     for await (const res of super.iterator<ApiAccount>({ url: this.apiPath }, options)) {
       yield new Account(res);

package/src/services/attendance.service.ts

@@ -12,10 +12,6 @@ type RequiredProps = 'user' | 'in_time';
 class AttendanceService extends Service {
   private apiPath = '/attendance';
 
-  constructor() {
-    super();
-  }
-
   create(data: RequirementsOf<ApiAttendance, RequiredProps>): Promise<Attendance>;
   create(
     data: RequirementsOf<ApiAttendance, RequiredProps>,