rotacloud 1.0.2 → 1.0.5

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

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

package/dist/services/leave.service.js

@@ -0,0 +1,42 @@
+import { Service } from './index.js';
+import { Leave } from '../models/leave.model.js';
+import { ErrorResponse } from '../models/error-response.model.js';
+import { LeaveType } from '../models/leave-type.model.js';
+class LeaveService extends Service {
+    constructor() {
+        super();
+        this.apiPath = '/leave';
+    }
+    create(data, options) {
+        return super.fetch({ url: `${this.apiPath}`, data, method: 'POST' }).then((res) => Promise.resolve(options?.rawResponse ? res : [...res.data.map((leave) => new Leave(leave))]), (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err)));
+    }
+    get(id, options) {
+        return super.fetch({ url: `${this.apiPath}/${id}` }, options).then((res) => Promise.resolve(options?.rawResponse ? res : new Leave(res.data)), (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err)));
+    }
+    async *list(options) {
+        for await (const res of super.iterator({ url: this.apiPath }, options)) {
+            yield new Leave(res);
+        }
+    }
+    async *listLeaveTypes(options) {
+        for await (const res of super.iterator({ url: this.apiPath }, options)) {
+            yield new LeaveType(res);
+        }
+    }
+    listByPage(options) {
+        return super.iterator({ url: this.apiPath }, options).byPage();
+    }
+    update(id, data, options) {
+        return super
+            .fetch({
+            url: `${this.apiPath}/${id}`,
+            data,
+            method: 'POST',
+        })
+            .then((res) => Promise.resolve(options?.rawResponse ? res : new Leave(res.data)), (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err)));
+    }
+    delete(id, options) {
+        return super.fetch({ url: `${this.apiPath}/${id}`, method: 'DELETE' }).then((res) => Promise.resolve(options?.rawResponse ? res : res.status), (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err)));
+    }
+}
+export { LeaveService };

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

@@ -0,0 +1,38 @@
+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';
+import { InternalQueryParams } from '../interfaces/query-params/internal-query-params.inteface.js';
+declare type RequiredProps = 'name';
+declare class LocationsService extends Service {
+    private apiPath;
+    constructor();
+    create(data: RequirementsOf<ApiLocation, RequiredProps>): Promise<Location>;
+    create(data: RequirementsOf<ApiLocation, RequiredProps>, options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<ApiLocation, any>>;
+    create(data: RequirementsOf<ApiLocation, RequiredProps>, options: Options<InternalQueryParams>): Promise<ApiLocation>;
+    get(id: number): Promise<Location>;
+    get(id: number, options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<ApiLocation, any>>;
+    get(id: number, options: Options<InternalQueryParams>): Promise<ApiLocation>;
+    list(options?: Options<LocationsQueryParams & InternalQueryParams>): AsyncGenerator<Location, void, unknown>;
+    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: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<ApiLocation, any>>;
+    update(id: number, data: Partial<ApiLocation>, options: Options<InternalQueryParams>): Promise<ApiLocation>;
+    delete(id: number): Promise<number>;
+    delete(id: number, options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<any, any>>;
+    delete(id: number, options: Options<InternalQueryParams>): Promise<number>;
+}
+export { LocationsService };

package/dist/services/locations.service.js

@@ -0,0 +1,36 @@
+import { Service } from './index.js';
+import { Location } from '../models/location.model.js';
+import { ErrorResponse } from '../models/error-response.model.js';
+class LocationsService extends Service {
+    constructor() {
+        super();
+        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)), (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err)));
+    }
+    get(id, options) {
+        return super.fetch({ url: `${this.apiPath}/${id}` }, options).then((res) => Promise.resolve(options?.rawResponse ? res : new Location(res.data)), (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err)));
+    }
+    async *list(options) {
+        for await (const res of super.iterator({ url: this.apiPath }, options)) {
+            yield new Location(res);
+        }
+    }
+    listByPage(options) {
+        return super.iterator({ url: this.apiPath }, 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)), (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err)));
+    }
+    delete(id, options) {
+        return super.fetch({ url: `${this.apiPath}/${id}`, method: 'DELETE' }).then((res) => Promise.resolve(options?.rawResponse ? res : res.status), (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err)));
+    }
+}
+export { LocationsService };

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

@@ -0,0 +1,38 @@
+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';
+import { InternalQueryParams } from '../interfaces/query-params/internal-query-params.inteface.js';
+declare type RequiredProps = 'name';
+declare class RolesService extends Service {
+    private apiPath;
+    constructor();
+    create(data: RequirementsOf<ApiRole, RequiredProps>): Promise<Role>;
+    create(data: RequirementsOf<ApiRole, RequiredProps>, options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<ApiRole, any>>;
+    create(data: RequirementsOf<ApiRole, RequiredProps>, options: Options<InternalQueryParams>): Promise<Role>;
+    get(id: number): Promise<Role>;
+    get(id: number, options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<ApiRole, any>>;
+    get(id: number, options: Options<InternalQueryParams>): Promise<Role>;
+    list(options?: Options<RolesQueryParams & InternalQueryParams>): AsyncGenerator<Role, void, unknown>;
+    listByPage(options?: Options<RolesQueryParams & InternalQueryParams>): AsyncGenerator<AxiosResponse<ApiRole[], any>, any, unknown>;
+    update(id: number, data: Partial<ApiRole>): Promise<Role>;
+    update(id: number, data: Partial<ApiRole>, options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<ApiRole, any>>;
+    update(id: number, data: Partial<ApiRole>, options: Options<InternalQueryParams>): Promise<Role>;
+    delete(id: number): Promise<number>;
+    delete(id: number, options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<any, any>>;
+    delete(id: number, options: Options<InternalQueryParams>): Promise<number>;
+}
+export { RolesService };

package/dist/services/roles.service.js

@@ -0,0 +1,36 @@
+import { Service } from './index.js';
+import { Role } from '../models/role.model.js';
+import { ErrorResponse } from '../models/error-response.model.js';
+class RolesService extends Service {
+    constructor() {
+        super();
+        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)), (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err)));
+    }
+    get(id, options) {
+        return super.fetch({ url: `${this.apiPath}/${id}` }, options).then((res) => Promise.resolve(options?.rawResponse ? res : new Role(res.data)), (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err)));
+    }
+    async *list(options) {
+        for await (const res of super.iterator({ url: this.apiPath }, options)) {
+            yield new Role(res);
+        }
+    }
+    listByPage(options) {
+        return super.iterator({ url: this.apiPath }, 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)), (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err)));
+    }
+    delete(id, options) {
+        return super.fetch({ url: `${this.apiPath}/${id}`, method: 'DELETE' }).then((res) => Promise.resolve(options?.rawResponse ? res : res.status), (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err)));
+    }
+}
+export { RolesService };

package/dist/services/service.d.ts

@@ -0,0 +1,20 @@
+import { AxiosRequestConfig, AxiosResponse } from 'axios';
+export declare type RequirementsOf<T, K extends keyof T> = Required<Pick<T, K>> & Partial<T>;
+export interface Options<T> {
+    rawResponse?: boolean;
+    params?: T;
+}
+export declare abstract class Service<ApiResponse = any> {
+    isLeaveRequest(endpoint?: string): boolean;
+    private buildQueryStr;
+    private getPagingObject;
+    fetch<T = ApiResponse>(httpOptions: AxiosRequestConfig, options?: any): Promise<AxiosResponse<T>>;
+    private listFetch;
+    private listResponses;
+    iterator<T = ApiResponse>(reqObject: any, options?: any): {
+        [Symbol.asyncIterator](): {
+            next(): Promise<IteratorResult<T, void>>;
+        };
+        byPage: () => AsyncGenerator<AxiosResponse<T[], any>, any, unknown>;
+    };
+}

package/dist/services/service.js

@@ -0,0 +1,94 @@
+import axios from 'axios';
+import { RotaCloud } from '../rotacloud.js';
+export class Service {
+    // rate limit tracking could be implemented here statically
+    isLeaveRequest(endpoint) {
+        return endpoint === '/leave_requests';
+    }
+    buildQueryStr(queryParams) {
+        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).toString();
+    }
+    getPagingObject(res) {
+        const links = res.headers.link.split(',');
+        const keyVal = {};
+        links.forEach((link) => {
+            const exp = link.split(';');
+            const key = exp[1].replace(' rel="', '').replace('"', '').trim();
+            const value = exp[0].replace('<', '').replace('>', '').trim();
+            keyVal[key] = value;
+        });
+        return keyVal;
+    }
+    async fetch(httpOptions, options) {
+        const headers = {
+            Authorization: `Bearer ${RotaCloud.config.apiKey}`,
+            // 'SDK-Version': Version.version,
+        };
+        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(httpOptions.url) ? (headers.User = `${httpOptions.data.user}`) : undefined;
+        }
+        const reqObject = {
+            ...httpOptions,
+            baseURL: RotaCloud.config.baseUri,
+            headers,
+            params: options?.params,
+            paramsSerializer: (params) => {
+                return params ? this.buildQueryStr(params) : '';
+            },
+        };
+        const response = await axios.request(reqObject);
+        return response;
+    }
+    async *listFetch(reqObject, options) {
+        let running = true;
+        do {
+            const res = await this.fetch(reqObject, options);
+            if (res.headers.link) {
+                const pagingObject = this.getPagingObject(res);
+                if (pagingObject.last) {
+                    reqObject.url = pagingObject.next;
+                }
+                else {
+                    running = false;
+                }
+            }
+            else {
+                running = false;
+            }
+            yield await res;
+        } while (running);
+    }
+    async *listResponses(reqObject, options) {
+        for await (const res of this.listFetch(reqObject, options)) {
+            yield* res.data;
+        }
+    }
+    iterator(reqObject, options) {
+        const iterator = this.listResponses(reqObject, options);
+        return {
+            [Symbol.asyncIterator]() {
+                return {
+                    next() {
+                        return iterator.next();
+                    },
+                };
+            },
+            byPage: () => {
+                return this.listFetch(reqObject, options);
+            },
+        };
+    }
+}

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

@@ -0,0 +1,56 @@
+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';
+import { InternalQueryParams } from '../interfaces/query-params/internal-query-params.inteface.js';
+declare type RequiredProps = 'end_time' | 'start_time' | 'location';
+declare class ShiftsService extends Service {
+    private apiPath;
+    constructor();
+    create(data: RequirementsOf<ApiShift, RequiredProps>): Promise<Shift>;
+    create(data: RequirementsOf<ApiShift, RequiredProps>, options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<ApiShift, any>>;
+    create(data: RequirementsOf<ApiShift, RequiredProps>, options: Options<InternalQueryParams>): Promise<Shift>;
+    get(id: number): Promise<Shift>;
+    get(id: number, options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<ApiShift, any>>;
+    get(id: number, options: Options<InternalQueryParams>): Promise<Shift>;
+    list(options?: Options<ShiftsQueryParams & InternalQueryParams>): AsyncGenerator<Shift, void, unknown>;
+    listByPage(options?: Options<ShiftsQueryParams & InternalQueryParams>): AsyncGenerator<AxiosResponse<ApiShift[], any>, any, unknown>;
+    update(id: number, data: Partial<ApiShift>): Promise<Shift>;
+    update(id: number, data: Partial<ApiShift>, options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<ApiShift, any>>;
+    update(id: number, data: Partial<ApiShift>, options: Options<InternalQueryParams>): Promise<Shift>;
+    delete(id: number): Promise<number>;
+    delete(id: number, options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<any, any>>;
+    delete(id: number, options: Options<InternalQueryParams>): Promise<number>;
+    acknowledge(data: number[]): Promise<number>;
+    acknowledge(data: number[], options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<any, any>>;
+    acknowledge(data: number[], options: Options<InternalQueryParams>): Promise<number>;
+    publish(data: number[]): Promise<number>;
+    publish(data: number[], options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<any, any>>;
+    publish(data: number[], options: Options<InternalQueryParams>): Promise<number>;
+    unpublish(data: number[]): Promise<number>;
+    unpublish(data: number[], options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<any, any>>;
+    unpublish(data: number[], options: Options<InternalQueryParams>): Promise<number>;
+}
+export { ShiftsService };

package/dist/services/shifts.service.js

@@ -0,0 +1,45 @@
+import { Service } from './index.js';
+import { Shift } from '../models/shift.model.js';
+import { ErrorResponse } from '../models/error-response.model.js';
+class ShiftsService extends Service {
+    constructor() {
+        super();
+        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)), (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err)));
+    }
+    get(id, options) {
+        return super.fetch({ url: `${this.apiPath}/${id}` }, options).then((res) => Promise.resolve(options?.rawResponse ? res : new Shift(res.data)), (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err)));
+    }
+    async *list(options) {
+        for await (const res of super.iterator({ url: this.apiPath }, options)) {
+            yield new Shift(res);
+        }
+    }
+    listByPage(options) {
+        return super.iterator({ url: this.apiPath }, options).byPage();
+    }
+    update(id, data, options) {
+        return super
+            .fetch({
+            url: `${this.apiPath}/${id}`,
+            data,
+            method: 'POST',
+        })
+            .then((res) => Promise.resolve(options?.rawResponse ? res : new Shift(res.data)), (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err)));
+    }
+    delete(id, options) {
+        return super.fetch({ url: `${this.apiPath}/${id}`, method: 'DELETE' }).then((res) => Promise.resolve(options?.rawResponse ? res : res.status), (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err)));
+    }
+    acknowledge(data, options) {
+        return super.fetch({ url: '/shifts_acknowledged', data, method: 'POST' }).then((res) => Promise.resolve(options?.rawResponse ? res : res.status), (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err)));
+    }
+    publish(data, options) {
+        return super.fetch({ url: '/shifts_published', data, method: 'POST' }).then((res) => Promise.resolve(options?.rawResponse ? res : res.status), (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err)));
+    }
+    unpublish(data, options) {
+        return super.fetch({ url: '/shifts_published', data, method: 'DELETE' }).then((res) => Promise.resolve(options?.rawResponse ? res : res.status), (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err)));
+    }
+}
+export { ShiftsService };

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

@@ -0,0 +1,38 @@
+import { AxiosResponse } from 'axios';
+import { ApiUser } from '../interfaces/index.js';
+import { Service, Options, RequirementsOf } from './index.js';
+import { User } from '../models/user.model.js';
+import { UsersQueryParams } from '../interfaces/query-params/users-query-params.interface.js';
+import { InternalQueryParams } from '../interfaces/query-params/internal-query-params.inteface.js';
+declare type RequiredProps = 'first_name' | 'last_name';
+declare class UsersService extends Service {
+    private apiPath;
+    constructor();
+    create(data: RequirementsOf<ApiUser, RequiredProps>): Promise<User>;
+    create(data: RequirementsOf<ApiUser, RequiredProps>, options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<ApiUser, any>>;
+    create(data: RequirementsOf<ApiUser, RequiredProps>, options: Options<InternalQueryParams>): Promise<User>;
+    get(id: number): Promise<User>;
+    get(id: number, options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<ApiUser, any>>;
+    get(id: number, options: Options<InternalQueryParams>): Promise<User>;
+    list(options?: Options<UsersQueryParams & InternalQueryParams>): AsyncGenerator<User, void, unknown>;
+    listByPage(options?: Options<UsersQueryParams & InternalQueryParams>): AsyncGenerator<AxiosResponse<ApiUser[], any>, any, unknown>;
+    update(id: number, data: Partial<ApiUser>): Promise<User>;
+    update(id: number, data: Partial<ApiUser>, options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<ApiUser, any>>;
+    update(id: number, data: Partial<ApiUser>, options: Options<InternalQueryParams>): Promise<User>;
+    delete(id: number): Promise<number>;
+    delete(id: number, options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<any, any>>;
+    delete(id: number, options: Options<InternalQueryParams>): Promise<number>;
+}
+export { UsersService };

package/dist/services/users.service.js

@@ -0,0 +1,36 @@
+import { Service } from './index.js';
+import { User } from '../models/user.model.js';
+import { ErrorResponse } from '../models/error-response.model.js';
+class UsersService extends Service {
+    constructor() {
+        super();
+        this.apiPath = '/users';
+    }
+    create(data, options) {
+        return super.fetch({ url: this.apiPath, data, method: 'POST' }).then((res) => Promise.resolve(options?.rawResponse ? res : new User(res.data)), (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err)));
+    }
+    get(id, options) {
+        return super.fetch({ url: `${this.apiPath}/${id}` }, options).then((res) => Promise.resolve(options?.rawResponse ? res : new User(res.data)), (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err)));
+    }
+    async *list(options) {
+        for await (const res of super.iterator({ url: this.apiPath }, options)) {
+            yield new User(res);
+        }
+    }
+    listByPage(options) {
+        return super.iterator({ url: this.apiPath }, options).byPage();
+    }
+    update(id, data, options) {
+        return super
+            .fetch({
+            url: `${this.apiPath}/${id}`,
+            data,
+            method: 'POST',
+        })
+            .then((res) => Promise.resolve(options?.rawResponse ? res : new User(res.data)), (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err)));
+    }
+    delete(id, options) {
+        return super.fetch({ url: `${this.apiPath}/${id}`, method: 'DELETE' }).then((res) => Promise.resolve(options?.rawResponse ? res : res.status), (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err)));
+    }
+}
+export { UsersService };

package/dist/version.d.ts

@@ -0,0 +1,3 @@
+export declare const Version: {
+    version: string;
+};

package/dist/version.js

@@ -0,0 +1 @@
+export const Version = { version: "1.0.5" };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rotacloud",
-  "version": "1.0.2",
+  "version": "1.0.5",
   "description": "The RotaCloud SDK for the RotaCloud API",
   "engines": {
     "node": ">=14.17.0"

package/src/rotacloud.ts

@@ -12,7 +12,7 @@ import {
 import { SDKConfig } from './interfaces/index.js';
 import { DaysOffService } from './services/days-off.service.js';
 
-export class Rotacloud {
+export class RotaCloud {
   public static config: SDKConfig;
 
   public defaultAPIURI = 'https://api.rotacloud.com/v1';
@@ -35,10 +35,10 @@ export class Rotacloud {
   }
 
   get config() {
-    return Rotacloud.config;
+    return RotaCloud.config;
   }
 
   set config(configVal: SDKConfig) {
-    Rotacloud.config = configVal;
+    RotaCloud.config = configVal;
   }
 }

package/src/services/service.ts

@@ -1,5 +1,5 @@
 import axios, { AxiosRequestConfig, AxiosRequestHeaders, AxiosResponse } from 'axios';
-import { Rotacloud } from '../rotacloud.js';
+import { RotaCloud } from '../rotacloud.js';
 import { Version } from '../version.js';
 
 export type RequirementsOf<T, K extends keyof T> = Required<Pick<T, K>> & Partial<T>;
@@ -53,11 +53,11 @@ export abstract class Service<ApiResponse = any> {
 
   public async fetch<T = ApiResponse>(httpOptions: AxiosRequestConfig, options?): Promise<AxiosResponse<T>> {
     const headers: AxiosRequestHeaders = {
-      Authorization: `Bearer ${Rotacloud.config.apiKey}`,
-      'SDK-Version': Version.version,
+      Authorization: `Bearer ${RotaCloud.config.apiKey}`,
+      // 'SDK-Version': Version.version,
     };
-    if (Rotacloud.config.accountId) {
-      headers.Account = String(Rotacloud.config.accountId);
+    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(httpOptions.url) ? (headers.User = `${httpOptions.data.user}`) : undefined;
@@ -65,7 +65,7 @@ export abstract class Service<ApiResponse = any> {
 
     const reqObject: AxiosRequestConfig<T> = {
       ...httpOptions,
-      baseURL: Rotacloud.config.baseUri,
+      baseURL: RotaCloud.config.baseUri,
       headers,
       params: options?.params,
       paramsSerializer: (params) => {

package/src/version.ts

@@ -1 +1 @@
-export const Version = { version: "1.0.1" }
+export const Version = { version: "1.0.5" }