rotacloud 1.1.1 → 1.2.0

package/src/services/accounts.service.ts

@@ -1,28 +1,39 @@
 import { AxiosResponse } from 'axios';
-import { Service, Options } from './index.js';
+import { Service, Options, OptionsExtended } from './index.js';
 
 import { Account } from '../interfaces/index.js';
 
-export class AccountsService extends Service {
+export class AccountsService extends Service<Account> {
   private apiPath = '/accounts';
 
   get(id: number): Promise<Account>;
-  get(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<Account, any>>;
-  get(id: number, options: Options): Promise<Account>;
-  get(id: number, options?: Options) {
+  get<F extends keyof Account>(
+    id: number,
+    options: { fields: F[]; rawResponse: true } & OptionsExtended<Account>,
+  ): Promise<AxiosResponse<Pick<Account, F>>>;
+  get<F extends keyof Account>(
+    id: number,
+    options: { fields: F[] } & OptionsExtended<Account>,
+  ): Promise<Pick<Account, F>>;
+  get(id: number, options: { rawResponse: true } & OptionsExtended<Account>): Promise<AxiosResponse<Account>>;
+  get(id: number, options?: OptionsExtended<Account>): Promise<Account>;
+  get(id: number, options?: OptionsExtended<Account>) {
     return super
       .fetch<Account>({ 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<Account>({ url: this.apiPath }, options)) {
-      yield res;
-    }
+  list(): AsyncGenerator<Account>;
+  list<F extends keyof Account>(options: { fields: F[] } & OptionsExtended<Account>): AsyncGenerator<Pick<Account, F>>;
+  list(options?: OptionsExtended<Account>): AsyncGenerator<Account>;
+  async *list(options?: OptionsExtended<Account>) {
+    yield* super.iterator({ url: this.apiPath }, options);
   }
 
-  listAll(options?: Options): Promise<Account[]>;
-  async listAll(options?: Options) {
+  listAll(): Promise<Account[]>;
+  listAll<F extends keyof Account>(options: { fields: F[] } & OptionsExtended<Account>): Promise<Pick<Account, F>[]>;
+  listAll(options?: OptionsExtended<Account>): Promise<Account[]>;
+  async listAll(options?: OptionsExtended<Account>) {
     const accounts = [] as Account[];
     for await (const account of this.list(options)) {
       accounts.push(account);
@@ -30,7 +41,12 @@ export class AccountsService extends Service {
     return accounts;
   }
 
-  listByPage(options?: Options) {
-    return super.iterator<Account>({ url: this.apiPath }, options).byPage();
+  listByPage(): AsyncGenerator<AxiosResponse<Account[]>>;
+  listByPage<F extends keyof Account>(
+    options: { fields: F[] } & OptionsExtended<Account>,
+  ): AsyncGenerator<AxiosResponse<Pick<Account, F>[]>>;
+  listByPage(options: OptionsExtended<Account>): AsyncGenerator<AxiosResponse<Account[]>>;
+  listByPage(options?: OptionsExtended<Account>) {
+    return super.iterator({ url: this.apiPath }, options).byPage();
   }
 }

package/src/services/attendance.service.ts

@@ -1,43 +1,60 @@
 import { AxiosResponse } from 'axios';
 import { Attendance } from '../interfaces/index.js';
-import { Service, Options, RequirementsOf } from './index.js';
+import { Service, Options, RequirementsOf, OptionsExtended } from './index.js';
 
 import { AttendanceQueryParams } from '../interfaces/query-params/attendance-query-params.interface.js';
 
 type RequiredProps = 'user' | 'in_time';
 
-export class AttendanceService extends Service {
+export class AttendanceService extends Service<Attendance> {
   private apiPath = '/attendance';
 
   create(data: RequirementsOf<Attendance, RequiredProps>): Promise<Attendance>;
   create(
     data: RequirementsOf<Attendance, RequiredProps>,
     options: { rawResponse: true } & Options,
-  ): Promise<AxiosResponse<Attendance, any>>;
+  ): Promise<AxiosResponse<Attendance>>;
   create(data: RequirementsOf<Attendance, RequiredProps>, options: Options): Promise<Attendance>;
   create(data: RequirementsOf<Attendance, RequiredProps>, options?: Options) {
     return super
-      .fetch<Attendance>({ url: this.apiPath, data, method: 'POST' })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+      .fetch<Attendance>({ url: this.apiPath, data, method: 'POST' }, options)
+      .then((res) => (options?.rawResponse ? res : res.data));
   }
 
   get(id: number): Promise<Attendance>;
-  get(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<Attendance, any>>;
-  get(id: number, options: Options): Promise<Attendance>;
-  get(id: number, options?: Options) {
+  get<F extends keyof Attendance>(
+    id: number,
+    options: { fields: F[]; rawResponse: true } & OptionsExtended<Attendance>,
+  ): Promise<AxiosResponse<Pick<Attendance, F>>>;
+  get<F extends keyof Attendance>(
+    id: number,
+    options: { fields: F[] } & OptionsExtended<Attendance>,
+  ): Promise<Pick<Attendance, F>>;
+  get(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<Attendance>>;
+  get(id: number, options?: OptionsExtended<Attendance>): Promise<Attendance>;
+  get(id: number, options?: OptionsExtended<Attendance>) {
     return super
       .fetch<Attendance>({ url: `${this.apiPath}/${id}` }, options)
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+      .then((res) => (options?.rawResponse ? res : res.data));
   }
 
-  async *list(query: AttendanceQueryParams, options?: Options) {
-    for await (const res of super.iterator<Attendance>({ url: this.apiPath, params: query }, options)) {
-      yield res;
-    }
+  list(query: AttendanceQueryParams): AsyncGenerator<Attendance>;
+  list<F extends keyof Attendance>(
+    query: AttendanceQueryParams,
+    options: { fields: F[] } & OptionsExtended<Attendance>,
+  ): AsyncGenerator<Pick<Attendance, F>>;
+  list(query: AttendanceQueryParams, options?: OptionsExtended<Attendance>): AsyncGenerator<Attendance>;
+  async *list(query: AttendanceQueryParams, options?: OptionsExtended<Attendance>) {
+    yield* super.iterator({ url: this.apiPath, params: query }, options);
   }
 
-  listAll(query: AttendanceQueryParams, options?: Options): Promise<Attendance[]>;
-  async listAll(query: AttendanceQueryParams, options?: Options) {
+  listAll(query: AttendanceQueryParams): Promise<Attendance[]>;
+  listAll<F extends keyof Attendance>(
+    query: AttendanceQueryParams,
+    options: { fields: F[] } & OptionsExtended<Attendance>,
+  ): Promise<Pick<Attendance, F>[]>;
+  listAll(query: AttendanceQueryParams, options?: OptionsExtended<Attendance>): Promise<Attendance[]>;
+  async listAll(query: AttendanceQueryParams, options?: OptionsExtended<Attendance>) {
     const attendance = [] as Attendance[];
     for await (const atten of this.list(query, options)) {
       attendance.push(atten);
@@ -45,8 +62,17 @@ export class AttendanceService extends Service {
     return attendance;
   }
 
-  listByPage(query: AttendanceQueryParams, options?: Options) {
-    return super.iterator<Attendance>({ url: this.apiPath, params: query }, options).byPage();
+  listByPage(query: AttendanceQueryParams): AsyncGenerator<AxiosResponse<Attendance[]>>;
+  listByPage<F extends keyof Attendance>(
+    query: AttendanceQueryParams,
+    options: { fields: F[] } & OptionsExtended<Attendance>,
+  ): AsyncGenerator<AxiosResponse<Pick<Attendance, F>[]>>;
+  listByPage(
+    query: AttendanceQueryParams,
+    options?: OptionsExtended<Attendance>,
+  ): AsyncGenerator<AxiosResponse<Attendance[]>>;
+  listByPage(query: AttendanceQueryParams, options?: OptionsExtended<Attendance>) {
+    return super.iterator({ url: this.apiPath, params: query }, options).byPage();
   }
 
   update(id: number, data: Partial<Attendance>): Promise<Attendance>;
@@ -54,24 +80,27 @@ export class AttendanceService extends Service {
     id: number,
     data: Partial<Attendance>,
     options: { rawResponse: true } & Options,
-  ): Promise<AxiosResponse<Attendance, any>>;
+  ): Promise<AxiosResponse<Attendance>>;
   update(id: number, data: Partial<Attendance>, options: Options): Promise<Attendance>;
   update(id: number, data: Partial<Attendance>, options?: Options) {
     return super
-      .fetch<Attendance>({
-        url: `${this.apiPath}/${id}`,
-        data,
-        method: 'POST',
-      })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+      .fetch<Attendance>(
+        {
+          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<Attendance, any>>;
-  delete(id: number, options: Options): Promise<number>;
+  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<Attendance>({ 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/auth.service.ts

@@ -8,8 +8,6 @@ export class AuthService extends Service {
   get(options?: { rawResponse: true } & Options): Promise<AxiosResponse<Auth, any>>;
   get(options?: Options): Promise<Auth>;
   get(options?: Options) {
-    return super
-      .fetch<Auth>({ url: this.apiPath }, options)
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+    return super.fetch<Auth>({ url: this.apiPath }, options).then((res) => (options?.rawResponse ? res : res.data));
   }
 }

package/src/services/availability.service.ts

@@ -4,7 +4,7 @@ import { Service, Options } from './index.js';
 import { AvailabilityQueryParams } from '../interfaces/query-params/availability-query-params.interface.js';
 import { Availability } from '../interfaces/availability.interface.js';
 
-export class AvailabilityService extends Service {
+export class AvailabilityService extends Service<Availability> {
   private apiPath = '/availability';
 
   update(data: Availability): Promise<Availability>;
@@ -12,12 +12,15 @@ export class AvailabilityService extends Service {
   update(data: Availability, options?: Options): Promise<Availability | AxiosResponse<Availability>>;
   update(data: Availability, options?: Options) {
     return super
-      .fetch<Availability>({
-        url: this.apiPath,
-        data,
-        method: 'POST',
-      })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+      .fetch<Availability>(
+        {
+          url: this.apiPath,
+          data,
+          method: 'POST',
+        },
+        options,
+      )
+      .then((res) => (options?.rawResponse ? res : res.data));
   }
 
   /** Alias of {@link AvailabilityService["update"]} */
@@ -45,13 +48,11 @@ export class AvailabilityService extends Service {
     );
   }
 
-  async *list(query: AvailabilityQueryParams, options?: Options) {
-    for await (const res of super.iterator<Availability>({ url: this.apiPath, params: query }, options)) {
-      yield res;
-    }
+  async *list(query?: AvailabilityQueryParams, options?: Options) {
+    yield* super.iterator({ url: this.apiPath, params: query }, options);
   }
 
-  listByPage(query: AvailabilityQueryParams, options?: Options) {
-    return super.iterator<Availability>({ url: this.apiPath, params: query }, options).byPage();
+  listByPage(query?: AvailabilityQueryParams, options?: Options) {
+    return super.iterator({ url: this.apiPath, params: query }, options).byPage();
   }
 }

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

@@ -1,20 +1,29 @@
 import { AxiosResponse } from 'axios';
 import { DailyBudgets } from '../interfaces/daily-budgets.interface.js';
-import { Service, Options } from './index.js';
+import { Service, OptionsExtended } from './index.js';
 
 import { DailyBudgetsQueryParams } from '../interfaces/query-params/daily-budgets-query-params.interface.js';
 
-export class DailyBudgetsService extends Service {
+export class DailyBudgetsService extends Service<DailyBudgets> {
   private apiPath = '/daily_budgets';
 
-  async *list(query: DailyBudgetsQueryParams, options?: Options) {
-    for await (const res of super.iterator<DailyBudgets>({ url: this.apiPath, params: query }, options)) {
-      yield res;
-    }
+  list(query: DailyBudgetsQueryParams): AsyncGenerator<DailyBudgets>;
+  list<F extends keyof DailyBudgets>(
+    query: DailyBudgetsQueryParams,
+    options: { fields: F[] } & OptionsExtended<DailyBudgets>,
+  ): AsyncGenerator<Pick<DailyBudgets, F>>;
+  list(query: DailyBudgetsQueryParams, options?: OptionsExtended<DailyBudgets>): AsyncGenerator<DailyBudgets>;
+  async *list(query: DailyBudgetsQueryParams, options?: OptionsExtended<DailyBudgets>) {
+    yield* super.iterator({ url: this.apiPath, params: query }, options);
   }
 
-  listAll(query: DailyBudgetsQueryParams, options?: Options): Promise<DailyBudgets[]>;
-  async listAll(query: DailyBudgetsQueryParams, options?: Options) {
+  listAll(query: DailyBudgetsQueryParams): Promise<DailyBudgets[]>;
+  listAll<F extends keyof DailyBudgets>(
+    query: DailyBudgetsQueryParams,
+    options: { fields: F[] } & OptionsExtended<DailyBudgets>,
+  ): Promise<Pick<DailyBudgets, F>[]>;
+  listAll(query: DailyBudgetsQueryParams, options?: OptionsExtended<DailyBudgets>): Promise<DailyBudgets[]>;
+  async listAll(query: DailyBudgetsQueryParams, options?: OptionsExtended<DailyBudgets>) {
     const attendance = [] as DailyBudgets[];
     for await (const atten of this.list(query, options)) {
       attendance.push(atten);
@@ -22,23 +31,35 @@ export class DailyBudgetsService extends Service {
     return attendance;
   }
 
-  listByPage(query: DailyBudgetsQueryParams, options?: Options) {
-    return super.iterator<DailyBudgets>({ url: this.apiPath, params: query }, options).byPage();
+  listByPage(query: DailyBudgetsQueryParams): AsyncGenerator<AxiosResponse<DailyBudgets[]>>;
+  listByPage<F extends keyof DailyBudgets>(
+    query: DailyBudgetsQueryParams,
+    options: { fields: F[] } & OptionsExtended<DailyBudgets>,
+  ): AsyncGenerator<AxiosResponse<Pick<DailyBudgets, F>[]>>;
+  listByPage(
+    query: DailyBudgetsQueryParams,
+    options?: OptionsExtended<DailyBudgets>,
+  ): AsyncGenerator<AxiosResponse<DailyBudgets[]>>;
+  listByPage(query: DailyBudgetsQueryParams, options?: OptionsExtended<DailyBudgets>) {
+    return super.iterator({ url: this.apiPath, params: query }, options).byPage();
   }
 
   update(data: Partial<DailyBudgets>[]): Promise<number>;
   update(
     data: Partial<DailyBudgets>[],
-    options: { rawResponse: true } & Options,
-  ): Promise<AxiosResponse<DailyBudgets, any>>;
-  update(data: Partial<DailyBudgets>[], options: Options): Promise<number>;
-  update(data: Partial<DailyBudgets>[], options?: Options) {
+    options: { rawResponse: true } & OptionsExtended<DailyBudgets>,
+  ): Promise<AxiosResponse<void>>;
+  update(data: Partial<DailyBudgets>[], options?: OptionsExtended<DailyBudgets>): Promise<number>;
+  update(data: Partial<DailyBudgets>[], options?: OptionsExtended<DailyBudgets>) {
     return super
-      .fetch<DailyBudgets>({
-        url: `${this.apiPath}`,
-        data,
-        method: 'POST',
-      })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.status));
+      .fetch<void>(
+        {
+          url: this.apiPath,
+          data,
+          method: 'POST',
+        },
+        options,
+      )
+      .then((res) => (options?.rawResponse ? res : res.status));
   }
 }

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

@@ -1,20 +1,29 @@
 import { AxiosResponse } from 'axios';
 import { DailyRevenue } from '../interfaces/daily-revenue.interface.js';
-import { Service, Options } from './index.js';
+import { Service, Options, OptionsExtended } from './index.js';
 
 import { DailyRevenueQueryParams } from '../interfaces/query-params/daily-revenue-query-params.interface.js';
 
-export class DailyRevenueService extends Service {
+export class DailyRevenueService extends Service<DailyRevenue> {
   private apiPath = '/daily_revenue';
 
-  async *list(query: DailyRevenueQueryParams, options?: Options) {
-    for await (const res of super.iterator<DailyRevenue>({ url: this.apiPath, params: query }, options)) {
-      yield res;
-    }
+  list(query?: DailyRevenueQueryParams): AsyncGenerator<DailyRevenue>;
+  list<F extends keyof DailyRevenue>(
+    query: DailyRevenueQueryParams,
+    options: { fields: F[] } & OptionsExtended<DailyRevenue>,
+  ): AsyncGenerator<Pick<DailyRevenue, F>>;
+  list(query?: DailyRevenueQueryParams, options?: OptionsExtended<DailyRevenue>): AsyncGenerator<DailyRevenue>;
+  async *list(query?: DailyRevenueQueryParams, options?: OptionsExtended<DailyRevenue>) {
+    yield* super.iterator<DailyRevenue>({ url: this.apiPath, params: query }, options);
   }
 
-  listAll(query: DailyRevenueQueryParams, options?: Options): Promise<DailyRevenue[]>;
-  async listAll(query: DailyRevenueQueryParams, options?: Options) {
+  listAll(query?: DailyRevenueQueryParams): Promise<DailyRevenue[]>;
+  listAll<F extends keyof DailyRevenue>(
+    query: DailyRevenueQueryParams,
+    options: { fields: F[] } & OptionsExtended<DailyRevenue>,
+  ): Promise<Pick<DailyRevenue, F>[]>;
+  listAll(query?: DailyRevenueQueryParams, options?: OptionsExtended<DailyRevenue>): Promise<DailyRevenue[]>;
+  async listAll(query?: DailyRevenueQueryParams, options?: OptionsExtended<DailyRevenue>) {
     const attendance = [] as DailyRevenue[];
     for await (const atten of this.list(query, options)) {
       attendance.push(atten);
@@ -22,23 +31,32 @@ export class DailyRevenueService extends Service {
     return attendance;
   }
 
-  listByPage(query: DailyRevenueQueryParams, options?: Options) {
+  listByPage(query?: DailyRevenueQueryParams): AsyncGenerator<AxiosResponse<DailyRevenue[]>>;
+  listByPage<F extends keyof DailyRevenue>(
+    query: DailyRevenueQueryParams,
+    options: { fields: F[] } & OptionsExtended<DailyRevenue>,
+  ): AsyncGenerator<AxiosResponse<Pick<DailyRevenue, F>[]>>;
+  listByPage(
+    query: DailyRevenueQueryParams,
+    options?: OptionsExtended<DailyRevenue>,
+  ): AsyncGenerator<AxiosResponse<DailyRevenue[]>>;
+  listByPage(query?: DailyRevenueQueryParams, options?: OptionsExtended<DailyRevenue>) {
     return super.iterator<DailyRevenue>({ url: this.apiPath, params: query }, options).byPage();
   }
 
   update(data: Partial<DailyRevenue>[]): Promise<number>;
-  update(
-    data: Partial<DailyRevenue>[],
-    options: { rawResponse: true } & Options,
-  ): Promise<AxiosResponse<DailyRevenue, any>>;
+  update(data: Partial<DailyRevenue>[], options: { rawResponse: true } & Options): Promise<AxiosResponse<void>>;
   update(data: Partial<DailyRevenue>[], options: Options): Promise<number>;
   update(data: Partial<DailyRevenue>[], options?: Options) {
     return super
-      .fetch<DailyRevenue>({
-        url: `${this.apiPath}`,
-        data,
-        method: 'POST',
-      })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.status));
+      .fetch<void>(
+        {
+          url: `${this.apiPath}`,
+          data,
+          method: 'POST',
+        },
+        options,
+      )
+      .then((res) => (options?.rawResponse ? res : res.status));
   }
 }

package/src/services/day-notes.service.ts

@@ -1,10 +1,10 @@
 import { AxiosResponse } from 'axios';
 import { DayNote } from '../interfaces/index.js';
-import { Service, Options } from './index.js';
+import { Service, Options, OptionsExtended } from './index.js';
 
 import { DayNotesQueryParams } from '../interfaces/query-params/day-notes-query-params.interface';
 
-export class DayNotesService extends Service {
+export class DayNotesService extends Service<DayNote> {
   private apiPath = '/day_notes';
 
   create(data: DayNote): Promise<DayNote>;
@@ -12,27 +12,44 @@ export class DayNotesService extends Service {
   create(data: DayNote, options: Options): Promise<DayNote>;
   create(data: DayNote, options?: Options) {
     return super
-      .fetch<DayNote>({ url: this.apiPath, data, method: 'POST' })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+      .fetch({ url: this.apiPath, data, method: 'POST' })
+      .then((res) => (options?.rawResponse ? res : res.data));
   }
 
   get(id: number): Promise<DayNote>;
-  get(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<DayNote, any>>;
-  get(id: number, options: Options): Promise<DayNote>;
-  get(id: number, options?: Options) {
+  get<F extends keyof DayNote>(
+    id: number,
+    options: { fields: F[]; rawResponse: true } & OptionsExtended<DayNote>,
+  ): Promise<AxiosResponse<Pick<DayNote, F>>>;
+  get<F extends keyof DayNote>(
+    id: number,
+    options: { fields: F[] } & OptionsExtended<DayNote>,
+  ): Promise<Pick<DayNote, F>>;
+  get(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<DayNote>>;
+  get(id: number, options?: OptionsExtended<DayNote>): Promise<DayNote>;
+  get(id: number, options?: OptionsExtended<DayNote>) {
     return super
       .fetch<DayNote>({ url: `${this.apiPath}/${id}` }, options)
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+      .then((res) => (options?.rawResponse ? res : res.data));
   }
 
-  async *list(query: DayNotesQueryParams, options?: Options) {
-    for await (const res of super.iterator<DayNote>({ url: this.apiPath, params: query }, options)) {
-      yield res;
-    }
+  list(query: DayNotesQueryParams): AsyncGenerator<DayNote>;
+  list<F extends keyof DayNote>(
+    query: DayNotesQueryParams,
+    options: { fields: F[] } & OptionsExtended<DayNote>,
+  ): AsyncGenerator<Pick<DayNote, F>>;
+  list(query: DayNotesQueryParams, options?: OptionsExtended<DayNote>): AsyncGenerator<DayNote>;
+  async *list(query: DayNotesQueryParams, options?: OptionsExtended<DayNote>) {
+    yield* super.iterator({ url: this.apiPath, params: query }, options);
   }
 
-  listAll(query: DayNotesQueryParams, options?: Options): Promise<DayNote[]>;
-  async listAll(query: DayNotesQueryParams, options?: Options) {
+  listAll(query: DayNotesQueryParams): Promise<DayNote[]>;
+  listAll<F extends keyof DayNote>(
+    query: DayNotesQueryParams,
+    options: { fields: F[] } & OptionsExtended<DayNote>,
+  ): Promise<Pick<DayNote, F>[]>;
+  listAll(query: DayNotesQueryParams, options?: OptionsExtended<DayNote>): Promise<DayNote[]>;
+  async listAll(query: DayNotesQueryParams, options?: OptionsExtended<DayNote>) {
     const dayNotes: DayNote[] = [];
     for await (const dayNote of this.list(query, options)) {
       dayNotes.push(dayNote);
@@ -40,8 +57,14 @@ export class DayNotesService extends Service {
     return dayNotes;
   }
 
-  listByPage(query: DayNotesQueryParams, options?: Options) {
-    return super.iterator<DayNote>({ url: this.apiPath, params: query }, options).byPage();
+  listByPage(query: DayNotesQueryParams): AsyncGenerator<AxiosResponse<DayNote[]>>;
+  listByPage<F extends keyof DayNote>(
+    query: DayNotesQueryParams,
+    options: { fields: F[] } & OptionsExtended<DayNote>,
+  ): AsyncGenerator<AxiosResponse<Pick<DayNote, F>[]>>;
+  listByPage(query: DayNotesQueryParams, options?: OptionsExtended<DayNote>): AsyncGenerator<AxiosResponse<DayNote[]>>;
+  listByPage(query: DayNotesQueryParams, options?: OptionsExtended<DayNote>) {
+    return super.iterator({ url: this.apiPath, params: query }, options).byPage();
   }
 
   update(id: number, data: Partial<DayNote>): Promise<DayNote>;
@@ -53,20 +76,23 @@ export class DayNotesService extends Service {
   update(id: number, data: Partial<DayNote>, options: Options): Promise<DayNote>;
   update(id: number, data: Partial<DayNote>, options?: Options) {
     return super
-      .fetch<DayNote>({
-        url: `${this.apiPath}/${id}`,
-        data,
-        method: 'POST',
-      })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+      .fetch<DayNote>(
+        {
+          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<DayNote>({ 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));
   }
 }