rotacloud 1.0.25 → 1.0.27

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

package/package.json

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

package/src/rotacloud.ts

@@ -3,6 +3,7 @@ import {
   AttendanceService,
   AvailabilityService,
   DailyBudgetsService,
+  DailyRevenueService,
   DaysOffService,
   GroupsService,
   LeaveEmbargoesService,
@@ -23,6 +24,7 @@ export class RotaCloud {
   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

@@ -5,22 +5,21 @@ 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';
-import { InternalQueryParams } from '../interfaces/query-params/internal-query-params.interface.js';
 
-class DailyBudgetsService extends Service {
+export class DailyBudgetsService extends Service {
   private apiPath = '/daily_budgets';
 
-  async *list(options?: Options<DailyBudgetsQueryParams & InternalQueryParams>) {
-    for await (const res of super.iterator<ApiDailyBudgets>({ url: this.apiPath }, options)) {
+  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(): Promise<DailyBudgets[]>;
-  async listAll() {
+  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()) {
+      for await (const atten of this.list(query, options)) {
         attendance.push(atten);
       }
       return attendance;
@@ -29,29 +28,26 @@ class DailyBudgetsService extends Service {
     }
   }
 
-  listByPage(options?: Options<DailyBudgetsQueryParams & InternalQueryParams>) {
-    return super.iterator<ApiDailyBudgets>({ url: this.apiPath }, options).byPage();
+  listByPage(query: DailyBudgetsQueryParams, options?: Options) {
+    return super.iterator<ApiDailyBudgets>({ url: this.apiPath, params: query }, options).byPage();
   }
 
-  update(id: number, data: Partial<ApiDailyBudgets>): Promise<DailyBudgets>;
+  update(data: Partial<ApiDailyBudgets>[]): Promise<number>;
   update(
-    id: number,
-    data: Partial<ApiDailyBudgets>,
-    options: { rawResponse: true; params?: InternalQueryParams }
+    data: Partial<ApiDailyBudgets>[],
+    options: { rawResponse: true } & Options
   ): Promise<AxiosResponse<ApiDailyBudgets, any>>;
-  update(id: number, data: Partial<ApiDailyBudgets>, options: Options<InternalQueryParams>): Promise<ApiDailyBudgets>;
-  update(id: number, data: Partial<ApiDailyBudgets>, options?: Options<InternalQueryParams>) {
+  update(data: Partial<ApiDailyBudgets>[], options: Options): Promise<number>;
+  update(data: Partial<ApiDailyBudgets>[], options?: Options) {
     return super
       .fetch<ApiDailyBudgets>({
-        url: `${this.apiPath}/${id}`,
+        url: `${this.apiPath}`,
         data,
         method: 'POST',
       })
       .then(
-        (res) => Promise.resolve(options?.rawResponse ? res : new DailyBudgets(res.data)),
+        (res) => Promise.resolve(options?.rawResponse ? res : res.status),
         (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err))
       );
   }
 }
-
-export { DailyBudgetsService };

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

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