rotacloud 1.1.1 → 1.2.0

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

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