rotacloud 1.0.55 → 1.0.57

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

@@ -0,0 +1,33 @@
+import { AxiosResponse } from 'axios';
+import { ApiRole } from '../interfaces/index.js';
+import { Service, Options, RequirementsOf } from './index.js';
+import { Role } from '../models/role.model.js';
+import { RolesQueryParams } from '../interfaces/query-params/roles-query-params.interface.js';
+type RequiredProps = 'name';
+export declare class RolesService extends Service {
+    private apiPath;
+    create(data: RequirementsOf<ApiRole, RequiredProps>): Promise<Role>;
+    create(data: RequirementsOf<ApiRole, RequiredProps>, options: {
+        rawResponse: true;
+    } & Options): Promise<AxiosResponse<ApiRole, any>>;
+    create(data: RequirementsOf<ApiRole, RequiredProps>, options: Options): Promise<Role>;
+    get(id: number): Promise<Role>;
+    get(id: number, options: {
+        rawResponse: true;
+    } & Options): Promise<AxiosResponse<ApiRole, 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<ApiRole[], any>, any, unknown>;
+    update(id: number, data: Partial<ApiRole>): Promise<Role>;
+    update(id: number, data: Partial<ApiRole>, options: {
+        rawResponse: true;
+    } & Options): Promise<AxiosResponse<ApiRole, any>>;
+    update(id: number, data: Partial<ApiRole>, options: Options): Promise<Role>;
+    delete(id: number): Promise<number>;
+    delete(id: number, options: {
+        rawResponse: true;
+    } & Options): Promise<AxiosResponse<any, any>>;
+    delete(id: number, options: Options): Promise<number>;
+}
+export {};

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

@@ -0,0 +1,112 @@
+"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;
+    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.RolesService = void 0;
+const index_js_1 = require("./index.js");
+const role_model_js_1 = require("../models/role.model.js");
+class RolesService extends index_js_1.Service {
+    constructor() {
+        super(...arguments);
+        this.apiPath = '/roles';
+    }
+    create(data, options) {
+        return super
+            .fetch({ url: this.apiPath, data, method: 'POST' })
+            .then((res) => Promise.resolve((options === null || options === void 0 ? void 0 : options.rawResponse) ? res : new role_model_js_1.Role(res.data)));
+    }
+    get(id, options) {
+        return super
+            .fetch({ url: `${this.apiPath}/${id}` }, options)
+            .then((res) => Promise.resolve((options === null || options === void 0 ? void 0 : options.rawResponse) ? res : new role_model_js_1.Role(res.data)));
+    }
+    list(query, options) {
+        const _super = Object.create(null, {
+            iterator: { get: () => super.iterator }
+        });
+        return __asyncGenerator(this, arguments, function* list_1() {
+            var _a, e_1, _b, _c;
+            try {
+                for (var _d = true, _e = __asyncValues(_super.iterator.call(this, { url: this.apiPath, params: query }, options)), _f; _f = yield __await(_e.next()), _a = _f.done, !_a; _d = true) {
+                    _c = _f.value;
+                    _d = false;
+                    const res = _c;
+                    yield yield __await(new role_model_js_1.Role(res));
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = _e.return)) yield __await(_b.call(_e));
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        });
+    }
+    listAll(query, options) {
+        var _a, e_2, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            const roles = [];
+            try {
+                for (var _d = true, _e = __asyncValues(this.list(query, options)), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+                    _c = _f.value;
+                    _d = false;
+                    const role = _c;
+                    roles.push(role);
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            return roles;
+        });
+    }
+    listByPage(query, options) {
+        return super.iterator({ url: this.apiPath, params: query }, options).byPage();
+    }
+    update(id, data, options) {
+        return super
+            .fetch({
+            url: `${this.apiPath}/${id}`,
+            data,
+            method: 'POST',
+        })
+            .then((res) => Promise.resolve((options === null || options === void 0 ? void 0 : options.rawResponse) ? res : new role_model_js_1.Role(res.data)));
+    }
+    delete(id, options) {
+        return super
+            .fetch({ url: `${this.apiPath}/${id}`, method: 'DELETE' })
+            .then((res) => Promise.resolve((options === null || options === void 0 ? void 0 : options.rawResponse) ? res : res.status));
+    }
+}
+exports.RolesService = RolesService;

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

@@ -0,0 +1,42 @@
+import { AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios';
+export type RequirementsOf<T, K extends keyof T> = Required<Pick<T, K>> & Partial<T>;
+export declare enum RetryStrategy {
+    Exponential = "expo",
+    Static = "static"
+}
+export type RetryOptions = {
+    /** Use exponential back-off */
+    exponential?: false;
+    /** The maximum number of retries before erroring */
+    maxRetries: number;
+    /** Delay in milliseconds between retry attempts - not used in exponential back-off */
+    delay: number;
+} | {
+    /** Use exponential back-off */
+    exponential: true;
+    /** The maximum number of retries before erroring */
+    maxRetries: number;
+};
+export interface Options {
+    rawResponse?: boolean;
+    expand?: string[];
+    fields?: string[];
+    limit?: number;
+    offset?: number;
+    dryRun?: boolean;
+}
+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>>;
+    /** Iterates through every page for a potentially paginated request */
+    private fetchPages;
+    private listResponses;
+    iterator<T = ApiResponse>(reqConfig: AxiosRequestConfig<T[]>, options?: Options): {
+        [Symbol.asyncIterator]: () => AsyncGenerator<Awaited<T>, void, undefined>;
+        byPage: () => AsyncGenerator<AxiosResponse<T[], any>, any, unknown>;
+    };
+}

package/dist/cjs/services/service.js

@@ -0,0 +1,177 @@
+"use strict";
+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]); }
+};
+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 __asyncDelegator = (this && this.__asyncDelegator) || function (o) {
+    var i, p;
+    return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
+    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Service = exports.RetryStrategy = void 0;
+const axios_1 = __importDefault(require("axios"));
+const axios_retry_1 = __importDefault(require("axios-retry"));
+const rotacloud_js_1 = require("../rotacloud.js");
+const version_js_1 = require("../version.js");
+const SDKError_model_js_1 = require("../models/SDKError.model.js");
+var RetryStrategy;
+(function (RetryStrategy) {
+    RetryStrategy["Exponential"] = "expo";
+    RetryStrategy["Static"] = "static";
+})(RetryStrategy || (exports.RetryStrategy = RetryStrategy = {}));
+const DEFAULT_RETRIES = 3;
+const DEFAULT_RETRY_DELAY = 2000;
+const DEFAULT_RETRY_STRATEGY_OPTIONS = {
+    [RetryStrategy.Exponential]: {
+        exponential: true,
+        maxRetries: DEFAULT_RETRIES,
+    },
+    [RetryStrategy.Static]: {
+        exponential: false,
+        maxRetries: DEFAULT_RETRIES,
+        delay: DEFAULT_RETRY_DELAY,
+    },
+};
+class Service {
+    constructor() {
+        this.client = this.initialiseAxios();
+    }
+    initialiseAxios() {
+        const client = axios_1.default.create();
+        client.interceptors.response.use((response) => response, (error) => {
+            const parsedError = this.parseClientError(error);
+            return Promise.reject(parsedError);
+        });
+        return client;
+    }
+    parseClientError(error) {
+        var _a;
+        if (!axios_1.default.isAxiosError(error))
+            return error;
+        const axiosErrorLocation = error.response || error.request;
+        const apiErrorMessage = (_a = axiosErrorLocation.data) === null || _a === void 0 ? void 0 : _a.error;
+        const sdkErrorParams = {
+            code: axiosErrorLocation.status,
+            message: apiErrorMessage || error.message,
+            data: axiosErrorLocation.data,
+        };
+        return new SDKError_model_js_1.SDKError(sdkErrorParams);
+    }
+    isLeaveRequest(endpoint) {
+        return endpoint === '/leave_requests';
+    }
+    buildQueryParams(options, extraParams) {
+        const queryParams = Object.assign(Object.assign({ expand: options === null || options === void 0 ? void 0 : options.expand, fields: options === null || options === void 0 ? void 0 : options.fields, limit: options === null || options === void 0 ? void 0 : options.limit, offset: options === null || options === void 0 ? void 0 : options.offset, dry_run: options === null || options === void 0 ? void 0 : options.dryRun }, extraParams), { 
+            // NOTE: Should not overridable so must come after spread of params
+            exclude_link_header: true });
+        const reducedParams = Object.entries(queryParams !== null && queryParams !== void 0 ? queryParams : {}).reduce((params, [key, val]) => {
+            if (val !== undefined && val !== '') {
+                if (Array.isArray(val))
+                    params.push(...val.map((item) => [`${key}[]`, String(item)]));
+                else
+                    params.push([key, String(val)]);
+            }
+            return params;
+        }, []);
+        return new URLSearchParams(reducedParams);
+    }
+    fetch(reqConfig, options) {
+        const headers = {
+            Authorization: rotacloud_js_1.RotaCloud.config.apiKey
+                ? `Bearer ${rotacloud_js_1.RotaCloud.config.apiKey}`
+                : `Basic ${rotacloud_js_1.RotaCloud.config.basicAuth}`,
+            'SDK-Version': version_js_1.Version.version,
+        };
+        const extraHeaders = rotacloud_js_1.RotaCloud.config.headers;
+        if (extraHeaders && typeof extraHeaders === 'object') {
+            for (const [key, val] of Object.entries(extraHeaders)) {
+                if (typeof key === 'string' && typeof val === 'string') {
+                    headers[key] = val;
+                }
+            }
+        }
+        if (rotacloud_js_1.RotaCloud.config.accountId) {
+            headers.Account = String(rotacloud_js_1.RotaCloud.config.accountId);
+        }
+        else {
+            // need to convert user field in payload to a header for creating leave_requests when using an API key
+            this.isLeaveRequest(reqConfig.url) ? (headers.User = `${reqConfig.data.user}`) : undefined;
+        }
+        const finalReqConfig = Object.assign(Object.assign({}, reqConfig), { baseURL: rotacloud_js_1.RotaCloud.config.baseUri, headers, params: this.buildQueryParams(options, reqConfig.params) });
+        if (rotacloud_js_1.RotaCloud.config.retry) {
+            const retryConfig = typeof rotacloud_js_1.RotaCloud.config.retry === 'string'
+                ? DEFAULT_RETRY_STRATEGY_OPTIONS[rotacloud_js_1.RotaCloud.config.retry]
+                : rotacloud_js_1.RotaCloud.config.retry;
+            (0, axios_retry_1.default)(this.client, {
+                retries: retryConfig.maxRetries,
+                retryDelay: (retryCount) => {
+                    if (retryConfig.exponential) {
+                        return axios_retry_1.default.exponentialDelay(retryCount);
+                    }
+                    return retryConfig.delay;
+                },
+            });
+        }
+        return this.client.request(finalReqConfig);
+    }
+    /** Iterates through every page for a potentially paginated request */
+    fetchPages(reqConfig, options) {
+        return __asyncGenerator(this, arguments, function* fetchPages_1() {
+            const fallbackLimit = 20;
+            const res = yield __await(this.fetch(reqConfig, options));
+            yield yield __await(res);
+            const limit = Number(res.headers['x-limit']) || fallbackLimit;
+            const entityCount = Number(res.headers['x-total-count']) || 0;
+            const requestOffset = Number(res.headers['x-offset']) || 0;
+            for (let offset = requestOffset + limit; offset < entityCount; offset += limit) {
+                yield yield __await(this.fetch(reqConfig, Object.assign(Object.assign({}, options), { offset })));
+            }
+        });
+    }
+    listResponses(reqConfig, options) {
+        return __asyncGenerator(this, arguments, function* listResponses_1() {
+            var _a, e_1, _b, _c;
+            try {
+                for (var _d = true, _e = __asyncValues(this.fetchPages(reqConfig, options)), _f; _f = yield __await(_e.next()), _a = _f.done, !_a; _d = true) {
+                    _c = _f.value;
+                    _d = false;
+                    const res = _c;
+                    yield __await(yield* __asyncDelegator(__asyncValues(res.data)));
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = _e.return)) yield __await(_b.call(_e));
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        });
+    }
+    iterator(reqConfig, options) {
+        return {
+            [Symbol.asyncIterator]: () => this.listResponses(reqConfig, options),
+            byPage: () => this.fetchPages(reqConfig, options),
+        };
+    }
+}
+exports.Service = Service;

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

@@ -0,0 +1,14 @@
+import { AxiosResponse } from 'axios';
+import { Settings } from '../models/settings.model.js';
+import { Service, Options } from './index.js';
+import { ApiSettings } from '../interfaces/index.js';
+import { SettingsQueryParams } from '../rotacloud.js';
+declare class SettingsService extends Service {
+    private apiPath;
+    get(query: SettingsQueryParams): Promise<Settings>;
+    get(query: SettingsQueryParams, options: {
+        rawResponse: true;
+    } & Options): Promise<AxiosResponse<ApiSettings, any>>;
+    get(query: SettingsQueryParams, options: Options): Promise<Settings>;
+}
+export { SettingsService };

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SettingsService = void 0;
+const settings_model_js_1 = require("../models/settings.model.js");
+const index_js_1 = require("./index.js");
+class SettingsService extends index_js_1.Service {
+    constructor() {
+        super(...arguments);
+        this.apiPath = '/settings';
+    }
+    get(query, options) {
+        return super
+            .fetch({ url: `${this.apiPath}`, params: query }, options)
+            .then((res) => Promise.resolve((options === null || options === void 0 ? void 0 : options.rawResponse) ? res : new settings_model_js_1.Settings(res.data)));
+    }
+}
+exports.SettingsService = SettingsService;

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

@@ -0,0 +1,82 @@
+import { AxiosResponse } from 'axios';
+import { ApiShift } from '../interfaces/index.js';
+import { Service, Options, RequirementsOf } from './index.js';
+import { Shift } from '../models/shift.model.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 {
+    private apiPath;
+    create(data: RequirementsOf<ApiShift, RequiredProps>): Promise<Shift>;
+    create(data: RequirementsOf<ApiShift, RequiredProps>, options: {
+        rawResponse: true;
+    } & Options): Promise<AxiosResponse<ApiShift, any>>;
+    create(data: RequirementsOf<ApiShift, RequiredProps>, options: Options): Promise<Shift>;
+    get(id: number): Promise<Shift>;
+    get(id: number, options: {
+        rawResponse: true;
+    } & Options): Promise<AxiosResponse<ApiShift, 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<ApiShift[], any>, any, unknown>;
+    update(shift: RequirementsOf<ApiShift, 'id'>): Promise<Shift>;
+    update(shift: RequirementsOf<ApiShift, 'id'>, options: {
+        rawResponse: true;
+    } & Options): Promise<AxiosResponse<ApiShift>>;
+    update(shift: RequirementsOf<ApiShift, 'id'>, options: Options): Promise<Shift>;
+    update(shifts: RequirementsOf<ApiShift, 'id'>[]): Promise<{
+        success: Shift[];
+        failed: {
+            id: number;
+            error: string;
+        }[];
+    }>;
+    update(shift: RequirementsOf<ApiShift, 'id'>, options: Options): Promise<Shift>;
+    update(shifts: RequirementsOf<ApiShift, 'id'>[], options: {
+        rawResponse: true;
+    } & Options): Promise<AxiosResponse<{
+        code: number;
+        data?: ApiShift;
+        error?: string;
+    }[]>>;
+    update(shifts: RequirementsOf<ApiShift, 'id'>[], options: Options): Promise<{
+        success: Shift[];
+        failed: {
+            id: number;
+            error: string;
+        }[];
+    }>;
+    delete(ids: number | number[]): Promise<number>;
+    delete(ids: number | number[], options: {
+        rawResponse: true;
+    } & Options): Promise<AxiosResponse<any, any>>;
+    delete(ids: number | number[], options: Options): Promise<number>;
+    acknowledge(data: number[]): Promise<number>;
+    acknowledge(data: number[], options: {
+        rawResponse: true;
+    } & Options): Promise<AxiosResponse<any, any>>;
+    acknowledge(data: number[], options: Options): Promise<number>;
+    publish(data: {
+        shifts: number[];
+    }): Promise<number>;
+    publish(data: {
+        shifts: number[];
+    }, options: {
+        rawResponse: true;
+    } & Options): Promise<AxiosResponse<any, any>>;
+    publish(data: {
+        shifts: number[];
+    }, options: Options): Promise<number>;
+    unpublish(data: {
+        shifts: number[];
+    }): Promise<number>;
+    unpublish(data: {
+        shifts: number[];
+    }, options: {
+        rawResponse: true;
+    } & Options): Promise<AxiosResponse<any, any>>;
+    unpublish(data: {
+        shifts: number[];
+    }, options: Options): Promise<number>;
+}
+export {};

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

@@ -0,0 +1,150 @@
+"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;
+    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.ShiftsService = void 0;
+const index_js_1 = require("./index.js");
+const shift_model_js_1 = require("../models/shift.model.js");
+class ShiftsService extends index_js_1.Service {
+    constructor() {
+        super(...arguments);
+        this.apiPath = '/shifts';
+    }
+    create(data, options) {
+        return super
+            .fetch({ url: this.apiPath, data, method: 'POST' })
+            .then((res) => Promise.resolve((options === null || options === void 0 ? void 0 : options.rawResponse) ? res : new shift_model_js_1.Shift(res.data)));
+    }
+    get(id, options) {
+        return super
+            .fetch({ url: `${this.apiPath}/${id}` }, options)
+            .then((res) => Promise.resolve((options === null || options === void 0 ? void 0 : options.rawResponse) ? res : new shift_model_js_1.Shift(res.data)));
+    }
+    list(query, options) {
+        const _super = Object.create(null, {
+            iterator: { get: () => super.iterator }
+        });
+        return __asyncGenerator(this, arguments, function* list_1() {
+            var _a, e_1, _b, _c;
+            try {
+                for (var _d = true, _e = __asyncValues(_super.iterator.call(this, { url: this.apiPath, params: query }, options)), _f; _f = yield __await(_e.next()), _a = _f.done, !_a; _d = true) {
+                    _c = _f.value;
+                    _d = false;
+                    const res = _c;
+                    yield yield __await(new shift_model_js_1.Shift(res));
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = _e.return)) yield __await(_b.call(_e));
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        });
+    }
+    listAll(query, options) {
+        var _a, e_2, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            const shifts = [];
+            try {
+                for (var _d = true, _e = __asyncValues(this.list(query, options)), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+                    _c = _f.value;
+                    _d = false;
+                    const shift = _c;
+                    shifts.push(shift);
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            return shifts;
+        });
+    }
+    listByPage(query, options) {
+        return super.iterator({ url: this.apiPath, params: query }, options).byPage();
+    }
+    update(shifts, options) {
+        if (!Array.isArray(shifts)) {
+            return super
+                .fetch({
+                url: `${this.apiPath}/${shifts.id}`,
+                data: shifts,
+                method: 'POST',
+            })
+                .then((res) => ((options === null || options === void 0 ? void 0 : options.rawResponse) ? res : new shift_model_js_1.Shift(res.data)));
+        }
+        return super
+            .fetch({
+            url: this.apiPath,
+            data: shifts,
+            method: 'POST',
+        })
+            .then((res) => {
+            if (options === null || options === void 0 ? void 0 : options.rawResponse)
+                return res;
+            const success = [];
+            const failed = [];
+            for (let shiftIdx = 0; shiftIdx < res.data.length; shiftIdx += 1) {
+                const { data, error } = res.data[shiftIdx];
+                if (data)
+                    success.push(new shift_model_js_1.Shift(data));
+                if (error)
+                    failed.push({ id: shifts[shiftIdx].id, error });
+            }
+            return { success, failed };
+        });
+    }
+    delete(ids, options) {
+        const params = Array.isArray(ids)
+            ? { url: this.apiPath, data: { ids }, method: 'DELETE' }
+            : { url: `${this.apiPath}/${ids}`, method: 'DELETE' };
+        return super.fetch(params).then((res) => Promise.resolve((options === null || options === void 0 ? void 0 : options.rawResponse) ? res : res.status));
+    }
+    acknowledge(data, options) {
+        return super
+            .fetch({ url: '/shifts_acknowledged', data, method: 'POST' })
+            .then((res) => Promise.resolve((options === null || options === void 0 ? void 0 : options.rawResponse) ? res : res.status));
+    }
+    publish(data, options) {
+        return super
+            .fetch({ url: '/shifts_published', data, method: 'POST' })
+            .then((res) => Promise.resolve((options === null || options === void 0 ? void 0 : options.rawResponse) ? res : res.status));
+    }
+    unpublish(data, options) {
+        return super
+            .fetch({ url: '/shifts_published', data, method: 'DELETE' })
+            .then((res) => Promise.resolve((options === null || options === void 0 ? void 0 : options.rawResponse) ? res : res.status));
+    }
+}
+exports.ShiftsService = ShiftsService;

package/dist/cjs/services/terminals-active.service.d.ts

@@ -0,0 +1,35 @@
+import { AxiosResponse } from 'axios';
+import { ApiTerminal, ApiTerminalLocation } from '../interfaces/index.js';
+import { Service, Options } from './index.js';
+import { Terminal } from '../models/terminal.model.js';
+interface LaunchTerminal {
+    terminal: number;
+    device: string;
+    location?: ApiTerminalLocation;
+}
+interface PingTerminal {
+    action: string;
+    device: string;
+}
+declare class TerminalsActiveService extends Service {
+    private apiPath;
+    launchTerminal(data: LaunchTerminal): Promise<Terminal>;
+    launchTerminal(data: LaunchTerminal, options: {
+        rawResponse: true;
+    } & Options): Promise<AxiosResponse<any, any>>;
+    launchTerminal(data: LaunchTerminal, options: Options): Promise<Terminal>;
+    pingTerminal(id: number, data: PingTerminal): Promise<number>;
+    pingTerminal(id: number, data: PingTerminal, options: {
+        rawResponse: true;
+    } & Options): Promise<AxiosResponse<any, any>>;
+    pingTerminal(id: number, data: PingTerminal, options: Options): Promise<number>;
+    list(options?: Options): AsyncGenerator<Terminal, void, unknown>;
+    listAll(options?: Options): Promise<Terminal[]>;
+    listByPage(options?: Options): AsyncGenerator<AxiosResponse<ApiTerminal[], any>, any, unknown>;
+    closeTerminal(id: number): Promise<number>;
+    closeTerminal(id: number, options: {
+        rawResponse: true;
+    } & Options): Promise<AxiosResponse<any, any>>;
+    closeTerminal(id: number, options: Options): Promise<number>;
+}
+export { TerminalsActiveService };