rotacloud 1.0.24 → 1.0.28

package/src/services/attendance.service.ts

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

package/src/services/auth.service.ts

@@ -0,0 +1,19 @@
+import { AxiosResponse } from 'axios';
+import { ApiAuth } from '../interfaces/index.js';
+import { Service, Options } from './index.js';
+
+import { Auth } from '../models/auth.model.js';
+import { ErrorResponse } from '../models/error-response.model.js';
+
+export class AuthService extends Service {
+  private apiPath = '/auth';
+
+  get(options?: { rawResponse: true } & Options): Promise<AxiosResponse<ApiAuth, any>>;
+  get(options?: Options): Promise<Auth>;
+  get(options?: Options) {
+    return super.fetch<ApiAuth>({ url: this.apiPath }, options).then(
+      (res) => Promise.resolve(options?.rawResponse ? res : new Auth(res.data)),
+      (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err))
+    );
+  }
+}

package/src/services/availability.service.ts

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

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

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

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

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

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

@@ -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/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 };