rotacloud 1.0.24 → 1.0.28

package/dist/mjs/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/mjs/services/daily-budgets.service.js

@@ -0,0 +1,38 @@
+import { Service } from './index.js';
+import { DailyBudgets } from '../models/daily-budgets.model.js';
+import { ErrorResponse } from '../models/error-response.model.js';
+export class DailyBudgetsService extends Service {
+    constructor() {
+        super(...arguments);
+        this.apiPath = '/daily_budgets';
+    }
+    async *list(query, options) {
+        for await (const res of super.iterator({ url: this.apiPath, params: query }, options)) {
+            yield new DailyBudgets(res);
+        }
+    }
+    async listAll(query, options) {
+        try {
+            const attendance = [];
+            for await (const atten of this.list(query, options)) {
+                attendance.push(atten);
+            }
+            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?.rawResponse ? res : res.status), (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err)));
+    }
+}

package/dist/mjs/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/mjs/services/daily-revenue.service.js

@@ -0,0 +1,38 @@
+import { Service } from './index.js';
+import { DailyRevenue } from '../models/daily-revenue.model.js';
+import { ErrorResponse } from '../models/error-response.model.js';
+export class DailyRevenueService extends Service {
+    constructor() {
+        super(...arguments);
+        this.apiPath = '/daily_revenue';
+    }
+    async *list(query, options) {
+        for await (const res of super.iterator({ url: this.apiPath, params: query }, options)) {
+            yield new DailyRevenue(res);
+        }
+    }
+    async listAll(query, options) {
+        try {
+            const attendance = [];
+            for await (const atten of this.list(query, options)) {
+                attendance.push(atten);
+            }
+            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?.rawResponse ? res : res.status), (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err)));
+    }
+}

package/dist/mjs/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/mjs/services/days-off.service.js

@@ -1,7 +1,7 @@
 import { Service } from './index.js';
 import { ErrorResponse } from '../models/error-response.model.js';
 import { DaysOff } from '../models/days-off.model.js';
-class DaysOffService extends Service {
+export class DaysOffService extends Service {
     constructor() {
         super(...arguments);
         this.apiPath = '/days_off';
@@ -18,15 +18,15 @@ class DaysOffService extends Service {
         })
             .then((res) => Promise.resolve(options?.rawResponse ? res : res.status), (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 DaysOff(res);
         }
     }
-    async listAll() {
+    async listAll(query, options) {
         try {
             const daysOff = [];
-            for await (const dayOff of this.list()) {
+            for await (const dayOff of this.list(query, options)) {
                 daysOff.push(dayOff);
             }
             return daysOff;
@@ -35,8 +35,8 @@ class DaysOffService 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();
     }
     delete(dates, users, options) {
         return super
@@ -51,4 +51,3 @@ class DaysOffService extends Service {
             .then((res) => Promise.resolve(options?.rawResponse ? res : res.status), (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err)));
     }
 }
-export { DaysOffService };

package/dist/mjs/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 {};

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

@@ -1,7 +1,7 @@
 import { Service } from './index.js';
 import { ErrorResponse } from '../models/error-response.model.js';
 import { Group } from '../models/group.model.js';
-class GroupsService extends Service {
+export class GroupsService extends Service {
     constructor() {
         super(...arguments);
         this.apiPath = '/groups';
@@ -12,15 +12,15 @@ class GroupsService extends Service {
     get(id, options) {
         return super.fetch({ url: `${this.apiPath}/${id}` }, options).then((res) => Promise.resolve(options?.rawResponse ? res : new Group(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 Group(res);
         }
     }
-    async listAll() {
+    async listAll(query, options) {
         try {
             const groups = [];
-            for await (const group of this.list()) {
+            for await (const group of this.list(query, options)) {
                 groups.push(group);
             }
             return groups;
@@ -29,8 +29,8 @@ class GroupsService 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 GroupsService 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 { GroupsService };

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

@@ -1,7 +1,10 @@
 export * from './service.js';
 export * from './accounts.service.js';
 export * from './attendance.service.js';
+export * from './auth.service.js';
 export * from './availability.service.js';
+export * from './daily-budgets.service.js';
+export * from './daily-revenue.service.js';
 export * from './days-off.service.js';
 export * from './groups.service.js';
 export * from './leave-request.service.js';

package/dist/mjs/services/index.js

@@ -1,7 +1,10 @@
 export * from './service.js';
 export * from './accounts.service.js';
 export * from './attendance.service.js';
+export * from './auth.service.js';
 export * from './availability.service.js';
+export * from './daily-budgets.service.js';
+export * from './daily-revenue.service.js';
 export * from './days-off.service.js';
 export * from './groups.service.js';
 export * from './leave-request.service.js';

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

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

package/dist/mjs/services/leave-embargoes.service.js

@@ -1,7 +1,7 @@
 import { Service } from './index.js';
 import { LeaveEmbargo } from '../models/leave-embargo.model.js';
 import { ErrorResponse } from '../models/error-response.model.js';
-class LeaveEmbargoesService extends Service {
+export class LeaveEmbargoesService extends Service {
     constructor() {
         super(...arguments);
         this.apiPath = '/leave_embargoes';
@@ -12,15 +12,15 @@ class LeaveEmbargoesService extends Service {
     get(id, options) {
         return super.fetch({ url: `${this.apiPath}/${id}` }, options).then((res) => Promise.resolve(options?.rawResponse ? res : new LeaveEmbargo(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 LeaveEmbargo(res);
         }
     }
-    async listAll() {
+    async listAll(query, options) {
         try {
             const leave = [];
-            for await (const leaveEmbargoRecord of this.list()) {
+            for await (const leaveEmbargoRecord of this.list(query, options)) {
                 leave.push(leaveEmbargoRecord);
             }
             return leave;
@@ -29,8 +29,8 @@ class LeaveEmbargoesService 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 LeaveEmbargoesService 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 { LeaveEmbargoesService };

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

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

package/dist/mjs/services/leave-request.service.js

@@ -1,7 +1,7 @@
 import { Service } from './index.js';
 import { ErrorResponse } from '../models/error-response.model.js';
 import { LeaveRequest } from '../models/leave-request.model.js';
-class LeaveRequestService extends Service {
+export class LeaveRequestService extends Service {
     constructor() {
         super(...arguments);
         this.apiPath = '/leave_requests';
@@ -12,15 +12,15 @@ class LeaveRequestService extends Service {
     get(id, options) {
         return super.fetch({ url: `${this.apiPath}/${id}` }, options).then((res) => Promise.resolve(options?.rawResponse ? res : new LeaveRequest(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 LeaveRequest(res);
         }
     }
-    async listAll() {
+    async listAll(query, options) {
         try {
             const leave = [];
-            for await (const leaveRequestRecord of this.list()) {
+            for await (const leaveRequestRecord of this.list(query, options)) {
                 leave.push(leaveRequestRecord);
             }
             return leave;
@@ -45,4 +45,3 @@ class LeaveRequestService 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 { LeaveRequestService };

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

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

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

@@ -2,26 +2,26 @@ import { Service } from './index.js';
 import { Leave } from '../models/leave.model.js';
 import { ErrorResponse } from '../models/error-response.model.js';
 import { LeaveType } from '../models/leave-type.model.js';
-class LeaveService extends Service {
+export class LeaveService extends Service {
     constructor() {
         super(...arguments);
         this.apiPath = '/leave';
     }
     create(data, options) {
-        return super.fetch({ url: `${this.apiPath}`, data, method: 'POST' }).then((res) => Promise.resolve(options?.rawResponse ? res : [...res.data.map((leave) => new Leave(leave))]), (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err)));
+        return super.fetch({ url: this.apiPath, data, method: 'POST' }).then((res) => Promise.resolve(options?.rawResponse ? res : [...res.data.map((leave) => new Leave(leave))]), (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err)));
     }
     get(id, options) {
         return super.fetch({ url: `${this.apiPath}/${id}` }, options).then((res) => Promise.resolve(options?.rawResponse ? res : new Leave(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 Leave(res);
         }
     }
-    async listAll() {
+    async listAll(query, options) {
         try {
             const leave = [];
-            for await (const leaveRecord of this.list()) {
+            for await (const leaveRecord of this.list(query, options)) {
                 leave.push(leaveRecord);
             }
             return leave;
@@ -30,13 +30,13 @@ class LeaveService extends Service {
             return err;
         }
     }
-    async *listLeaveTypes(options) {
-        for await (const res of super.iterator({ url: this.apiPath }, options)) {
+    async *listLeaveTypes(query, options) {
+        for await (const res of super.iterator({ url: this.apiPath, params: query }, options)) {
             yield new LeaveType(res);
         }
     }
-    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
@@ -51,4 +51,3 @@ class LeaveService 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 { LeaveService };