rotacloud 1.0.24 → 1.0.28

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

@@ -3,36 +3,31 @@ 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.interface.js';
 declare type RequiredProps = 'name';
-declare class LocationsService extends Service {
+export 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>;
+    } & Options): Promise<AxiosResponse<ApiLocation, any>>;
+    create(data: RequirementsOf<ApiLocation, RequiredProps>, options: Options): Promise<Location>;
     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>;
-    listAll(): Promise<Location[]>;
-    listByPage(options?: Options<LocationsQueryParams & InternalQueryParams>): AsyncGenerator<AxiosResponse<ApiLocation[], any>, any, unknown>;
+    } & Options): Promise<AxiosResponse<ApiLocation, 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: {
         rawResponse: true;
-        params?: InternalQueryParams;
-    }): Promise<AxiosResponse<ApiLocation, any>>;
-    update(id: number, data: Partial<ApiLocation>, options: Options<InternalQueryParams>): Promise<ApiLocation>;
+    } & Options): Promise<AxiosResponse<ApiLocation, any>>;
+    update(id: number, data: Partial<ApiLocation>, options: Options): Promise<Location>;
     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>;
+    } & Options): Promise<AxiosResponse<any, any>>;
+    delete(id: number, options: Options): Promise<number>;
 }
-export { LocationsService };
+export {};

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

@@ -1,7 +1,7 @@
 import { Service } from './index.js';
 import { Location } from '../models/location.model.js';
 import { ErrorResponse } from '../models/error-response.model.js';
-class LocationsService extends Service {
+export class LocationsService extends Service {
     constructor() {
         super(...arguments);
         this.apiPath = '/locations';
@@ -12,15 +12,15 @@ class LocationsService extends Service {
     get(id, options) {
         return super.fetch({ url: `${this.apiPath}/${id}` }, options).then((res) => Promise.resolve(options?.rawResponse ? res : new Location(res.data)), (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err)));
     }
-    async *list(options) {
-        for await (const res of super.iterator({ url: this.apiPath }, options)) {
+    async *list(query, options) {
+        for await (const res of super.iterator({ url: this.apiPath, params: query }, options)) {
             yield new Location(res);
         }
     }
-    async listAll() {
+    async listAll(query, options) {
         try {
             const locations = [];
-            for await (const location of this.list()) {
+            for await (const location of this.list(query, options)) {
                 locations.push(location);
             }
             return locations;
@@ -29,8 +29,8 @@ class LocationsService extends Service {
             return err;
         }
     }
-    listByPage(options) {
-        return super.iterator({ url: this.apiPath }, options).byPage();
+    listByPage(query, options) {
+        return super.iterator({ url: this.apiPath, params: query }, options).byPage();
     }
     update(id, data, options) {
         return super
@@ -45,4 +45,3 @@ class LocationsService extends Service {
         return super.fetch({ url: `${this.apiPath}/${id}`, method: 'DELETE' }).then((res) => Promise.resolve(options?.rawResponse ? res : res.status), (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err)));
     }
 }
-export { LocationsService };

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

@@ -3,36 +3,31 @@ 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.interface.js';
 declare type RequiredProps = 'name';
-declare class RolesService extends Service {
+export 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>;
+    } & Options): Promise<AxiosResponse<ApiRole, any>>;
+    create(data: RequirementsOf<ApiRole, RequiredProps>, options: Options): 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>;
-    listAll(): Promise<Role[]>;
-    listByPage(options?: Options<RolesQueryParams & InternalQueryParams>): AsyncGenerator<AxiosResponse<ApiRole[], any>, any, unknown>;
+    } & Options): Promise<AxiosResponse<ApiRole, 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: {
         rawResponse: true;
-        params?: InternalQueryParams;
-    }): Promise<AxiosResponse<ApiRole, any>>;
-    update(id: number, data: Partial<ApiRole>, options: Options<InternalQueryParams>): Promise<Role>;
+    } & Options): Promise<AxiosResponse<ApiRole, any>>;
+    update(id: number, data: Partial<ApiRole>, options: Options): 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>;
+    } & Options): Promise<AxiosResponse<any, any>>;
+    delete(id: number, options: Options): Promise<number>;
 }
-export { RolesService };
+export {};

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

@@ -1,7 +1,7 @@
 import { Service } from './index.js';
 import { Role } from '../models/role.model.js';
 import { ErrorResponse } from '../models/error-response.model.js';
-class RolesService extends Service {
+export class RolesService extends Service {
     constructor() {
         super(...arguments);
         this.apiPath = '/roles';
@@ -12,15 +12,15 @@ class RolesService extends Service {
     get(id, options) {
         return super.fetch({ url: `${this.apiPath}/${id}` }, options).then((res) => Promise.resolve(options?.rawResponse ? res : new Role(res.data)), (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err)));
     }
-    async *list(options) {
-        for await (const res of super.iterator({ url: this.apiPath }, options)) {
+    async *list(query, options) {
+        for await (const res of super.iterator({ url: this.apiPath, params: query }, options)) {
             yield new Role(res);
         }
     }
-    async listAll() {
+    async listAll(query, options) {
         try {
             const roles = [];
-            for await (const role of this.list()) {
+            for await (const role of this.list(query, options)) {
                 roles.push(role);
             }
             return roles;
@@ -29,8 +29,8 @@ class RolesService extends Service {
             return err;
         }
     }
-    listByPage(options) {
-        return super.iterator({ url: this.apiPath }, options).byPage();
+    listByPage(query, options) {
+        return super.iterator({ url: this.apiPath, params: query }, options).byPage();
     }
     update(id, data, options) {
         return super
@@ -45,4 +45,3 @@ class RolesService extends Service {
         return super.fetch({ url: `${this.apiPath}/${id}`, method: 'DELETE' }).then((res) => Promise.resolve(options?.rawResponse ? res : res.status), (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err)));
     }
 }
-export { RolesService };

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

@@ -1,17 +1,19 @@
 import { AxiosRequestConfig, AxiosResponse } from 'axios';
 export declare type RequirementsOf<T, K extends keyof T> = Required<Pick<T, K>> & Partial<T>;
-export interface Options<T> {
+export interface Options {
     rawResponse?: boolean;
-    params?: T;
+    expand?: string[];
+    fields?: string[];
+    limit?: number;
 }
 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>>;
+    fetch<T = ApiResponse>(httpOptions: AxiosRequestConfig, options?: Options): Promise<AxiosResponse<T>>;
     private listFetch;
     private listResponses;
-    iterator<T = ApiResponse>(reqObject: any, options?: any): {
+    iterator<T = ApiResponse>(reqObject: any, options?: Options): {
         [Symbol.asyncIterator](): {
             next(): Promise<IteratorResult<T, void>>;
         };

package/dist/mjs/services/service.js

@@ -45,7 +45,12 @@ export class Service {
             ...httpOptions,
             baseURL: RotaCloud.config.baseUri,
             headers,
-            params: options?.params,
+            params: {
+                expand: options?.expand,
+                fields: options?.fields,
+                limit: options?.limit,
+                ...httpOptions?.params,
+            },
             paramsSerializer: (params) => {
                 return params ? this.buildQueryStr(params) : '';
             },
@@ -69,7 +74,7 @@ export class Service {
             else {
                 running = false;
             }
-            yield await res;
+            yield res;
         } while (running);
     }
     async *listResponses(reqObject, options) {

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

@@ -3,54 +3,46 @@ 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.interface.js';
 declare type RequiredProps = 'end_time' | 'start_time' | 'location';
-declare class ShiftsService extends Service {
+export 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>;
+    } & Options): Promise<AxiosResponse<ApiShift, any>>;
+    create(data: RequirementsOf<ApiShift, RequiredProps>, options: Options): 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>;
-    listAll(): Promise<Shift[]>;
-    listByPage(options?: Options<ShiftsQueryParams & InternalQueryParams>): AsyncGenerator<AxiosResponse<ApiShift[], any>, any, unknown>;
+    } & Options): Promise<AxiosResponse<ApiShift, 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(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>;
+    } & Options): Promise<AxiosResponse<ApiShift, any>>;
+    update(id: number, data: Partial<ApiShift>, options: Options): 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>;
+    } & Options): Promise<AxiosResponse<any, any>>;
+    delete(id: number, options: Options): 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>;
+    } & Options): Promise<AxiosResponse<any, any>>;
+    acknowledge(data: number[], options: Options): 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>;
+    } & Options): Promise<AxiosResponse<any, any>>;
+    publish(data: number[], options: Options): 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>;
+    } & Options): Promise<AxiosResponse<any, any>>;
+    unpublish(data: number[], options: Options): Promise<number>;
 }
-export { ShiftsService };
+export {};

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

@@ -1,7 +1,7 @@
 import { Service } from './index.js';
 import { Shift } from '../models/shift.model.js';
 import { ErrorResponse } from '../models/error-response.model.js';
-class ShiftsService extends Service {
+export class ShiftsService extends Service {
     constructor() {
         super(...arguments);
         this.apiPath = '/shifts';
@@ -12,15 +12,15 @@ class ShiftsService extends Service {
     get(id, options) {
         return super.fetch({ url: `${this.apiPath}/${id}` }, options).then((res) => Promise.resolve(options?.rawResponse ? res : new Shift(res.data)), (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err)));
     }
-    async *list(options) {
-        for await (const res of super.iterator({ url: this.apiPath }, options)) {
+    async *list(query, options) {
+        for await (const res of super.iterator({ url: this.apiPath, params: query }, options)) {
             yield new Shift(res);
         }
     }
-    async listAll() {
+    async listAll(query, options) {
         try {
             const shifts = [];
-            for await (const shift of this.list()) {
+            for await (const shift of this.list(query, options)) {
                 shifts.push(shift);
             }
             return shifts;
@@ -29,8 +29,8 @@ class ShiftsService extends Service {
             return err;
         }
     }
-    listByPage(options) {
-        return super.iterator({ url: this.apiPath }, options).byPage();
+    listByPage(query, options) {
+        return super.iterator({ url: this.apiPath, params: query }, options).byPage();
     }
     update(id, data, options) {
         return super
@@ -54,4 +54,3 @@ class ShiftsService extends Service {
         return super.fetch({ url: '/shifts_published', data, method: 'DELETE' }).then((res) => Promise.resolve(options?.rawResponse ? res : res.status), (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err)));
     }
 }
-export { ShiftsService };

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

@@ -3,36 +3,31 @@ 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.interface.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>;
+    } & Options): Promise<AxiosResponse<ApiUser, any>>;
+    create(data: RequirementsOf<ApiUser, RequiredProps>, options: Options): 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>;
-    listAll(): Promise<User[]>;
-    listByPage(options?: Options<UsersQueryParams & InternalQueryParams>): AsyncGenerator<AxiosResponse<ApiUser[], any>, any, unknown>;
+    } & Options): Promise<AxiosResponse<ApiUser, 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: {
         rawResponse: true;
-        params?: InternalQueryParams;
-    }): Promise<AxiosResponse<ApiUser, any>>;
-    update(id: number, data: Partial<ApiUser>, options: Options<InternalQueryParams>): Promise<User>;
+    } & Options): Promise<AxiosResponse<ApiUser, any>>;
+    update(id: number, data: Partial<ApiUser>, options: Options): 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>;
+    } & Options): Promise<AxiosResponse<any, any>>;
+    delete(id: number, options: Options): Promise<number>;
 }
 export { UsersService };

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

@@ -12,15 +12,15 @@ class UsersService extends Service {
     get(id, options) {
         return super.fetch({ url: `${this.apiPath}/${id}` }, options).then((res) => Promise.resolve(options?.rawResponse ? res : new User(res.data)), (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err)));
     }
-    async *list(options) {
-        for await (const res of super.iterator({ url: this.apiPath }, options)) {
+    async *list(query, options) {
+        for await (const res of super.iterator({ url: this.apiPath, params: query }, options)) {
             yield new User(res);
         }
     }
-    async listAll() {
+    async listAll(query, options) {
         try {
             const users = [];
-            for await (const user of this.list()) {
+            for await (const user of this.list(query, options)) {
                 users.push(user);
             }
             return users;
@@ -29,8 +29,8 @@ class UsersService extends Service {
             return err;
         }
     }
-    listByPage(options) {
-        return super.iterator({ url: this.apiPath }, options).byPage();
+    listByPage(query, options) {
+        return super.iterator({ url: this.apiPath, params: query }, options).byPage();
     }
     update(id, data, options) {
         return super

package/dist/mjs/version.js

@@ -1 +1 @@
-export const Version = { version: '1.0.24' };
+export const Version = { version: '1.0.28' };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rotacloud",
-  "version": "1.0.24",
+  "version": "1.0.28",
   "description": "The RotaCloud SDK for the RotaCloud API",
   "engines": {
     "node": ">=14.17.0"

package/src/interfaces/auth.interface.ts

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

package/src/interfaces/index.ts

@@ -2,6 +2,7 @@ export * from './account-service.interface.js';
 export * from './account-services.interface.js';
 export * from './account.interface.js';
 export * from './attendance.interface.js';
+export * from './auth.interface.js';
 export * from './availability-pattern.interface.js';
 export * from './availability.interface.js';
 export * from './daily-budgets.interface.js';

package/src/interfaces/query-params/daily-budgets-query-params.interface.ts

@@ -1,5 +1,5 @@
 export interface DailyBudgetsQueryParams {
-  start?: string;
-  end?: string;
+  start: string;
+  end: string;
   locations?: number[];
 }

package/src/models/auth.model.ts

@@ -0,0 +1,11 @@
+import { ApiAuth, ApiAuthAccount } from '../interfaces/index.js';
+
+export class Auth {
+  public two_factor_enabled: boolean;
+  public accounts: ApiAuthAccount[];
+
+  constructor(auth: ApiAuth) {
+    this.two_factor_enabled = auth.two_factor_enabled;
+    this.accounts = auth.accounts;
+  }
+}

package/src/models/daily-budgets.model.ts

@@ -9,5 +9,7 @@ export class DailyBudgets {
   constructor(dailyBudgets: ApiDailyBudgets) {
     this.date = dailyBudgets.date;
     this.location = dailyBudgets.location;
+    this.hours_budget = dailyBudgets.hours_budget;
+    this.salary_budget = dailyBudgets.salary_budget;
   }
 }

package/src/rotacloud.ts

@@ -1,7 +1,10 @@
 import {
   AccountsService,
   AttendanceService,
+  AuthService,
   AvailabilityService,
+  DailyBudgetsService,
+  DailyRevenueService,
   DaysOffService,
   GroupsService,
   LeaveEmbargoesService,
@@ -20,7 +23,10 @@ export class RotaCloud {
   public defaultAPIURI = 'https://api.rotacloud.com/v1';
   public accounts = new AccountsService();
   public attendance = new AttendanceService();
+  public auth = new AuthService();
   public availability = new AvailabilityService();
+  public dailyBudgets = new DailyBudgetsService();
+  public dailyRevenue = new DailyRevenueService();
   public daysOff = new DaysOffService();
   public group = new GroupsService();
   public leaveEmbargoes = new LeaveEmbargoesService();

package/src/services/accounts.service.ts

@@ -2,22 +2,21 @@ import { Account } from '../models/account.model.js';
 import { Service, Options } from './index.js';
 
 import { ApiAccount } from '../interfaces/index.js';
-import { InternalQueryParams } from '../interfaces/query-params/internal-query-params.interface.js';
 
 class AccountsService extends Service {
   private apiPath = '/accounts';
 
-  async *list(options?: Options<InternalQueryParams>) {
+  async *list(options?: Options) {
     for await (const res of super.iterator<ApiAccount>({ url: this.apiPath }, options)) {
       yield new Account(res);
     }
   }
 
-  listAll(): Promise<Account[]>;
-  async listAll() {
+  listAll(options?: Options): Promise<Account[]>;
+  async listAll(options?: Options) {
     try {
       const accounts = [] as Account[];
-      for await (const account of this.list()) {
+      for await (const account of this.list(options)) {
         accounts.push(account);
       }
       return accounts;
@@ -26,7 +25,7 @@ class AccountsService extends Service {
     }
   }
 
-  listByPage(options?: Options<InternalQueryParams>) {
+  listByPage(options?: Options) {
     return super.iterator<ApiAccount>({ url: this.apiPath }, options).byPage();
   }
 }