rotacloud 1.1.2 → 1.2.0

package/src/services/groups.service.ts

@@ -1,12 +1,12 @@
 import { AxiosResponse } from 'axios';
 import { Group } from '../interfaces/index.js';
-import { Service, Options, RequirementsOf } from './index.js';
+import { Service, Options, RequirementsOf, OptionsExtended } from './index.js';
 
 import { GroupsQueryParams } from '../interfaces/query-params/groups-query-params.interface.js';
 
 type RequiredProps = 'name';
 
-export class GroupsService extends Service {
+export class GroupsService extends Service<Group> {
   private apiPath = '/groups';
 
   create(data: RequirementsOf<Group, RequiredProps>): Promise<Group>;
@@ -17,27 +17,41 @@ export class GroupsService extends Service {
   create(data: RequirementsOf<Group, RequiredProps>, options: Options): Promise<Group>;
   create(data: RequirementsOf<Group, RequiredProps>, options?: Options) {
     return super
-      .fetch<Group>({ url: this.apiPath, data, method: 'POST' })
+      .fetch({ url: this.apiPath, data, method: 'POST' })
       .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
   }
 
   get(id: number): Promise<Group>;
-  get(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<Group, any>>;
-  get(id: number, options: Options): Promise<Group>;
-  get(id: number, options?: Options) {
+  get<F extends keyof Group>(
+    id: number,
+    options: { fields: F[]; rawResponse: true } & OptionsExtended<Group>,
+  ): Promise<AxiosResponse<Pick<Group, F>>>;
+  get<F extends keyof Group>(id: number, options: { fields: F[] } & OptionsExtended<Group>): Promise<Pick<Group, F>>;
+  get(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<Group>>;
+  get(id: number, options?: OptionsExtended<Group>): Promise<Group>;
+  get(id: number, options?: OptionsExtended<Group>) {
     return super
       .fetch<Group>({ url: `${this.apiPath}/${id}` }, options)
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+      .then((res) => (options?.rawResponse ? res : res.data));
   }
 
-  async *list(query?: GroupsQueryParams, options?: Options) {
-    for await (const res of super.iterator<Group>({ url: this.apiPath, params: query }, options)) {
-      yield res;
-    }
+  list(query?: GroupsQueryParams): AsyncGenerator<Group>;
+  list<F extends keyof Group>(
+    query: GroupsQueryParams,
+    options: { fields: F[] } & OptionsExtended<Group>,
+  ): AsyncGenerator<Pick<Group, F>>;
+  list(query?: GroupsQueryParams, options?: OptionsExtended<Group>): AsyncGenerator<Group>;
+  async *list(query?: GroupsQueryParams, options?: OptionsExtended<Group>) {
+    yield* super.iterator({ url: this.apiPath, params: query }, options);
   }
 
-  listAll(query?: GroupsQueryParams, options?: Options): Promise<Group[]>;
-  async listAll(query: GroupsQueryParams, options?: Options) {
+  listAll(query?: GroupsQueryParams): Promise<Group[]>;
+  listAll<F extends keyof Group>(
+    query: GroupsQueryParams,
+    options: { fields: F[] } & OptionsExtended<Group>,
+  ): Promise<Pick<Group, F>[]>;
+  listAll(query?: GroupsQueryParams, options?: OptionsExtended<Group>): Promise<Group[]>;
+  async listAll(query?: GroupsQueryParams, options?: OptionsExtended<Group>) {
     const groups = [] as Group[];
     for await (const group of this.list(query, options)) {
       groups.push(group);
@@ -45,8 +59,14 @@ export class GroupsService extends Service {
     return groups;
   }
 
-  listByPage(query?: GroupsQueryParams, options?: Options) {
-    return super.iterator<Group>({ url: this.apiPath, params: query }, options).byPage();
+  listByPage(query?: GroupsQueryParams): AsyncGenerator<AxiosResponse<Group[]>>;
+  listByPage<F extends keyof Group>(
+    query: GroupsQueryParams,
+    options: { fields: F[] } & OptionsExtended<Group>,
+  ): AsyncGenerator<AxiosResponse<Pick<Group, F>[]>>;
+  listByPage(query?: GroupsQueryParams, options?: OptionsExtended<Group>): AsyncGenerator<AxiosResponse<Group[]>>;
+  listByPage(query?: GroupsQueryParams, options?: OptionsExtended<Group>) {
+    return super.iterator({ url: this.apiPath, params: query }, options).byPage();
   }
 
   update(id: number, data: Partial<Group>): Promise<Group>;
@@ -58,20 +78,20 @@ export class GroupsService extends Service {
   update(id: number, data: Partial<Group>, options: Options): Promise<Group>;
   update(id: number, data: Partial<Group>, options?: Options) {
     return super
-      .fetch<Group>({
+      .fetch({
         url: `${this.apiPath}/${id}`,
         data,
         method: 'POST',
       })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+      .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<Group>({ 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/leave-embargoes.service.ts

@@ -1,12 +1,12 @@
 import { AxiosResponse } from 'axios';
 import { LeaveEmbargo } from '../interfaces/index.js';
-import { Service, Options, RequirementsOf } from './index.js';
+import { Service, Options, RequirementsOf, OptionsExtended } from './index.js';
 
 import { LeaveEmbargoesQueryParams } from '../rotacloud.js';
 
 type RequiredProps = 'start_date' | 'end_date' | 'users';
 
-export class LeaveEmbargoesService extends Service {
+export class LeaveEmbargoesService extends Service<LeaveEmbargo> {
   private apiPath = '/leave_embargoes';
 
   create(data: RequirementsOf<LeaveEmbargo, RequiredProps>): Promise<LeaveEmbargo>;
@@ -17,27 +17,44 @@ export class LeaveEmbargoesService extends Service {
   create(data: RequirementsOf<LeaveEmbargo, RequiredProps>, options: Options): Promise<LeaveEmbargo>;
   create(data: RequirementsOf<LeaveEmbargo, RequiredProps>, options?: Options) {
     return super
-      .fetch<LeaveEmbargo>({ url: this.apiPath, data, method: 'POST' })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+      .fetch<LeaveEmbargo>({ url: this.apiPath, data, method: 'POST' }, options)
+      .then((res) => (options?.rawResponse ? res : res.data));
   }
 
   get(id: number): Promise<LeaveEmbargo>;
-  get(id: number, options: { rawResponse: true }): Promise<AxiosResponse<LeaveEmbargo, any>>;
-  get(id: number, options: Options): Promise<LeaveEmbargo>;
-  get(id: number, options?: Options) {
+  get<F extends keyof LeaveEmbargo>(
+    id: number,
+    options: { fields: F[]; rawResponse: true } & OptionsExtended<LeaveEmbargo>,
+  ): Promise<AxiosResponse<Pick<LeaveEmbargo, F>>>;
+  get<F extends keyof LeaveEmbargo>(
+    id: number,
+    options: { fields: F[] } & OptionsExtended<LeaveEmbargo>,
+  ): Promise<Pick<LeaveEmbargo, F>>;
+  get(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<LeaveEmbargo>>;
+  get(id: number, options?: OptionsExtended<LeaveEmbargo>): Promise<LeaveEmbargo>;
+  get(id: number, options?: OptionsExtended<LeaveEmbargo>) {
     return super
       .fetch<LeaveEmbargo>({ url: `${this.apiPath}/${id}` }, options)
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+      .then((res) => (options?.rawResponse ? res : res.data));
   }
 
-  async *list(query: LeaveEmbargoesQueryParams, options?: Options) {
-    for await (const res of super.iterator<LeaveEmbargo>({ url: this.apiPath, params: query }, options)) {
-      yield res;
-    }
+  list(query?: LeaveEmbargoesQueryParams): AsyncGenerator<LeaveEmbargo>;
+  list<F extends keyof LeaveEmbargo>(
+    query: LeaveEmbargoesQueryParams,
+    options: { fields: F[] } & OptionsExtended<LeaveEmbargo>,
+  ): AsyncGenerator<Pick<LeaveEmbargo, F>>;
+  list(query?: LeaveEmbargoesQueryParams, options?: OptionsExtended<LeaveEmbargo>): AsyncGenerator<LeaveEmbargo>;
+  async *list(query?: LeaveEmbargoesQueryParams, options?: OptionsExtended<LeaveEmbargo>) {
+    yield* super.iterator({ url: this.apiPath, params: query }, options);
   }
 
-  listAll(query: LeaveEmbargoesQueryParams, options?: Options): Promise<LeaveEmbargo[]>;
-  async listAll(query: LeaveEmbargoesQueryParams, options?: Options) {
+  listAll(query?: LeaveEmbargoesQueryParams): Promise<LeaveEmbargo[]>;
+  listAll<F extends keyof LeaveEmbargo>(
+    query: LeaveEmbargoesQueryParams,
+    options: { fields: F[] } & OptionsExtended<LeaveEmbargo>,
+  ): Promise<Pick<LeaveEmbargo, F>[]>;
+  listAll(query?: LeaveEmbargoesQueryParams, options?: OptionsExtended<LeaveEmbargo>): Promise<LeaveEmbargo[]>;
+  async listAll(query?: LeaveEmbargoesQueryParams, options?: OptionsExtended<LeaveEmbargo>) {
     const leave = [] as LeaveEmbargo[];
     for await (const leaveEmbargoRecord of this.list(query, options)) {
       leave.push(leaveEmbargoRecord);
@@ -45,8 +62,17 @@ export class LeaveEmbargoesService extends Service {
     return leave;
   }
 
-  listByPage(query: LeaveEmbargoesQueryParams, options?: Options) {
-    return super.iterator<LeaveEmbargo>({ url: this.apiPath, params: query }, options).byPage();
+  listByPage(query?: LeaveEmbargoesQueryParams): AsyncGenerator<AxiosResponse<LeaveEmbargo[]>>;
+  listByPage<F extends keyof LeaveEmbargo>(
+    query: LeaveEmbargoesQueryParams,
+    options: { fields: F[] } & OptionsExtended<LeaveEmbargo>,
+  ): AsyncGenerator<AxiosResponse<Pick<LeaveEmbargo, F>[]>>;
+  listByPage(
+    query: LeaveEmbargoesQueryParams,
+    options?: OptionsExtended<LeaveEmbargo>,
+  ): AsyncGenerator<AxiosResponse<LeaveEmbargo[]>>;
+  listByPage(query?: LeaveEmbargoesQueryParams, options?: OptionsExtended<LeaveEmbargo>) {
+    return super.iterator({ url: this.apiPath, params: query }, options).byPage();
   }
 
   update(id: number, data: Partial<LeaveEmbargo>): Promise<LeaveEmbargo>;
@@ -58,20 +84,23 @@ export class LeaveEmbargoesService extends Service {
   update(id: number, data: Partial<LeaveEmbargo>, options: Options): Promise<LeaveEmbargo>;
   update(id: number, data: Partial<LeaveEmbargo>, options?: Options) {
     return super
-      .fetch<LeaveEmbargo>({
-        url: `${this.apiPath}/${id}`,
-        data,
-        method: 'POST',
-      })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+      .fetch<LeaveEmbargo>(
+        {
+          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<LeaveEmbargo>({ 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/leave-request.service.ts

@@ -1,12 +1,12 @@
 import { AxiosResponse } from 'axios';
 import { LeaveRequest } from '../interfaces/index.js';
-import { Service, Options, RequirementsOf } from './index.js';
+import { Service, Options, RequirementsOf, OptionsExtended } from './index.js';
 
 import { LeaveRequestsQueryParams } from '../interfaces/query-params/leave-requests-query-params.interface.js';
 
 type RequiredProps = 'start_date' | 'end_date' | 'type' | 'user';
 
-export class LeaveRequestService extends Service {
+export class LeaveRequestService extends Service<LeaveRequest> {
   private apiPath = '/leave_requests';
 
   create(data: RequirementsOf<LeaveRequest, RequiredProps>): Promise<LeaveRequest>;
@@ -25,26 +25,43 @@ export class LeaveRequestService extends Service {
         },
         options,
       )
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+      .then((res) => (options?.rawResponse ? res : res.data));
   }
 
   get(id: number): Promise<LeaveRequest>;
-  get(id: number, options: { rawResponse: true }): Promise<AxiosResponse<LeaveRequest, any>>;
-  get(id: number, options: Options): Promise<LeaveRequest>;
-  get(id: number, options?: Options) {
+  get<F extends keyof LeaveRequest>(
+    id: number,
+    options: { fields: F[]; rawResponse: true } & OptionsExtended<LeaveRequest>,
+  ): Promise<AxiosResponse<Pick<LeaveRequest, F>>>;
+  get<F extends keyof LeaveRequest>(
+    id: number,
+    options: { fields: F[] } & OptionsExtended<LeaveRequest>,
+  ): Promise<Pick<LeaveRequest, F>>;
+  get(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<LeaveRequest>>;
+  get(id: number, options?: OptionsExtended<LeaveRequest>): Promise<LeaveRequest>;
+  get(id: number, options?: OptionsExtended<LeaveRequest>) {
     return super
       .fetch<LeaveRequest>({ url: `${this.apiPath}/${id}` }, options)
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+      .then((res) => (options?.rawResponse ? res : res.data));
   }
 
-  async *list(query?: LeaveRequestsQueryParams, options?: Options) {
-    for await (const res of super.iterator<LeaveRequest>({ url: this.apiPath, params: query }, options)) {
-      yield res;
-    }
+  list(query?: LeaveRequestsQueryParams): AsyncGenerator<LeaveRequest>;
+  list<F extends keyof LeaveRequest>(
+    query: LeaveRequestsQueryParams,
+    options: { fields: F[] } & OptionsExtended<LeaveRequest>,
+  ): AsyncGenerator<Pick<LeaveRequest, F>>;
+  list(query?: LeaveRequestsQueryParams, options?: OptionsExtended<LeaveRequest>): AsyncGenerator<LeaveRequest>;
+  async *list(query?: LeaveRequestsQueryParams, options?: OptionsExtended<LeaveRequest>) {
+    yield* super.iterator({ url: this.apiPath, params: query }, options);
   }
 
-  listAll(query?: LeaveRequestsQueryParams, options?: Options): Promise<LeaveRequest[]>;
-  async listAll(query: LeaveRequestsQueryParams, options?: Options) {
+  listAll(query?: LeaveRequestsQueryParams): Promise<LeaveRequest[]>;
+  listAll<F extends keyof LeaveRequest>(
+    query: LeaveRequestsQueryParams,
+    options: { fields: F[] } & OptionsExtended<LeaveRequest>,
+  ): Promise<Pick<LeaveRequest, F>[]>;
+  listAll(query?: LeaveRequestsQueryParams, options?: OptionsExtended<LeaveRequest>): Promise<LeaveRequest[]>;
+  async listAll(query?: LeaveRequestsQueryParams, options?: OptionsExtended<LeaveRequest>) {
     const leave = [] as LeaveRequest[];
     for await (const leaveRequestRecord of this.list(query, options)) {
       leave.push(leaveRequestRecord);
@@ -52,8 +69,17 @@ export class LeaveRequestService extends Service {
     return leave;
   }
 
-  listByPage(query?: LeaveRequestsQueryParams, options?: Options) {
-    return super.iterator<LeaveRequest>({ url: `${this.apiPath}`, params: query }, options).byPage();
+  listByPage(query?: LeaveRequestsQueryParams): AsyncGenerator<AxiosResponse<LeaveRequest[]>>;
+  listByPage<F extends keyof LeaveRequest>(
+    query: LeaveRequestsQueryParams,
+    options: { fields: F[] } & OptionsExtended<LeaveRequest>,
+  ): AsyncGenerator<AxiosResponse<Pick<LeaveRequest, F>[]>>;
+  listByPage(
+    query: LeaveRequestsQueryParams,
+    options?: OptionsExtended<LeaveRequest>,
+  ): AsyncGenerator<AxiosResponse<LeaveRequest[]>>;
+  listByPage(query?: LeaveRequestsQueryParams, options?: OptionsExtended<LeaveRequest>) {
+    return super.iterator({ url: `${this.apiPath}`, params: query }, options).byPage();
   }
 
   update(id: number, data: Partial<LeaveRequest>): Promise<LeaveRequest>;
@@ -65,20 +91,23 @@ export class LeaveRequestService extends Service {
   update(id: number, data: Partial<LeaveRequest>, options: Options): Promise<LeaveRequest>;
   update(id: number, data: Partial<LeaveRequest>, options?: Options) {
     return super
-      .fetch<LeaveRequest>({
-        url: `${this.apiPath}/${id}`,
-        data,
-        method: 'POST',
-      })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+      .fetch<LeaveRequest>(
+        {
+          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<LeaveRequest, 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<LeaveRequest>({ 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/leave.service.ts

@@ -1,12 +1,12 @@
 import { AxiosResponse } from 'axios';
-import { Leave, LeaveType } from '../interfaces/index.js';
-import { Service, Options, RequirementsOf } from './index.js';
+import { Leave } from '../interfaces/index.js';
+import { Service, Options, RequirementsOf, OptionsExtended } from './index.js';
 
 import { LeaveQueryParams } from '../interfaces/query-params/leave-query-params.interface.js';
 
 type RequiredProps = 'users' | 'type' | 'start_date' | 'end_date';
 
-export class LeaveService extends Service {
+export class LeaveService extends Service<Leave> {
   private apiPath = '/leave';
 
   create(data: RequirementsOf<Leave, RequiredProps>): Promise<Leave[]>;
@@ -17,27 +17,41 @@ export class LeaveService extends Service {
   create(data: RequirementsOf<Leave, RequiredProps>, options: Options): Promise<Leave[]>;
   create(data: RequirementsOf<Leave, RequiredProps>, options?: Options) {
     return super
-      .fetch<Leave[]>({ url: this.apiPath, data, method: 'POST' }, options)
-      .then((res) => Promise.resolve(options?.rawResponse ? res : [...res.data.map((leave) => leave)]));
+      .fetch({ url: this.apiPath, data, method: 'POST' }, options)
+      .then((res) => (options?.rawResponse ? res : [...res.data.map((leave) => leave)]));
   }
 
   get(id: number): Promise<Leave>;
-  get(id: number, options: { rawResponse: true }): Promise<AxiosResponse<Leave, any>>;
-  get(id: number, options: Options): Promise<Leave>;
-  get(id: number, options?: Options) {
+  get<F extends keyof Leave>(
+    id: number,
+    options: { fields: F[]; rawResponse: true } & OptionsExtended<Leave>,
+  ): Promise<AxiosResponse<Pick<Leave, F>>>;
+  get<F extends keyof Leave>(id: number, options: { fields: F[] } & OptionsExtended<Leave>): Promise<Pick<Leave, F>>;
+  get(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<Leave>>;
+  get(id: number, options?: OptionsExtended<Leave>): Promise<Leave>;
+  get(id: number, options?: OptionsExtended<Leave>) {
     return super
       .fetch<Leave>({ url: `${this.apiPath}/${id}` }, options)
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+      .then((res) => (options?.rawResponse ? res : res.data));
   }
 
-  async *list(query: LeaveQueryParams, options?: Options) {
-    for await (const res of super.iterator<Leave>({ url: this.apiPath, params: query }, options)) {
-      yield res;
-    }
+  list(query?: LeaveQueryParams): AsyncGenerator<Leave>;
+  list<F extends keyof Leave>(
+    query: LeaveQueryParams,
+    options: { fields: F[] } & OptionsExtended<Leave>,
+  ): AsyncGenerator<Pick<Leave, F>>;
+  list(query?: LeaveQueryParams, options?: OptionsExtended<Leave>): AsyncGenerator<Leave>;
+  async *list(query?: LeaveQueryParams, options?: OptionsExtended<Leave>) {
+    yield* super.iterator({ url: this.apiPath, params: query }, options);
   }
 
-  listAll(query: LeaveQueryParams, options?: Options): Promise<Leave[]>;
-  async listAll(query: LeaveQueryParams, options?: Options) {
+  listAll(query?: LeaveQueryParams): Promise<Leave[]>;
+  listAll<F extends keyof Leave>(
+    query: LeaveQueryParams,
+    options: { fields: F[] } & OptionsExtended<Leave>,
+  ): Promise<Pick<Leave, F>[]>;
+  listAll(query?: LeaveQueryParams, options?: OptionsExtended<Leave>): Promise<Leave[]>;
+  async listAll(query?: LeaveQueryParams, options?: OptionsExtended<Leave>) {
     const leave = [] as Leave[];
     for await (const leaveRecord of this.list(query, options)) {
       leave.push(leaveRecord);
@@ -45,14 +59,14 @@ export class LeaveService extends Service {
     return leave;
   }
 
-  async *listLeaveTypes(query: LeaveQueryParams, options?: Options) {
-    for await (const res of super.iterator<LeaveType>({ url: this.apiPath, params: query }, options)) {
-      yield res;
-    }
-  }
-
-  listByPage(query: LeaveQueryParams, options?: Options) {
-    return super.iterator<Leave>({ url: this.apiPath, params: query }, options).byPage();
+  listByPage(query?: LeaveQueryParams): AsyncGenerator<AxiosResponse<Leave[]>>;
+  listByPage<F extends keyof Leave>(
+    query: LeaveQueryParams,
+    options: { fields: F[] } & OptionsExtended<Leave>,
+  ): AsyncGenerator<AxiosResponse<Pick<Leave, F>[]>>;
+  listByPage(query?: LeaveQueryParams, options?: OptionsExtended<Leave>): AsyncGenerator<AxiosResponse<Leave[]>>;
+  listByPage(query?: LeaveQueryParams, options?: OptionsExtended<Leave>) {
+    return super.iterator({ url: this.apiPath, params: query }, options).byPage();
   }
 
   update(id: number, data: Partial<Leave>): Promise<Leave>;
@@ -72,15 +86,15 @@ export class LeaveService extends Service {
         },
         options,
       )
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+      .then((res) => (options?.rawResponse ? res : res.data));
   }
 
   delete(id: number): Promise<number>;
-  delete(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<Leave, 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<Leave>({ 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/locations.service.ts

@@ -1,12 +1,12 @@
 import { AxiosResponse } from 'axios';
 import { Location } from '../interfaces/index.js';
-import { Service, Options, RequirementsOf } from './index.js';
+import { Service, Options, RequirementsOf, OptionsExtended } from './index.js';
 
 import { LocationsQueryParams } from '../interfaces/query-params/locations-query-params.interface.js';
 
 type RequiredProps = 'name';
 
-export class LocationsService extends Service {
+export class LocationsService extends Service<Location> {
   private apiPath = '/locations';
 
   create(data: RequirementsOf<Location, RequiredProps>): Promise<Location>;
@@ -17,27 +17,44 @@ export class LocationsService extends Service {
   create(data: RequirementsOf<Location, RequiredProps>, options: Options): Promise<Location>;
   create(data: RequirementsOf<Location, RequiredProps>, options?: Options) {
     return super
-      .fetch<Location>({ url: `${this.apiPath}`, data, method: 'POST' })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+      .fetch<Location>({ url: `${this.apiPath}`, data, method: 'POST' }, options)
+      .then((res) => (options?.rawResponse ? res : res.data));
   }
 
   get(id: number): Promise<Location>;
-  get(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<Location, any>>;
-  get(id: number, options: Options): Promise<Location>;
-  get(id: number, options?: Options) {
+  get<F extends keyof Location>(
+    id: number,
+    options: { fields: F[]; rawResponse: true } & OptionsExtended<Location>,
+  ): Promise<AxiosResponse<Pick<Location, F>>>;
+  get<F extends keyof Location>(
+    id: number,
+    options: { fields: F[] } & OptionsExtended<Location>,
+  ): Promise<Pick<Location, F>>;
+  get(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<Location>>;
+  get(id: number, options?: OptionsExtended<Location>): Promise<Location>;
+  get(id: number, options?: OptionsExtended<Location>) {
     return super
       .fetch<Location>({ url: `${this.apiPath}/${id}` }, options)
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+      .then((res) => (options?.rawResponse ? res : res.data));
   }
 
-  async *list(query?: LocationsQueryParams, options?: Options) {
-    for await (const res of super.iterator<Location>({ url: this.apiPath, params: query }, options)) {
-      yield res;
-    }
+  list(query?: LocationsQueryParams): AsyncGenerator<Location>;
+  list<F extends keyof Location>(
+    query: LocationsQueryParams,
+    options: { fields: F[] } & OptionsExtended<Location>,
+  ): AsyncGenerator<Pick<Location, F>>;
+  list(query?: LocationsQueryParams, options?: OptionsExtended<Location>): AsyncGenerator<Location>;
+  async *list(query?: LocationsQueryParams, options?: OptionsExtended<Location>) {
+    yield* super.iterator({ url: this.apiPath, params: query }, options);
   }
 
-  listAll(query?: LocationsQueryParams, options?: Options): Promise<Location[]>;
-  async listAll(query: LocationsQueryParams, options?: Options) {
+  listAll(query?: LocationsQueryParams): Promise<Location[]>;
+  listAll<F extends keyof Location>(
+    query: LocationsQueryParams,
+    options: { fields: F[] } & OptionsExtended<Location>,
+  ): Promise<Pick<Location, F>[]>;
+  listAll(query?: LocationsQueryParams, options?: OptionsExtended<Location>): Promise<Location[]>;
+  async listAll(query?: LocationsQueryParams, options?: OptionsExtended<Location>) {
     const locations = [] as Location[];
     for await (const location of this.list(query, options)) {
       locations.push(location);
@@ -45,8 +62,17 @@ export class LocationsService extends Service {
     return locations;
   }
 
-  listByPage(query?: LocationsQueryParams, options?: Options) {
-    return super.iterator<Location>({ url: this.apiPath, params: query }, options).byPage();
+  listByPage(query?: LocationsQueryParams): AsyncGenerator<AxiosResponse<Location[]>>;
+  listByPage<F extends keyof Location>(
+    query: LocationsQueryParams,
+    options: { fields: F[] } & OptionsExtended<Location>,
+  ): AsyncGenerator<AxiosResponse<Pick<Location, F>[]>>;
+  listByPage(
+    query: LocationsQueryParams,
+    options?: OptionsExtended<Location>,
+  ): AsyncGenerator<AxiosResponse<Location[]>>;
+  listByPage(query?: LocationsQueryParams, options?: OptionsExtended<Location>) {
+    return super.iterator({ url: this.apiPath, params: query }, options).byPage();
   }
 
   update(id: number, data: Partial<Location>): Promise<Location>;
@@ -58,20 +84,23 @@ export class LocationsService extends Service {
   update(id: number, data: Partial<Location>, options: Options): Promise<Location>;
   update(id: number, data: Partial<Location>, options?: Options) {
     return super
-      .fetch<Location>({
-        url: `${this.apiPath}/${id}`,
-        data,
-        method: 'POST',
-      })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+      .fetch<Location>(
+        {
+          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<Location>({ 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/pins.service.ts

@@ -1,16 +1,21 @@
 import { AxiosResponse } from 'axios';
 import { Pin } from '../interfaces/index.js';
-import { Service, Options } from './index.js';
+import { Service, Options, OptionsExtended } from './index.js';
 
-export class PinsService extends Service {
+export class PinsService extends Service<Pin> {
   private apiPath = '/pins';
 
   get(id: string): Promise<Pin>;
-  get(id: string, options?: { rawResponse: true } & Options): Promise<AxiosResponse<Pin, any>>;
-  get(id: string, options?: Options): Promise<Pin>;
-  get(id: string, options?: Options) {
+  get<F extends keyof Pin>(
+    id: string,
+    options: { fields: F[]; rawResponse: true } & OptionsExtended<Pin>,
+  ): Promise<AxiosResponse<Pick<Pin, F>>>;
+  get<F extends keyof Pin>(id: string, options: { fields: F[] } & OptionsExtended<Pin>): Promise<Pick<Pin, F>>;
+  get(id: string, options: { rawResponse: true } & Options): Promise<AxiosResponse<Pin>>;
+  get(id: string, options?: OptionsExtended<Pin>): Promise<Pin>;
+  get(id: string, options?: OptionsExtended<Pin>) {
     return super
       .fetch<Pin>({ url: `${this.apiPath}/${id}` }, options)
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+      .then((res) => (options?.rawResponse ? res : res.data));
   }
 }