rotacloud 1.0.25 → 1.0.30

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

package/src/services/roles.service.ts

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

package/src/services/service.ts

@@ -4,9 +4,11 @@ import { Version } from '../version.js';
 
 export type RequirementsOf<T, K extends keyof T> = Required<Pick<T, K>> & Partial<T>;
 
-export interface Options<T> {
+export interface Options {
   rawResponse?: boolean;
-  params?: T;
+  expand?: string[];
+  fields?: string[];
+  limit?: number;
 }
 
 interface PagingObject {
@@ -51,7 +53,7 @@ export abstract class Service<ApiResponse = any> {
     return keyVal;
   }
 
-  public async fetch<T = ApiResponse>(httpOptions: AxiosRequestConfig, options?): Promise<AxiosResponse<T>> {
+  public async fetch<T = ApiResponse>(httpOptions: AxiosRequestConfig, options?: Options): Promise<AxiosResponse<T>> {
     const headers: AxiosRequestHeaders = {
       Authorization: `Bearer ${RotaCloud.config.apiKey}`,
       'SDK-Version': Version.version,
@@ -67,7 +69,12 @@ export abstract class Service<ApiResponse = any> {
       ...httpOptions,
       baseURL: RotaCloud.config.baseUri,
       headers,
-      params: options?.params,
+      params: {
+        expand: options?.expand,
+        fields: options?.fields,
+        limit: options?.limit,
+        ...httpOptions?.params,
+      },
       paramsSerializer: (params) => {
         return params ? this.buildQueryStr(params) : '';
       },
@@ -77,7 +84,10 @@ export abstract class Service<ApiResponse = any> {
     return response;
   }
 
-  private async *listFetch<T = ApiResponse>(reqObject, options?): AsyncGenerator<AxiosResponse<T[], any>> {
+  private async *listFetch<T = ApiResponse>(
+    reqObject: AxiosRequestConfig<T[]>,
+    options?: Options
+  ): AsyncGenerator<AxiosResponse<T[], any>> {
     let running = true;
     do {
       const res = await this.fetch<T[]>(reqObject, options);
@@ -91,17 +101,17 @@ export abstract class Service<ApiResponse = any> {
       } else {
         running = false;
       }
-      yield await res;
+      yield res;
     } while (running);
   }
 
-  private async *listResponses<T = ApiResponse>(reqObject, options?) {
+  private async *listResponses<T = ApiResponse>(reqObject, options?: Options) {
     for await (const res of this.listFetch<T>(reqObject, options)) {
       yield* res.data;
     }
   }
 
-  public iterator<T = ApiResponse>(reqObject, options?) {
+  public iterator<T = ApiResponse>(reqObject, options?: Options) {
     const iterator = this.listResponses<T>(reqObject, options);
     return {
       [Symbol.asyncIterator]() {