rotacloud 1.1.2 → 1.2.1

package/dist/mjs/services/terminals-active.service.js

@@ -7,21 +7,19 @@ export class TerminalsActiveService extends Service {
     launchTerminal(data, options) {
         return super
             .fetch({
-            url: `${this.apiPath}`,
+            url: this.apiPath,
             data,
             method: 'POST',
-        })
-            .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+        }, options)
+            .then((res) => (options?.rawResponse ? res : res.data));
     }
     pingTerminal(id, data, options) {
         return super
-            .fetch({ url: `${this.apiPath}/${id}`, data, method: 'POST' })
-            .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+            .fetch({ url: `${this.apiPath}/${id}`, data, method: 'POST' }, options)
+            .then((res) => (options?.rawResponse ? res : res.data));
     }
     async *list(options) {
-        for await (const res of super.iterator({ url: this.apiPath }, options)) {
-            yield res;
-        }
+        yield* super.iterator({ url: this.apiPath }, options);
     }
     async listAll(options) {
         const users = [];
@@ -35,7 +33,7 @@ export class TerminalsActiveService extends Service {
     }
     closeTerminal(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/terminals.service.d.ts

@@ -1,8 +1,8 @@
 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 declare class TerminalsService extends Service {
+export declare class TerminalsService extends Service<Terminal> {
     private apiPath;
     create(data: RequirementsOf<Terminal, RequiredProps>): Promise<Terminal>;
     create(data: RequirementsOf<Terminal, RequiredProps>, options: {
@@ -10,10 +10,17 @@ export declare class TerminalsService extends Service {
     } & Options): Promise<AxiosResponse<Terminal, any>>;
     create(data: RequirementsOf<Terminal, RequiredProps>, options: Options): Promise<Terminal>;
     get(id: number): 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, any>>;
-    get(id: number, options: Options): Promise<Terminal>;
+    } & Options): Promise<AxiosResponse<Terminal>>;
+    get(id: number, options?: OptionsExtended<Terminal>): Promise<Terminal>;
     update(id: number, data: Partial<Terminal>): Promise<Terminal>;
     update(id: number, data: Partial<Terminal>, options: {
         rawResponse: true;
@@ -22,10 +29,22 @@ export declare class TerminalsService extends Service {
     closeTerminal(id: number): Promise<number>;
     closeTerminal(id: number, options: {
         rawResponse: true;
-    } & Options): Promise<AxiosResponse<number, any>>;
+    } & Options): Promise<AxiosResponse<void>>;
     closeTerminal(id: number, options: Options): Promise<number>;
-    list(options?: Options): AsyncGenerator<Terminal, void, unknown>;
-    listAll(options?: Options): Promise<Terminal[]>;
-    listByPage(options?: Options): AsyncGenerator<AxiosResponse<Terminal[], any>, any, unknown>;
+    list(): AsyncGenerator<Terminal>;
+    list<F extends keyof Terminal>(options: {
+        fields: F[];
+    } & OptionsExtended<Terminal>): AsyncGenerator<Pick<Terminal, F>>;
+    list(options?: OptionsExtended<Terminal>): AsyncGenerator<Terminal>;
+    listAll(): Promise<Terminal[]>;
+    listAll<F extends keyof Terminal>(options: {
+        fields: F[];
+    } & OptionsExtended<Terminal>): Promise<Pick<Terminal, F>[]>;
+    listAll(options?: OptionsExtended<Terminal>): Promise<Terminal[]>;
+    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[]>>;
 }
 export {};

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

@@ -7,12 +7,12 @@ export class TerminalsService extends Service {
     create(data, options) {
         return super
             .fetch({ url: this.apiPath, data, method: 'POST' })
-            .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));
     }
     update(id, data, options) {
         return super
@@ -21,17 +21,15 @@ 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, 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));
     }
     async *list(options) {
-        for await (const res of super.iterator({ url: this.apiPath }, options)) {
-            yield res;
-        }
+        yield* super.iterator({ url: this.apiPath }, options);
     }
     async listAll(options) {
         const users = [];

package/dist/mjs/services/time-zone.service.d.ts

@@ -1,14 +1,14 @@
 import { AxiosResponse } from 'axios';
 import { Service, Options } from './index.js';
 import { TimeZone } from '../interfaces/index.js';
-export declare class TimeZoneService extends Service {
+export declare class TimeZoneService extends Service<TimeZone> {
     private apiPath;
     get(id: number): Promise<TimeZone>;
     get(id: number, options: {
         rawResponse: true;
     } & Options): Promise<AxiosResponse<TimeZone, any>>;
     get(id: number, options: Options): Promise<TimeZone>;
-    list(options?: Options): AsyncGenerator<TimeZone, void, unknown>;
+    list(options?: Options): AsyncGenerator<TimeZone, void, undefined>;
     listAll(options?: Options): Promise<TimeZone[]>;
     listByPage(options?: Options): AsyncGenerator<AxiosResponse<TimeZone[], any>, any, unknown>;
 }

package/dist/mjs/services/time-zone.service.js

@@ -7,12 +7,10 @@ export class TimeZoneService 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));
     }
     async *list(options) {
-        for await (const res of super.iterator({ url: this.apiPath }, options)) {
-            yield res;
-        }
+        yield* super.iterator({ url: this.apiPath }, options);
     }
     async listAll(options) {
         const timezones = [];

package/dist/mjs/services/toil-accruals.service.d.ts

@@ -15,13 +15,13 @@ export declare class ToilAccrualsService extends Service {
         rawResponse: true;
     } & Options): Promise<AxiosResponse<ToilAccrual, any>>;
     get(id: number, options: Options): Promise<ToilAccrual>;
-    list(query: ToilAccrualsQueryParams, options?: Options): AsyncGenerator<ToilAccrual, void, unknown>;
-    listAll(query: ToilAccrualsQueryParams, options?: Options): Promise<ToilAccrual[]>;
-    listByPage(query: ToilAccrualsQueryParams, options?: Options): AsyncGenerator<AxiosResponse<ToilAccrual[], any>, any, unknown>;
+    list(query?: ToilAccrualsQueryParams, options?: Options): AsyncGenerator<ToilAccrual, void, undefined>;
+    listAll(query?: ToilAccrualsQueryParams, options?: Options): Promise<ToilAccrual[]>;
+    listByPage(query?: ToilAccrualsQueryParams, options?: Options): AsyncGenerator<AxiosResponse<ToilAccrual[], any>, any, unknown>;
     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/toil-accruals.service.js

@@ -7,17 +7,15 @@ export class ToilAccrualsService extends Service {
     create(data, options) {
         return super
             .fetch({ url: this.apiPath, data, method: 'POST' })
-            .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 toilAccruals = [];
@@ -32,6 +30,6 @@ export class ToilAccrualsService extends Service {
     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/toil-allowance.service.d.ts

@@ -1,9 +1,9 @@
 import { Options, Service } from './service';
 import { ToilAllowanceQueryParams } from '../interfaces/query-params/toil-allowance-query-params.interface';
 import { ToilAllowance } from '../interfaces/toil-allowance.interface';
-export declare class ToilAllowanceService extends Service {
+export declare class ToilAllowanceService extends Service<ToilAllowance> {
     private apiPath;
-    list(year: number, query: ToilAllowanceQueryParams, options?: Options): AsyncGenerator<ToilAllowance, void, unknown>;
+    list(year: number, query: ToilAllowanceQueryParams, options?: Options): AsyncGenerator<ToilAllowance, void, undefined>;
     listAll(year: number, query: ToilAllowanceQueryParams, options?: Options): Promise<ToilAllowance[]>;
-    listByPage(year: number, query: ToilAllowanceQueryParams, options?: Options): AsyncGenerator<import("axios").AxiosResponse<ToilAllowance[][], any>, any, unknown>;
+    listByPage(year: number, query: ToilAllowanceQueryParams, options?: Options): AsyncGenerator<import("axios").AxiosResponse<ToilAllowance[], any>, any, unknown>;
 }

package/dist/mjs/services/toil-allowance.service.js

@@ -5,9 +5,7 @@ export class ToilAllowanceService extends Service {
         this.apiPath = '/toil_allowance';
     }
     async *list(year, query, options) {
-        for await (const res of super.iterator({ url: `${this.apiPath}/${year}`, params: query }, options)) {
-            yield res;
-        }
+        yield* super.iterator({ url: `${this.apiPath}/${year}`, params: query }, options);
     }
     async listAll(year, query, options) {
         const toilAllowances = [];

package/dist/mjs/services/users-clock-in.service.d.ts

@@ -1,6 +1,6 @@
 import { AxiosResponse } from 'axios';
 import { UserBreak, UserClockedIn, UserClockedOut, TerminalLocation } from '../interfaces/index.js';
-import { Service, Options, RequirementsOf } from './index.js';
+import { Service, Options, RequirementsOf, OptionsExtended } from './index.js';
 interface UserClockIn {
     method: string;
     shift: number;
@@ -20,35 +20,47 @@ interface UserBreakRequest {
 }
 type RequiredPropsClockIn = 'method';
 type RequiredPropsBreak = 'method' | 'action';
-export declare class UsersClockInService extends Service {
+export declare class UsersClockInService extends Service<UserClockedIn> {
     private apiPath;
     getClockedInUser(id: number): Promise<UserClockedIn>;
     getClockedInUser(id: number, options: {
         rawResponse: true;
-    } & Options): Promise<AxiosResponse<UserClockedIn, any>>;
+    } & Options): Promise<AxiosResponse<UserClockedIn>>;
     getClockedInUser(id: number, options: Options): Promise<UserClockedIn>;
-    list(options?: Options): AsyncGenerator<UserClockedIn, void, unknown>;
-    listAll(options?: Options): Promise<UserClockedIn[]>;
-    listByPage(options?: Options): AsyncGenerator<AxiosResponse<UserClockedIn[], any>, any, unknown>;
+    list(): AsyncGenerator<UserClockedIn>;
+    list<F extends keyof UserClockedIn>(options: {
+        fields: F[];
+    } & OptionsExtended<UserClockedIn>): AsyncGenerator<Pick<UserClockedIn, F>>;
+    list(options?: OptionsExtended<UserClockedIn>): AsyncGenerator<UserClockedIn>;
+    listAll(): Promise<UserClockedIn[]>;
+    listAll<F extends keyof UserClockedIn>(options: {
+        fields: F[];
+    } & OptionsExtended<UserClockedIn>): Promise<Pick<UserClockedIn, F>[]>;
+    listAll(options?: OptionsExtended<UserClockedIn>): Promise<UserClockedIn[]>;
+    listByPage(): AsyncGenerator<AxiosResponse<UserClockedIn[]>>;
+    listByPage<F extends keyof UserClockedIn>(options: {
+        fields: F[];
+    } & OptionsExtended<UserClockedIn>): AsyncGenerator<AxiosResponse<Pick<UserClockedIn, F>[]>>;
+    listByPage(options?: OptionsExtended<UserClockedIn>): AsyncGenerator<AxiosResponse<UserClockedIn[]>>;
     clockIn(data: RequirementsOf<UserClockIn, RequiredPropsClockIn>): Promise<UserClockedIn>;
     clockIn(data: RequirementsOf<UserClockIn, RequiredPropsClockIn>, options: {
         rawResponse: true;
-    } & Options): Promise<AxiosResponse<UserClockedIn, any>>;
+    } & Options): Promise<AxiosResponse<UserClockedIn>>;
     clockIn(data: RequirementsOf<UserClockIn, RequiredPropsClockIn>, options: Options): Promise<UserClockedIn>;
     clockOut(id: number, data: UserClockOut): Promise<UserClockedOut>;
     clockOut(id: number, data: UserClockOut, options: {
         rawResponse: true;
-    } & Options): Promise<AxiosResponse<UserClockedOut, any>>;
+    } & Options): Promise<AxiosResponse<UserClockedOut>>;
     clockOut(id: number, data: UserClockOut, options: Options): Promise<UserClockedOut>;
     startBreak(id: number, data: RequirementsOf<UserBreakRequest, RequiredPropsBreak>): Promise<UserBreak>;
     startBreak(id: number, data: RequirementsOf<UserBreakRequest, RequiredPropsBreak>, options: {
         rawResponse: true;
-    } & Options): Promise<AxiosResponse<UserBreak, any>>;
+    } & Options): Promise<AxiosResponse<UserBreak>>;
     startBreak(id: number, data: RequirementsOf<UserBreakRequest, RequiredPropsBreak>, options: Options): Promise<UserBreak>;
     endBreak(id: number, data: RequirementsOf<UserBreakRequest, RequiredPropsBreak>): Promise<UserBreak>;
     endBreak(id: number, data: RequirementsOf<UserBreakRequest, RequiredPropsBreak>, options: {
         rawResponse: true;
-    } & Options): Promise<AxiosResponse<UserBreak, any>>;
+    } & Options): Promise<AxiosResponse<UserBreak>>;
     endBreak(id: number, data: RequirementsOf<UserBreakRequest, RequiredPropsBreak>, options: Options): Promise<UserBreak>;
 }
 export {};

package/dist/mjs/services/users-clock-in.service.js

@@ -7,7 +7,7 @@ export class UsersClockInService extends Service {
     getClockedInUser(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(options) {
         for await (const res of super.iterator({ url: this.apiPath }, options)) {
@@ -27,21 +27,21 @@ export class UsersClockInService extends Service {
     clockIn(data, options) {
         return super
             .fetch({ url: this.apiPath, data, method: 'POST' })
-            .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+            .then((res) => (options?.rawResponse ? res : res.data));
     }
     clockOut(id, data, options) {
         return super
             .fetch({ url: `${this.apiPath}/${id}`, data, method: 'DELETE' })
-            .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+            .then((res) => (options?.rawResponse ? res : res.data));
     }
     startBreak(id, data, options) {
         return super
             .fetch({ url: `${this.apiPath}/${id}`, data, method: 'POST' })
-            .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+            .then((res) => (options?.rawResponse ? res : res.data));
     }
     endBreak(id, data, options) {
         return super
             .fetch({ url: `${this.apiPath}/${id}`, data, method: 'POST' })
-            .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+            .then((res) => (options?.rawResponse ? res : res.data));
     }
 }

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

@@ -1,23 +1,42 @@
 import { AxiosResponse } from 'axios';
 import { User } from '../interfaces/index.js';
-import { Service, Options, RequirementsOf } from './index.js';
+import { Service, Options, RequirementsOf, OptionsExtended } from './index.js';
 import { UsersQueryParams } from '../interfaces/query-params/users-query-params.interface.js';
 type RequiredProps = 'first_name' | 'last_name';
-export declare class UsersService extends Service {
+export declare class UsersService extends Service<User> {
     private apiPath;
     create(data: RequirementsOf<User, RequiredProps>): Promise<User>;
     create(data: RequirementsOf<User, RequiredProps>, options: {
         rawResponse: true;
-    } & Options): Promise<AxiosResponse<User, any>>;
+    } & Options): Promise<AxiosResponse<User>>;
     create(data: RequirementsOf<User, RequiredProps>, options: Options): Promise<User>;
     get(id: number): Promise<User>;
+    get<F extends keyof User>(id: number, options: {
+        fields: F[];
+        rawResponse: true;
+    } & OptionsExtended<User>): Promise<AxiosResponse<Pick<User, F>>>;
+    get<F extends keyof User>(id: number, options: {
+        fields: F[];
+    } & OptionsExtended<User>): Promise<Pick<User, F>>;
     get(id: number, options: {
         rawResponse: true;
-    } & Options): Promise<AxiosResponse<User, any>>;
-    get(id: number, options: Options): Promise<User>;
-    list(query: UsersQueryParams, options?: Options): AsyncGenerator<User, void, unknown>;
-    listAll(query: UsersQueryParams, options?: Options): Promise<User[]>;
-    listByPage(query: UsersQueryParams, options?: Options): AsyncGenerator<AxiosResponse<User[], any>, any, unknown>;
+    } & Options): Promise<AxiosResponse<User>>;
+    get(id: number, options?: OptionsExtended<User>): Promise<User>;
+    list(query?: UsersQueryParams): AsyncGenerator<User>;
+    list<F extends keyof User>(query: UsersQueryParams, options: {
+        fields: F[];
+    } & OptionsExtended<User>): AsyncGenerator<Pick<User, F>>;
+    list(query?: UsersQueryParams, options?: OptionsExtended<User>): AsyncGenerator<User>;
+    listAll(query?: UsersQueryParams): Promise<User[]>;
+    listAll<F extends keyof User>(query: UsersQueryParams, options: {
+        fields: F[];
+    } & OptionsExtended<User>): Promise<Pick<User, F>[]>;
+    listAll(query?: UsersQueryParams, options?: OptionsExtended<User>): Promise<User[]>;
+    listByPage(query?: UsersQueryParams): AsyncGenerator<AxiosResponse<User[]>>;
+    listByPage<F extends keyof User>(query: UsersQueryParams, options: {
+        fields: F[];
+    } & OptionsExtended<User>): AsyncGenerator<AxiosResponse<Pick<User, F>[]>>;
+    listByPage(query?: UsersQueryParams, options?: OptionsExtended<User>): AsyncGenerator<AxiosResponse<User[]>>;
     update(id: number, data: Partial<User>): Promise<User>;
     update(id: number, data: Partial<User>, options: {
         rawResponse: true;
@@ -26,7 +45,7 @@ export declare class UsersService 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/users.service.js

@@ -6,18 +6,16 @@ export class UsersService 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 users = [];
@@ -35,12 +33,12 @@ export class UsersService 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/version.js

@@ -1 +1 @@
-export const Version = { version: '1.1.2' };
+export const Version = { version: '1.2.1' };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rotacloud",
-  "version": "1.1.2",
+  "version": "1.2.1",
   "description": "The RotaCloud SDK for the RotaCloud API",
   "engines": {
     "node": ">=16.10.0"

package/src/interfaces/query-params/index.ts

@@ -9,7 +9,6 @@ export * from './days-off-patterns-query-params.interface.js';
 export * from './days-off-query-params.interface.js';
 export * from './documents-query-params.interface.js';
 export * from './groups-query-params.interface.js';
-export * from './internal-query-params.interface.js';
 export * from './leave-embargoes-query-params.interface.js';
 export * from './leave-query-params.interface.js';
 export * from './leave-requests-query-params.interface.js';

package/src/interfaces/role-rate.interface.ts

@@ -1,6 +1,6 @@
 export interface RoleRate {
   [key: string]: {
-    per_hour: number;
-    per_shift: number;
+    per_hour: number | null;
+    per_shift: number | null;
   };
 }

package/src/interfaces/user.interface.ts

@@ -31,12 +31,13 @@ export interface User {
   salary: number;
   salary_type: string;
   overtime_rate: number;
-  role_rates: LeaveRate;
-  leave_rates: RoleRate;
+  role_rates: RoleRate | null;
+  leave_rates: LeaveRate;
   leave_rates_unit: string;
   leave_rates_type: string;
   notes: string | null;
   pin: string | null;
+  salaried_cost_location: number | null;
 }
 
 export interface UserBreak {

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