rotacloud 1.0.55 → 1.0.57

package/dist/mjs/services/service.js

@@ -0,0 +1,140 @@
+import axios from 'axios';
+import axiosRetry from 'axios-retry';
+import { RotaCloud } from '../rotacloud.js';
+import { Version } from '../version.js';
+import { SDKError } from '../models/SDKError.model.js';
+export var RetryStrategy;
+(function (RetryStrategy) {
+    RetryStrategy["Exponential"] = "expo";
+    RetryStrategy["Static"] = "static";
+})(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,
+    },
+};
+export class Service {
+    constructor() {
+        this.client = this.initialiseAxios();
+    }
+    initialiseAxios() {
+        const client = axios.create();
+        client.interceptors.response.use((response) => response, (error) => {
+            const parsedError = this.parseClientError(error);
+            return Promise.reject(parsedError);
+        });
+        return client;
+    }
+    parseClientError(error) {
+        if (!axios.isAxiosError(error))
+            return error;
+        const axiosErrorLocation = error.response || error.request;
+        const apiErrorMessage = axiosErrorLocation.data?.error;
+        const sdkErrorParams = {
+            code: axiosErrorLocation.status,
+            message: apiErrorMessage || error.message,
+            data: axiosErrorLocation.data,
+        };
+        return new SDKError(sdkErrorParams);
+    }
+    isLeaveRequest(endpoint) {
+        return endpoint === '/leave_requests';
+    }
+    buildQueryParams(options, extraParams) {
+        const queryParams = {
+            expand: options?.expand,
+            fields: options?.fields,
+            limit: options?.limit,
+            offset: options?.offset,
+            dry_run: options?.dryRun,
+            ...extraParams,
+            // NOTE: Should not overridable so must come after spread of params
+            exclude_link_header: true,
+        };
+        const reducedParams = Object.entries(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.config.apiKey
+                ? `Bearer ${RotaCloud.config.apiKey}`
+                : `Basic ${RotaCloud.config.basicAuth}`,
+            'SDK-Version': Version.version,
+        };
+        const extraHeaders = 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.config.accountId) {
+            headers.Account = String(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 = {
+            ...reqConfig,
+            baseURL: RotaCloud.config.baseUri,
+            headers,
+            params: this.buildQueryParams(options, reqConfig.params),
+        };
+        if (RotaCloud.config.retry) {
+            const retryConfig = typeof RotaCloud.config.retry === 'string'
+                ? DEFAULT_RETRY_STRATEGY_OPTIONS[RotaCloud.config.retry]
+                : RotaCloud.config.retry;
+            axiosRetry(this.client, {
+                retries: retryConfig.maxRetries,
+                retryDelay: (retryCount) => {
+                    if (retryConfig.exponential) {
+                        return axiosRetry.exponentialDelay(retryCount);
+                    }
+                    return retryConfig.delay;
+                },
+            });
+        }
+        return this.client.request(finalReqConfig);
+    }
+    /** Iterates through every page for a potentially paginated request */
+    async *fetchPages(reqConfig, options) {
+        const fallbackLimit = 20;
+        const res = await this.fetch(reqConfig, options);
+        yield 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 this.fetch(reqConfig, { ...options, offset });
+        }
+    }
+    async *listResponses(reqConfig, options) {
+        for await (const res of this.fetchPages(reqConfig, options)) {
+            yield* res.data;
+        }
+    }
+    iterator(reqConfig, options) {
+        return {
+            [Symbol.asyncIterator]: () => this.listResponses(reqConfig, options),
+            byPage: () => this.fetchPages(reqConfig, options),
+        };
+    }
+}

package/dist/mjs/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/mjs/services/settings.service.js

@@ -0,0 +1,14 @@
+import { Settings } from '../models/settings.model.js';
+import { Service } from './index.js';
+class SettingsService extends Service {
+    constructor() {
+        super(...arguments);
+        this.apiPath = '/settings';
+    }
+    get(query, options) {
+        return super
+            .fetch({ url: `${this.apiPath}`, params: query }, options)
+            .then((res) => Promise.resolve(options?.rawResponse ? res : new Settings(res.data)));
+    }
+}
+export { SettingsService };

package/dist/mjs/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/mjs/services/shifts.service.js

@@ -0,0 +1,85 @@
+import { Service } from './index.js';
+import { Shift } from '../models/shift.model.js';
+export class ShiftsService extends Service {
+    constructor() {
+        super(...arguments);
+        this.apiPath = '/shifts';
+    }
+    create(data, options) {
+        return super
+            .fetch({ url: this.apiPath, data, method: 'POST' })
+            .then((res) => Promise.resolve(options?.rawResponse ? res : new Shift(res.data)));
+    }
+    get(id, options) {
+        return super
+            .fetch({ url: `${this.apiPath}/${id}` }, options)
+            .then((res) => Promise.resolve(options?.rawResponse ? res : new Shift(res.data)));
+    }
+    async *list(query, options) {
+        for await (const res of super.iterator({ url: this.apiPath, params: query }, options)) {
+            yield new Shift(res);
+        }
+    }
+    async listAll(query, options) {
+        const shifts = [];
+        for await (const shift of this.list(query, options)) {
+            shifts.push(shift);
+        }
+        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?.rawResponse ? res : new Shift(res.data)));
+        }
+        return super
+            .fetch({
+            url: this.apiPath,
+            data: shifts,
+            method: 'POST',
+        })
+            .then((res) => {
+            if (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(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?.rawResponse ? res : res.status));
+    }
+    acknowledge(data, options) {
+        return super
+            .fetch({ url: '/shifts_acknowledged', data, method: 'POST' })
+            .then((res) => Promise.resolve(options?.rawResponse ? res : res.status));
+    }
+    publish(data, options) {
+        return super
+            .fetch({ url: '/shifts_published', data, method: 'POST' })
+            .then((res) => Promise.resolve(options?.rawResponse ? res : res.status));
+    }
+    unpublish(data, options) {
+        return super
+            .fetch({ url: '/shifts_published', data, method: 'DELETE' })
+            .then((res) => Promise.resolve(options?.rawResponse ? res : res.status));
+    }
+}

package/dist/mjs/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 };

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

@@ -0,0 +1,43 @@
+import { Service } from './index.js';
+import { Terminal } from '../models/terminal.model.js';
+class TerminalsActiveService extends Service {
+    constructor() {
+        super(...arguments);
+        this.apiPath = '/terminals_active';
+    }
+    launchTerminal(data, options) {
+        return super
+            .fetch({
+            url: `${this.apiPath}`,
+            data,
+            method: 'POST',
+        })
+            .then((res) => Promise.resolve(options?.rawResponse ? res : new Terminal(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));
+    }
+    async *list(options) {
+        for await (const res of super.iterator({ url: this.apiPath }, options)) {
+            yield new Terminal(res);
+        }
+    }
+    async listAll(options) {
+        const users = [];
+        for await (const user of this.list(options)) {
+            users.push(user);
+        }
+        return users;
+    }
+    listByPage(options) {
+        return super.iterator({ url: this.apiPath }, options).byPage();
+    }
+    closeTerminal(id, options) {
+        return super
+            .fetch({ url: `${this.apiPath}/${id}`, method: 'DELETE' })
+            .then((res) => Promise.resolve(options?.rawResponse ? res : res.status));
+    }
+}
+export { TerminalsActiveService };

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

@@ -0,0 +1,32 @@
+import { AxiosResponse } from 'axios';
+import { ApiTerminal } from '../interfaces/index.js';
+import { Service, Options, RequirementsOf } from './index.js';
+import { Terminal } from '../models/terminal.model.js';
+type RequiredProps = 'name' | 'timezone';
+declare class TerminalsService extends Service {
+    private apiPath;
+    create(data: RequirementsOf<ApiTerminal, RequiredProps>): Promise<Terminal>;
+    create(data: RequirementsOf<ApiTerminal, RequiredProps>, options: {
+        rawResponse: true;
+    } & Options): Promise<AxiosResponse<ApiTerminal, any>>;
+    create(data: RequirementsOf<ApiTerminal, RequiredProps>, options: Options): Promise<Terminal>;
+    get(id: number): Promise<Terminal>;
+    get(id: number, options: {
+        rawResponse: true;
+    } & Options): Promise<AxiosResponse<ApiTerminal, any>>;
+    get(id: number, options: Options): Promise<Terminal>;
+    update(id: number, data: Partial<ApiTerminal>): Promise<Terminal>;
+    update(id: number, data: Partial<ApiTerminal>, options: {
+        rawResponse: true;
+    } & Options): Promise<AxiosResponse<ApiTerminal, any>>;
+    update(id: number, data: Partial<ApiTerminal>, options: Options): Promise<Terminal>;
+    closeTerminal(id: number): Promise<number>;
+    closeTerminal(id: number, options: {
+        rawResponse: true;
+    } & Options): Promise<AxiosResponse<number, any>>;
+    closeTerminal(id: number, 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>;
+}
+export { TerminalsService };

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

@@ -0,0 +1,48 @@
+import { Service } from './index.js';
+import { Terminal } from '../models/terminal.model.js';
+class TerminalsService extends Service {
+    constructor() {
+        super(...arguments);
+        this.apiPath = '/terminals';
+    }
+    create(data, options) {
+        return super
+            .fetch({ url: this.apiPath, data, method: 'POST' })
+            .then((res) => Promise.resolve(options?.rawResponse ? res : new Terminal(res.data)));
+    }
+    get(id, options) {
+        return super
+            .fetch({ url: `${this.apiPath}/${id}` }, options)
+            .then((res) => Promise.resolve(options?.rawResponse ? res : new Terminal(res.data)));
+    }
+    update(id, data, options) {
+        return super
+            .fetch({
+            url: `${this.apiPath}/${id}`,
+            data,
+            method: 'POST',
+        })
+            .then((res) => Promise.resolve(options?.rawResponse ? res : new Terminal(res.data)));
+    }
+    closeTerminal(id, options) {
+        return super
+            .fetch({ url: `${this.apiPath}/${id}`, method: 'DELETE' })
+            .then((res) => Promise.resolve(options?.rawResponse ? res : res.status));
+    }
+    async *list(options) {
+        for await (const res of super.iterator({ url: this.apiPath }, options)) {
+            yield new Terminal(res);
+        }
+    }
+    async listAll(options) {
+        const users = [];
+        for await (const user of this.list(options)) {
+            users.push(user);
+        }
+        return users;
+    }
+    listByPage(options) {
+        return super.iterator({ url: this.apiPath }, options).byPage();
+    }
+}
+export { TerminalsService };

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

@@ -0,0 +1,28 @@
+import { AxiosResponse } from 'axios';
+import { Options, RequirementsOf, Service } from './service';
+import { ToilAccrualsQueryParams } from '../interfaces/query-params/toil-accruals-query-params.interface';
+import { ToilAccrual } from '../models/toil-accrual.model';
+import { ApiToilAccrual } from '../interfaces/toil-accrual.interface';
+type RequiredProps = 'duration_hours' | 'leave_year' | 'user_id';
+export declare class ToilAccrualsService extends Service {
+    private apiPath;
+    create(data: RequirementsOf<ApiToilAccrual, RequiredProps>): Promise<ToilAccrual>;
+    create(data: RequirementsOf<ApiToilAccrual, RequiredProps>, options: {
+        rawResponse: true;
+    } & Options): Promise<AxiosResponse<ApiToilAccrual, any>>;
+    create(data: RequirementsOf<ApiToilAccrual, RequiredProps>, options: Options): Promise<ToilAccrual>;
+    get(id: number): Promise<ToilAccrual>;
+    get(id: number, options: {
+        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<ApiToilAccrual[], any>, any, unknown>;
+    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/mjs/services/toil-accruals.service.js

@@ -0,0 +1,38 @@
+import { Service } from './service';
+import { ToilAccrual } from '../models/toil-accrual.model';
+export class ToilAccrualsService extends Service {
+    constructor() {
+        super(...arguments);
+        this.apiPath = '/toil_accruals';
+    }
+    create(data, options) {
+        return super
+            .fetch({ url: this.apiPath, data, method: 'POST' })
+            .then((res) => Promise.resolve(options?.rawResponse ? res : new ToilAccrual(res.data)));
+    }
+    get(id, options) {
+        return super
+            .fetch({ url: `${this.apiPath}/${id}` }, options)
+            .then((res) => Promise.resolve(options?.rawResponse ? res : new ToilAccrual(res.data)));
+    }
+    async *list(query, options) {
+        for await (const res of super.iterator({ url: this.apiPath, params: query }, options)) {
+            yield new ToilAccrual(res);
+        }
+    }
+    async listAll(query, options) {
+        const toilAccruals = [];
+        for await (const accrual of this.list(query, options)) {
+            toilAccruals.push(accrual);
+        }
+        return toilAccruals;
+    }
+    listByPage(query, options) {
+        return super.iterator({ url: this.apiPath, params: query }, options).byPage();
+    }
+    delete(id, options) {
+        return super
+            .fetch({ url: `${this.apiPath}/${id}`, method: 'DELETE' })
+            .then((res) => Promise.resolve(options?.rawResponse ? res : res.status));
+    }
+}

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

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

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

@@ -0,0 +1,23 @@
+import { Service } from './service';
+import { ToilAllowance } from '../models/toil-allowance.model';
+export class ToilAllowanceService extends Service {
+    constructor() {
+        super(...arguments);
+        this.apiPath = '/toil_allowance';
+    }
+    async *list(year, query, options) {
+        for await (const res of super.iterator({ url: `${this.apiPath}/${year}`, params: query }, options)) {
+            yield new ToilAllowance(res);
+        }
+    }
+    async listAll(year, query, options) {
+        const toilAllowances = [];
+        for await (const allowance of this.list(year, query, options)) {
+            toilAllowances.push(allowance);
+        }
+        return toilAllowances;
+    }
+    listByPage(year, query, options) {
+        return super.iterator({ url: `${this.apiPath}/${year}`, params: query }, options).byPage();
+    }
+}

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

@@ -0,0 +1,62 @@
+import { AxiosResponse } from 'axios';
+import { ApiUserBreak, ApiUserClockedIn, ApiUserClockedOut, ApiTerminalLocation } from '../interfaces/index.js';
+import { Service, Options, RequirementsOf } from './index.js';
+import { UserClockedIn, UserClockedOut } from '../models/index.js';
+interface UserClockIn {
+    method: string;
+    shift: number;
+    terminal: number;
+    user: number;
+    photo?: string;
+    location: ApiTerminalLocation;
+}
+interface UserClockOut extends Omit<UserClockIn, 'user' | 'shift'> {
+}
+interface UserBreak {
+    method: string;
+    action: string;
+    terminal: number;
+    photo?: string;
+    location: ApiTerminalLocation;
+}
+declare class UserBreak {
+    start_time: number;
+    start_location: ApiTerminalLocation;
+    end_time: number | null;
+    end_location: ApiTerminalLocation | null;
+    constructor(apiUserBreak: ApiUserBreak);
+}
+type RequiredPropsClockIn = 'method';
+type RequiredPropsBreak = 'method' | 'action';
+declare class UsersClockInService extends Service {
+    private apiPath;
+    getClockedInUser(id: number): Promise<UserClockedIn>;
+    getClockedInUser(id: number, options: {
+        rawResponse: true;
+    } & Options): Promise<AxiosResponse<ApiUserClockedIn, any>>;
+    getClockedInUser(id: number, options: Options): Promise<UserClockedIn>;
+    list(options?: Options): AsyncGenerator<UserClockedIn, void, unknown>;
+    listAll(options?: Options): Promise<UserClockedIn[]>;
+    listByPage(options?: Options): AsyncGenerator<AxiosResponse<ApiUserClockedIn[], any>, any, unknown>;
+    clockIn(data: RequirementsOf<UserClockIn, RequiredPropsClockIn>): Promise<UserClockedIn>;
+    clockIn(data: RequirementsOf<UserClockIn, RequiredPropsClockIn>, options: {
+        rawResponse: true;
+    } & Options): Promise<AxiosResponse<ApiUserClockedIn, any>>;
+    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<ApiUserClockedOut, any>>;
+    clockOut(id: number, data: UserClockOut, options: Options): Promise<UserClockedOut>;
+    startBreak(id: number, data: RequirementsOf<UserBreak, RequiredPropsBreak>): Promise<UserBreak>;
+    startBreak(id: number, data: RequirementsOf<UserBreak, RequiredPropsBreak>, options: {
+        rawResponse: true;
+    } & Options): Promise<AxiosResponse<ApiUserBreak, any>>;
+    startBreak(id: number, data: RequirementsOf<UserBreak, RequiredPropsBreak>, options: Options): Promise<UserBreak>;
+    endBreak(id: number, data: RequirementsOf<UserBreak, RequiredPropsBreak>): Promise<UserBreak>;
+    endBreak(id: number, data: RequirementsOf<UserBreak, RequiredPropsBreak>, options: {
+        rawResponse: true;
+    } & Options): Promise<AxiosResponse<ApiUserBreak, any>>;
+    endBreak(id: number, data: RequirementsOf<UserBreak, RequiredPropsBreak>, options: Options): Promise<UserBreak>;
+}
+export { UsersClockInService };