rotacloud 1.0.8 → 1.0.9

package/dist/mjs/models/shift.model.d.ts

@@ -0,0 +1,24 @@
+import { ApiShift } from '../interfaces/index.js';
+export declare class Shift {
+    id: number;
+    deleted: boolean;
+    published: boolean;
+    open: boolean;
+    start_time: number;
+    end_time: number;
+    minutes_break: number;
+    user: number;
+    location: number;
+    role: number | null;
+    notes: string | null;
+    created_by: number;
+    created_at: number;
+    updated_at: number | null;
+    claimed: boolean;
+    claimed_at: number | null;
+    acknowledged: boolean;
+    acknowledged_at: number | null;
+    swap_requests: number[];
+    unavailability_requests: number[];
+    constructor(shift: ApiShift);
+}

package/dist/mjs/models/terminal.model.d.ts

@@ -0,0 +1,19 @@
+export declare class LatLngObject {
+    lat: number;
+    lng: number;
+    radius: number;
+}
+export declare class Terminal {
+    id: number;
+    deleted: boolean;
+    name: string;
+    active: boolean;
+    type: string;
+    device: string;
+    version: string;
+    ip: string;
+    location: LatLngObject;
+    timezone: number;
+    require_photo: boolean;
+    require_photo_breaks: boolean;
+}

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

@@ -0,0 +1,33 @@
+import { ApiUser } from '../interfaces/user.interface.js';
+export interface LeaveRates {
+    [leave_type_id: string]: number;
+}
+export interface RolePayCodes {
+    [role_id: string]: string;
+}
+export interface RoleRates {
+    [role_id: string]: {
+        per_hour: number;
+        per_shift: number;
+    };
+}
+export interface Preferences {
+    setup_steps_hidden: boolean;
+}
+export interface TeamProperties {
+    admin?: boolean;
+    features?: string[];
+    permissions?: string[];
+    product_updates_access_key?: string;
+    product_updates_access_secret?: string;
+    intercom?: any;
+    [other_properties: string]: any;
+}
+export declare class User {
+    id: number;
+    first_name: string;
+    last_name: string;
+    photo: string | null;
+    preferred_name: string | null;
+    constructor(user: ApiUser);
+}

package/dist/mjs/package.json

@@ -0,0 +1,3 @@
+{
+    "type": "module"
+}

package/dist/mjs/rotacloud.d.ts

@@ -0,0 +1,20 @@
+import { AccountsService, AttendanceService, DaysOffService, GroupsService, LeaveEmbargoesService, LeaveRequestService, LeaveService, LocationsService, RolesService, ShiftsService, UsersService } from './services/index.js';
+import { SDKConfig } from './interfaces/index.js';
+export declare class RotaCloud {
+    static config: SDKConfig;
+    defaultAPIURI: string;
+    accounts: AccountsService;
+    attendance: AttendanceService;
+    daysOff: DaysOffService;
+    group: GroupsService;
+    leaveEmbargoes: LeaveEmbargoesService;
+    leaveRequests: LeaveRequestService;
+    leave: LeaveService;
+    locations: LocationsService;
+    roles: RolesService;
+    shifts: ShiftsService;
+    users: UsersService;
+    constructor(config: SDKConfig);
+    get config(): SDKConfig;
+    set config(configVal: SDKConfig);
+}

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

@@ -0,0 +1,10 @@
+import { Account } from '../models/account.model.js';
+import { Service, Options } from './index.js';
+import { ApiAccount } from '../interfaces/index.js';
+import { InternalQueryParams } from '../interfaces/query-params/internal-query-params.inteface.js';
+declare class AccountsService extends Service {
+    private apiPath;
+    list(options?: Options<InternalQueryParams>): AsyncGenerator<Account, void, unknown>;
+    listByPage(options?: Options<InternalQueryParams>): AsyncGenerator<import("axios").AxiosResponse<ApiAccount[], any>, any, unknown>;
+}
+export { AccountsService };

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

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

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

@@ -0,0 +1,24 @@
+import { AxiosResponse } from 'axios';
+import { ApiDaysOff } from '../interfaces/index.js';
+import { Service, Options } from './index.js';
+import { InternalQueryParams } from '../interfaces/query-params/internal-query-params.inteface.js';
+import { DaysOff } from '../models/days-off.model.js';
+import { DaysOffQueryParams } from '../interfaces/query-params/days-off-query-params.interface.js';
+declare class DaysOffService extends Service<ApiDaysOff> {
+    private apiPath;
+    create(dates: string[], users: number[]): Promise<number>;
+    create(dates: string[], users: number[], options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<ApiDaysOff, any>>;
+    create(dates: string[], users: number[], options: Options<InternalQueryParams>): Promise<number>;
+    list(options?: Options<DaysOffQueryParams & InternalQueryParams>): AsyncGenerator<DaysOff, void, unknown>;
+    listByPage(options?: Options<DaysOffQueryParams & InternalQueryParams>): AsyncGenerator<AxiosResponse<ApiDaysOff[], any>, any, unknown>;
+    delete(dates: string[], users: number[]): Promise<number>;
+    delete(dates: string[], users: number[], options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<any, any>>;
+    delete(dates: string[], users: number[], options: Options<InternalQueryParams>): Promise<number>;
+}
+export { DaysOffService };

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

@@ -0,0 +1,37 @@
+import { AxiosResponse } from 'axios';
+import { ApiGroup } from '../interfaces/index.js';
+import { Service, Options, RequirementsOf } from './index.js';
+import { InternalQueryParams } from '../interfaces/query-params/internal-query-params.inteface.js';
+import { Group } from '../models/group.model.js';
+import { GroupsQueryParams } from '../interfaces/query-params/groups-query-params.interface.js';
+declare type RequiredProps = 'name';
+declare class GroupsService extends Service {
+    private apiPath;
+    create(data: RequirementsOf<ApiGroup, RequiredProps>): Promise<Group>;
+    create(data: RequirementsOf<ApiGroup, RequiredProps>, options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<ApiGroup, any>>;
+    create(data: RequirementsOf<ApiGroup, RequiredProps>, options: Options<InternalQueryParams>): Promise<Group>;
+    get(id: number): Promise<Group>;
+    get(id: number, options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<ApiGroup, any>>;
+    get(id: number, options: Options<InternalQueryParams>): Promise<Group>;
+    list(options?: Options<GroupsQueryParams & InternalQueryParams>): AsyncGenerator<Group, void, unknown>;
+    listByPage(options?: Options<GroupsQueryParams & InternalQueryParams>): AsyncGenerator<AxiosResponse<ApiGroup[], any>, any, unknown>;
+    update(id: number, data: Partial<ApiGroup>): Promise<Group>;
+    update(id: number, data: Partial<ApiGroup>, options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<ApiGroup, any>>;
+    update(id: number, data: Partial<ApiGroup>, options: Options<InternalQueryParams>): Promise<Group>;
+    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 { GroupsService };

package/dist/mjs/services/index.js

@@ -0,0 +1,12 @@
+export * from './service.js';
+export * from './accounts.service.js';
+export * from './attendance.service.js';
+export * from './days-off.service.js';
+export * from './groups.service.js';
+export * from './leave-request.service.js';
+export * from './leave-embargoes.service.js';
+export * from './leave.service.js';
+export * from './locations.service.js';
+export * from './roles.service.js';
+export * from './shifts.service.js';
+export * from './users.service.js';

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

@@ -0,0 +1,37 @@
+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 { UsersQueryParams } from '../interfaces/query-params/users-query-params.interface.js';
+import { InternalQueryParams } from '../interfaces/query-params/internal-query-params.inteface.js';
+declare type RequiredProps = 'start_date' | 'end_date' | 'users';
+declare class LeaveEmbargoesService extends Service {
+    private apiPath;
+    create(data: RequirementsOf<ApiLeaveEmbargo, RequiredProps>): Promise<LeaveEmbargo>;
+    create(data: RequirementsOf<ApiLeaveEmbargo, RequiredProps>, options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<ApiLeaveEmbargo, any>>;
+    create(data: RequirementsOf<ApiLeaveEmbargo, RequiredProps>, options: Options<InternalQueryParams>): Promise<LeaveEmbargo>;
+    get(id: number): Promise<LeaveEmbargo>;
+    get(id: number, options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<ApiLeaveEmbargo, any>>;
+    get(id: number, options: Options<InternalQueryParams>): Promise<LeaveEmbargo>;
+    list(options?: Options<UsersQueryParams & InternalQueryParams>): AsyncGenerator<LeaveEmbargo, void, unknown>;
+    listByPage(options?: Options<UsersQueryParams & InternalQueryParams>): AsyncGenerator<AxiosResponse<ApiLeaveEmbargo[], any>, any, unknown>;
+    update(id: number, data: Partial<ApiLeaveEmbargo>): Promise<LeaveEmbargo>;
+    update(id: number, data: Partial<ApiLeaveEmbargo>, options: {
+        rawResponse: true;
+        params?: InternalQueryParams;
+    }): Promise<AxiosResponse<ApiLeaveEmbargo, any>>;
+    update(id: number, data: Partial<ApiLeaveEmbargo>, options: Options<InternalQueryParams>): Promise<LeaveEmbargo>;
+    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 { LeaveEmbargoesService };

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

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

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

@@ -0,0 +1,39 @@
+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;
+    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/mjs/services/locations.service.d.ts

@@ -0,0 +1,37 @@
+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;
+    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/mjs/services/roles.service.d.ts

@@ -0,0 +1,37 @@
+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;
+    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/mjs/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/mjs/services/shifts.service.d.ts

@@ -0,0 +1,55 @@
+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;
+    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/mjs/services/users.service.d.ts

@@ -0,0 +1,37 @@
+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;
+    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/mjs/version.d.ts

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

package/dist/mjs/version.js

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

package/fixup

@@ -0,0 +1,11 @@
+cat >dist/cjs/package.json <<!EOF
+{
+    "type": "commonjs"
+}
+!EOF
+
+cat >dist/mjs/package.json <<!EOF
+{
+    "type": "module"
+}
+!EOF

package/package.json

@@ -1,15 +1,21 @@
 {
   "name": "rotacloud",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "description": "The RotaCloud SDK for the RotaCloud API",
   "engines": {
     "node": ">=14.17.0"
   },
-  "main": "dist/rotacloud.js",
-  "type": "module",
+  "main": "dist/cjs/rotacloud.js",
+  "module": "dist/mjs/rotacloud.js",
+  "exports": {
+    ".": {
+      "require": "./dist/cjs/rotacloud.js",
+      "import": "./dist/mjs/rotacloud.js"
+    }
+  },
   "scripts": {
     "version:output": "echo 'export const Version = { version: \"'$npm_package_version'\" }' > ./src/version.ts",
-    "build": "rm -rf ./dist && tsc",
+    "build": "rm -rf dist/* && tsc -p tsconfig.json && tsc -p tsconfig-cjs.json && ./fixup",
     "watch": "rm -rf ./dist && tsc --watch",
     "lint": "eslint src --ext .ts",
     "test": "echo \"Error: no test specified\" && exit 1"

package/src/version.ts

@@ -1 +1 @@
-export const Version = { version: "1.0.8" }
+export const Version = { version: "1.0.9" }