rotacloud 1.0.23 → 1.0.27

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.22' };
+export const Version = { version: '1.0.27' };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rotacloud",
-  "version": "1.0.23",
+  "version": "1.0.27",
   "description": "The RotaCloud SDK for the RotaCloud API",
   "engines": {
     "node": ">=14.17.0"
@@ -15,8 +15,6 @@
   },
   "scripts": {
     "version:bump": "npm --no-git-tag-version version patch",
-    "version:copy": "cross-var echo export const Version = { version: \"'$npm_package_version'\" } > ./src/version.ts",
-    "version:all": "npm run version:bump && npm run version:copy",
     "watch": "rm -rf dist/* && concurrently \"tsc -p tsconfig.json --watch\" \"tsc -p tsconfig-cjs.json --watch\" && ./fixup",
     "build": "rm -rf dist/* && tsc -p tsconfig.json && tsc -p tsconfig-cjs.json && ./fixup",
     "lint": "eslint src --ext .ts",

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/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

@@ -2,6 +2,8 @@ import {
   AccountsService,
   AttendanceService,
   AvailabilityService,
+  DailyBudgetsService,
+  DailyRevenueService,
   DaysOffService,
   GroupsService,
   LeaveEmbargoesService,
@@ -21,6 +23,8 @@ export class RotaCloud {
   public accounts = new AccountsService();
   public attendance = new AttendanceService();
   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();
   }
 }

package/src/services/attendance.service.ts

@@ -5,23 +5,19 @@ import { Service, Options, RequirementsOf } from './index.js';
 import { Attendance } from '../models/attendance.model.js';
 import { ErrorResponse } from '../models/error-response.model.js';
 import { AttendanceQueryParams } from '../interfaces/query-params/attendance-query-params.interface.js';
-import { InternalQueryParams } from '../interfaces/query-params/internal-query-params.interface.js';
 
 type RequiredProps = 'user' | 'in_time';
 
-class AttendanceService extends Service {
+export class AttendanceService extends Service {
   private apiPath = '/attendance';
 
   create(data: RequirementsOf<ApiAttendance, RequiredProps>): Promise<Attendance>;
   create(
     data: RequirementsOf<ApiAttendance, RequiredProps>,
-    options: { rawResponse: true; params?: InternalQueryParams }
+    options: { rawResponse: true } & Options
   ): Promise<AxiosResponse<ApiAttendance, any>>;
-  create(
-    data: RequirementsOf<ApiAttendance, RequiredProps>,
-    options: Options<InternalQueryParams>
-  ): Promise<ApiAttendance>;
-  create(data: RequirementsOf<ApiAttendance, RequiredProps>, options?: Options<InternalQueryParams>) {
+  create(data: RequirementsOf<ApiAttendance, RequiredProps>, options: Options): Promise<ApiAttendance>;
+  create(data: RequirementsOf<ApiAttendance, RequiredProps>, options?: Options) {
     return super.fetch<ApiAttendance>({ url: this.apiPath, data, method: 'POST' }).then(
       (res) => Promise.resolve(options?.rawResponse ? res : new Attendance(res.data)),
       (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err))
@@ -29,29 +25,26 @@ class AttendanceService extends Service {
   }
 
   get(id: number): Promise<Attendance>;
-  get(
-    id: number,
-    options: { rawResponse: true; params?: InternalQueryParams }
-  ): Promise<AxiosResponse<ApiAttendance, any>>;
-  get(id: number, options: Options<InternalQueryParams>): Promise<ApiAttendance>;
-  get(id: number, options?: Options<InternalQueryParams>) {
+  get(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<ApiAttendance, any>>;
+  get(id: number, options: Options): Promise<Attendance>;
+  get(id: number, options?: Options) {
     return super.fetch<ApiAttendance>({ url: `${this.apiPath}/${id}` }, options).then(
       (res) => Promise.resolve(options?.rawResponse ? res : new Attendance(res.data)),
       (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err))
     );
   }
 
-  async *list(options?: Options<AttendanceQueryParams & InternalQueryParams>) {
-    for await (const res of super.iterator<ApiAttendance>({ url: this.apiPath }, options)) {
+  async *list(query: AttendanceQueryParams, options?: Options) {
+    for await (const res of super.iterator<ApiAttendance>({ url: this.apiPath, params: query }, options)) {
       yield new Attendance(res);
     }
   }
 
-  listAll(): Promise<Attendance[]>;
-  async listAll() {
+  listAll(query: AttendanceQueryParams, options?: Options): Promise<Attendance[]>;
+  async listAll(query: AttendanceQueryParams, options?: Options) {
     try {
       const attendance = [] as Attendance[];
-      for await (const atten of this.list()) {
+      for await (const atten of this.list(query, options)) {
         attendance.push(atten);
       }
       return attendance;
@@ -60,18 +53,18 @@ class AttendanceService extends Service {
     }
   }
 
-  listByPage(options?: Options<AttendanceQueryParams & InternalQueryParams>) {
-    return super.iterator<ApiAttendance>({ url: this.apiPath }, options).byPage();
+  listByPage(query: AttendanceQueryParams, options?: Options) {
+    return super.iterator<ApiAttendance>({ url: this.apiPath, params: query }, options).byPage();
   }
 
   update(id: number, data: Partial<ApiAttendance>): Promise<Attendance>;
   update(
     id: number,
     data: Partial<ApiAttendance>,
-    options: { rawResponse: true; params?: InternalQueryParams }
+    options: { rawResponse: true } & Options
   ): Promise<AxiosResponse<ApiAttendance, any>>;
-  update(id: number, data: Partial<ApiAttendance>, options: Options<InternalQueryParams>): Promise<Attendance>;
-  update(id: number, data: Partial<ApiAttendance>, options?: Options<InternalQueryParams>) {
+  update(id: number, data: Partial<ApiAttendance>, options: Options): Promise<Attendance>;
+  update(id: number, data: Partial<ApiAttendance>, options?: Options) {
     return super
       .fetch<ApiAttendance>({
         url: `${this.apiPath}/${id}`,
@@ -85,17 +78,12 @@ class AttendanceService extends Service {
   }
 
   delete(id: number): Promise<number>;
-  delete(
-    id: number,
-    options: { rawResponse: true; params?: InternalQueryParams }
-  ): Promise<AxiosResponse<ApiAttendance, any>>;
-  delete(id: number, options: Options<InternalQueryParams>): Promise<number>;
-  delete(id: number, options?: Options<InternalQueryParams>) {
+  delete(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<ApiAttendance, any>>;
+  delete(id: number, options: Options): Promise<number>;
+  delete(id: number, options?: Options) {
     return super.fetch<ApiAttendance>({ 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 { AttendanceService };

package/src/services/availability.service.ts

@@ -1,28 +1,18 @@
 import { AxiosResponse } from 'axios';
-import { Service, Options, RequirementsOf } from './index.js';
+import { Service, Options } from './index.js';
 
-import { InternalQueryParams } from '../interfaces/query-params/internal-query-params.interface.js';
 import { AvailabilityQueryParams } from '../interfaces/query-params/availability-query-params.interface.js';
 import { Availability } from '../models/availability.model.js';
 import { ApiAvailability } from '../interfaces/availability.interface.js';
 import { ErrorResponse } from '../models/error-response.model.js';
 
-type RequiredProps = 'start' | 'end';
-type RequiredOptions<T> = RequirementsOf<Options<T>, 'params'>;
-
 export class AvailabilityService extends Service {
   private apiPath = '/availability';
 
   update(data: ApiAvailability): Promise<Availability>;
-  update(
-    data: ApiAvailability,
-    options: { rawResponse: true; params?: InternalQueryParams }
-  ): Promise<AxiosResponse<ApiAvailability>>;
-  update(
-    data: ApiAvailability,
-    options?: Options<InternalQueryParams>
-  ): Promise<Availability | AxiosResponse<ApiAvailability>>;
-  update(data: ApiAvailability, options?: Options<InternalQueryParams>) {
+  update(data: ApiAvailability, options: { rawResponse: true } & Options): Promise<AxiosResponse<ApiAvailability>>;
+  update(data: ApiAvailability, options?: Options): Promise<Availability | AxiosResponse<ApiAvailability>>;
+  update(data: ApiAvailability, options?: Options) {
     return super
       .fetch<ApiAvailability>({
         url: this.apiPath,
@@ -37,15 +27,9 @@ export class AvailabilityService extends Service {
 
   /** Alias of {@link AvailabilityService["update"]} */
   create(data: ApiAvailability): Promise<Availability>;
-  create(
-    data: ApiAvailability,
-    options: { rawResponse: true; params?: InternalQueryParams }
-  ): Promise<AxiosResponse<ApiAvailability>>;
-  create(
-    data: ApiAvailability,
-    options?: Options<InternalQueryParams>
-  ): Promise<Availability | AxiosResponse<ApiAvailability>>;
-  create(data: ApiAvailability, options?: Options<InternalQueryParams>) {
+  create(data: ApiAvailability, options: { rawResponse: true } & Options): Promise<AxiosResponse<ApiAvailability>>;
+  create(data: ApiAvailability, options?: Options): Promise<Availability | AxiosResponse<ApiAvailability>>;
+  create(data: ApiAvailability, options?: Options) {
     return this.update(data, options);
   }
 
@@ -53,14 +37,10 @@ export class AvailabilityService extends Service {
   delete(
     user: number,
     dates: string[],
-    options: { rawResponse: true; params?: InternalQueryParams }
+    options: { rawResponse: true } & Options
   ): Promise<AxiosResponse<ApiAvailability>>;
-  delete(
-    user: number,
-    dates: string[],
-    options?: Options<InternalQueryParams>
-  ): Promise<Availability | AxiosResponse<ApiAvailability>>;
-  delete(user: number, dates: string[], options?: Options<InternalQueryParams>) {
+  delete(user: number, dates: string[], options?: Options): Promise<Availability | AxiosResponse<ApiAvailability>>;
+  delete(user: number, dates: string[], options?: Options) {
     return this.update(
       {
         user,
@@ -76,13 +56,13 @@ export class AvailabilityService extends Service {
     );
   }
 
-  async *list(options: RequiredOptions<RequirementsOf<AvailabilityQueryParams, RequiredProps> & InternalQueryParams>) {
-    for await (const res of super.iterator<ApiAvailability>({ url: this.apiPath }, options)) {
+  async *list(query: AvailabilityQueryParams, options?: Options) {
+    for await (const res of super.iterator<ApiAvailability>({ url: this.apiPath, params: query }, options)) {
       yield new Availability(res);
     }
   }
 
-  listByPage(options: RequiredOptions<RequirementsOf<AvailabilityQueryParams, RequiredProps> & InternalQueryParams>) {
-    return super.iterator<ApiAvailability>({ url: this.apiPath }, options).byPage();
+  listByPage(query: AvailabilityQueryParams, options?: Options) {
+    return super.iterator<ApiAvailability>({ url: this.apiPath, params: query }, options).byPage();
   }
 }

package/src/services/daily-budgets.service.ts

@@ -0,0 +1,53 @@
+import { AxiosResponse } from 'axios';
+import { ApiDailyBudgets } from '../interfaces/daily-budgets.interface.js';
+import { Service, Options } from './index.js';
+
+import { DailyBudgets } from '../models/daily-budgets.model.js';
+import { ErrorResponse } from '../models/error-response.model.js';
+import { DailyBudgetsQueryParams } from '../interfaces/query-params/daily-budgets-query-params.interface.js';
+
+export class DailyBudgetsService extends Service {
+  private apiPath = '/daily_budgets';
+
+  async *list(query: DailyBudgetsQueryParams, options?: Options) {
+    for await (const res of super.iterator<ApiDailyBudgets>({ url: this.apiPath, params: query }, options)) {
+      yield new DailyBudgets(res);
+    }
+  }
+
+  listAll(query: DailyBudgetsQueryParams, options?: Options): Promise<DailyBudgets[]>;
+  async listAll(query: DailyBudgetsQueryParams, options?: Options) {
+    try {
+      const attendance = [] as DailyBudgets[];
+      for await (const atten of this.list(query, options)) {
+        attendance.push(atten);
+      }
+      return attendance;
+    } catch (err) {
+      return err;
+    }
+  }
+
+  listByPage(query: DailyBudgetsQueryParams, options?: Options) {
+    return super.iterator<ApiDailyBudgets>({ url: this.apiPath, params: query }, options).byPage();
+  }
+
+  update(data: Partial<ApiDailyBudgets>[]): Promise<number>;
+  update(
+    data: Partial<ApiDailyBudgets>[],
+    options: { rawResponse: true } & Options
+  ): Promise<AxiosResponse<ApiDailyBudgets, any>>;
+  update(data: Partial<ApiDailyBudgets>[], options: Options): Promise<number>;
+  update(data: Partial<ApiDailyBudgets>[], options?: Options) {
+    return super
+      .fetch<ApiDailyBudgets>({
+        url: `${this.apiPath}`,
+        data,
+        method: 'POST',
+      })
+      .then(
+        (res) => Promise.resolve(options?.rawResponse ? res : res.status),
+        (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err))
+      );
+  }
+}