rotacloud 1.0.55 → 1.0.56

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

@@ -0,0 +1,33 @@
+import { AxiosResponse } from 'axios';
+import { ApiLeaveEmbargo } from '../interfaces/index.js';
+import { Service, Options, RequirementsOf } from './index.js';
+import { LeaveEmbargo } from '../models/leave-embargo.model.js';
+import { LeaveEmbargoesQueryParams } from '../rotacloud.js';
+type RequiredProps = 'start_date' | 'end_date' | 'users';
+export declare class LeaveEmbargoesService extends Service {
+    private apiPath;
+    create(data: RequirementsOf<ApiLeaveEmbargo, RequiredProps>): Promise<LeaveEmbargo>;
+    create(data: RequirementsOf<ApiLeaveEmbargo, RequiredProps>, options: {
+        rawResponse: true;
+    } & Options): Promise<AxiosResponse<ApiLeaveEmbargo, any>>;
+    create(data: RequirementsOf<ApiLeaveEmbargo, RequiredProps>, options: Options): Promise<LeaveEmbargo>;
+    get(id: number): Promise<LeaveEmbargo>;
+    get(id: number, options: {
+        rawResponse: true;
+    }): Promise<AxiosResponse<ApiLeaveEmbargo, any>>;
+    get(id: number, options: Options): Promise<LeaveEmbargo>;
+    list(query: LeaveEmbargoesQueryParams, options?: Options): AsyncGenerator<LeaveEmbargo, void, unknown>;
+    listAll(query: LeaveEmbargoesQueryParams, options?: Options): Promise<LeaveEmbargo[]>;
+    listByPage(query: LeaveEmbargoesQueryParams, options?: Options): AsyncGenerator<AxiosResponse<ApiLeaveEmbargo[], any>, any, unknown>;
+    update(id: number, data: Partial<ApiLeaveEmbargo>): Promise<LeaveEmbargo>;
+    update(id: number, data: Partial<ApiLeaveEmbargo>, options: {
+        rawResponse: true;
+    } & Options): Promise<AxiosResponse<ApiLeaveEmbargo, any>>;
+    update(id: number, data: Partial<ApiLeaveEmbargo>, options: Options): Promise<LeaveEmbargo>;
+    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/leave-embargoes.service.js

@@ -0,0 +1,47 @@
+import { Service } from './index.js';
+import { LeaveEmbargo } from '../models/leave-embargo.model.js';
+export class LeaveEmbargoesService extends Service {
+    constructor() {
+        super(...arguments);
+        this.apiPath = '/leave_embargoes';
+    }
+    create(data, options) {
+        return super
+            .fetch({ url: this.apiPath, data, method: 'POST' })
+            .then((res) => Promise.resolve(options?.rawResponse ? res : new LeaveEmbargo(res.data)));
+    }
+    get(id, options) {
+        return super
+            .fetch({ url: `${this.apiPath}/${id}` }, options)
+            .then((res) => Promise.resolve(options?.rawResponse ? res : new LeaveEmbargo(res.data)));
+    }
+    async *list(query, options) {
+        for await (const res of super.iterator({ url: this.apiPath, params: query }, options)) {
+            yield new LeaveEmbargo(res);
+        }
+    }
+    async listAll(query, options) {
+        const leave = [];
+        for await (const leaveEmbargoRecord of this.list(query, options)) {
+            leave.push(leaveEmbargoRecord);
+        }
+        return leave;
+    }
+    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?.rawResponse ? res : new LeaveEmbargo(res.data)));
+    }
+    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/leave-request.service.d.ts

@@ -0,0 +1,33 @@
+import { AxiosResponse } from 'axios';
+import { ApiLeaveRequest } from '../interfaces/index.js';
+import { Service, Options, RequirementsOf } from './index.js';
+import { LeaveRequestsQueryParams } from '../interfaces/query-params/leave-requests-query-params.interface.js';
+import { LeaveRequest } from '../models/leave-request.model.js';
+type RequiredProps = 'start_date' | 'end_date' | 'type' | 'user';
+export declare class LeaveRequestService extends Service {
+    private apiPath;
+    create(data: RequirementsOf<ApiLeaveRequest, RequiredProps>): Promise<LeaveRequest>;
+    create(data: RequirementsOf<ApiLeaveRequest, RequiredProps>, options: {
+        rawResponse: true;
+    } & Options): Promise<AxiosResponse<ApiLeaveRequest, any>>;
+    create(data: RequirementsOf<ApiLeaveRequest, RequiredProps>, options: Options): Promise<LeaveRequest>;
+    get(id: number): Promise<LeaveRequest>;
+    get(id: number, options: {
+        rawResponse: true;
+    }): Promise<AxiosResponse<ApiLeaveRequest, any>>;
+    get(id: number, options: Options): Promise<LeaveRequest>;
+    list(query?: LeaveRequestsQueryParams, options?: Options): AsyncGenerator<LeaveRequest, void, unknown>;
+    listAll(query?: LeaveRequestsQueryParams, options?: Options): Promise<LeaveRequest[]>;
+    listByPage(query?: LeaveRequestsQueryParams, options?: Options): AsyncGenerator<AxiosResponse<ApiLeaveRequest[], any>, any, unknown>;
+    update(id: number, data: Partial<ApiLeaveRequest>): Promise<LeaveRequest>;
+    update(id: number, data: Partial<ApiLeaveRequest>, options: {
+        rawResponse: true;
+    } & Options): Promise<AxiosResponse<ApiLeaveRequest, any>>;
+    update(id: number, data: Partial<ApiLeaveRequest>, options: Options): Promise<LeaveRequest>;
+    delete(id: number): Promise<number>;
+    delete(id: number, options: {
+        rawResponse: true;
+    } & Options): Promise<AxiosResponse<ApiLeaveRequest, any>>;
+    delete(id: number, options: Options): Promise<number>;
+}
+export {};

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

@@ -0,0 +1,51 @@
+import { Service } from './index.js';
+import { LeaveRequest } from '../models/leave-request.model.js';
+export class LeaveRequestService extends Service {
+    constructor() {
+        super(...arguments);
+        this.apiPath = '/leave_requests';
+    }
+    create(data, options) {
+        return super
+            .fetch({
+            url: this.apiPath,
+            data,
+            method: 'POST',
+        }, options)
+            .then((res) => Promise.resolve(options?.rawResponse ? res : new LeaveRequest(res.data)));
+    }
+    get(id, options) {
+        return super
+            .fetch({ url: `${this.apiPath}/${id}` }, options)
+            .then((res) => Promise.resolve(options?.rawResponse ? res : new LeaveRequest(res.data)));
+    }
+    async *list(query, options) {
+        for await (const res of super.iterator({ url: this.apiPath, params: query }, options)) {
+            yield new LeaveRequest(res);
+        }
+    }
+    async listAll(query, options) {
+        const leave = [];
+        for await (const leaveRequestRecord of this.list(query, options)) {
+            leave.push(leaveRequestRecord);
+        }
+        return leave;
+    }
+    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?.rawResponse ? res : new LeaveRequest(res.data)));
+    }
+    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/leave-types.service.d.ts

@@ -0,0 +1,12 @@
+import { AxiosResponse } from 'axios';
+import { ApiLeaveType } from '../interfaces/index.js';
+import { Service, Options } from './index.js';
+import { LeaveType } from '../models/index.js';
+export declare class LeaveTypesService extends Service {
+    private apiPath;
+    get(): Promise<LeaveType[]>;
+    get(options: {
+        rawResponse: true;
+    }): Promise<AxiosResponse<ApiLeaveType[]>>;
+    get(options: Options): Promise<LeaveType[]>;
+}

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

@@ -0,0 +1,13 @@
+import { Service } from './index.js';
+import { LeaveType } from '../models/index.js';
+export class LeaveTypesService extends Service {
+    constructor() {
+        super(...arguments);
+        this.apiPath = '/leave_types';
+    }
+    get(options) {
+        return super
+            .fetch({ url: this.apiPath }, options)
+            .then((res) => Promise.resolve(options?.rawResponse ? res : res.data.map((leaveType) => new LeaveType(leaveType))));
+    }
+}

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

@@ -0,0 +1,35 @@
+import { AxiosResponse } from 'axios';
+import { ApiLeave } from '../interfaces/index.js';
+import { Service, Options, RequirementsOf } from './index.js';
+import { Leave } from '../models/leave.model.js';
+import { LeaveQueryParams } from '../interfaces/query-params/leave-query-params.interface.js';
+import { LeaveType } from '../models/leave-type.model.js';
+type RequiredProps = 'users' | 'type' | 'start_date' | 'end_date';
+export declare class LeaveService extends Service {
+    private apiPath;
+    create(data: RequirementsOf<ApiLeave, RequiredProps>): Promise<Leave[]>;
+    create(data: RequirementsOf<ApiLeave, RequiredProps>, options: {
+        rawResponse: true;
+    } & Options): Promise<AxiosResponse<ApiLeave[], any>>;
+    create(data: RequirementsOf<ApiLeave, RequiredProps>, options: Options): Promise<Leave[]>;
+    get(id: number): Promise<Leave>;
+    get(id: number, options: {
+        rawResponse: true;
+    }): Promise<AxiosResponse<ApiLeave, any>>;
+    get(id: number, options: Options): Promise<Leave>;
+    list(query: LeaveQueryParams, options?: Options): AsyncGenerator<Leave, void, unknown>;
+    listAll(query: LeaveQueryParams, options?: Options): Promise<Leave[]>;
+    listLeaveTypes(query: LeaveQueryParams, options?: Options): AsyncGenerator<LeaveType, void, unknown>;
+    listByPage(query: LeaveQueryParams, options?: Options): AsyncGenerator<AxiosResponse<ApiLeave[], any>, any, unknown>;
+    update(id: number, data: Partial<ApiLeave>): Promise<Leave>;
+    update(id: number, data: Partial<ApiLeave>, options: {
+        rawResponse: true;
+    } & Options): Promise<AxiosResponse<ApiLeave, any>>;
+    update(id: number, data: Partial<ApiLeave>, options: Options): Promise<Leave>;
+    delete(id: number): Promise<number>;
+    delete(id: number, options: {
+        rawResponse: true;
+    } & Options): Promise<AxiosResponse<ApiLeave, any>>;
+    delete(id: number, options: Options): Promise<number>;
+}
+export {};

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

@@ -0,0 +1,53 @@
+import { Service } from './index.js';
+import { Leave } from '../models/leave.model.js';
+import { LeaveType } from '../models/leave-type.model.js';
+export class LeaveService extends Service {
+    constructor() {
+        super(...arguments);
+        this.apiPath = '/leave';
+    }
+    create(data, options) {
+        return super
+            .fetch({ url: this.apiPath, data, method: 'POST' }, options)
+            .then((res) => Promise.resolve(options?.rawResponse ? res : [...res.data.map((leave) => new Leave(leave))]));
+    }
+    get(id, options) {
+        return super
+            .fetch({ url: `${this.apiPath}/${id}` }, options)
+            .then((res) => Promise.resolve(options?.rawResponse ? res : new Leave(res.data)));
+    }
+    async *list(query, options) {
+        for await (const res of super.iterator({ url: this.apiPath, params: query }, options)) {
+            yield new Leave(res);
+        }
+    }
+    async listAll(query, options) {
+        const leave = [];
+        for await (const leaveRecord of this.list(query, options)) {
+            leave.push(leaveRecord);
+        }
+        return leave;
+    }
+    async *listLeaveTypes(query, options) {
+        for await (const res of super.iterator({ url: this.apiPath, params: query }, options)) {
+            yield new LeaveType(res);
+        }
+    }
+    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',
+        }, options)
+            .then((res) => Promise.resolve(options?.rawResponse ? res : new Leave(res.data)));
+    }
+    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/locations.service.d.ts

@@ -0,0 +1,33 @@
+import { AxiosResponse } from 'axios';
+import { ApiLocation } from '../interfaces/index.js';
+import { Service, Options, RequirementsOf } from './index.js';
+import { Location } from '../models/location.model.js';
+import { LocationsQueryParams } from '../interfaces/query-params/locations-query-params.interface.js';
+type RequiredProps = 'name';
+export declare class LocationsService extends Service {
+    private apiPath;
+    create(data: RequirementsOf<ApiLocation, RequiredProps>): Promise<Location>;
+    create(data: RequirementsOf<ApiLocation, RequiredProps>, options: {
+        rawResponse: true;
+    } & Options): Promise<AxiosResponse<ApiLocation, any>>;
+    create(data: RequirementsOf<ApiLocation, RequiredProps>, options: Options): Promise<Location>;
+    get(id: number): Promise<Location>;
+    get(id: number, options: {
+        rawResponse: true;
+    } & Options): Promise<AxiosResponse<ApiLocation, any>>;
+    get(id: number, options: Options): Promise<Location>;
+    list(query?: LocationsQueryParams, options?: Options): AsyncGenerator<Location, void, unknown>;
+    listAll(query?: LocationsQueryParams, options?: Options): Promise<Location[]>;
+    listByPage(query?: LocationsQueryParams, options?: Options): AsyncGenerator<AxiosResponse<ApiLocation[], any>, any, unknown>;
+    update(id: number, data: Partial<ApiLocation>): Promise<Location>;
+    update(id: number, data: Partial<ApiLocation>, options: {
+        rawResponse: true;
+    } & Options): Promise<AxiosResponse<ApiLocation, any>>;
+    update(id: number, data: Partial<ApiLocation>, options: Options): Promise<Location>;
+    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/locations.service.js

@@ -0,0 +1,47 @@
+import { Service } from './index.js';
+import { Location } from '../models/location.model.js';
+export class LocationsService extends Service {
+    constructor() {
+        super(...arguments);
+        this.apiPath = '/locations';
+    }
+    create(data, options) {
+        return super
+            .fetch({ url: `${this.apiPath}`, data, method: 'POST' })
+            .then((res) => Promise.resolve(options?.rawResponse ? res : new Location(res.data)));
+    }
+    get(id, options) {
+        return super
+            .fetch({ url: `${this.apiPath}/${id}` }, options)
+            .then((res) => Promise.resolve(options?.rawResponse ? res : new Location(res.data)));
+    }
+    async *list(query, options) {
+        for await (const res of super.iterator({ url: this.apiPath, params: query }, options)) {
+            yield new Location(res);
+        }
+    }
+    async listAll(query, options) {
+        const locations = [];
+        for await (const location of this.list(query, options)) {
+            locations.push(location);
+        }
+        return locations;
+    }
+    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?.rawResponse ? res : new Location(res.data)));
+    }
+    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/pins.service.d.ts

@@ -0,0 +1,11 @@
+import { AxiosResponse } from 'axios';
+import { ApiPin } from '../interfaces/index.js';
+import { Service, Options } from './index.js';
+export declare class PinsService extends Service {
+    private apiPath;
+    get(id: string): Promise<ApiPin>;
+    get(id: string, options?: {
+        rawResponse: true;
+    } & Options): Promise<AxiosResponse<ApiPin, any>>;
+    get(id: string, options?: Options): Promise<ApiPin>;
+}

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

@@ -0,0 +1,12 @@
+import { Service } from './index.js';
+export class PinsService extends Service {
+    constructor() {
+        super(...arguments);
+        this.apiPath = '/pins';
+    }
+    get(id, options) {
+        return super
+            .fetch({ url: `${this.apiPath}/${id}` }, options)
+            .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+    }
+}

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

@@ -0,0 +1,47 @@
+import { Service } from './index.js';
+import { Role } from '../models/role.model.js';
+export class RolesService extends Service {
+    constructor() {
+        super(...arguments);
+        this.apiPath = '/roles';
+    }
+    create(data, options) {
+        return super
+            .fetch({ url: this.apiPath, data, method: 'POST' })
+            .then((res) => Promise.resolve(options?.rawResponse ? res : new Role(res.data)));
+    }
+    get(id, options) {
+        return super
+            .fetch({ url: `${this.apiPath}/${id}` }, options)
+            .then((res) => Promise.resolve(options?.rawResponse ? res : new Role(res.data)));
+    }
+    async *list(query, options) {
+        for await (const res of super.iterator({ url: this.apiPath, params: query }, options)) {
+            yield new Role(res);
+        }
+    }
+    async listAll(query, options) {
+        const roles = [];
+        for await (const role of this.list(query, options)) {
+            roles.push(role);
+        }
+        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?.rawResponse ? res : new Role(res.data)));
+    }
+    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/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/mjs/services/service.js

@@ -0,0 +1,138 @@
+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: `Bearer ${RotaCloud.config.apiKey}`,
+            '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),
+        };
+    }
+}