rotacloud 1.0.10 → 1.0.13

package/dist/cjs/interfaces/availability.interface.d.ts

@@ -2,12 +2,12 @@ export interface ApiAvailabilityPeriod {
     start_time: string;
     end_time: string;
 }
-export interface ApiAvailabilityDates {
+export interface ApiAvailabilityDate {
     date: string;
     available: ApiAvailabilityPeriod[];
     unavailable: ApiAvailabilityPeriod[];
 }
 export interface ApiAvailability {
     user: number;
-    dates: ApiAvailabilityDates[];
+    dates: ApiAvailabilityDate[];
 }

package/dist/cjs/interfaces/query-params/availability-query-params.interface.d.ts

@@ -1,5 +1,12 @@
 export interface AvailabilityQueryParams {
+    /** Start of date range for fetching availability (ISO date format `YYYY-MM-DD`) */
     start?: string;
+    /** End of date range for fetching availability (inclusive) (ISO date format `YYYY-MM-DD`)  */
     end?: string;
+    /**
+     * List of user IDs to get availability for
+     *
+     * If undefined, all users on the account will be selected
+     */
     users?: number[];
 }

package/dist/cjs/models/availability.model.d.ts

@@ -1,6 +1,6 @@
-import { ApiAvailability, ApiAvailabilityDates } from '../interfaces/index.js';
+import { ApiAvailability, ApiAvailabilityDate } from '../interfaces/index.js';
 export declare class Availability {
     user: number;
-    dates: ApiAvailabilityDates[];
+    dates: ApiAvailabilityDate[];
     constructor(availability: ApiAvailability);
 }

package/dist/cjs/models/user.model.d.ts

@@ -25,9 +25,39 @@ export interface TeamProperties {
 }
 export declare class User {
     id: number;
+    created_at: number;
+    created_by: number;
+    deleted: boolean;
+    deleted_at: number | null;
+    deleted_by: number | null;
+    level: string;
     first_name: string;
+    middle_name: string | null;
     last_name: string;
-    photo: string | null;
     preferred_name: string | null;
+    photo: string | null;
+    two_factor_enabled: boolean;
+    email: string;
+    has_account: boolean;
+    invite_sent: boolean;
+    group: number | null;
+    locations: number[];
+    roles: number[];
+    default_role: number | null;
+    dob: string | null;
+    start_date: string | null;
+    final_working_date: string | null;
+    weekly_hours: number | null;
+    holiday_allowance: number;
+    holiday_allowance_unit: string;
+    payroll_id: string | null;
+    salary: number;
+    salary_type: string;
+    overtime_rate: number;
+    role_rates: LeaveRates;
+    leave_rates: RoleRates;
+    leave_rates_unit: string;
+    leave_rates_type: string;
+    notes: string | null;
     constructor(user: ApiUser);
 }

package/dist/cjs/models/user.model.js

@@ -5,10 +5,40 @@ exports.User = void 0;
 class User {
     constructor(user) {
         this.id = user.id;
+        this.created_at = user.created_at;
+        this.created_by = user.created_by;
+        this.deleted = user.deleted;
+        this.deleted_at = user.deleted_at;
+        this.deleted_by = user.deleted_by;
+        this.level = user.level;
         this.first_name = user.first_name;
+        this.middle_name = user.middle_name;
         this.last_name = user.last_name;
-        this.photo = user.photo;
         this.preferred_name = user.preferred_name;
+        this.photo = user.photo;
+        this.two_factor_enabled = user.two_factor_enabled;
+        this.email = user.email;
+        this.has_account = user.has_account;
+        this.invite_sent = user.invite_sent;
+        this.group = user.group;
+        this.locations = user.locations;
+        this.roles = user.roles;
+        this.default_role = user.default_role;
+        this.dob = user.dob;
+        this.start_date = user.start_date;
+        this.final_working_date = user.final_working_date;
+        this.weekly_hours = user.weekly_hours;
+        this.holiday_allowance = user.holiday_allowance;
+        this.holiday_allowance_unit = user.holiday_allowance_unit;
+        this.payroll_id = user.payroll_id;
+        this.salary = user.salary;
+        this.salary_type = user.salary_type;
+        this.overtime_rate = user.overtime_rate;
+        this.role_rates = user.role_rates;
+        this.leave_rates = user.leave_rates;
+        this.leave_rates_unit = user.leave_rates_unit;
+        this.leave_rates_type = user.leave_rates_type;
+        this.notes = user.notes;
     }
 }
 exports.User = User;

package/dist/cjs/rotacloud.d.ts

@@ -1,10 +1,11 @@
-import { AccountsService, AttendanceService, DaysOffService, GroupsService, LeaveEmbargoesService, LeaveRequestService, LeaveService, LocationsService, RolesService, ShiftsService, UsersService } from './services/index.js';
+import { AccountsService, AttendanceService, AvailabilityService, DaysOffService, GroupsService, LeaveEmbargoesService, LeaveRequestService, LeaveService, LocationsService, RolesService, ShiftsService, UsersService } from './services/index.js';
 import { SDKConfig } from './interfaces/index.js';
 export declare class RotaCloud {
     static config: SDKConfig;
     defaultAPIURI: string;
     accounts: AccountsService;
     attendance: AttendanceService;
+    availability: AvailabilityService;
     daysOff: DaysOffService;
     group: GroupsService;
     leaveEmbargoes: LeaveEmbargoesService;

package/dist/cjs/rotacloud.js

@@ -7,6 +7,7 @@ class RotaCloud {
         this.defaultAPIURI = 'https://api.rotacloud.com/v1';
         this.accounts = new index_js_1.AccountsService();
         this.attendance = new index_js_1.AttendanceService();
+        this.availability = new index_js_1.AvailabilityService();
         this.daysOff = new index_js_1.DaysOffService();
         this.group = new index_js_1.GroupsService();
         this.leaveEmbargoes = new index_js_1.LeaveEmbargoesService();

package/dist/cjs/services/accounts.service.d.ts

@@ -5,6 +5,7 @@ import { InternalQueryParams } from '../interfaces/query-params/internal-query-p
 declare class AccountsService extends Service {
     private apiPath;
     list(options?: Options<InternalQueryParams>): AsyncGenerator<Account, void, unknown>;
+    listAll(): Promise<Account[]>;
     listByPage(options?: Options<InternalQueryParams>): AsyncGenerator<import("axios").AxiosResponse<ApiAccount[], any>, any, unknown>;
 }
 export { AccountsService };

package/dist/cjs/services/accounts.service.js

@@ -1,4 +1,13 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 var __asyncValues = (this && this.__asyncValues) || function (o) {
     if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
     var m = o[Symbol.asyncIterator], i;
@@ -48,6 +57,31 @@ class AccountsService extends index_js_1.Service {
             }
         });
     }
+    listAll() {
+        var e_2, _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const accounts = [];
+                try {
+                    for (var _b = __asyncValues(this.list()), _c; _c = yield _b.next(), !_c.done;) {
+                        const account = _c.value;
+                        accounts.push(account);
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (_c && !_c.done && (_a = _b.return)) yield _a.call(_b);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+                return accounts;
+            }
+            catch (err) {
+                return err;
+            }
+        });
+    }
     listByPage(options) {
         return super.iterator({ url: this.apiPath }, options).byPage();
     }

package/dist/cjs/services/attendance.service.d.ts

@@ -20,6 +20,7 @@ declare class AttendanceService extends Service {
     }): Promise<AxiosResponse<ApiAttendance, any>>;
     get(id: number, options: Options<InternalQueryParams>): Promise<ApiAttendance>;
     list(options?: Options<AttendanceQueryParams & InternalQueryParams>): AsyncGenerator<Attendance, void, unknown>;
+    listAll(): Promise<Attendance[]>;
     listByPage(options?: Options<AttendanceQueryParams & InternalQueryParams>): AsyncGenerator<AxiosResponse<ApiAttendance[], any>, any, unknown>;
     update(id: number, data: Partial<ApiAttendance>): Promise<Attendance>;
     update(id: number, data: Partial<ApiAttendance>, options: {

package/dist/cjs/services/attendance.service.js

@@ -1,4 +1,13 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 var __asyncValues = (this && this.__asyncValues) || function (o) {
     if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
     var m = o[Symbol.asyncIterator], i;
@@ -55,6 +64,31 @@ class AttendanceService extends index_js_1.Service {
             }
         });
     }
+    listAll() {
+        var e_2, _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const attendance = [];
+                try {
+                    for (var _b = __asyncValues(this.list()), _c; _c = yield _b.next(), !_c.done;) {
+                        const atten = _c.value;
+                        attendance.push(atten);
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (_c && !_c.done && (_a = _b.return)) yield _a.call(_b);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+                return attendance;
+            }
+            catch (err) {
+                return err;
+            }
+        });
+    }
     listByPage(options) {
         return super.iterator({ url: this.apiPath }, options).byPage();
     }

package/dist/cjs/services/availability.service.d.ts

@@ -0,0 +1,13 @@
+import { Service, Options, RequirementsOf } from './index.js';
+import { InternalQueryParams } from '../interfaces/query-params/internal-query-params.inteface.js';
+import { AvailabilityQueryParams } from '../interfaces/query-params/availability-query-params.interface.js';
+import { Availability } from '../models/availability.model.js';
+import { ApiAvailability } from '../interfaces/availability.interface.js';
+declare type RequiredProps = 'start' | 'end';
+declare type RequiredOptions<T> = RequirementsOf<Options<T>, 'params'>;
+export declare class AvailabilityService extends Service {
+    private apiPath;
+    list(options: RequiredOptions<RequirementsOf<AvailabilityQueryParams, RequiredProps> & InternalQueryParams>): AsyncGenerator<Availability, void, unknown>;
+    listByPage(options: RequiredOptions<RequirementsOf<AvailabilityQueryParams, RequiredProps> & InternalQueryParams>): AsyncGenerator<import("axios").AxiosResponse<ApiAvailability[], any>, any, unknown>;
+}
+export {};

package/dist/cjs/services/availability.service.js

@@ -0,0 +1,55 @@
+"use strict";
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvailabilityService = void 0;
+const index_js_1 = require("./index.js");
+const availability_model_js_1 = require("../models/availability.model.js");
+class AvailabilityService extends index_js_1.Service {
+    constructor() {
+        super(...arguments);
+        this.apiPath = '/availability';
+    }
+    list(options) {
+        const _super = Object.create(null, {
+            iterator: { get: () => super.iterator }
+        });
+        return __asyncGenerator(this, arguments, function* list_1() {
+            var e_1, _a;
+            try {
+                for (var _b = __asyncValues(_super.iterator.call(this, { url: this.apiPath }, options)), _c; _c = yield __await(_b.next()), !_c.done;) {
+                    const res = _c.value;
+                    yield yield __await(new availability_model_js_1.Availability(res));
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) yield __await(_a.call(_b));
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        });
+    }
+    listByPage(options) {
+        return super.iterator({ url: this.apiPath }, options).byPage();
+    }
+}
+exports.AvailabilityService = AvailabilityService;

package/dist/cjs/services/days-off.service.d.ts

@@ -13,6 +13,7 @@ declare class DaysOffService extends Service<ApiDaysOff> {
     }): Promise<AxiosResponse<ApiDaysOff, any>>;
     create(dates: string[], users: number[], options: Options<InternalQueryParams>): Promise<number>;
     list(options?: Options<DaysOffQueryParams & InternalQueryParams>): AsyncGenerator<DaysOff, void, unknown>;
+    listAll(): Promise<DaysOff[]>;
     listByPage(options?: Options<DaysOffQueryParams & InternalQueryParams>): AsyncGenerator<AxiosResponse<ApiDaysOff[], any>, any, unknown>;
     delete(dates: string[], users: number[]): Promise<number>;
     delete(dates: string[], users: number[], options: {

package/dist/cjs/services/days-off.service.js

@@ -1,4 +1,13 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 var __asyncValues = (this && this.__asyncValues) || function (o) {
     if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
     var m = o[Symbol.asyncIterator], i;
@@ -61,6 +70,31 @@ class DaysOffService extends index_js_1.Service {
             }
         });
     }
+    listAll() {
+        var e_2, _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const daysOff = [];
+                try {
+                    for (var _b = __asyncValues(this.list()), _c; _c = yield _b.next(), !_c.done;) {
+                        const dayOff = _c.value;
+                        daysOff.push(dayOff);
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (_c && !_c.done && (_a = _b.return)) yield _a.call(_b);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+                return daysOff;
+            }
+            catch (err) {
+                return err;
+            }
+        });
+    }
     listByPage(options) {
         return super.iterator({ url: this.apiPath }, options).byPage();
     }

package/dist/cjs/services/groups.service.d.ts

@@ -20,6 +20,7 @@ declare class GroupsService extends Service {
     }): Promise<AxiosResponse<ApiGroup, any>>;
     get(id: number, options: Options<InternalQueryParams>): Promise<Group>;
     list(options?: Options<GroupsQueryParams & InternalQueryParams>): AsyncGenerator<Group, void, unknown>;
+    listAll(): Promise<Group[]>;
     listByPage(options?: Options<GroupsQueryParams & InternalQueryParams>): AsyncGenerator<AxiosResponse<ApiGroup[], any>, any, unknown>;
     update(id: number, data: Partial<ApiGroup>): Promise<Group>;
     update(id: number, data: Partial<ApiGroup>, options: {

package/dist/cjs/services/groups.service.js

@@ -1,4 +1,13 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 var __asyncValues = (this && this.__asyncValues) || function (o) {
     if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
     var m = o[Symbol.asyncIterator], i;
@@ -55,6 +64,31 @@ class GroupsService extends index_js_1.Service {
             }
         });
     }
+    listAll() {
+        var e_2, _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const groups = [];
+                try {
+                    for (var _b = __asyncValues(this.list()), _c; _c = yield _b.next(), !_c.done;) {
+                        const group = _c.value;
+                        groups.push(group);
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (_c && !_c.done && (_a = _b.return)) yield _a.call(_b);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+                return groups;
+            }
+            catch (err) {
+                return err;
+            }
+        });
+    }
     listByPage(options) {
         return super.iterator({ url: this.apiPath }, options).byPage();
     }

package/dist/cjs/services/index.d.ts

@@ -1,6 +1,7 @@
 export * from './service.js';
 export * from './accounts.service.js';
 export * from './attendance.service.js';
+export * from './availability.service.js';
 export * from './days-off.service.js';
 export * from './groups.service.js';
 export * from './leave-request.service.js';

package/dist/cjs/services/index.js

@@ -13,6 +13,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./service.js"), exports);
 __exportStar(require("./accounts.service.js"), exports);
 __exportStar(require("./attendance.service.js"), exports);
+__exportStar(require("./availability.service.js"), exports);
 __exportStar(require("./days-off.service.js"), exports);
 __exportStar(require("./groups.service.js"), exports);
 __exportStar(require("./leave-request.service.js"), exports);

package/dist/cjs/services/leave-embargoes.service.d.ts

@@ -20,6 +20,7 @@ declare class LeaveEmbargoesService extends Service {
     }): Promise<AxiosResponse<ApiLeaveEmbargo, any>>;
     get(id: number, options: Options<InternalQueryParams>): Promise<LeaveEmbargo>;
     list(options?: Options<UsersQueryParams & InternalQueryParams>): AsyncGenerator<LeaveEmbargo, void, unknown>;
+    listAll(): Promise<LeaveEmbargo[]>;
     listByPage(options?: Options<UsersQueryParams & InternalQueryParams>): AsyncGenerator<AxiosResponse<ApiLeaveEmbargo[], any>, any, unknown>;
     update(id: number, data: Partial<ApiLeaveEmbargo>): Promise<LeaveEmbargo>;
     update(id: number, data: Partial<ApiLeaveEmbargo>, options: {

package/dist/cjs/services/leave-embargoes.service.js

@@ -1,4 +1,13 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 var __asyncValues = (this && this.__asyncValues) || function (o) {
     if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
     var m = o[Symbol.asyncIterator], i;
@@ -55,6 +64,31 @@ class LeaveEmbargoesService extends index_js_1.Service {
             }
         });
     }
+    listAll() {
+        var e_2, _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const leave = [];
+                try {
+                    for (var _b = __asyncValues(this.list()), _c; _c = yield _b.next(), !_c.done;) {
+                        const leaveEmbargoRecord = _c.value;
+                        leave.push(leaveEmbargoRecord);
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (_c && !_c.done && (_a = _b.return)) yield _a.call(_b);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+                return leave;
+            }
+            catch (err) {
+                return err;
+            }
+        });
+    }
     listByPage(options) {
         return super.iterator({ url: this.apiPath }, options).byPage();
     }

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

@@ -20,6 +20,7 @@ declare class LeaveRequestService extends Service {
     }): Promise<AxiosResponse<ApiLeaveRequest, any>>;
     get(id: number, options: Options<InternalQueryParams>): Promise<LeaveRequest>;
     list(options?: Options<LeaveQueryParams & InternalQueryParams>): AsyncGenerator<LeaveRequest, void, unknown>;
+    listAll(): Promise<LeaveRequest[]>;
     listByPage(options?: Options<LeaveQueryParams & InternalQueryParams>): AsyncGenerator<AxiosResponse<ApiLeaveRequest[], any>, any, unknown>;
     update(id: number, data: Partial<ApiLeaveRequest>): Promise<LeaveRequest>;
     update(id: number, data: Partial<ApiLeaveRequest>, options: {

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

@@ -1,4 +1,13 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 var __asyncValues = (this && this.__asyncValues) || function (o) {
     if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
     var m = o[Symbol.asyncIterator], i;
@@ -55,6 +64,31 @@ class LeaveRequestService extends index_js_1.Service {
             }
         });
     }
+    listAll() {
+        var e_2, _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const leave = [];
+                try {
+                    for (var _b = __asyncValues(this.list()), _c; _c = yield _b.next(), !_c.done;) {
+                        const leaveRequestRecord = _c.value;
+                        leave.push(leaveRequestRecord);
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (_c && !_c.done && (_a = _b.return)) yield _a.call(_b);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+                return leave;
+            }
+            catch (err) {
+                return err;
+            }
+        });
+    }
     listByPage(options) {
         return super.iterator({ url: `${this.apiPath}` }, options).byPage();
     }

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

@@ -21,6 +21,7 @@ declare class LeaveService extends Service {
     }): Promise<AxiosResponse<ApiLeave, any>>;
     get(id: number, options: Options<InternalQueryParams>): Promise<Leave>;
     list(options?: Options<LeaveQueryParams & InternalQueryParams>): AsyncGenerator<Leave, void, unknown>;
+    listAll(): Promise<Leave[]>;
     listLeaveTypes(options?: Options<InternalQueryParams>): AsyncGenerator<LeaveType, void, unknown>;
     listByPage(options?: Options<LeaveQueryParams & InternalQueryParams>): AsyncGenerator<AxiosResponse<ApiLeave[], any>, any, unknown>;
     update(id: number, data: Partial<ApiLeave>): Promise<Leave>;

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

@@ -1,4 +1,13 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 var __asyncValues = (this && this.__asyncValues) || function (o) {
     if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
     var m = o[Symbol.asyncIterator], i;
@@ -56,24 +65,49 @@ class LeaveService extends index_js_1.Service {
             }
         });
     }
+    listAll() {
+        var e_2, _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const leave = [];
+                try {
+                    for (var _b = __asyncValues(this.list()), _c; _c = yield _b.next(), !_c.done;) {
+                        const leaveRecord = _c.value;
+                        leave.push(leaveRecord);
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (_c && !_c.done && (_a = _b.return)) yield _a.call(_b);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+                return leave;
+            }
+            catch (err) {
+                return err;
+            }
+        });
+    }
     listLeaveTypes(options) {
         const _super = Object.create(null, {
             iterator: { get: () => super.iterator }
         });
         return __asyncGenerator(this, arguments, function* listLeaveTypes_1() {
-            var e_2, _a;
+            var e_3, _a;
             try {
                 for (var _b = __asyncValues(_super.iterator.call(this, { url: this.apiPath }, options)), _c; _c = yield __await(_b.next()), !_c.done;) {
                     const res = _c.value;
                     yield yield __await(new leave_type_model_js_1.LeaveType(res));
                 }
             }
-            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
             finally {
                 try {
                     if (_c && !_c.done && (_a = _b.return)) yield __await(_a.call(_b));
                 }
-                finally { if (e_2) throw e_2.error; }
+                finally { if (e_3) throw e_3.error; }
             }
         });
     }

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

@@ -20,6 +20,7 @@ declare class LocationsService extends Service {
     }): Promise<AxiosResponse<ApiLocation, any>>;
     get(id: number, options: Options<InternalQueryParams>): Promise<ApiLocation>;
     list(options?: Options<LocationsQueryParams & InternalQueryParams>): AsyncGenerator<Location, void, unknown>;
+    listAll(): Promise<Location[]>;
     listByPage(options?: Options<LocationsQueryParams & InternalQueryParams>): AsyncGenerator<AxiosResponse<ApiLocation[], any>, any, unknown>;
     update(id: number, data: Partial<ApiLocation>): Promise<Location>;
     update(id: number, data: Partial<ApiLocation>, options: {