rotacloud 1.1.1 → 1.2.0

package/dist/mjs/services/leave-request.service.d.ts

@@ -1,9 +1,9 @@
 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 declare class LeaveRequestService extends Service {
+export declare class LeaveRequestService extends Service<LeaveRequest> {
     private apiPath;
     create(data: RequirementsOf<LeaveRequest, RequiredProps>): Promise<LeaveRequest>;
     create(data: RequirementsOf<LeaveRequest, RequiredProps>, options: {
@@ -11,13 +11,32 @@ export declare class LeaveRequestService extends Service {
     } & Options): Promise<AxiosResponse<LeaveRequest, any>>;
     create(data: RequirementsOf<LeaveRequest, RequiredProps>, options: Options): Promise<LeaveRequest>;
     get(id: number): Promise<LeaveRequest>;
+    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;
-    }): Promise<AxiosResponse<LeaveRequest, any>>;
-    get(id: number, options: Options): Promise<LeaveRequest>;
-    list(query?: LeaveRequestsQueryParams, options?: Options): AsyncGenerator<LeaveRequest, void, unknown>;
-    listAll(query?: LeaveRequestsQueryParams, options?: Options): Promise<LeaveRequest[]>;
-    listByPage(query?: LeaveRequestsQueryParams, options?: Options): AsyncGenerator<AxiosResponse<LeaveRequest[], any>, any, unknown>;
+    } & Options): Promise<AxiosResponse<LeaveRequest>>;
+    get(id: number, options?: OptionsExtended<LeaveRequest>): Promise<LeaveRequest>;
+    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>;
+    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[]>;
+    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[]>>;
     update(id: number, data: Partial<LeaveRequest>): Promise<LeaveRequest>;
     update(id: number, data: Partial<LeaveRequest>, options: {
         rawResponse: true;
@@ -26,7 +45,7 @@ export declare class LeaveRequestService extends Service {
     delete(id: number): Promise<number>;
     delete(id: number, options: {
         rawResponse: true;
-    } & Options): Promise<AxiosResponse<LeaveRequest, any>>;
+    } & Options): Promise<AxiosResponse<void>>;
     delete(id: number, options: Options): Promise<number>;
 }
 export {};

package/dist/mjs/services/leave-request.service.js

@@ -11,17 +11,15 @@ export class LeaveRequestService extends Service {
             data,
             method: 'POST',
         }, options)
-            .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+            .then((res) => (options?.rawResponse ? res : res.data));
     }
     get(id, options) {
         return super
             .fetch({ url: `${this.apiPath}/${id}` }, options)
-            .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+            .then((res) => (options?.rawResponse ? res : res.data));
     }
     async *list(query, options) {
-        for await (const res of super.iterator({ url: this.apiPath, params: query }, options)) {
-            yield res;
-        }
+        yield* super.iterator({ url: this.apiPath, params: query }, options);
     }
     async listAll(query, options) {
         const leave = [];
@@ -39,12 +37,12 @@ export class LeaveRequestService extends Service {
             url: `${this.apiPath}/${id}`,
             data,
             method: 'POST',
-        })
-            .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+        }, options)
+            .then((res) => (options?.rawResponse ? res : res.data));
     }
     delete(id, options) {
         return super
-            .fetch({ url: `${this.apiPath}/${id}`, method: 'DELETE' })
-            .then((res) => Promise.resolve(options?.rawResponse ? res : res.status));
+            .fetch({ url: `${this.apiPath}/${id}`, method: 'DELETE' }, options)
+            .then((res) => (options?.rawResponse ? res : res.status));
     }
 }

package/dist/mjs/services/leave.service.d.ts

@@ -1,9 +1,9 @@
 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 declare class LeaveService extends Service {
+export declare class LeaveService extends Service<Leave> {
     private apiPath;
     create(data: RequirementsOf<Leave, RequiredProps>): Promise<Leave[]>;
     create(data: RequirementsOf<Leave, RequiredProps>, options: {
@@ -11,14 +11,32 @@ export declare class LeaveService extends Service {
     } & Options): Promise<AxiosResponse<Leave[], any>>;
     create(data: RequirementsOf<Leave, RequiredProps>, options: Options): Promise<Leave[]>;
     get(id: number): Promise<Leave>;
+    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;
-    }): Promise<AxiosResponse<Leave, any>>;
-    get(id: number, options: Options): Promise<Leave>;
-    list(query: LeaveQueryParams, options?: Options): AsyncGenerator<Leave, void, unknown>;
-    listAll(query: LeaveQueryParams, options?: Options): Promise<Leave[]>;
-    listLeaveTypes(query: LeaveQueryParams, options?: Options): AsyncGenerator<LeaveType, void, unknown>;
-    listByPage(query: LeaveQueryParams, options?: Options): AsyncGenerator<AxiosResponse<Leave[], any>, any, unknown>;
+    } & Options): Promise<AxiosResponse<Leave>>;
+    get(id: number, options?: OptionsExtended<Leave>): Promise<Leave>;
+    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>;
+    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[]>;
+    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[]>>;
     update(id: number, data: Partial<Leave>): Promise<Leave>;
     update(id: number, data: Partial<Leave>, options: {
         rawResponse: true;
@@ -27,7 +45,7 @@ export declare class LeaveService extends Service {
     delete(id: number): Promise<number>;
     delete(id: number, options: {
         rawResponse: true;
-    } & Options): Promise<AxiosResponse<Leave, any>>;
+    } & Options): Promise<AxiosResponse<void>>;
     delete(id: number, options: Options): Promise<number>;
 }
 export {};

package/dist/mjs/services/leave.service.js

@@ -7,17 +7,15 @@ export class LeaveService extends Service {
     create(data, options) {
         return super
             .fetch({ url: this.apiPath, data, method: 'POST' }, options)
-            .then((res) => Promise.resolve(options?.rawResponse ? res : [...res.data.map((leave) => leave)]));
+            .then((res) => (options?.rawResponse ? res : [...res.data.map((leave) => leave)]));
     }
     get(id, options) {
         return super
             .fetch({ url: `${this.apiPath}/${id}` }, options)
-            .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+            .then((res) => (options?.rawResponse ? res : res.data));
     }
     async *list(query, options) {
-        for await (const res of super.iterator({ url: this.apiPath, params: query }, options)) {
-            yield res;
-        }
+        yield* super.iterator({ url: this.apiPath, params: query }, options);
     }
     async listAll(query, options) {
         const leave = [];
@@ -26,11 +24,6 @@ export class LeaveService extends Service {
         }
         return leave;
     }
-    async *listLeaveTypes(query, options) {
-        for await (const res of super.iterator({ url: this.apiPath, params: query }, options)) {
-            yield res;
-        }
-    }
     listByPage(query, options) {
         return super.iterator({ url: this.apiPath, params: query }, options).byPage();
     }
@@ -41,11 +34,11 @@ export class LeaveService extends Service {
             data,
             method: 'POST',
         }, options)
-            .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+            .then((res) => (options?.rawResponse ? res : res.data));
     }
     delete(id, options) {
         return super
             .fetch({ url: `${this.apiPath}/${id}`, method: 'DELETE' })
-            .then((res) => Promise.resolve(options?.rawResponse ? res : res.status));
+            .then((res) => (options?.rawResponse ? res : res.status));
     }
 }

package/dist/mjs/services/locations.service.d.ts

@@ -1,9 +1,9 @@
 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 declare class LocationsService extends Service {
+export declare class LocationsService extends Service<Location> {
     private apiPath;
     create(data: RequirementsOf<Location, RequiredProps>): Promise<Location>;
     create(data: RequirementsOf<Location, RequiredProps>, options: {
@@ -11,13 +11,32 @@ export declare class LocationsService extends Service {
     } & Options): Promise<AxiosResponse<Location, any>>;
     create(data: RequirementsOf<Location, RequiredProps>, options: Options): Promise<Location>;
     get(id: number): Promise<Location>;
+    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, any>>;
-    get(id: number, options: Options): Promise<Location>;
-    list(query?: LocationsQueryParams, options?: Options): AsyncGenerator<Location, void, unknown>;
-    listAll(query?: LocationsQueryParams, options?: Options): Promise<Location[]>;
-    listByPage(query?: LocationsQueryParams, options?: Options): AsyncGenerator<AxiosResponse<Location[], any>, any, unknown>;
+    } & Options): Promise<AxiosResponse<Location>>;
+    get(id: number, options?: OptionsExtended<Location>): Promise<Location>;
+    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>;
+    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[]>;
+    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[]>>;
     update(id: number, data: Partial<Location>): Promise<Location>;
     update(id: number, data: Partial<Location>, options: {
         rawResponse: true;
@@ -26,7 +45,7 @@ export declare class LocationsService extends Service {
     delete(id: number): Promise<number>;
     delete(id: number, options: {
         rawResponse: true;
-    } & Options): Promise<AxiosResponse<any, any>>;
+    } & Options): Promise<AxiosResponse<void>>;
     delete(id: number, options: Options): Promise<number>;
 }
 export {};

package/dist/mjs/services/locations.service.js

@@ -6,18 +6,16 @@ export class LocationsService extends Service {
     }
     create(data, options) {
         return super
-            .fetch({ url: `${this.apiPath}`, data, method: 'POST' })
-            .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+            .fetch({ url: `${this.apiPath}`, data, method: 'POST' }, options)
+            .then((res) => (options?.rawResponse ? res : res.data));
     }
     get(id, options) {
         return super
             .fetch({ url: `${this.apiPath}/${id}` }, options)
-            .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+            .then((res) => (options?.rawResponse ? res : res.data));
     }
     async *list(query, options) {
-        for await (const res of super.iterator({ url: this.apiPath, params: query }, options)) {
-            yield res;
-        }
+        yield* super.iterator({ url: this.apiPath, params: query }, options);
     }
     async listAll(query, options) {
         const locations = [];
@@ -35,12 +33,12 @@ export class LocationsService extends Service {
             url: `${this.apiPath}/${id}`,
             data,
             method: 'POST',
-        })
-            .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+        }, options)
+            .then((res) => (options?.rawResponse ? res : res.data));
     }
     delete(id, options) {
         return super
-            .fetch({ url: `${this.apiPath}/${id}`, method: 'DELETE' })
-            .then((res) => Promise.resolve(options?.rawResponse ? res : res.status));
+            .fetch({ url: `${this.apiPath}/${id}`, method: 'DELETE' }, options)
+            .then((res) => (options?.rawResponse ? res : res.status));
     }
 }

package/dist/mjs/services/pins.service.d.ts

@@ -1,11 +1,18 @@
 import { AxiosResponse } from 'axios';
 import { Pin } from '../interfaces/index.js';
-import { Service, Options } from './index.js';
-export declare class PinsService extends Service {
+import { Service, Options, OptionsExtended } from './index.js';
+export declare class PinsService extends Service<Pin> {
     private apiPath;
     get(id: string): Promise<Pin>;
-    get(id: string, options?: {
+    get<F extends keyof Pin>(id: string, options: {
+        fields: F[];
         rawResponse: true;
-    } & Options): Promise<AxiosResponse<Pin, any>>;
-    get(id: string, options?: Options): Promise<Pin>;
+    } & 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>;
 }

package/dist/mjs/services/pins.service.js

@@ -7,6 +7,6 @@ export class PinsService extends Service {
     get(id, options) {
         return super
             .fetch({ url: `${this.apiPath}/${id}` }, options)
-            .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+            .then((res) => (options?.rawResponse ? res : res.data));
     }
 }

package/dist/mjs/services/roles.service.d.ts

@@ -1,9 +1,9 @@
 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 declare class RolesService extends Service {
+export declare class RolesService extends Service<Role> {
     private apiPath;
     create(data: RequirementsOf<Role, RequiredProps>): Promise<Role>;
     create(data: RequirementsOf<Role, RequiredProps>, options: {
@@ -11,13 +11,32 @@ export declare class RolesService extends Service {
     } & Options): Promise<AxiosResponse<Role, any>>;
     create(data: RequirementsOf<Role, RequiredProps>, options: Options): Promise<Role>;
     get(id: number): Promise<Role>;
+    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, any>>;
-    get(id: number, options: Options): Promise<Role>;
-    list(query?: RolesQueryParams, options?: Options): AsyncGenerator<Role, void, unknown>;
-    listAll(query?: RolesQueryParams, options?: Options): Promise<Role[]>;
-    listByPage(query?: RolesQueryParams, options?: Options): AsyncGenerator<AxiosResponse<Role[], any>, any, unknown>;
+    } & Options): Promise<AxiosResponse<Role>>;
+    get(id: number, options?: OptionsExtended<Role>): Promise<Role>;
+    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>;
+    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[]>;
+    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[]>>;
     update(id: number, data: Partial<Role>): Promise<Role>;
     update(id: number, data: Partial<Role>, options: {
         rawResponse: true;
@@ -26,7 +45,7 @@ export declare class RolesService extends Service {
     delete(id: number): Promise<number>;
     delete(id: number, options: {
         rawResponse: true;
-    } & Options): Promise<AxiosResponse<any, any>>;
+    } & Options): Promise<AxiosResponse<void>>;
     delete(id: number, options: Options): Promise<number>;
 }
 export {};

package/dist/mjs/services/roles.service.js

@@ -6,18 +6,16 @@ export class RolesService extends Service {
     }
     create(data, options) {
         return super
-            .fetch({ url: this.apiPath, data, method: 'POST' })
-            .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+            .fetch({ url: this.apiPath, data, method: 'POST' }, options)
+            .then((res) => (options?.rawResponse ? res : res.data));
     }
     get(id, options) {
         return super
             .fetch({ url: `${this.apiPath}/${id}` }, options)
-            .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+            .then((res) => (options?.rawResponse ? res : res.data));
     }
     async *list(query, options) {
-        for await (const res of super.iterator({ url: this.apiPath, params: query }, options)) {
-            yield res;
-        }
+        yield* super.iterator({ url: this.apiPath, params: query }, options);
     }
     async listAll(query, options) {
         const roles = [];
@@ -35,12 +33,12 @@ export class RolesService extends Service {
             url: `${this.apiPath}/${id}`,
             data,
             method: 'POST',
-        })
-            .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+        }, options)
+            .then((res) => (options?.rawResponse ? res : res.data));
     }
     delete(id, options) {
         return super
-            .fetch({ url: `${this.apiPath}/${id}`, method: 'DELETE' })
-            .then((res) => Promise.resolve(options?.rawResponse ? res : res.status));
+            .fetch({ url: `${this.apiPath}/${id}`, method: 'DELETE' }, options)
+            .then((res) => (options?.rawResponse ? res : res.status));
     }
 }

package/dist/mjs/services/service.d.ts

@@ -19,19 +19,28 @@ 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)[];
+};
 export declare abstract class Service<ApiResponse = any> {
     protected client: AxiosInstance;
     private initialiseAxios;
     private parseClientError;
     private isLeaveRequest;
     private buildQueryParams;
-    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>>>;
     /** Iterates through every page for a potentially paginated request */
     private fetchPages;
     private listResponses;

package/dist/mjs/services/service.js

@@ -50,7 +50,6 @@ export class Service {
     }
     buildQueryParams(options, extraParams) {
         const queryParams = {
-            expand: options?.expand,
             fields: options?.fields,
             limit: options?.limit,
             offset: options?.offset,
@@ -114,7 +113,6 @@ export class Service {
         }
         return this.client.request(finalReqConfig);
     }
-    /** Iterates through every page for a potentially paginated request */
     async *fetchPages(reqConfig, options) {
         const fallbackLimit = 20;
         const res = await this.fetch(reqConfig, options);

package/dist/mjs/services/settings.service.d.ts

@@ -2,7 +2,7 @@ import { AxiosResponse } from 'axios';
 import { Service, Options } from './index.js';
 import { Settings } from '../interfaces/index.js';
 import { SettingsQueryParams } from '../rotacloud.js';
-export declare class SettingsService extends Service {
+export declare class SettingsService extends Service<Settings> {
     private apiPath;
     get(query: SettingsQueryParams): Promise<Settings>;
     get(query: SettingsQueryParams, options: {

package/dist/mjs/services/settings.service.js

@@ -7,6 +7,6 @@ export class SettingsService extends Service {
     get(query, options) {
         return super
             .fetch({ url: `${this.apiPath}`, params: query }, options)
-            .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+            .then((res) => (options?.rawResponse ? res : res.data));
     }
 }

package/dist/mjs/services/shifts.service.d.ts

@@ -1,9 +1,9 @@
 import { 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 declare class ShiftsService extends Service {
+export declare class ShiftsService extends Service<Shift> {
     private apiPath;
     create(data: RequirementsOf<Shift, RequiredProps>): Promise<Shift>;
     create(data: RequirementsOf<Shift, RequiredProps>, options: {
@@ -11,13 +11,32 @@ export declare class ShiftsService extends Service {
     } & Options): Promise<AxiosResponse<Shift, any>>;
     create(data: RequirementsOf<Shift, RequiredProps>, options: Options): Promise<Shift>;
     get(id: number): Promise<Shift>;
+    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, any>>;
-    get(id: number, options: Options): Promise<Shift>;
-    list(query: ShiftsQueryParams, options?: Options): AsyncGenerator<Shift, void, unknown>;
-    listAll(query: ShiftsQueryParams, options?: Options): Promise<Shift[]>;
-    listByPage(query: ShiftsQueryParams, options?: Options): AsyncGenerator<AxiosResponse<Shift[], any>, any, unknown>;
+    } & Options): Promise<AxiosResponse<Shift>>;
+    get(id: number, options?: OptionsExtended<Shift>): Promise<Shift>;
+    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>;
+    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[]>;
+    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[]>>;
     update(shift: RequirementsOf<Shift, 'id'>): Promise<Shift>;
     update(shift: RequirementsOf<Shift, 'id'>, options: {
         rawResponse: true;
@@ -48,12 +67,12 @@ export declare class ShiftsService extends Service {
     delete(ids: number | number[]): Promise<number>;
     delete(ids: number | number[], options: {
         rawResponse: true;
-    } & Options): Promise<AxiosResponse<any, any>>;
+    } & Options): Promise<AxiosResponse<void>>;
     delete(ids: number | number[], options: Options): Promise<number>;
     acknowledge(data: number[]): Promise<number>;
     acknowledge(data: number[], options: {
         rawResponse: true;
-    } & Options): Promise<AxiosResponse<any, any>>;
+    } & Options): Promise<AxiosResponse<any>>;
     acknowledge(data: number[], options: Options): Promise<number>;
     publish(data: {
         shifts: number[];
@@ -62,7 +81,7 @@ export declare class ShiftsService extends Service {
         shifts: number[];
     }, options: {
         rawResponse: true;
-    } & Options): Promise<AxiosResponse<any, any>>;
+    } & Options): Promise<AxiosResponse<any>>;
     publish(data: {
         shifts: number[];
     }, options: Options): Promise<number>;
@@ -73,7 +92,7 @@ export declare class ShiftsService extends Service {
         shifts: number[];
     }, options: {
         rawResponse: true;
-    } & Options): Promise<AxiosResponse<any, any>>;
+    } & Options): Promise<AxiosResponse<any>>;
     unpublish(data: {
         shifts: number[];
     }, options: Options): Promise<number>;