rotacloud 1.1.1 → 1.2.0

package/src/services/terminals-active.service.ts

@@ -1,6 +1,6 @@
 import { AxiosResponse } from 'axios';
 import { Terminal, TerminalLocation } from '../interfaces/index.js';
-import { Service, Options } from './index.js';
+import { Service, Options, OptionsExtended } from './index.js';
 
 interface LaunchTerminal {
   terminal: number;
@@ -13,20 +13,23 @@ interface PingTerminal {
   device: string;
 }
 
-export class TerminalsActiveService extends Service {
+export class TerminalsActiveService extends Service<Terminal> {
   private apiPath = '/terminals_active';
 
   launchTerminal(data: LaunchTerminal): Promise<Terminal>;
-  launchTerminal(data: LaunchTerminal, options: { rawResponse: true } & Options): Promise<AxiosResponse<any, any>>;
+  launchTerminal(data: LaunchTerminal, options: { rawResponse: true } & Options): Promise<AxiosResponse<Terminal>>;
   launchTerminal(data: LaunchTerminal, options: Options): Promise<Terminal>;
   launchTerminal(data: LaunchTerminal, options?: Options) {
     return super
-      .fetch<Terminal>({
-        url: `${this.apiPath}`,
-        data,
-        method: 'POST',
-      })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+      .fetch<Terminal>(
+        {
+          url: this.apiPath,
+          data,
+          method: 'POST',
+        },
+        options,
+      )
+      .then((res) => (options?.rawResponse ? res : res.data));
   }
 
   pingTerminal(id: number, data: PingTerminal): Promise<number>;
@@ -34,22 +37,27 @@ export class TerminalsActiveService extends Service {
     id: number,
     data: PingTerminal,
     options: { rawResponse: true } & Options,
-  ): Promise<AxiosResponse<any, any>>;
+  ): Promise<AxiosResponse<number>>;
   pingTerminal(id: number, data: PingTerminal, options: Options): Promise<number>;
   pingTerminal(id: number, data: PingTerminal, options?: Options) {
     return super
-      .fetch({ url: `${this.apiPath}/${id}`, data, method: 'POST' })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+      .fetch<number>({ url: `${this.apiPath}/${id}`, data, method: 'POST' }, options)
+      .then((res) => (options?.rawResponse ? res : res.data));
   }
 
-  async *list(options?: Options) {
-    for await (const res of super.iterator<Terminal>({ url: this.apiPath }, options)) {
-      yield res;
-    }
+  list(): AsyncGenerator<Terminal>;
+  list<F extends keyof Terminal>(
+    options: { fields: F[] } & OptionsExtended<Terminal>,
+  ): AsyncGenerator<Pick<Terminal, F>>;
+  list(options?: OptionsExtended<Terminal>): AsyncGenerator<Terminal>;
+  async *list(options?: OptionsExtended<Terminal>) {
+    yield* super.iterator({ url: this.apiPath }, options);
   }
 
-  listAll(options?: Options): Promise<Terminal[]>;
-  async listAll(options?: Options) {
+  listAll(): Promise<Terminal[]>;
+  listAll<F extends keyof Terminal>(options: { fields: F[] } & OptionsExtended<Terminal>): Promise<Pick<Terminal, F>[]>;
+  listAll(options?: OptionsExtended<Terminal>): Promise<Terminal[]>;
+  async listAll(options?: OptionsExtended<Terminal>) {
     const users = [] as Terminal[];
     for await (const user of this.list(options)) {
       users.push(user);
@@ -57,16 +65,21 @@ export class TerminalsActiveService extends Service {
     return users;
   }
 
-  listByPage(options?: Options) {
-    return super.iterator<Terminal>({ url: this.apiPath }, options).byPage();
+  listByPage(): AsyncGenerator<AxiosResponse<Terminal[]>>;
+  listByPage<F extends keyof Terminal>(
+    options: { fields: F[] } & OptionsExtended<Terminal>,
+  ): AsyncGenerator<AxiosResponse<Pick<Terminal, F>[]>>;
+  listByPage(options?: OptionsExtended<Terminal>): AsyncGenerator<AxiosResponse<Terminal[]>>;
+  listByPage(options?: OptionsExtended<Terminal>) {
+    return super.iterator({ url: this.apiPath }, options).byPage();
   }
 
   closeTerminal(id: number): Promise<number>;
-  closeTerminal(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<any, any>>;
+  closeTerminal(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<void>>;
   closeTerminal(id: number, options: Options): Promise<number>;
   closeTerminal(id: number, options?: Options) {
     return super
-      .fetch({ url: `${this.apiPath}/${id}`, method: 'DELETE' })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.status));
+      .fetch<void>({ url: `${this.apiPath}/${id}`, method: 'DELETE' }, options)
+      .then((res) => (options?.rawResponse ? res : res.status));
   }
 }

package/src/services/terminals.service.ts

@@ -1,10 +1,10 @@
 import { AxiosResponse } from 'axios';
 import { Terminal } from '../interfaces/index.js';
-import { Service, Options, RequirementsOf } from './index.js';
+import { Service, Options, RequirementsOf, OptionsExtended } from './index.js';
 
 type RequiredProps = 'name' | 'timezone';
 
-export class TerminalsService extends Service {
+export class TerminalsService extends Service<Terminal> {
   private apiPath = '/terminals';
 
   create(data: RequirementsOf<Terminal, RequiredProps>): Promise<Terminal>;
@@ -16,16 +16,24 @@ export class TerminalsService extends Service {
   create(data: RequirementsOf<Terminal, RequiredProps>, options?: Options) {
     return super
       .fetch<Terminal>({ url: this.apiPath, data, method: 'POST' })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+      .then((res) => (options?.rawResponse ? res : res.data));
   }
 
   get(id: number): Promise<Terminal>;
-  get(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<Terminal, any>>;
-  get(id: number, options: Options): Promise<Terminal>;
+  get<F extends keyof Terminal>(
+    id: number,
+    options: { fields: F[]; rawResponse: true } & OptionsExtended<Terminal>,
+  ): Promise<AxiosResponse<Pick<Terminal, F>>>;
+  get<F extends keyof Terminal>(
+    id: number,
+    options: { fields: F[] } & OptionsExtended<Terminal>,
+  ): Promise<Pick<Terminal, F>>;
+  get(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<Terminal>>;
+  get(id: number, options?: OptionsExtended<Terminal>): Promise<Terminal>;
   get(id: number, options?: Options) {
     return super
       .fetch<Terminal>({ url: `${this.apiPath}/${id}` }, options)
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+      .then((res) => (options?.rawResponse ? res : res.data));
   }
 
   update(id: number, data: Partial<Terminal>): Promise<Terminal>;
@@ -42,26 +50,31 @@ export class TerminalsService extends Service {
         data,
         method: 'POST',
       })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+      .then((res) => (options?.rawResponse ? res : res.data));
   }
 
   closeTerminal(id: number): Promise<number>;
-  closeTerminal(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<number, any>>;
+  closeTerminal(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<void>>;
   closeTerminal(id: number, options: Options): Promise<number>;
   closeTerminal(id: number, options?: Options) {
     return super
-      .fetch({ url: `${this.apiPath}/${id}`, method: 'DELETE' })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.status));
+      .fetch<void>({ url: `${this.apiPath}/${id}`, method: 'DELETE' })
+      .then((res) => (options?.rawResponse ? res : res.status));
   }
 
-  async *list(options?: Options) {
-    for await (const res of super.iterator<Terminal>({ url: this.apiPath }, options)) {
-      yield res;
-    }
+  list(): AsyncGenerator<Terminal>;
+  list<F extends keyof Terminal>(
+    options: { fields: F[] } & OptionsExtended<Terminal>,
+  ): AsyncGenerator<Pick<Terminal, F>>;
+  list(options?: OptionsExtended<Terminal>): AsyncGenerator<Terminal>;
+  async *list(options?: OptionsExtended<Terminal>) {
+    yield* super.iterator({ url: this.apiPath }, options);
   }
 
-  listAll(options?: Options): Promise<Terminal[]>;
-  async listAll(options?: Options) {
+  listAll(): Promise<Terminal[]>;
+  listAll<F extends keyof Terminal>(options: { fields: F[] } & OptionsExtended<Terminal>): Promise<Pick<Terminal, F>[]>;
+  listAll(options?: OptionsExtended<Terminal>): Promise<Terminal[]>;
+  async listAll(options?: OptionsExtended<Terminal>) {
     const users = [] as Terminal[];
     for await (const user of this.list(options)) {
       users.push(user);
@@ -69,7 +82,12 @@ export class TerminalsService extends Service {
     return users;
   }
 
-  listByPage(options?: Options) {
-    return super.iterator<Terminal>({ url: this.apiPath }, options).byPage();
+  listByPage(): AsyncGenerator<AxiosResponse<Terminal[]>>;
+  listByPage<F extends keyof Terminal>(
+    options: { fields: F[] } & OptionsExtended<Terminal>,
+  ): AsyncGenerator<AxiosResponse<Pick<Terminal, F>[]>>;
+  listByPage(options?: OptionsExtended<Terminal>): AsyncGenerator<AxiosResponse<Terminal[]>>;
+  listByPage(options?: OptionsExtended<Terminal>) {
+    return super.iterator({ url: this.apiPath }, options).byPage();
   }
 }

package/src/services/time-zone.service.ts

@@ -0,0 +1,34 @@
+import { AxiosResponse } from 'axios';
+import { Service, Options } from './index.js';
+
+import { TimeZone } from '../interfaces/index.js';
+
+export class TimeZoneService extends Service<TimeZone> {
+  private apiPath = '/timezones';
+
+  get(id: number): Promise<TimeZone>;
+  get(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<TimeZone, any>>;
+  get(id: number, options: Options): Promise<TimeZone>;
+  get(id: number, options?: Options) {
+    return super
+      .fetch<TimeZone>({ url: `${this.apiPath}/${id}` }, options)
+      .then((res) => (options?.rawResponse ? res : res.data));
+  }
+
+  async *list(options?: Options) {
+    yield* super.iterator({ url: this.apiPath }, options);
+  }
+
+  listAll(options?: Options): Promise<TimeZone[]>;
+  async listAll(options?: Options) {
+    const timezones = [] as TimeZone[];
+    for await (const timezone of this.list(options)) {
+      timezones.push(timezone);
+    }
+    return timezones;
+  }
+
+  listByPage(options?: Options) {
+    return super.iterator({ url: this.apiPath }, options).byPage();
+  }
+}

package/src/services/toil-accruals.service.ts

@@ -17,7 +17,7 @@ export class ToilAccrualsService extends Service {
   create(data: RequirementsOf<ToilAccrual, RequiredProps>, options?: Options) {
     return super
       .fetch<ToilAccrual>({ url: this.apiPath, data, method: 'POST' })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+      .then((res) => (options?.rawResponse ? res : res.data));
   }
 
   get(id: number): Promise<ToilAccrual>;
@@ -26,16 +26,14 @@ export class ToilAccrualsService extends Service {
   get(id: number, options?: Options) {
     return super
       .fetch<ToilAccrual>({ url: `${this.apiPath}/${id}` }, options)
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+      .then((res) => (options?.rawResponse ? res : res.data));
   }
 
-  async *list(query: ToilAccrualsQueryParams, options?: Options) {
-    for await (const res of super.iterator<ToilAccrual>({ url: this.apiPath, params: query }, options)) {
-      yield res;
-    }
+  async *list(query?: ToilAccrualsQueryParams, options?: Options) {
+    yield* super.iterator<ToilAccrual>({ url: this.apiPath, params: query }, options);
   }
 
-  async listAll(query: ToilAccrualsQueryParams, options?: Options): Promise<ToilAccrual[]> {
+  async listAll(query?: ToilAccrualsQueryParams, options?: Options): Promise<ToilAccrual[]> {
     const toilAccruals = [] as ToilAccrual[];
     for await (const accrual of this.list(query, options)) {
       toilAccruals.push(accrual);
@@ -43,16 +41,16 @@ export class ToilAccrualsService extends Service {
     return toilAccruals;
   }
 
-  listByPage(query: ToilAccrualsQueryParams, options?: Options) {
+  listByPage(query?: ToilAccrualsQueryParams, options?: Options) {
     return super.iterator<ToilAccrual>({ url: this.apiPath, params: query }, options).byPage();
   }
 
   delete(id: number): Promise<number>;
-  delete(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<any, any>>;
+  delete(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<void>>;
   delete(id: number, options: Options): Promise<number>;
   delete(id: number, options?: Options) {
     return super
-      .fetch<ToilAccrual>({ url: `${this.apiPath}/${id}`, method: 'DELETE' })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.status));
+      .fetch<void>({ url: `${this.apiPath}/${id}`, method: 'DELETE' })
+      .then((res) => (options?.rawResponse ? res : res.status));
   }
 }

package/src/services/toil-allowance.service.ts

@@ -2,13 +2,11 @@ import { Options, Service } from './service';
 import { ToilAllowanceQueryParams } from '../interfaces/query-params/toil-allowance-query-params.interface';
 import { ToilAllowance } from '../interfaces/toil-allowance.interface';
 
-export class ToilAllowanceService extends Service {
+export class ToilAllowanceService extends Service<ToilAllowance> {
   private apiPath = '/toil_allowance';
 
   async *list(year: number, query: ToilAllowanceQueryParams, options?: Options) {
-    for await (const res of super.iterator<ToilAllowance>({ url: `${this.apiPath}/${year}`, params: query }, options)) {
-      yield res;
-    }
+    yield* super.iterator({ url: `${this.apiPath}/${year}`, params: query }, options);
   }
 
   async listAll(year: number, query: ToilAllowanceQueryParams, options?: Options): Promise<ToilAllowance[]> {
@@ -20,6 +18,6 @@ export class ToilAllowanceService extends Service {
   }
 
   listByPage(year: number, query: ToilAllowanceQueryParams, options?: Options) {
-    return super.iterator<ToilAllowance[]>({ url: `${this.apiPath}/${year}`, params: query }, options).byPage();
+    return super.iterator({ url: `${this.apiPath}/${year}`, params: query }, options).byPage();
   }
 }

package/src/services/users-clock-in.service.ts

@@ -1,6 +1,6 @@
 import { AxiosResponse } from 'axios';
 import { UserBreak, UserClockedIn, UserClockedOut, TerminalLocation } from '../interfaces/index.js';
-import { Service, Options, RequirementsOf } from './index.js';
+import { Service, Options, RequirementsOf, OptionsExtended } from './index.js';
 
 interface UserClockIn {
   method: string;
@@ -24,26 +24,35 @@ interface UserBreakRequest {
 type RequiredPropsClockIn = 'method';
 type RequiredPropsBreak = 'method' | 'action';
 
-export class UsersClockInService extends Service {
+export class UsersClockInService extends Service<UserClockedIn> {
   private apiPath = '/users_clocked_in';
 
   getClockedInUser(id: number): Promise<UserClockedIn>;
-  getClockedInUser(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<UserClockedIn, any>>;
+  getClockedInUser(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<UserClockedIn>>;
   getClockedInUser(id: number, options: Options): Promise<UserClockedIn>;
   getClockedInUser(id: number, options?: Options) {
     return super
       .fetch<UserClockedIn>({ url: `${this.apiPath}/${id}` }, options)
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+      .then((res) => (options?.rawResponse ? res : res.data));
   }
 
-  async *list(options?: Options) {
+  list(): AsyncGenerator<UserClockedIn>;
+  list<F extends keyof UserClockedIn>(
+    options: { fields: F[] } & OptionsExtended<UserClockedIn>,
+  ): AsyncGenerator<Pick<UserClockedIn, F>>;
+  list(options?: OptionsExtended<UserClockedIn>): AsyncGenerator<UserClockedIn>;
+  async *list(options?: OptionsExtended<UserClockedIn>) {
     for await (const res of super.iterator<UserClockedIn>({ url: this.apiPath }, options)) {
       yield res;
     }
   }
 
-  listAll(options?: Options): Promise<UserClockedIn[]>;
-  async listAll(options?: Options) {
+  listAll(): Promise<UserClockedIn[]>;
+  listAll<F extends keyof UserClockedIn>(
+    options: { fields: F[] } & OptionsExtended<UserClockedIn>,
+  ): Promise<Pick<UserClockedIn, F>[]>;
+  listAll(options?: OptionsExtended<UserClockedIn>): Promise<UserClockedIn[]>;
+  async listAll(options?: OptionsExtended<UserClockedIn>) {
     const users = [] as UserClockedIn[];
     for await (const user of this.list(options)) {
       users.push(user);
@@ -51,7 +60,12 @@ export class UsersClockInService extends Service {
     return users;
   }
 
-  listByPage(options?: Options) {
+  listByPage(): AsyncGenerator<AxiosResponse<UserClockedIn[]>>;
+  listByPage<F extends keyof UserClockedIn>(
+    options: { fields: F[] } & OptionsExtended<UserClockedIn>,
+  ): AsyncGenerator<AxiosResponse<Pick<UserClockedIn, F>[]>>;
+  listByPage(options?: OptionsExtended<UserClockedIn>): AsyncGenerator<AxiosResponse<UserClockedIn[]>>;
+  listByPage(options?: OptionsExtended<UserClockedIn>) {
     return super.iterator<UserClockedIn>({ url: this.apiPath }, options).byPage();
   }
 
@@ -59,12 +73,12 @@ export class UsersClockInService extends Service {
   clockIn(
     data: RequirementsOf<UserClockIn, RequiredPropsClockIn>,
     options: { rawResponse: true } & Options,
-  ): Promise<AxiosResponse<UserClockedIn, any>>;
+  ): Promise<AxiosResponse<UserClockedIn>>;
   clockIn(data: RequirementsOf<UserClockIn, RequiredPropsClockIn>, options: Options): Promise<UserClockedIn>;
   clockIn(data: RequirementsOf<UserClockIn, RequiredPropsClockIn>, options?: Options) {
     return super
       .fetch<UserClockedIn>({ url: this.apiPath, data, method: 'POST' })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+      .then((res) => (options?.rawResponse ? res : res.data));
   }
 
   clockOut(id: number, data: UserClockOut): Promise<UserClockedOut>;
@@ -72,12 +86,12 @@ export class UsersClockInService extends Service {
     id: number,
     data: UserClockOut,
     options: { rawResponse: true } & Options,
-  ): Promise<AxiosResponse<UserClockedOut, any>>;
+  ): Promise<AxiosResponse<UserClockedOut>>;
   clockOut(id: number, data: UserClockOut, options: Options): Promise<UserClockedOut>;
   clockOut(id: number, data: UserClockOut, options?: Options) {
     return super
       .fetch<UserClockedOut>({ url: `${this.apiPath}/${id}`, data, method: 'DELETE' })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+      .then((res) => (options?.rawResponse ? res : res.data));
   }
 
   startBreak(id: number, data: RequirementsOf<UserBreakRequest, RequiredPropsBreak>): Promise<UserBreak>;
@@ -85,7 +99,7 @@ export class UsersClockInService extends Service {
     id: number,
     data: RequirementsOf<UserBreakRequest, RequiredPropsBreak>,
     options: { rawResponse: true } & Options,
-  ): Promise<AxiosResponse<UserBreak, any>>;
+  ): Promise<AxiosResponse<UserBreak>>;
   startBreak(
     id: number,
     data: RequirementsOf<UserBreakRequest, RequiredPropsBreak>,
@@ -94,7 +108,7 @@ export class UsersClockInService extends Service {
   startBreak(id: number, data: RequirementsOf<UserBreakRequest, RequiredPropsBreak>, options?: Options) {
     return super
       .fetch<UserBreak>({ url: `${this.apiPath}/${id}`, data, method: 'POST' })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+      .then((res) => (options?.rawResponse ? res : res.data));
   }
 
   endBreak(id: number, data: RequirementsOf<UserBreakRequest, RequiredPropsBreak>): Promise<UserBreak>;
@@ -102,7 +116,7 @@ export class UsersClockInService extends Service {
     id: number,
     data: RequirementsOf<UserBreakRequest, RequiredPropsBreak>,
     options: { rawResponse: true } & Options,
-  ): Promise<AxiosResponse<UserBreak, any>>;
+  ): Promise<AxiosResponse<UserBreak>>;
   endBreak(
     id: number,
     data: RequirementsOf<UserBreakRequest, RequiredPropsBreak>,
@@ -111,6 +125,6 @@ export class UsersClockInService extends Service {
   endBreak(id: number, data: RequirementsOf<UserBreakRequest, RequiredPropsBreak>, options?: Options) {
     return super
       .fetch<UserBreak>({ url: `${this.apiPath}/${id}`, data, method: 'POST' })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+      .then((res) => (options?.rawResponse ? res : res.data));
   }
 }

package/src/services/users.service.ts

@@ -1,43 +1,57 @@
 import { AxiosResponse } from 'axios';
 import { User } from '../interfaces/index.js';
-import { Service, Options, RequirementsOf } from './index.js';
+import { Service, Options, RequirementsOf, OptionsExtended } from './index.js';
 
 import { UsersQueryParams } from '../interfaces/query-params/users-query-params.interface.js';
 
 type RequiredProps = 'first_name' | 'last_name';
 
-export class UsersService extends Service {
+export class UsersService extends Service<User> {
   private apiPath = '/users';
 
   create(data: RequirementsOf<User, RequiredProps>): Promise<User>;
   create(
     data: RequirementsOf<User, RequiredProps>,
     options: { rawResponse: true } & Options,
-  ): Promise<AxiosResponse<User, any>>;
+  ): Promise<AxiosResponse<User>>;
   create(data: RequirementsOf<User, RequiredProps>, options: Options): Promise<User>;
   create(data: RequirementsOf<User, RequiredProps>, options?: Options) {
     return super
-      .fetch<User>({ url: this.apiPath, data, method: 'POST' })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+      .fetch<User>({ url: this.apiPath, data, method: 'POST' }, options)
+      .then((res) => (options?.rawResponse ? res : res.data));
   }
 
   get(id: number): Promise<User>;
-  get(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<User, any>>;
-  get(id: number, options: Options): Promise<User>;
-  get(id: number, options?: Options) {
+  get<F extends keyof User>(
+    id: number,
+    options: { fields: F[]; rawResponse: true } & OptionsExtended<User>,
+  ): Promise<AxiosResponse<Pick<User, F>>>;
+  get<F extends keyof User>(id: number, options: { fields: F[] } & OptionsExtended<User>): Promise<Pick<User, F>>;
+  get(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<User>>;
+  get(id: number, options?: OptionsExtended<User>): Promise<User>;
+  get(id: number, options?: OptionsExtended<User>) {
     return super
       .fetch<User>({ url: `${this.apiPath}/${id}` }, options)
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+      .then((res) => (options?.rawResponse ? res : res.data));
   }
 
-  async *list(query: UsersQueryParams, options?: Options) {
-    for await (const res of super.iterator<User>({ url: this.apiPath, params: query }, options)) {
-      yield res;
-    }
+  list(query?: UsersQueryParams): AsyncGenerator<User>;
+  list<F extends keyof User>(
+    query: UsersQueryParams,
+    options: { fields: F[] } & OptionsExtended<User>,
+  ): AsyncGenerator<Pick<User, F>>;
+  list(query?: UsersQueryParams, options?: OptionsExtended<User>): AsyncGenerator<User>;
+  async *list(query?: UsersQueryParams, options?: OptionsExtended<User>) {
+    yield* super.iterator({ url: this.apiPath, params: query }, options);
   }
 
-  listAll(query: UsersQueryParams, options?: Options): Promise<User[]>;
-  async listAll(query: UsersQueryParams, options?: Options) {
+  listAll(query?: UsersQueryParams): Promise<User[]>;
+  listAll<F extends keyof User>(
+    query: UsersQueryParams,
+    options: { fields: F[] } & OptionsExtended<User>,
+  ): Promise<Pick<User, F>[]>;
+  listAll(query?: UsersQueryParams, options?: OptionsExtended<User>): Promise<User[]>;
+  async listAll(query?: UsersQueryParams, options?: OptionsExtended<User>) {
     const users = [] as User[];
     for await (const user of this.list(query, options)) {
       users.push(user);
@@ -45,8 +59,14 @@ export class UsersService extends Service {
     return users;
   }
 
-  listByPage(query: UsersQueryParams, options?: Options) {
-    return super.iterator<User>({ url: this.apiPath, params: query }, options).byPage();
+  listByPage(query?: UsersQueryParams): AsyncGenerator<AxiosResponse<User[]>>;
+  listByPage<F extends keyof User>(
+    query: UsersQueryParams,
+    options: { fields: F[] } & OptionsExtended<User>,
+  ): AsyncGenerator<AxiosResponse<Pick<User, F>[]>>;
+  listByPage(query?: UsersQueryParams, options?: OptionsExtended<User>): AsyncGenerator<AxiosResponse<User[]>>;
+  listByPage(query?: UsersQueryParams, options?: OptionsExtended<User>) {
+    return super.iterator({ url: this.apiPath, params: query }, options).byPage();
   }
 
   update(id: number, data: Partial<User>): Promise<User>;
@@ -54,20 +74,23 @@ export class UsersService extends Service {
   update(id: number, data: Partial<User>, options: Options): Promise<User>;
   update(id: number, data: Partial<User>, options?: Options) {
     return super
-      .fetch<User>({
-        url: `${this.apiPath}/${id}`,
-        data,
-        method: 'POST',
-      })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+      .fetch<User>(
+        {
+          url: `${this.apiPath}/${id}`,
+          data,
+          method: 'POST',
+        },
+        options,
+      )
+      .then((res) => (options?.rawResponse ? res : res.data));
   }
 
   delete(id: number): Promise<number>;
-  delete(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<any, any>>;
+  delete(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<void>>;
   delete(id: number, options: Options): Promise<number>;
   delete(id: number, options?: Options) {
     return super
-      .fetch<User>({ url: `${this.apiPath}/${id}`, method: 'DELETE' })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.status));
+      .fetch<void>({ url: `${this.apiPath}/${id}`, method: 'DELETE' }, options)
+      .then((res) => (options?.rawResponse ? res : res.status));
   }
 }

package/src/version.ts

@@ -1 +1 @@
-export const Version = { version: '1.1.1' };
+export const Version = { version: '1.2.0' };

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

@@ -1,5 +0,0 @@
-export interface InternalQueryParams {
-    expand?: string[];
-    fields?: string[];
-    limit?: number;
-}

package/dist/mjs/interfaces/query-params/internal-query-params.interface.d.ts

@@ -1,5 +0,0 @@
-export interface InternalQueryParams {
-    expand?: string[];
-    fields?: string[];
-    limit?: number;
-}

package/src/interfaces/query-params/internal-query-params.interface.ts

@@ -1,5 +0,0 @@
-export interface InternalQueryParams {
-  expand?: string[];
-  fields?: string[];
-  limit?: number;
-}