rotacloud 1.0.23 → 1.0.27

package/.github/workflows/publish.yml

@@ -27,7 +27,7 @@ jobs:
           registry-url: https://registry.npmjs.org/
       - name: Add version number to package
         run: |
-          version="$(npm show . version)"
+          version=$(node -pe "require('./package.json').version")
           echo "Version is $version"
           echo "export const Version = { version: '$version' };" > ./src/version.ts
       - name: Run CI

package/README.md

@@ -2,8 +2,7 @@
 
 ## Contributing
 
-Please ensure you perform the ```npm run version:all``` command before commiting and pushing your changes to the remote branch.
-
+Please ensure you perform the `npm run version:bump` command before commiting and pushing your changes to the remote branch.
 
 ## Configuration
 

package/dist/cjs/interfaces/query-params/daily-budgets-query-params.interface.d.ts

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

package/dist/cjs/models/daily-budgets.model.js

@@ -5,6 +5,8 @@ class DailyBudgets {
     constructor(dailyBudgets) {
         this.date = dailyBudgets.date;
         this.location = dailyBudgets.location;
+        this.hours_budget = dailyBudgets.hours_budget;
+        this.salary_budget = dailyBudgets.salary_budget;
     }
 }
 exports.DailyBudgets = DailyBudgets;

package/dist/cjs/rotacloud.d.ts

@@ -1,4 +1,4 @@
-import { AccountsService, AttendanceService, AvailabilityService, DaysOffService, GroupsService, LeaveEmbargoesService, LeaveRequestService, LeaveService, LocationsService, RolesService, ShiftsService, UsersService } from './services/index.js';
+import { AccountsService, AttendanceService, AvailabilityService, DailyBudgetsService, DailyRevenueService, DaysOffService, GroupsService, LeaveEmbargoesService, LeaveRequestService, LeaveService, LocationsService, RolesService, ShiftsService, UsersService } from './services/index.js';
 import { SDKConfig } from './interfaces/index.js';
 export declare class RotaCloud {
     static config: SDKConfig;
@@ -6,6 +6,8 @@ export declare class RotaCloud {
     accounts: AccountsService;
     attendance: AttendanceService;
     availability: AvailabilityService;
+    dailyBudgets: DailyBudgetsService;
+    dailyRevenue: DailyRevenueService;
     daysOff: DaysOffService;
     group: GroupsService;
     leaveEmbargoes: LeaveEmbargoesService;

package/dist/cjs/rotacloud.js

@@ -18,6 +18,8 @@ class RotaCloud {
         this.accounts = new index_js_1.AccountsService();
         this.attendance = new index_js_1.AttendanceService();
         this.availability = new index_js_1.AvailabilityService();
+        this.dailyBudgets = new index_js_1.DailyBudgetsService();
+        this.dailyRevenue = new index_js_1.DailyRevenueService();
         this.daysOff = new index_js_1.DaysOffService();
         this.group = new index_js_1.GroupsService();
         this.leaveEmbargoes = new index_js_1.LeaveEmbargoesService();

package/dist/cjs/services/accounts.service.d.ts

@@ -1,11 +1,10 @@
 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';
 declare class AccountsService extends Service {
     private apiPath;
-    list(options?: Options<InternalQueryParams>): AsyncGenerator<Account, void, unknown>;
-    listAll(): Promise<Account[]>;
-    listByPage(options?: Options<InternalQueryParams>): AsyncGenerator<import("axios").AxiosResponse<ApiAccount[], any>, any, unknown>;
+    list(options?: Options): AsyncGenerator<Account, void, unknown>;
+    listAll(options?: Options): Promise<Account[]>;
+    listByPage(options?: Options): AsyncGenerator<import("axios").AxiosResponse<ApiAccount[], any>, any, unknown>;
 }
 export { AccountsService };

package/dist/cjs/services/accounts.service.js

@@ -57,13 +57,13 @@ class AccountsService extends index_js_1.Service {
             }
         });
     }
-    listAll() {
+    listAll(options) {
         var e_2, _a;
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 const accounts = [];
                 try {
-                    for (var _b = __asyncValues(this.list()), _c; _c = yield _b.next(), !_c.done;) {
+                    for (var _b = __asyncValues(this.list(options)), _c; _c = yield _b.next(), !_c.done;) {
                         const account = _c.value;
                         accounts.push(account);
                     }

package/dist/cjs/services/attendance.service.d.ts

@@ -3,36 +3,31 @@ import { ApiAttendance } from '../interfaces/index.js';
 import { Service, Options, RequirementsOf } from './index.js';
 import { Attendance } from '../models/attendance.model.js';
 import { AttendanceQueryParams } from '../interfaces/query-params/attendance-query-params.interface.js';
-import { InternalQueryParams } from '../interfaces/query-params/internal-query-params.interface.js';
 declare type RequiredProps = 'user' | 'in_time';
-declare class AttendanceService extends Service {
+export declare class AttendanceService extends Service {
     private apiPath;
     create(data: RequirementsOf<ApiAttendance, RequiredProps>): Promise<Attendance>;
     create(data: RequirementsOf<ApiAttendance, RequiredProps>, options: {
         rawResponse: true;
-        params?: InternalQueryParams;
-    }): Promise<AxiosResponse<ApiAttendance, any>>;
-    create(data: RequirementsOf<ApiAttendance, RequiredProps>, options: Options<InternalQueryParams>): Promise<ApiAttendance>;
+    } & Options): Promise<AxiosResponse<ApiAttendance, any>>;
+    create(data: RequirementsOf<ApiAttendance, RequiredProps>, options: Options): Promise<ApiAttendance>;
     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>;
-    list(options?: Options<AttendanceQueryParams & InternalQueryParams>): AsyncGenerator<Attendance, void, unknown>;
-    listAll(): Promise<Attendance[]>;
-    listByPage(options?: Options<AttendanceQueryParams & InternalQueryParams>): AsyncGenerator<AxiosResponse<ApiAttendance[], any>, any, unknown>;
+    } & Options): Promise<AxiosResponse<ApiAttendance, any>>;
+    get(id: number, options: Options): Promise<Attendance>;
+    list(query: AttendanceQueryParams, options?: Options): AsyncGenerator<Attendance, void, unknown>;
+    listAll(query: AttendanceQueryParams, options?: Options): Promise<Attendance[]>;
+    listByPage(query: AttendanceQueryParams, options?: Options): AsyncGenerator<AxiosResponse<ApiAttendance[], any>, any, unknown>;
     update(id: number, data: Partial<ApiAttendance>): Promise<Attendance>;
     update(id: number, data: Partial<ApiAttendance>, options: {
         rawResponse: true;
-        params?: InternalQueryParams;
-    }): Promise<AxiosResponse<ApiAttendance, any>>;
-    update(id: number, data: Partial<ApiAttendance>, options: Options<InternalQueryParams>): Promise<Attendance>;
+    } & Options): Promise<AxiosResponse<ApiAttendance, any>>;
+    update(id: number, data: Partial<ApiAttendance>, options: Options): Promise<Attendance>;
     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>;
+    } & Options): Promise<AxiosResponse<ApiAttendance, any>>;
+    delete(id: number, options: Options): Promise<number>;
 }
-export { AttendanceService };
+export {};

package/dist/cjs/services/attendance.service.js

@@ -43,14 +43,14 @@ class AttendanceService extends index_js_1.Service {
     get(id, options) {
         return super.fetch({ url: `${this.apiPath}/${id}` }, options).then((res) => Promise.resolve((options === null || options === void 0 ? void 0 : options.rawResponse) ? res : new attendance_model_js_1.Attendance(res.data)), (err) => Promise.reject((options === null || options === void 0 ? void 0 : options.rawResponse) ? err : new error_response_model_js_1.ErrorResponse(err)));
     }
-    list(options) {
+    list(query, options) {
         const _super = Object.create(null, {
             iterator: { get: () => super.iterator }
         });
         return __asyncGenerator(this, arguments, function* list_1() {
             var e_1, _a;
             try {
-                for (var _b = __asyncValues(_super.iterator.call(this, { url: this.apiPath }, options)), _c; _c = yield __await(_b.next()), !_c.done;) {
+                for (var _b = __asyncValues(_super.iterator.call(this, { url: this.apiPath, params: query }, options)), _c; _c = yield __await(_b.next()), !_c.done;) {
                     const res = _c.value;
                     yield yield __await(new attendance_model_js_1.Attendance(res));
                 }
@@ -64,13 +64,13 @@ class AttendanceService extends index_js_1.Service {
             }
         });
     }
-    listAll() {
+    listAll(query, options) {
         var e_2, _a;
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 const attendance = [];
                 try {
-                    for (var _b = __asyncValues(this.list()), _c; _c = yield _b.next(), !_c.done;) {
+                    for (var _b = __asyncValues(this.list(query, options)), _c; _c = yield _b.next(), !_c.done;) {
                         const atten = _c.value;
                         attendance.push(atten);
                     }
@@ -89,8 +89,8 @@ class AttendanceService extends index_js_1.Service {
             }
         });
     }
-    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/cjs/services/availability.service.d.ts

@@ -1,33 +1,26 @@
 import { AxiosResponse } from 'axios';
-import { Service, Options, RequirementsOf } from './index.js';
-import { InternalQueryParams } from '../interfaces/query-params/internal-query-params.interface.js';
+import { Service, Options } from './index.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';
-declare type RequiredProps = 'start' | 'end';
-declare type RequiredOptions<T> = RequirementsOf<Options<T>, 'params'>;
 export declare class AvailabilityService extends Service {
     private apiPath;
     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>>;
+    } & Options): Promise<AxiosResponse<ApiAvailability>>;
+    update(data: ApiAvailability, options?: Options): Promise<Availability | AxiosResponse<ApiAvailability>>;
     /** 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>>;
+    } & Options): Promise<AxiosResponse<ApiAvailability>>;
+    create(data: ApiAvailability, options?: Options): Promise<Availability | AxiosResponse<ApiAvailability>>;
     delete(user: number, dates: string[]): Promise<Availability>;
     delete(user: number, dates: string[], options: {
         rawResponse: true;
-        params?: InternalQueryParams;
-    }): Promise<AxiosResponse<ApiAvailability>>;
-    delete(user: number, dates: string[], options?: Options<InternalQueryParams>): Promise<Availability | AxiosResponse<ApiAvailability>>;
-    list(options: RequiredOptions<RequirementsOf<AvailabilityQueryParams, RequiredProps> & InternalQueryParams>): AsyncGenerator<Availability, void, unknown>;
-    listByPage(options: RequiredOptions<RequirementsOf<AvailabilityQueryParams, RequiredProps> & InternalQueryParams>): AsyncGenerator<AxiosResponse<ApiAvailability[], any>, any, unknown>;
+    } & Options): Promise<AxiosResponse<ApiAvailability>>;
+    delete(user: number, dates: string[], options?: Options): Promise<Availability | AxiosResponse<ApiAvailability>>;
+    list(query: AvailabilityQueryParams, options?: Options): AsyncGenerator<Availability, void, unknown>;
+    listByPage(query: AvailabilityQueryParams, options?: Options): AsyncGenerator<AxiosResponse<ApiAvailability[], any>, any, unknown>;
 }
-export {};

package/dist/cjs/services/availability.service.js

@@ -52,14 +52,14 @@ class AvailabilityService extends index_js_1.Service {
             }),
         }, options);
     }
-    list(options) {
+    list(query, options) {
         const _super = Object.create(null, {
             iterator: { get: () => super.iterator }
         });
         return __asyncGenerator(this, arguments, function* list_1() {
             var e_1, _a;
             try {
-                for (var _b = __asyncValues(_super.iterator.call(this, { url: this.apiPath }, options)), _c; _c = yield __await(_b.next()), !_c.done;) {
+                for (var _b = __asyncValues(_super.iterator.call(this, { url: this.apiPath, params: query }, options)), _c; _c = yield __await(_b.next()), !_c.done;) {
                     const res = _c.value;
                     yield yield __await(new availability_model_js_1.Availability(res));
                 }
@@ -73,8 +73,8 @@ class AvailabilityService extends index_js_1.Service {
             }
         });
     }
-    listByPage(options) {
-        return super.iterator({ url: this.apiPath }, options).byPage();
+    listByPage(query, options) {
+        return super.iterator({ url: this.apiPath, params: query }, options).byPage();
     }
 }
 exports.AvailabilityService = AvailabilityService;

package/dist/cjs/services/daily-budgets.service.d.ts

@@ -0,0 +1,16 @@
+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 { DailyBudgetsQueryParams } from '../interfaces/query-params/daily-budgets-query-params.interface.js';
+export declare class DailyBudgetsService extends Service {
+    private apiPath;
+    list(query: DailyBudgetsQueryParams, options?: Options): AsyncGenerator<DailyBudgets, void, unknown>;
+    listAll(query: DailyBudgetsQueryParams, options?: Options): Promise<DailyBudgets[]>;
+    listByPage(query: DailyBudgetsQueryParams, options?: Options): AsyncGenerator<AxiosResponse<ApiDailyBudgets[], any>, any, unknown>;
+    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>;
+}

package/dist/cjs/services/daily-budgets.service.js

@@ -0,0 +1,99 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DailyBudgetsService = void 0;
+const index_js_1 = require("./index.js");
+const daily_budgets_model_js_1 = require("../models/daily-budgets.model.js");
+const error_response_model_js_1 = require("../models/error-response.model.js");
+class DailyBudgetsService extends index_js_1.Service {
+    constructor() {
+        super(...arguments);
+        this.apiPath = '/daily_budgets';
+    }
+    list(query, options) {
+        const _super = Object.create(null, {
+            iterator: { get: () => super.iterator }
+        });
+        return __asyncGenerator(this, arguments, function* list_1() {
+            var e_1, _a;
+            try {
+                for (var _b = __asyncValues(_super.iterator.call(this, { url: this.apiPath, params: query }, options)), _c; _c = yield __await(_b.next()), !_c.done;) {
+                    const res = _c.value;
+                    yield yield __await(new daily_budgets_model_js_1.DailyBudgets(res));
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) yield __await(_a.call(_b));
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        });
+    }
+    listAll(query, options) {
+        var e_2, _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const attendance = [];
+                try {
+                    for (var _b = __asyncValues(this.list(query, options)), _c; _c = yield _b.next(), !_c.done;) {
+                        const atten = _c.value;
+                        attendance.push(atten);
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (_c && !_c.done && (_a = _b.return)) yield _a.call(_b);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+                return attendance;
+            }
+            catch (err) {
+                return err;
+            }
+        });
+    }
+    listByPage(query, options) {
+        return super.iterator({ url: this.apiPath, params: query }, options).byPage();
+    }
+    update(data, options) {
+        return super
+            .fetch({
+            url: `${this.apiPath}`,
+            data,
+            method: 'POST',
+        })
+            .then((res) => Promise.resolve((options === null || options === void 0 ? void 0 : options.rawResponse) ? res : res.status), (err) => Promise.reject((options === null || options === void 0 ? void 0 : options.rawResponse) ? err : new error_response_model_js_1.ErrorResponse(err)));
+    }
+}
+exports.DailyBudgetsService = DailyBudgetsService;

package/dist/cjs/services/daily-revenue.service.d.ts

@@ -0,0 +1,16 @@
+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 { DailyRevenueQueryParams } from '../interfaces/query-params/daily-revenue-query-params.interface.js';
+export declare class DailyRevenueService extends Service {
+    private apiPath;
+    list(query: DailyRevenueQueryParams, options?: Options): AsyncGenerator<DailyRevenue, void, unknown>;
+    listAll(query: DailyRevenueQueryParams, options?: Options): Promise<DailyRevenue[]>;
+    listByPage(query: DailyRevenueQueryParams, options?: Options): AsyncGenerator<AxiosResponse<ApiDailyRevenue[], any>, any, unknown>;
+    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>;
+}

package/dist/cjs/services/daily-revenue.service.js

@@ -0,0 +1,99 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DailyRevenueService = void 0;
+const index_js_1 = require("./index.js");
+const daily_revenue_model_js_1 = require("../models/daily-revenue.model.js");
+const error_response_model_js_1 = require("../models/error-response.model.js");
+class DailyRevenueService extends index_js_1.Service {
+    constructor() {
+        super(...arguments);
+        this.apiPath = '/daily_revenue';
+    }
+    list(query, options) {
+        const _super = Object.create(null, {
+            iterator: { get: () => super.iterator }
+        });
+        return __asyncGenerator(this, arguments, function* list_1() {
+            var e_1, _a;
+            try {
+                for (var _b = __asyncValues(_super.iterator.call(this, { url: this.apiPath, params: query }, options)), _c; _c = yield __await(_b.next()), !_c.done;) {
+                    const res = _c.value;
+                    yield yield __await(new daily_revenue_model_js_1.DailyRevenue(res));
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) yield __await(_a.call(_b));
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        });
+    }
+    listAll(query, options) {
+        var e_2, _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const attendance = [];
+                try {
+                    for (var _b = __asyncValues(this.list(query, options)), _c; _c = yield _b.next(), !_c.done;) {
+                        const atten = _c.value;
+                        attendance.push(atten);
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (_c && !_c.done && (_a = _b.return)) yield _a.call(_b);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+                return attendance;
+            }
+            catch (err) {
+                return err;
+            }
+        });
+    }
+    listByPage(query, options) {
+        return super.iterator({ url: this.apiPath, params: query }, options).byPage();
+    }
+    update(data, options) {
+        return super
+            .fetch({
+            url: `${this.apiPath}`,
+            data,
+            method: 'POST',
+        })
+            .then((res) => Promise.resolve((options === null || options === void 0 ? void 0 : options.rawResponse) ? res : res.status), (err) => Promise.reject((options === null || options === void 0 ? void 0 : options.rawResponse) ? err : new error_response_model_js_1.ErrorResponse(err)));
+    }
+}
+exports.DailyRevenueService = DailyRevenueService;

package/dist/cjs/services/days-off.service.d.ts

@@ -1,25 +1,21 @@
 import { AxiosResponse } from 'axios';
 import { ApiDaysOff } from '../interfaces/index.js';
 import { Service, Options } from './index.js';
-import { InternalQueryParams } from '../interfaces/query-params/internal-query-params.interface.js';
 import { DaysOff } from '../models/days-off.model.js';
 import { DaysOffQueryParams } from '../interfaces/query-params/days-off-query-params.interface.js';
-declare class DaysOffService extends Service<ApiDaysOff> {
+export declare class DaysOffService extends Service<ApiDaysOff> {
     private apiPath;
     create(dates: string[], users: number[]): Promise<number>;
     create(dates: string[], users: number[], options: {
         rawResponse: true;
-        params?: InternalQueryParams;
-    }): Promise<AxiosResponse<ApiDaysOff, any>>;
-    create(dates: string[], users: number[], options: Options<InternalQueryParams>): Promise<number>;
-    list(options?: Options<DaysOffQueryParams & InternalQueryParams>): AsyncGenerator<DaysOff, void, unknown>;
-    listAll(): Promise<DaysOff[]>;
-    listByPage(options?: Options<DaysOffQueryParams & InternalQueryParams>): AsyncGenerator<AxiosResponse<ApiDaysOff[], any>, any, unknown>;
+    } & Options): Promise<AxiosResponse<ApiDaysOff, any>>;
+    create(dates: string[], users: number[], options: Options): Promise<number>;
+    list(query: DaysOffQueryParams, options?: Options): AsyncGenerator<DaysOff, void, unknown>;
+    listAll(query: DaysOffQueryParams, options?: Options): Promise<DaysOff[]>;
+    listByPage(query: DaysOffQueryParams, options?: Options): AsyncGenerator<AxiosResponse<ApiDaysOff[], any>, any, unknown>;
     delete(dates: string[], users: number[]): Promise<number>;
     delete(dates: string[], users: number[], options: {
         rawResponse: true;
-        params?: InternalQueryParams;
-    }): Promise<AxiosResponse<any, any>>;
-    delete(dates: string[], users: number[], options: Options<InternalQueryParams>): Promise<number>;
+    } & Options): Promise<AxiosResponse<any, any>>;
+    delete(dates: string[], users: number[], options: Options): Promise<number>;
 }
-export { DaysOffService };

package/dist/cjs/services/days-off.service.js

@@ -49,14 +49,14 @@ class DaysOffService extends index_js_1.Service {
         })
             .then((res) => Promise.resolve((options === null || options === void 0 ? void 0 : options.rawResponse) ? res : res.status), (err) => Promise.reject((options === null || options === void 0 ? void 0 : options.rawResponse) ? err : new error_response_model_js_1.ErrorResponse(err)));
     }
-    list(options) {
+    list(query, options) {
         const _super = Object.create(null, {
             iterator: { get: () => super.iterator }
         });
         return __asyncGenerator(this, arguments, function* list_1() {
             var e_1, _a;
             try {
-                for (var _b = __asyncValues(_super.iterator.call(this, { url: this.apiPath }, options)), _c; _c = yield __await(_b.next()), !_c.done;) {
+                for (var _b = __asyncValues(_super.iterator.call(this, { url: this.apiPath, params: query }, options)), _c; _c = yield __await(_b.next()), !_c.done;) {
                     const res = _c.value;
                     yield yield __await(new days_off_model_js_1.DaysOff(res));
                 }
@@ -70,13 +70,13 @@ class DaysOffService extends index_js_1.Service {
             }
         });
     }
-    listAll() {
+    listAll(query, options) {
         var e_2, _a;
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 const daysOff = [];
                 try {
-                    for (var _b = __asyncValues(this.list()), _c; _c = yield _b.next(), !_c.done;) {
+                    for (var _b = __asyncValues(this.list(query, options)), _c; _c = yield _b.next(), !_c.done;) {
                         const dayOff = _c.value;
                         daysOff.push(dayOff);
                     }
@@ -95,8 +95,8 @@ class DaysOffService extends index_js_1.Service {
             }
         });
     }
-    listByPage(options) {
-        return super.iterator({ url: this.apiPath }, options).byPage();
+    listByPage(query, options) {
+        return super.iterator({ url: this.apiPath, params: query }, options).byPage();
     }
     delete(dates, users, options) {
         return super

package/dist/cjs/services/groups.service.d.ts

@@ -1,38 +1,33 @@
 import { AxiosResponse } from 'axios';
 import { ApiGroup } from '../interfaces/index.js';
 import { Service, Options, RequirementsOf } from './index.js';
-import { InternalQueryParams } from '../interfaces/query-params/internal-query-params.interface.js';
 import { Group } from '../models/group.model.js';
 import { GroupsQueryParams } from '../interfaces/query-params/groups-query-params.interface.js';
 declare type RequiredProps = 'name';
-declare class GroupsService extends Service {
+export declare class GroupsService extends Service {
     private apiPath;
     create(data: RequirementsOf<ApiGroup, RequiredProps>): Promise<Group>;
     create(data: RequirementsOf<ApiGroup, RequiredProps>, options: {
         rawResponse: true;
-        params?: InternalQueryParams;
-    }): Promise<AxiosResponse<ApiGroup, any>>;
-    create(data: RequirementsOf<ApiGroup, RequiredProps>, options: Options<InternalQueryParams>): Promise<Group>;
+    } & Options): Promise<AxiosResponse<ApiGroup, any>>;
+    create(data: RequirementsOf<ApiGroup, RequiredProps>, options: Options): Promise<Group>;
     get(id: number): Promise<Group>;
     get(id: number, options: {
         rawResponse: true;
-        params?: InternalQueryParams;
-    }): Promise<AxiosResponse<ApiGroup, any>>;
-    get(id: number, options: Options<InternalQueryParams>): Promise<Group>;
-    list(options?: Options<GroupsQueryParams & InternalQueryParams>): AsyncGenerator<Group, void, unknown>;
-    listAll(): Promise<Group[]>;
-    listByPage(options?: Options<GroupsQueryParams & InternalQueryParams>): AsyncGenerator<AxiosResponse<ApiGroup[], any>, any, unknown>;
+    } & Options): Promise<AxiosResponse<ApiGroup, any>>;
+    get(id: number, options: Options): Promise<Group>;
+    list(query: GroupsQueryParams, options?: Options): AsyncGenerator<Group, void, unknown>;
+    listAll(query: GroupsQueryParams, options?: Options): Promise<Group[]>;
+    listByPage(query: GroupsQueryParams, options?: Options): AsyncGenerator<AxiosResponse<ApiGroup[], any>, any, unknown>;
     update(id: number, data: Partial<ApiGroup>): Promise<Group>;
     update(id: number, data: Partial<ApiGroup>, options: {
         rawResponse: true;
-        params?: InternalQueryParams;
-    }): Promise<AxiosResponse<ApiGroup, any>>;
-    update(id: number, data: Partial<ApiGroup>, options: Options<InternalQueryParams>): Promise<Group>;
+    } & Options): Promise<AxiosResponse<ApiGroup, any>>;
+    update(id: number, data: Partial<ApiGroup>, options: Options): Promise<Group>;
     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 { GroupsService };
+export {};