rotacloud 1.0.25 → 1.0.27

package/src/services/days-off.service.ts

@@ -3,21 +3,21 @@ import { ApiDaysOff } from '../interfaces/index.js';
 import { Service, Options } from './index.js';
 
 import { ErrorResponse } from '../models/error-response.model.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';
 
-class DaysOffService extends Service<ApiDaysOff> {
+export class DaysOffService extends Service<ApiDaysOff> {
   private apiPath = '/days_off';
 
   create(dates: string[], users: number[]): Promise<number>;
   create(
     dates: string[],
     users: number[],
-    options: { rawResponse: true; params?: InternalQueryParams }
+    options: { rawResponse: true } & Options
   ): Promise<AxiosResponse<ApiDaysOff, any>>;
-  create(dates: string[], users: number[], options: Options<InternalQueryParams>): Promise<number>;
-  create(dates: string[], users: number[], options?: Options<InternalQueryParams>) {
+  create(dates: string[], users: number[], options: Options): Promise<number>;
+  create(dates: string[], users: number[], options?: Options) {
     return super
       .fetch({
         url: this.apiPath,
@@ -33,17 +33,17 @@ class DaysOffService extends Service<ApiDaysOff> {
       );
   }
 
-  async *list(options?: Options<DaysOffQueryParams & InternalQueryParams>) {
-    for await (const res of super.iterator({ url: this.apiPath }, options)) {
+  async *list(query: DaysOffQueryParams, options?: Options) {
+    for await (const res of super.iterator({ url: this.apiPath, params: query }, options)) {
       yield new DaysOff(res);
     }
   }
 
-  listAll(): Promise<DaysOff[]>;
-  async listAll() {
+  listAll(query: DaysOffQueryParams, options?: Options): Promise<DaysOff[]>;
+  async listAll(query: DaysOffQueryParams, options?: Options) {
     try {
       const daysOff = [] as DaysOff[];
-      for await (const dayOff of this.list()) {
+      for await (const dayOff of this.list(query, options)) {
         daysOff.push(dayOff);
       }
       return daysOff;
@@ -52,18 +52,14 @@ class DaysOffService extends Service<ApiDaysOff> {
     }
   }
 
-  listByPage(options?: Options<DaysOffQueryParams & InternalQueryParams>) {
-    return super.iterator({ url: this.apiPath }, options).byPage();
+  listByPage(query: DaysOffQueryParams, options?: Options) {
+    return super.iterator({ url: this.apiPath, params: query }, options).byPage();
   }
 
   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>;
-  delete(dates: string[], users: number[], options?: Options<InternalQueryParams>) {
+  delete(dates: string[], users: number[], options: { rawResponse: true } & Options): Promise<AxiosResponse<any, any>>;
+  delete(dates: string[], users: number[], options: Options): Promise<number>;
+  delete(dates: string[], users: number[], options?: Options) {
     return super
       .fetch({
         url: this.apiPath,
@@ -79,5 +75,3 @@ class DaysOffService extends Service<ApiDaysOff> {
       );
   }
 }
-
-export { DaysOffService };

package/src/services/groups.service.ts

@@ -3,22 +3,22 @@ import { ApiGroup } from '../interfaces/index.js';
 import { Service, Options, RequirementsOf } from './index.js';
 
 import { ErrorResponse } from '../models/error-response.model.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';
 
 type RequiredProps = 'name';
 
-class GroupsService extends Service {
+export class GroupsService extends Service {
   private apiPath = '/groups';
 
   create(data: RequirementsOf<ApiGroup, RequiredProps>): Promise<Group>;
   create(
     data: RequirementsOf<ApiGroup, RequiredProps>,
-    options: { rawResponse: true; params?: InternalQueryParams }
+    options: { rawResponse: true } & Options
   ): Promise<AxiosResponse<ApiGroup, any>>;
-  create(data: RequirementsOf<ApiGroup, RequiredProps>, options: Options<InternalQueryParams>): Promise<Group>;
-  create(data: RequirementsOf<ApiGroup, RequiredProps>, options?: Options<InternalQueryParams>) {
+  create(data: RequirementsOf<ApiGroup, RequiredProps>, options: Options): Promise<Group>;
+  create(data: RequirementsOf<ApiGroup, RequiredProps>, options?: Options) {
     return super.fetch<ApiGroup>({ url: this.apiPath, data, method: 'POST' }).then(
       (res) => Promise.resolve(options?.rawResponse ? res : new Group(res.data)),
       (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err))
@@ -26,26 +26,26 @@ class GroupsService extends Service {
   }
 
   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>;
-  get(id: number, options?: Options<InternalQueryParams>) {
+  get(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<ApiGroup, any>>;
+  get(id: number, options: Options): Promise<Group>;
+  get(id: number, options?: Options) {
     return super.fetch<ApiGroup>({ 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?: Options<GroupsQueryParams & InternalQueryParams>) {
-    for await (const res of super.iterator<ApiGroup>({ url: this.apiPath }, options)) {
+  async *list(query: GroupsQueryParams, options?: Options) {
+    for await (const res of super.iterator<ApiGroup>({ url: this.apiPath, params: query }, options)) {
       yield new Group(res);
     }
   }
 
-  listAll(): Promise<Group[]>;
-  async listAll() {
+  listAll(query: GroupsQueryParams, options?: Options): Promise<Group[]>;
+  async listAll(query: GroupsQueryParams, options?: Options) {
     try {
       const groups = [] as Group[];
-      for await (const group of this.list()) {
+      for await (const group of this.list(query, options)) {
         groups.push(group);
       }
       return groups;
@@ -54,18 +54,18 @@ class GroupsService extends Service {
     }
   }
 
-  listByPage(options?: Options<GroupsQueryParams & InternalQueryParams>) {
-    return super.iterator<ApiGroup>({ url: this.apiPath }, options).byPage();
+  listByPage(query: GroupsQueryParams, options?: Options) {
+    return super.iterator<ApiGroup>({ url: this.apiPath, params: query }, options).byPage();
   }
 
   update(id: number, data: Partial<ApiGroup>): Promise<Group>;
   update(
     id: number,
     data: Partial<ApiGroup>,
-    options: { rawResponse: true; params?: InternalQueryParams }
+    options: { rawResponse: true } & Options
   ): Promise<AxiosResponse<ApiGroup, any>>;
-  update(id: number, data: Partial<ApiGroup>, options: Options<InternalQueryParams>): Promise<Group>;
-  update(id: number, data: Partial<ApiGroup>, options?: Options<InternalQueryParams>) {
+  update(id: number, data: Partial<ApiGroup>, options: Options): Promise<Group>;
+  update(id: number, data: Partial<ApiGroup>, options?: Options) {
     return super
       .fetch<ApiGroup>({
         url: `${this.apiPath}/${id}`,
@@ -79,14 +79,12 @@ class GroupsService extends Service {
   }
 
   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>;
-  delete(id: number, options?: Options<InternalQueryParams>) {
+  delete(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<any, any>>;
+  delete(id: number, options: Options): Promise<number>;
+  delete(id: number, options?: Options) {
     return super.fetch<ApiGroup>({ 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/src/services/index.ts

@@ -3,6 +3,7 @@ export * from './accounts.service.js';
 export * from './attendance.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/src/services/leave-embargoes.service.ts

@@ -4,24 +4,20 @@ import { Service, Options, RequirementsOf } from './index.js';
 
 import { LeaveEmbargo } from '../models/leave-embargo.model.js';
 import { ErrorResponse } from '../models/error-response.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';
 
 type RequiredProps = 'start_date' | 'end_date' | 'users';
 
-class LeaveEmbargoesService extends Service {
+export class LeaveEmbargoesService extends Service {
   private apiPath = '/leave_embargoes';
 
   create(data: RequirementsOf<ApiLeaveEmbargo, RequiredProps>): Promise<LeaveEmbargo>;
   create(
     data: RequirementsOf<ApiLeaveEmbargo, RequiredProps>,
-    options: { rawResponse: true; params?: InternalQueryParams }
+    options: { rawResponse: true } & Options
   ): Promise<AxiosResponse<ApiLeaveEmbargo, any>>;
-  create(
-    data: RequirementsOf<ApiLeaveEmbargo, RequiredProps>,
-    options: Options<InternalQueryParams>
-  ): Promise<LeaveEmbargo>;
-  create(data: RequirementsOf<ApiLeaveEmbargo, RequiredProps>, options?: Options<InternalQueryParams>) {
+  create(data: RequirementsOf<ApiLeaveEmbargo, RequiredProps>, options: Options): Promise<LeaveEmbargo>;
+  create(data: RequirementsOf<ApiLeaveEmbargo, RequiredProps>, options?: Options) {
     return super.fetch<ApiLeaveEmbargo>({ url: this.apiPath, data, method: 'POST' }).then(
       (res) => Promise.resolve(options?.rawResponse ? res : new LeaveEmbargo(res.data)),
       (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err))
@@ -29,29 +25,26 @@ class LeaveEmbargoesService extends Service {
   }
 
   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>;
-  get(id: number, options?: Options<InternalQueryParams>) {
+  get(id: number, options: { rawResponse: true }): Promise<AxiosResponse<ApiLeaveEmbargo, any>>;
+  get(id: number, options: Options): Promise<LeaveEmbargo>;
+  get(id: number, options?: Options) {
     return super.fetch<ApiLeaveEmbargo>({ 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?: Options<UsersQueryParams & InternalQueryParams>) {
-    for await (const res of super.iterator<ApiLeaveEmbargo>({ url: this.apiPath }, options)) {
+  async *list(query: LeaveEmbargoesQueryParams, options?: Options) {
+    for await (const res of super.iterator<ApiLeaveEmbargo>({ url: this.apiPath, params: query }, options)) {
       yield new LeaveEmbargo(res);
     }
   }
 
-  listAll(): Promise<LeaveEmbargo[]>;
-  async listAll() {
+  listAll(query: LeaveEmbargoesQueryParams, options?: Options): Promise<LeaveEmbargo[]>;
+  async listAll(query: LeaveEmbargoesQueryParams, options?: Options) {
     try {
       const leave = [] as LeaveEmbargo[];
-      for await (const leaveEmbargoRecord of this.list()) {
+      for await (const leaveEmbargoRecord of this.list(query, options)) {
         leave.push(leaveEmbargoRecord);
       }
       return leave;
@@ -60,18 +53,18 @@ class LeaveEmbargoesService extends Service {
     }
   }
 
-  listByPage(options?: Options<UsersQueryParams & InternalQueryParams>) {
-    return super.iterator<ApiLeaveEmbargo>({ url: this.apiPath }, options).byPage();
+  listByPage(query: LeaveEmbargoesQueryParams, options?: Options) {
+    return super.iterator<ApiLeaveEmbargo>({ url: this.apiPath, params: query }, options).byPage();
   }
 
   update(id: number, data: Partial<ApiLeaveEmbargo>): Promise<LeaveEmbargo>;
   update(
     id: number,
     data: Partial<ApiLeaveEmbargo>,
-    options: { rawResponse: true; params?: InternalQueryParams }
+    options: { rawResponse: true } & Options
   ): Promise<AxiosResponse<ApiLeaveEmbargo, any>>;
-  update(id: number, data: Partial<ApiLeaveEmbargo>, options: Options<InternalQueryParams>): Promise<LeaveEmbargo>;
-  update(id: number, data: Partial<ApiLeaveEmbargo>, options?: Options<InternalQueryParams>) {
+  update(id: number, data: Partial<ApiLeaveEmbargo>, options: Options): Promise<LeaveEmbargo>;
+  update(id: number, data: Partial<ApiLeaveEmbargo>, options?: Options) {
     return super
       .fetch<ApiLeaveEmbargo>({
         url: `${this.apiPath}/${id}`,
@@ -85,14 +78,12 @@ class LeaveEmbargoesService extends Service {
   }
 
   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>;
-  delete(id: number, options?: Options<InternalQueryParams>) {
+  delete(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<any, any>>;
+  delete(id: number, options: Options): Promise<number>;
+  delete(id: number, options?: Options) {
     return super.fetch<ApiLeaveEmbargo>({ 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/src/services/leave-request.service.ts

@@ -4,24 +4,21 @@ import { Service, Options, RequirementsOf } from './index.js';
 
 import { ErrorResponse } from '../models/error-response.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 { LeaveRequest } from '../models/leave-request.model.js';
 
 type RequiredProps = 'start_date' | 'end_date' | 'type' | 'user';
 
-class LeaveRequestService extends Service {
+export class LeaveRequestService extends Service {
   private apiPath = '/leave_requests';
 
   create(data: RequirementsOf<ApiLeaveRequest, RequiredProps>): Promise<LeaveRequest>;
   create(
     data: RequirementsOf<ApiLeaveRequest, RequiredProps>,
-    options: { rawResponse: true; params?: InternalQueryParams }
+    options: { rawResponse: true } & Options
   ): Promise<AxiosResponse<ApiLeaveRequest, any>>;
-  create(
-    data: RequirementsOf<ApiLeaveRequest, RequiredProps>,
-    options: Options<InternalQueryParams>
-  ): Promise<LeaveRequest>;
-  create(data: RequirementsOf<ApiLeaveRequest, RequiredProps>, options?: Options<InternalQueryParams>) {
+  create(data: RequirementsOf<ApiLeaveRequest, RequiredProps>, options: Options): Promise<LeaveRequest>;
+  create(data: RequirementsOf<ApiLeaveRequest, RequiredProps>, options?: Options) {
     return super.fetch<ApiLeaveRequest>({ url: this.apiPath, data, method: 'POST' }).then(
       (res) => Promise.resolve(options?.rawResponse ? res : new LeaveRequest(res.data)),
       (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err))
@@ -29,29 +26,26 @@ class LeaveRequestService extends Service {
   }
 
   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>;
-  get(id: number, options?: Options<InternalQueryParams>) {
+  get(id: number, options: { rawResponse: true }): Promise<AxiosResponse<ApiLeaveRequest, any>>;
+  get(id: number, options: Options): Promise<LeaveRequest>;
+  get(id: number, options?: Options) {
     return super.fetch<ApiLeaveRequest>({ 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?: Options<LeaveQueryParams & InternalQueryParams>) {
-    for await (const res of super.iterator<ApiLeaveRequest>({ url: `${this.apiPath}` }, options)) {
+  async *list(query: LeaveQueryParams, options?: Options) {
+    for await (const res of super.iterator<ApiLeaveRequest>({ url: this.apiPath, params: query }, options)) {
       yield new LeaveRequest(res);
     }
   }
 
-  listAll(): Promise<LeaveRequest[]>;
-  async listAll() {
+  listAll(query: LeaveQueryParams, options?: Options): Promise<LeaveRequest[]>;
+  async listAll(query: LeaveQueryParams, options?: Options) {
     try {
       const leave = [] as LeaveRequest[];
-      for await (const leaveRequestRecord of this.list()) {
+      for await (const leaveRequestRecord of this.list(query, options)) {
         leave.push(leaveRequestRecord);
       }
       return leave;
@@ -60,7 +54,7 @@ class LeaveRequestService extends Service {
     }
   }
 
-  listByPage(options?: Options<LeaveQueryParams & InternalQueryParams>) {
+  listByPage(options?: Options) {
     return super.iterator<ApiLeaveRequest>({ url: `${this.apiPath}` }, options).byPage();
   }
 
@@ -68,10 +62,10 @@ class LeaveRequestService extends Service {
   update(
     id: number,
     data: Partial<ApiLeaveRequest>,
-    options: { rawResponse: true; params?: InternalQueryParams }
+    options: { rawResponse: true } & Options
   ): Promise<AxiosResponse<ApiLeaveRequest, any>>;
-  update(id: number, data: Partial<ApiLeaveRequest>, options: Options<InternalQueryParams>): Promise<LeaveRequest>;
-  update(id: number, data: Partial<ApiLeaveRequest>, options?: Options<InternalQueryParams>) {
+  update(id: number, data: Partial<ApiLeaveRequest>, options: Options): Promise<LeaveRequest>;
+  update(id: number, data: Partial<ApiLeaveRequest>, options?: Options) {
     return super
       .fetch<ApiLeaveRequest>({
         url: `${this.apiPath}/${id}`,
@@ -85,17 +79,12 @@ class LeaveRequestService extends Service {
   }
 
   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>;
-  delete(id: number, options?: Options<InternalQueryParams>) {
+  delete(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<ApiLeaveRequest, any>>;
+  delete(id: number, options: Options): Promise<number>;
+  delete(id: number, options?: Options) {
     return super.fetch<ApiLeaveRequest>({ 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/src/services/leave.service.ts

@@ -5,48 +5,48 @@ import { Service, Options, RequirementsOf } from './index.js';
 import { Leave } from '../models/leave.model.js';
 import { ErrorResponse } from '../models/error-response.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';
 
 type RequiredProps = 'users' | 'type' | 'start_date' | 'end_date';
 
-class LeaveService extends Service {
+export class LeaveService extends Service {
   private apiPath = '/leave';
 
   create(data: RequirementsOf<ApiLeave, RequiredProps>): Promise<Leave[]>;
   create(
     data: RequirementsOf<ApiLeave, RequiredProps>,
-    options: { rawResponse: true; params?: InternalQueryParams }
+    options: { rawResponse: true } & Options
   ): Promise<AxiosResponse<ApiLeave[], any>>;
-  create(data: RequirementsOf<ApiLeave, RequiredProps>, options: Options<InternalQueryParams>): Promise<Leave[]>;
-  create(data: RequirementsOf<ApiLeave, RequiredProps>, options?: Options<InternalQueryParams>) {
-    return super.fetch<ApiLeave[]>({ url: `${this.apiPath}`, data, method: 'POST' }).then(
+  create(data: RequirementsOf<ApiLeave, RequiredProps>, options: Options): Promise<Leave[]>;
+  create(data: RequirementsOf<ApiLeave, RequiredProps>, options?: Options) {
+    return super.fetch<ApiLeave[]>({ 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: number): Promise<Leave>;
-  get(id: number, options: { rawResponse: true; params?: InternalQueryParams }): Promise<AxiosResponse<ApiLeave, any>>;
-  get(id: number, options: Options<InternalQueryParams>): Promise<Leave>;
-  get(id: number, options?: Options<InternalQueryParams>) {
+  get(id: number, options: { rawResponse: true }): Promise<AxiosResponse<ApiLeave, any>>;
+  get(id: number, options: Options): Promise<Leave>;
+  get(id: number, options?: Options) {
     return super.fetch<ApiLeave>({ 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?: Options<LeaveQueryParams & InternalQueryParams>) {
-    for await (const res of super.iterator<ApiLeave>({ url: this.apiPath }, options)) {
+  async *list(query: LeaveQueryParams, options?: Options) {
+    for await (const res of super.iterator<ApiLeave>({ url: this.apiPath, params: query }, options)) {
       yield new Leave(res);
     }
   }
 
-  listAll(): Promise<Leave[]>;
-  async listAll() {
+  listAll(query: LeaveQueryParams, options?: Options): Promise<Leave[]>;
+  async listAll(query: LeaveQueryParams, options?: Options) {
     try {
       const leave = [] as Leave[];
-      for await (const leaveRecord of this.list()) {
+      for await (const leaveRecord of this.list(query, options)) {
         leave.push(leaveRecord);
       }
       return leave;
@@ -55,24 +55,24 @@ class LeaveService extends Service {
     }
   }
 
-  async *listLeaveTypes(options?: Options<InternalQueryParams>) {
-    for await (const res of super.iterator<ApiLeaveType>({ url: this.apiPath }, options)) {
+  async *listLeaveTypes(query: LeaveQueryParams, options?: Options) {
+    for await (const res of super.iterator<ApiLeaveType>({ url: this.apiPath, params: query }, options)) {
       yield new LeaveType(res);
     }
   }
 
-  listByPage(options?: Options<LeaveQueryParams & InternalQueryParams>) {
-    return super.iterator<ApiLeave>({ url: this.apiPath }, options).byPage();
+  listByPage(query: LeaveQueryParams, options?: Options) {
+    return super.iterator<ApiLeave>({ url: this.apiPath, params: query }, options).byPage();
   }
 
   update(id: number, data: Partial<ApiLeave>): Promise<Leave>;
   update(
     id: number,
     data: Partial<ApiLeave>,
-    options: { rawResponse: true; params?: InternalQueryParams }
+    options: { rawResponse: true } & Options
   ): Promise<AxiosResponse<ApiLeave, any>>;
-  update(id: number, data: Partial<ApiLeave>, options: Options<InternalQueryParams>): Promise<Leave>;
-  update(id: number, data: Partial<ApiLeave>, options?: Options<InternalQueryParams>) {
+  update(id: number, data: Partial<ApiLeave>, options: Options): Promise<Leave>;
+  update(id: number, data: Partial<ApiLeave>, options?: Options) {
     return super
       .fetch<ApiLeave>({
         url: `${this.apiPath}/${id}`,
@@ -86,17 +86,12 @@ class LeaveService extends Service {
   }
 
   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>;
-  delete(id: number, options?: Options<InternalQueryParams>) {
+  delete(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<ApiLeave, any>>;
+  delete(id: number, options: Options): Promise<number>;
+  delete(id: number, options?: Options) {
     return super.fetch<ApiLeave>({ 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 };

package/src/services/locations.service.ts

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