rotacloud 1.1.2 → 1.2.0

package/src/services/roles.service.ts

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

@@ -29,13 +29,15 @@ export type RetryOptions =
 
 export interface Options {
   rawResponse?: boolean;
-  expand?: string[];
-  fields?: string[];
   limit?: number;
   offset?: number;
   dryRun?: boolean;
 }
 
+export type OptionsExtended<T = unknown> = Options & {
+  fields?: (keyof T)[];
+};
+
 const DEFAULT_RETRIES = 3;
 const DEFAULT_RETRY_DELAY = 2000;
 
@@ -51,7 +53,7 @@ const DEFAULT_RETRY_STRATEGY_OPTIONS: Record<RetryStrategy, RetryOptions> = {
   },
 };
 
-type ParameterPrimitive = string | boolean | number | null;
+type ParameterPrimitive = string | boolean | number | null | symbol;
 type ParameterValue = ParameterPrimitive | ParameterPrimitive[] | undefined;
 
 export abstract class Service<ApiResponse = any> {
@@ -65,7 +67,7 @@ export abstract class Service<ApiResponse = any> {
         const parsedError = this.parseClientError(error);
 
         return Promise.reject(parsedError);
-      }
+      },
     );
     return client;
   }
@@ -87,9 +89,11 @@ export abstract class Service<ApiResponse = any> {
     return endpoint === '/leave_requests';
   }
 
-  private buildQueryParams(options?: Options, extraParams?: Record<string, ParameterValue>) {
+  private buildQueryParams<T = ApiResponse>(
+    options?: OptionsExtended<T>,
+    extraParams?: Record<string, ParameterValue>,
+  ) {
     const queryParams: Record<string, ParameterValue> = {
-      expand: options?.expand,
       fields: options?.fields,
       limit: options?.limit,
       offset: options?.offset,
@@ -109,7 +113,21 @@ export abstract class Service<ApiResponse = any> {
     return new URLSearchParams(reducedParams);
   }
 
-  fetch<T = ApiResponse>(reqConfig: AxiosRequestConfig, options?: Options): Promise<AxiosResponse<T>> {
+  fetch<T = ApiResponse>(reqConfig: AxiosRequestConfig): Promise<AxiosResponse<T>>;
+  fetch<T = ApiResponse>(
+    reqConfig: AxiosRequestConfig,
+    options: { fields: Required<OptionsExtended<T>>['fields'] } & OptionsExtended<T>,
+  ): Promise<AxiosResponse<Pick<T, (typeof options)['fields'][number]>>>;
+  fetch<T extends unknown[] = ApiResponse[], E = T[number]>(
+    reqConfig: AxiosRequestConfig,
+    options: { fields: Required<OptionsExtended<E>>['fields'] } & OptionsExtended<E>,
+  ): Promise<AxiosResponse<Pick<E, (typeof options)['fields'][number]>[]>>;
+  fetch<T extends unknown[] = ApiResponse[]>(
+    reqConfig: AxiosRequestConfig,
+    options?: Options,
+  ): Promise<AxiosResponse<T>>;
+  fetch<T = ApiResponse>(reqConfig: AxiosRequestConfig, options?: Options): Promise<AxiosResponse<T | Partial<T>>>;
+  fetch<T = ApiResponse>(reqConfig: AxiosRequestConfig, options?: Options) {
     const headers: Record<string, string> = {
       Authorization: RotaCloud.config.apiKey
         ? `Bearer ${RotaCloud.config.apiKey}`
@@ -161,9 +179,17 @@ export abstract class Service<ApiResponse = any> {
   }
 
   /** Iterates through every page for a potentially paginated request */
-  private async *fetchPages<T>(
+  private fetchPages<T = ApiResponse>(
+    reqConfig: AxiosRequestConfig<T[]>,
+    options: { fields: Required<OptionsExtended<T>>['fields'] } & OptionsExtended<T>,
+  ): AsyncGenerator<AxiosResponse<Pick<T, (typeof options)['fields'][number]>[]>>;
+  private fetchPages<T = ApiResponse>(
+    reqConfig: AxiosRequestConfig<T[]>,
+    options?: Options,
+  ): AsyncGenerator<AxiosResponse<T[]>>;
+  private async *fetchPages<T = ApiResponse>(
     reqConfig: AxiosRequestConfig<T[]>,
-    options: Options | undefined
+    options?: Options,
   ): AsyncGenerator<AxiosResponse<T[]>> {
     const fallbackLimit = 20;
     const res = await this.fetch<T[]>(reqConfig, options);

package/src/services/settings.service.ts

@@ -5,7 +5,7 @@ import { Settings } from '../interfaces/index.js';
 
 import { SettingsQueryParams } from '../rotacloud.js';
 
-export class SettingsService extends Service {
+export class SettingsService extends Service<Settings> {
   private apiPath = '/settings';
 
   get(query: SettingsQueryParams): Promise<Settings>;
@@ -14,6 +14,6 @@ export class SettingsService extends Service {
   get(query: SettingsQueryParams, options?: Options) {
     return super
       .fetch<Settings>({ url: `${this.apiPath}`, params: query }, options)
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+      .then((res) => (options?.rawResponse ? res : res.data));
   }
 }

package/src/services/shifts.service.ts

@@ -1,12 +1,12 @@
 import { AxiosRequestConfig, AxiosResponse } from 'axios';
 import { Shift } from '../interfaces/index.js';
-import { Service, Options, RequirementsOf } from './index.js';
+import { Service, Options, RequirementsOf, OptionsExtended } from './index.js';
 
 import { ShiftsQueryParams } from '../interfaces/query-params/shifts-query-params.interface.js';
 
 type RequiredProps = 'end_time' | 'start_time' | 'location';
 
-export class ShiftsService extends Service {
+export class ShiftsService extends Service<Shift> {
   private apiPath = '/shifts';
 
   create(data: RequirementsOf<Shift, RequiredProps>): Promise<Shift>;
@@ -17,27 +17,41 @@ export class ShiftsService extends Service {
   create(data: RequirementsOf<Shift, RequiredProps>, options: Options): Promise<Shift>;
   create(data: RequirementsOf<Shift, RequiredProps>, options?: Options) {
     return super
-      .fetch<Shift>({ url: this.apiPath, data, method: 'POST' })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+      .fetch<Shift>({ url: this.apiPath, data, method: 'POST' }, options)
+      .then((res) => (options?.rawResponse ? res : res.data));
   }
 
   get(id: number): Promise<Shift>;
-  get(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<Shift, any>>;
-  get(id: number, options: Options): Promise<Shift>;
-  get(id: number, options?: Options) {
+  get<F extends keyof Shift>(
+    id: number,
+    options: { fields: F[]; rawResponse: true } & OptionsExtended<Shift>,
+  ): Promise<AxiosResponse<Pick<Shift, F>>>;
+  get<F extends keyof Shift>(id: number, options: { fields: F[] } & OptionsExtended<Shift>): Promise<Pick<Shift, F>>;
+  get(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<Shift>>;
+  get(id: number, options?: OptionsExtended<Shift>): Promise<Shift>;
+  get(id: number, options?: OptionsExtended<Shift>) {
     return super
       .fetch<Shift>({ url: `${this.apiPath}/${id}` }, options)
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+      .then((res) => (options?.rawResponse ? res : res.data));
   }
 
-  async *list(query: ShiftsQueryParams, options?: Options) {
-    for await (const res of super.iterator<Shift>({ url: this.apiPath, params: query }, options)) {
-      yield res;
-    }
+  list(query: ShiftsQueryParams): AsyncGenerator<Shift>;
+  list<F extends keyof Shift>(
+    query: ShiftsQueryParams,
+    options: { fields: F[] } & OptionsExtended<Shift>,
+  ): AsyncGenerator<Pick<Shift, F>>;
+  list(query: ShiftsQueryParams, options?: OptionsExtended<Shift>): AsyncGenerator<Shift>;
+  async *list(query: ShiftsQueryParams, options?: OptionsExtended<Shift>) {
+    yield* super.iterator({ url: this.apiPath, params: query }, options);
   }
 
-  listAll(query: ShiftsQueryParams, options?: Options): Promise<Shift[]>;
-  async listAll(query: ShiftsQueryParams, options?: Options) {
+  listAll(query: ShiftsQueryParams): Promise<Shift[]>;
+  listAll<F extends keyof Shift>(
+    query: ShiftsQueryParams,
+    options: { fields: F[] } & OptionsExtended<Shift>,
+  ): Promise<Pick<Shift, F>[]>;
+  listAll(query: ShiftsQueryParams, options?: OptionsExtended<Shift>): Promise<Shift[]>;
+  async listAll(query: ShiftsQueryParams, options?: OptionsExtended<Shift>) {
     const shifts = [] as Shift[];
     for await (const shift of this.list(query, options)) {
       shifts.push(shift);
@@ -45,7 +59,13 @@ export class ShiftsService extends Service {
     return shifts;
   }
 
-  listByPage(query: ShiftsQueryParams, options?: Options) {
+  listByPage(query: ShiftsQueryParams): AsyncGenerator<AxiosResponse<Shift[]>>;
+  listByPage<F extends keyof Shift>(
+    query: ShiftsQueryParams,
+    options: { fields: F[] } & OptionsExtended<Shift>,
+  ): AsyncGenerator<AxiosResponse<Pick<Shift, F>[]>>;
+  listByPage(query: ShiftsQueryParams, options?: OptionsExtended<Shift>): AsyncGenerator<AxiosResponse<Shift[]>>;
+  listByPage(query: ShiftsQueryParams, options?: OptionsExtended<Shift>) {
     return super.iterator<Shift>({ url: this.apiPath, params: query }, options).byPage();
   }
 
@@ -65,20 +85,26 @@ export class ShiftsService extends Service {
   update(shifts: RequirementsOf<Shift, 'id'> | RequirementsOf<Shift, 'id'>[], options?: Options) {
     if (!Array.isArray(shifts)) {
       return super
-        .fetch<Shift>({
-          url: `${this.apiPath}/${shifts.id}`,
-          data: shifts,
-          method: 'POST',
-        })
+        .fetch<Shift>(
+          {
+            url: `${this.apiPath}/${shifts.id}`,
+            data: shifts,
+            method: 'POST',
+          },
+          options,
+        )
         .then((res) => (options?.rawResponse ? res : res.data));
     }
 
     return super
-      .fetch<{ code: number; data?: Shift; error?: string }[]>({
-        url: this.apiPath,
-        data: shifts,
-        method: 'POST',
-      })
+      .fetch<{ code: number; data?: Shift; error?: string }[]>(
+        {
+          url: this.apiPath,
+          data: shifts,
+          method: 'POST',
+        },
+        options,
+      )
       .then((res) => {
         if (options?.rawResponse) return res;
 
@@ -94,40 +120,40 @@ export class ShiftsService extends Service {
   }
 
   delete(ids: number | number[]): Promise<number>;
-  delete(ids: number | number[], options: { rawResponse: true } & Options): Promise<AxiosResponse<any, any>>;
+  delete(ids: number | number[], options: { rawResponse: true } & Options): Promise<AxiosResponse<void>>;
   delete(ids: number | number[], options: Options): Promise<number>;
   delete(ids: number | number[], options?: Options) {
     const params: AxiosRequestConfig = Array.isArray(ids)
       ? { url: this.apiPath, data: { ids }, method: 'DELETE' }
       : { url: `${this.apiPath}/${ids}`, method: 'DELETE' };
 
-    return super.fetch<Shift>(params).then((res) => Promise.resolve(options?.rawResponse ? res : res.status));
+    return super.fetch<void>(params, options).then((res) => (options?.rawResponse ? res : res.status));
   }
 
   acknowledge(data: number[]): Promise<number>;
-  acknowledge(data: number[], options: { rawResponse: true } & Options): Promise<AxiosResponse<any, any>>;
+  acknowledge(data: number[], options: { rawResponse: true } & Options): Promise<AxiosResponse<any>>;
   acknowledge(data: number[], options: Options): Promise<number>;
   acknowledge(data: number[], options?: Options) {
     return super
-      .fetch<Shift>({ url: '/shifts_acknowledged', data, method: 'POST' })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.status));
+      .fetch<Shift>({ url: '/shifts_acknowledged', data, method: 'POST' }, options)
+      .then((res) => (options?.rawResponse ? res : res.status));
   }
 
   publish(data: { shifts: number[] }): Promise<number>;
-  publish(data: { shifts: number[] }, options: { rawResponse: true } & Options): Promise<AxiosResponse<any, any>>;
+  publish(data: { shifts: number[] }, options: { rawResponse: true } & Options): Promise<AxiosResponse<any>>;
   publish(data: { shifts: number[] }, options: Options): Promise<number>;
   publish(data: { shifts: number[] }, options?: Options) {
     return super
-      .fetch<Shift>({ url: '/shifts_published', data, method: 'POST' })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.status));
+      .fetch<Shift>({ url: '/shifts_published', data, method: 'POST' }, options)
+      .then((res) => (options?.rawResponse ? res : res.status));
   }
 
   unpublish(data: { shifts: number[] }): Promise<number>;
-  unpublish(data: { shifts: number[] }, options: { rawResponse: true } & Options): Promise<AxiosResponse<any, any>>;
+  unpublish(data: { shifts: number[] }, options: { rawResponse: true } & Options): Promise<AxiosResponse<any>>;
   unpublish(data: { shifts: number[] }, options: Options): Promise<number>;
   unpublish(data: { shifts: number[] }, options?: Options) {
     return super
-      .fetch<Shift>({ url: '/shifts_published', data, method: 'DELETE' })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.status));
+      .fetch<Shift>({ url: '/shifts_published', data, method: 'DELETE' }, options)
+      .then((res) => (options?.rawResponse ? res : res.status));
   }
 }

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

@@ -3,7 +3,7 @@ import { Service, Options } from './index.js';
 
 import { TimeZone } from '../interfaces/index.js';
 
-export class TimeZoneService extends Service {
+export class TimeZoneService extends Service<TimeZone> {
   private apiPath = '/timezones';
 
   get(id: number): Promise<TimeZone>;
@@ -12,13 +12,11 @@ export class TimeZoneService extends Service {
   get(id: number, options?: Options) {
     return super
       .fetch<TimeZone>({ 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) {
-    for await (const res of super.iterator<TimeZone>({ url: this.apiPath }, options)) {
-      yield res;
-    }
+    yield* super.iterator({ url: this.apiPath }, options);
   }
 
   listAll(options?: Options): Promise<TimeZone[]>;
@@ -31,6 +29,6 @@ export class TimeZoneService extends Service {
   }
 
   listByPage(options?: Options) {
-    return super.iterator<TimeZone>({ url: this.apiPath }, options).byPage();
+    return super.iterator({ url: this.apiPath }, options).byPage();
   }
 }