rotacloud 1.0.58 → 1.1.1

package/src/services/terminals.service.ts

@@ -1,50 +1,48 @@
 import { AxiosResponse } from 'axios';
-import { ApiTerminal } from '../interfaces/index.js';
+import { Terminal } from '../interfaces/index.js';
 import { Service, Options, RequirementsOf } from './index.js';
 
-import { Terminal } from '../models/terminal.model.js';
-
 type RequiredProps = 'name' | 'timezone';
 
-class TerminalsService extends Service {
+export class TerminalsService extends Service {
   private apiPath = '/terminals';
 
-  create(data: RequirementsOf<ApiTerminal, RequiredProps>): Promise<Terminal>;
+  create(data: RequirementsOf<Terminal, 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>;
-  create(data: RequirementsOf<ApiTerminal, RequiredProps>, options?: Options) {
+    data: RequirementsOf<Terminal, RequiredProps>,
+    options: { rawResponse: true } & Options,
+  ): Promise<AxiosResponse<Terminal, any>>;
+  create(data: RequirementsOf<Terminal, RequiredProps>, options: Options): Promise<Terminal>;
+  create(data: RequirementsOf<Terminal, RequiredProps>, options?: Options) {
     return super
-      .fetch<ApiTerminal>({ url: this.apiPath, data, method: 'POST' })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : new Terminal(res.data)));
+      .fetch<Terminal>({ url: this.apiPath, data, method: 'POST' })
+      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
   }
 
   get(id: number): Promise<Terminal>;
-  get(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<ApiTerminal, any>>;
+  get(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<Terminal, any>>;
   get(id: number, options: Options): Promise<Terminal>;
   get(id: number, options?: Options) {
     return super
-      .fetch<ApiTerminal>({ url: `${this.apiPath}/${id}` }, options)
-      .then((res) => Promise.resolve(options?.rawResponse ? res : new Terminal(res.data)));
+      .fetch<Terminal>({ url: `${this.apiPath}/${id}` }, options)
+      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
   }
 
-  update(id: number, data: Partial<ApiTerminal>): Promise<Terminal>;
+  update(id: number, data: Partial<Terminal>): 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>;
-  update(id: number, data: Partial<ApiTerminal>, options?: Options) {
+    data: Partial<Terminal>,
+    options: { rawResponse: true } & Options,
+  ): Promise<AxiosResponse<Terminal, any>>;
+  update(id: number, data: Partial<Terminal>, options: Options): Promise<Terminal>;
+  update(id: number, data: Partial<Terminal>, options?: Options) {
     return super
-      .fetch<ApiTerminal>({
+      .fetch<Terminal>({
         url: `${this.apiPath}/${id}`,
         data,
         method: 'POST',
       })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : new Terminal(res.data)));
+      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
   }
 
   closeTerminal(id: number): Promise<number>;
@@ -57,8 +55,8 @@ class TerminalsService extends Service {
   }
 
   async *list(options?: Options) {
-    for await (const res of super.iterator<ApiTerminal>({ url: this.apiPath }, options)) {
-      yield new Terminal(res);
+    for await (const res of super.iterator<Terminal>({ url: this.apiPath }, options)) {
+      yield res;
     }
   }
 
@@ -72,7 +70,6 @@ class TerminalsService extends Service {
   }
 
   listByPage(options?: Options) {
-    return super.iterator<ApiTerminal>({ url: this.apiPath }, options).byPage();
+    return super.iterator<Terminal>({ url: this.apiPath }, options).byPage();
   }
 }
-export { TerminalsService };

package/src/services/toil-accruals.service.ts

@@ -1,24 +1,23 @@
 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';
+import { ToilAccrual } from '../interfaces/toil-accrual.interface';
 
 type RequiredProps = 'duration_hours' | 'leave_year' | 'user_id';
 
 export class ToilAccrualsService extends Service {
   private apiPath = '/toil_accruals';
 
-  create(data: RequirementsOf<ApiToilAccrual, RequiredProps>): Promise<ToilAccrual>;
+  create(data: RequirementsOf<ToilAccrual, 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>;
-  create(data: RequirementsOf<ApiToilAccrual, RequiredProps>, options?: Options) {
+    data: RequirementsOf<ToilAccrual, RequiredProps>,
+    options: { rawResponse: true } & Options,
+  ): Promise<AxiosResponse<ToilAccrual, any>>;
+  create(data: RequirementsOf<ToilAccrual, RequiredProps>, options: Options): Promise<ToilAccrual>;
+  create(data: RequirementsOf<ToilAccrual, RequiredProps>, options?: Options) {
     return super
       .fetch<ToilAccrual>({ url: this.apiPath, data, method: 'POST' })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : new ToilAccrual(res.data)));
+      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
   }
 
   get(id: number): Promise<ToilAccrual>;
@@ -27,12 +26,12 @@ export class ToilAccrualsService extends Service {
   get(id: number, options?: Options) {
     return super
       .fetch<ToilAccrual>({ url: `${this.apiPath}/${id}` }, options)
-      .then((res) => Promise.resolve(options?.rawResponse ? res : new ToilAccrual(res.data)));
+      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
   }
 
   async *list(query: ToilAccrualsQueryParams, options?: Options) {
-    for await (const res of super.iterator<ApiToilAccrual>({ url: this.apiPath, params: query }, options)) {
-      yield new ToilAccrual(res);
+    for await (const res of super.iterator<ToilAccrual>({ url: this.apiPath, params: query }, options)) {
+      yield res;
     }
   }
 
@@ -45,7 +44,7 @@ export class ToilAccrualsService extends Service {
   }
 
   listByPage(query: ToilAccrualsQueryParams, options?: Options) {
-    return super.iterator<ApiToilAccrual>({ url: this.apiPath, params: query }, options).byPage();
+    return super.iterator<ToilAccrual>({ url: this.apiPath, params: query }, options).byPage();
   }
 
   delete(id: number): Promise<number>;
@@ -53,7 +52,7 @@ export class ToilAccrualsService extends Service {
   delete(id: number, options: Options): Promise<number>;
   delete(id: number, options?: Options) {
     return super
-      .fetch<ApiToilAccrual>({ url: `${this.apiPath}/${id}`, method: 'DELETE' })
+      .fetch<ToilAccrual>({ url: `${this.apiPath}/${id}`, method: 'DELETE' })
       .then((res) => Promise.resolve(options?.rawResponse ? res : res.status));
   }
 }

package/src/services/toil-allowance.service.ts

@@ -1,17 +1,13 @@
 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';
+import { ToilAllowance } from '../interfaces/toil-allowance.interface';
 
 export class ToilAllowanceService extends Service {
   private apiPath = '/toil_allowance';
 
   async *list(year: number, query: ToilAllowanceQueryParams, options?: Options) {
-    for await (const res of super.iterator<ApiToilAllowance>(
-      { url: `${this.apiPath}/${year}`, params: query },
-      options
-    )) {
-      yield new ToilAllowance(res);
+    for await (const res of super.iterator<ToilAllowance>({ url: `${this.apiPath}/${year}`, params: query }, options)) {
+      yield res;
     }
   }
 
@@ -24,6 +20,6 @@ export class ToilAllowanceService extends Service {
   }
 
   listByPage(year: number, query: ToilAllowanceQueryParams, options?: Options) {
-    return super.iterator<ApiToilAllowance[]>({ url: `${this.apiPath}/${year}`, params: query }, options).byPage();
+    return super.iterator<ToilAllowance[]>({ url: `${this.apiPath}/${year}`, params: query }, options).byPage();
   }
 }

package/src/services/users-clock-in.service.ts

@@ -1,59 +1,44 @@
 import { AxiosResponse } from 'axios';
-import { ApiUserBreak, ApiUserClockedIn, ApiUserClockedOut, ApiTerminalLocation } from '../interfaces/index.js';
+import { UserBreak, UserClockedIn, UserClockedOut, TerminalLocation } 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;
+  location: TerminalLocation;
 }
 
 interface UserClockOut extends Omit<UserClockIn, 'user' | 'shift'> {}
 
-interface UserBreak {
+interface UserBreakRequest {
   method: string;
   action: string;
   terminal: number;
   photo?: string;
-  location: ApiTerminalLocation;
-}
-
-class UserBreak {
-  public start_time: number;
-  public start_location: ApiTerminalLocation;
-  public end_time: number | null;
-  public end_location: ApiTerminalLocation | null;
-  constructor(apiUserBreak: ApiUserBreak) {
-    this.start_time = apiUserBreak.start_time;
-    this.start_location = apiUserBreak.start_location;
-    this.end_time = apiUserBreak.end_time ?? null;
-    this.end_location = apiUserBreak.end_location ?? null;
-  }
+  location: TerminalLocation;
 }
 
 type RequiredPropsClockIn = 'method';
 type RequiredPropsBreak = 'method' | 'action';
 
-class UsersClockInService extends Service {
+export class UsersClockInService extends Service {
   private apiPath = '/users_clocked_in';
 
   getClockedInUser(id: number): Promise<UserClockedIn>;
-  getClockedInUser(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<ApiUserClockedIn, any>>;
+  getClockedInUser(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<UserClockedIn, any>>;
   getClockedInUser(id: number, options: Options): Promise<UserClockedIn>;
   getClockedInUser(id: number, options?: Options) {
     return super
-      .fetch<ApiUserClockedIn>({ url: `${this.apiPath}/${id}` }, options)
-      .then((res) => Promise.resolve(options?.rawResponse ? res : new UserClockedIn(res.data)));
+      .fetch<UserClockedIn>({ url: `${this.apiPath}/${id}` }, options)
+      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
   }
 
   async *list(options?: Options) {
-    for await (const res of super.iterator<ApiUserClockedIn>({ url: this.apiPath }, options)) {
-      yield new UserClockedIn(res);
+    for await (const res of super.iterator<UserClockedIn>({ url: this.apiPath }, options)) {
+      yield res;
     }
   }
 
@@ -67,59 +52,65 @@ class UsersClockInService extends Service {
   }
 
   listByPage(options?: Options) {
-    return super.iterator<ApiUserClockedIn>({ url: this.apiPath }, options).byPage();
+    return super.iterator<UserClockedIn>({ url: this.apiPath }, options).byPage();
   }
 
   clockIn(data: RequirementsOf<UserClockIn, RequiredPropsClockIn>): Promise<UserClockedIn>;
   clockIn(
     data: RequirementsOf<UserClockIn, RequiredPropsClockIn>,
-    options: { rawResponse: true } & Options
-  ): Promise<AxiosResponse<ApiUserClockedIn, any>>;
+    options: { rawResponse: true } & Options,
+  ): Promise<AxiosResponse<UserClockedIn, any>>;
   clockIn(data: RequirementsOf<UserClockIn, RequiredPropsClockIn>, options: Options): Promise<UserClockedIn>;
   clockIn(data: RequirementsOf<UserClockIn, RequiredPropsClockIn>, options?: Options) {
     return super
-      .fetch<ApiUserClockedIn>({ url: this.apiPath, data, method: 'POST' })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : new UserClockedIn(res.data)));
+      .fetch<UserClockedIn>({ url: this.apiPath, data, method: 'POST' })
+      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
   }
 
   clockOut(id: number, data: UserClockOut): Promise<UserClockedOut>;
   clockOut(
     id: number,
     data: UserClockOut,
-    options: { rawResponse: true } & Options
-  ): Promise<AxiosResponse<ApiUserClockedOut, any>>;
+    options: { rawResponse: true } & Options,
+  ): Promise<AxiosResponse<UserClockedOut, any>>;
   clockOut(id: number, data: UserClockOut, options: Options): Promise<UserClockedOut>;
   clockOut(id: number, data: UserClockOut, options?: Options) {
     return super
-      .fetch<ApiUserClockedOut>({ url: `${this.apiPath}/${id}`, data, method: 'DELETE' })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : new UserClockedOut(res.data)));
+      .fetch<UserClockedOut>({ url: `${this.apiPath}/${id}`, data, method: 'DELETE' })
+      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
   }
 
-  startBreak(id: number, data: RequirementsOf<UserBreak, RequiredPropsBreak>): Promise<UserBreak>;
+  startBreak(id: number, data: RequirementsOf<UserBreakRequest, 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>;
-  startBreak(id: number, data: RequirementsOf<UserBreak, RequiredPropsBreak>, options?: Options) {
+    data: RequirementsOf<UserBreakRequest, RequiredPropsBreak>,
+    options: { rawResponse: true } & Options,
+  ): Promise<AxiosResponse<UserBreak, any>>;
+  startBreak(
+    id: number,
+    data: RequirementsOf<UserBreakRequest, RequiredPropsBreak>,
+    options: Options,
+  ): Promise<UserBreak>;
+  startBreak(id: number, data: RequirementsOf<UserBreakRequest, RequiredPropsBreak>, options?: Options) {
     return super
-      .fetch<ApiUserBreak>({ url: `${this.apiPath}/${id}`, data, method: 'POST' })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : new UserBreak(res.data)));
+      .fetch<UserBreak>({ url: `${this.apiPath}/${id}`, data, method: 'POST' })
+      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
   }
 
-  endBreak(id: number, data: RequirementsOf<UserBreak, RequiredPropsBreak>): Promise<UserBreak>;
+  endBreak(id: number, data: RequirementsOf<UserBreakRequest, RequiredPropsBreak>): Promise<UserBreak>;
+  endBreak(
+    id: number,
+    data: RequirementsOf<UserBreakRequest, RequiredPropsBreak>,
+    options: { rawResponse: true } & Options,
+  ): Promise<AxiosResponse<UserBreak, any>>;
   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>;
-  endBreak(id: number, data: RequirementsOf<UserBreak, RequiredPropsBreak>, options?: Options) {
+    data: RequirementsOf<UserBreakRequest, RequiredPropsBreak>,
+    options: Options,
+  ): Promise<UserBreak>;
+  endBreak(id: number, data: RequirementsOf<UserBreakRequest, RequiredPropsBreak>, options?: Options) {
     return super
-      .fetch<ApiUserBreak>({ url: `${this.apiPath}/${id}`, data, method: 'POST' })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : new UserBreak(res.data)));
+      .fetch<UserBreak>({ url: `${this.apiPath}/${id}`, data, method: 'POST' })
+      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
   }
 }
-
-export { UsersClockInService };

package/src/services/users.service.ts

@@ -1,40 +1,38 @@
 import { AxiosResponse } from 'axios';
-import { ApiUser } from '../interfaces/index.js';
+import { User } 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';
 
 type RequiredProps = 'first_name' | 'last_name';
 
-class UsersService extends Service {
+export class UsersService extends Service {
   private apiPath = '/users';
 
-  create(data: RequirementsOf<ApiUser, RequiredProps>): Promise<User>;
+  create(data: RequirementsOf<User, RequiredProps>): Promise<User>;
   create(
-    data: RequirementsOf<ApiUser, RequiredProps>,
-    options: { rawResponse: true } & Options
-  ): Promise<AxiosResponse<ApiUser, any>>;
-  create(data: RequirementsOf<ApiUser, RequiredProps>, options: Options): Promise<User>;
-  create(data: RequirementsOf<ApiUser, RequiredProps>, options?: Options) {
+    data: RequirementsOf<User, RequiredProps>,
+    options: { rawResponse: true } & Options,
+  ): Promise<AxiosResponse<User, any>>;
+  create(data: RequirementsOf<User, RequiredProps>, options: Options): Promise<User>;
+  create(data: RequirementsOf<User, RequiredProps>, options?: Options) {
     return super
-      .fetch<ApiUser>({ url: this.apiPath, data, method: 'POST' })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : new User(res.data)));
+      .fetch<User>({ url: this.apiPath, data, method: 'POST' })
+      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
   }
 
   get(id: number): Promise<User>;
-  get(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<ApiUser, any>>;
+  get(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<User, any>>;
   get(id: number, options: Options): Promise<User>;
   get(id: number, options?: Options) {
     return super
-      .fetch<ApiUser>({ url: `${this.apiPath}/${id}` }, options)
-      .then((res) => Promise.resolve(options?.rawResponse ? res : new User(res.data)));
+      .fetch<User>({ url: `${this.apiPath}/${id}` }, options)
+      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
   }
 
   async *list(query: UsersQueryParams, options?: Options) {
-    for await (const res of super.iterator<ApiUser>({ url: this.apiPath, params: query }, options)) {
-      yield new User(res);
+    for await (const res of super.iterator<User>({ url: this.apiPath, params: query }, options)) {
+      yield res;
     }
   }
 
@@ -48,24 +46,20 @@ class UsersService extends Service {
   }
 
   listByPage(query: UsersQueryParams, options?: Options) {
-    return super.iterator<ApiUser>({ url: this.apiPath, params: query }, options).byPage();
+    return super.iterator<User>({ url: this.apiPath, params: query }, options).byPage();
   }
 
-  update(id: number, data: Partial<ApiUser>): Promise<User>;
-  update(
-    id: number,
-    data: Partial<ApiUser>,
-    options: { rawResponse: true } & Options
-  ): Promise<AxiosResponse<ApiUser, any>>;
-  update(id: number, data: Partial<ApiUser>, options: Options): Promise<User>;
-  update(id: number, data: Partial<ApiUser>, options?: Options) {
+  update(id: number, data: Partial<User>): Promise<User>;
+  update(id: number, data: Partial<User>, options: { rawResponse: true } & Options): Promise<AxiosResponse<User, any>>;
+  update(id: number, data: Partial<User>, options: Options): Promise<User>;
+  update(id: number, data: Partial<User>, options?: Options) {
     return super
-      .fetch<ApiUser>({
+      .fetch<User>({
         url: `${this.apiPath}/${id}`,
         data,
         method: 'POST',
       })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : new User(res.data)));
+      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
   }
 
   delete(id: number): Promise<number>;
@@ -73,9 +67,7 @@ class UsersService extends Service {
   delete(id: number, options: Options): Promise<number>;
   delete(id: number, options?: Options) {
     return super
-      .fetch<ApiUser>({ url: `${this.apiPath}/${id}`, method: 'DELETE' })
+      .fetch<User>({ url: `${this.apiPath}/${id}`, method: 'DELETE' })
       .then((res) => Promise.resolve(options?.rawResponse ? res : res.status));
   }
 }
-
-export { UsersService };

package/src/version.ts

@@ -1 +1 @@
-export const Version = { version: '1.0.58' };
+export const Version = { version: '1.1.1' };

package/dist/cjs/models/account.model.d.ts

@@ -1,46 +0,0 @@
-import { ApiAccount } from '../interfaces/index.js';
-export declare class Account {
-    id: number;
-    name: string;
-    level: string;
-    created: number;
-    expired: boolean;
-    owner: number;
-    timezone: number;
-    industry: number;
-    phone: string | null;
-    address_1: string | null;
-    address_2: string | null;
-    city: string | null;
-    county: string | null;
-    postcode: string | null;
-    country: number;
-    services: any;
-    total_price: number;
-    pricing: {
-        current: boolean;
-        name: string;
-        max_employees: number;
-        total_price: number;
-    };
-    expires_in: number;
-    features_disabled: string[];
-    first_billed: string | null;
-    owed: number;
-    trial: boolean;
-    can_restart_trial: boolean;
-    next_billed: string;
-    hide_billing: boolean;
-    total_employees: number;
-    payment_card: string | null;
-    billing_type: string;
-    billing_term: string;
-    billing_email: string | null;
-    billing_address: string | null;
-    grouped_billing_parent: number | null;
-    grouped_billing_children: number[] | null;
-    vat_number: string | null;
-    suspended: boolean;
-    suspended_message: string | null;
-    constructor(account: ApiAccount);
-}

package/dist/cjs/models/account.model.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Account = void 0;
-class Account {
-    constructor(account) {
-        Object.assign(this, account);
-    }
-}
-exports.Account = Account;

package/dist/cjs/models/attendance.model.d.ts

@@ -1,27 +0,0 @@
-import { ApiAttendance, ApiTerminalLocation, ApiShift } from '../interfaces/index.js';
-export declare class Attendance {
-    id: number;
-    deleted: boolean;
-    approved: boolean;
-    in_time: number;
-    out_time: number;
-    minutes_break: number;
-    user: number;
-    location: number;
-    role: number;
-    minutes_late: number;
-    hours: number;
-    hours_auto: number;
-    hours_is_auto: boolean;
-    notes: string | null;
-    shift: ApiShift | null;
-    in_method: string;
-    out_method: string;
-    in_location: ApiTerminalLocation;
-    out_location: ApiTerminalLocation;
-    in_device: number;
-    out_device: number;
-    in_terminal: number | null;
-    out_terminal: number | null;
-    constructor(attendance: ApiAttendance);
-}

package/dist/cjs/models/attendance.model.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Attendance = void 0;
-class Attendance {
-    constructor(attendance) {
-        this.id = attendance.id;
-        this.deleted = attendance.deleted;
-        this.approved = attendance.approved;
-        this.in_time = attendance.in_time;
-        this.out_time = attendance.out_time;
-        this.minutes_break = attendance.minutes_break;
-        this.user = attendance.user;
-        this.location = attendance.location;
-        this.role = attendance.role;
-        this.minutes_late = attendance.minutes_late;
-        this.hours = attendance.hours;
-        this.hours_auto = attendance.hours_auto;
-        this.hours_is_auto = attendance.hours_is_auto;
-        this.notes = attendance.notes;
-        this.shift = attendance.shift;
-        this.in_method = attendance.in_method;
-        this.out_method = attendance.out_method;
-        this.in_location = attendance.in_location;
-        this.out_location = attendance.out_location;
-        this.in_device = attendance.in_device;
-        this.out_device = attendance.out_device;
-        this.in_terminal = attendance.in_terminal;
-        this.out_terminal = attendance.out_terminal;
-    }
-}
-exports.Attendance = Attendance;

package/dist/cjs/models/auth.model.d.ts

@@ -1,6 +0,0 @@
-import { ApiAuth, ApiAuthAccount } from '../interfaces/index.js';
-export declare class Auth {
-    two_factor_enabled: boolean;
-    accounts: ApiAuthAccount[];
-    constructor(auth: ApiAuth);
-}

package/dist/cjs/models/auth.model.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Auth = void 0;
-class Auth {
-    constructor(auth) {
-        this.two_factor_enabled = auth.two_factor_enabled;
-        this.accounts = auth.accounts;
-    }
-}
-exports.Auth = Auth;

package/dist/cjs/models/availability-pattern.model.d.ts

@@ -1,17 +0,0 @@
-import { ApiAvailabilityPatternAvailability, ApiAvailabilityPattern } from '../interfaces/index.js';
-export declare class AvailabilityPattern {
-    id: number;
-    user: number;
-    name: string;
-    start_date: string;
-    end_date: string;
-    repeat_weeks: number;
-    mon: ApiAvailabilityPatternAvailability;
-    tue: ApiAvailabilityPatternAvailability;
-    wed: ApiAvailabilityPatternAvailability;
-    thu: ApiAvailabilityPatternAvailability;
-    fri: ApiAvailabilityPatternAvailability;
-    sat: ApiAvailabilityPatternAvailability;
-    sun: ApiAvailabilityPatternAvailability;
-    constructor(apiAvailabilityPatterns: ApiAvailabilityPattern);
-}

package/dist/cjs/models/availability-pattern.model.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AvailabilityPattern = void 0;
-class AvailabilityPattern {
-    constructor(apiAvailabilityPatterns) {
-        this.id = apiAvailabilityPatterns.id;
-        this.user = apiAvailabilityPatterns.user;
-        this.name = apiAvailabilityPatterns.name;
-        this.start_date = apiAvailabilityPatterns.start_date;
-        this.end_date = apiAvailabilityPatterns.end_date;
-        this.repeat_weeks = apiAvailabilityPatterns.repeat_weeks;
-        this.mon = apiAvailabilityPatterns.mon;
-        this.tue = apiAvailabilityPatterns.tue;
-        this.wed = apiAvailabilityPatterns.wed;
-        this.thu = apiAvailabilityPatterns.thu;
-        this.fri = apiAvailabilityPatterns.fri;
-        this.sat = apiAvailabilityPatterns.sat;
-        this.sun = apiAvailabilityPatterns.sun;
-    }
-}
-exports.AvailabilityPattern = AvailabilityPattern;

package/dist/cjs/models/availability.model.d.ts

@@ -1,6 +0,0 @@
-import { ApiAvailability, ApiAvailabilityDate } from '../interfaces/index.js';
-export declare class Availability {
-    user: number;
-    dates: ApiAvailabilityDate[];
-    constructor(availability: ApiAvailability);
-}

package/dist/cjs/models/availability.model.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Availability = void 0;
-class Availability {
-    constructor(availability) {
-        this.user = availability.user;
-        this.dates = availability.dates;
-    }
-}
-exports.Availability = Availability;