taxtank-core 0.32.89 → 0.33.2

package/src/lib/models/user/user-roles.const.d.ts

@@ -0,0 +1,7 @@
+import { UserRolesEnum } from 'taxtank-core/common';
+/**
+ * role hierarchy
+ */
+export declare const USER_ROLES: {
+    [key: string]: UserRolesEnum[];
+};

package/src/lib/models/user/user.d.ts

@@ -0,0 +1,72 @@
+import { User as BaseUser } from '../../db/Models/user/user';
+import { UserRolesEnum } from 'taxtank-core/common';
+import { Address } from '../address';
+import { ClientDetails } from '../client';
+import { EmployeeDetails } from '../employee/employee-details';
+import { Phone } from '../phone/phone';
+import { ServiceSubscription } from '../service-subscription';
+import { ServiceSubscriptionItem } from '../service-subscription';
+import { SoleDetails } from '../sole';
+import { AppFile } from '../file';
+import { AccountSetupItem } from '../account-setup/account-setup-item';
+export declare class User extends BaseUser {
+    subscriptions: ServiceSubscription[];
+    clientDetails: ClientDetails;
+    employeeDetails: EmployeeDetails;
+    soleDetails: SoleDetails;
+    address: Address;
+    phone: Phone;
+    createdAt: Date;
+    clients: User[];
+    file: AppFile;
+    blacklistSetupItems: AccountSetupItem[];
+    get fullName(): string;
+    get photo(): string;
+    get activeSubscription(): ServiceSubscription;
+    get lastSubscription(): ServiceSubscription;
+    /**
+     * @TODO refactor
+     *
+     */
+    get position(): string;
+    /**
+     * search roles including hierarchy
+     */
+    hasRoles(roles: UserRolesEnum | UserRolesEnum[]): boolean;
+    isOnboarding(): boolean;
+    isInactive(): boolean;
+    hasSubscription(): boolean;
+    isLoggedIn(): boolean;
+    isClient(): boolean;
+    isEmployee(): boolean;
+    isAccountant(): boolean;
+    isAdvisor(): boolean;
+    isImpersonator(): boolean;
+    /**
+     * Check if current user is firm owner
+     */
+    isFirmOwner(): boolean;
+    /**
+     * Check if current user is firm manager
+     */
+    isManager(): boolean;
+    /**
+     * check if user has property tank access
+     */
+    hasPropertyTank(): boolean;
+    /**
+     * check if user has property tank access
+     */
+    hasWorkTank(): boolean;
+    /**
+     * Get user subscription role by provided role type
+     * @param roleType by which role should be returned
+     */
+    getSubscriptionRole(roleType: UserRolesEnum): ServiceSubscriptionItem;
+    isCurrentFinancialYear(): boolean;
+    /**
+     * financial years available in the app for user
+     * starts from 2022 for new users and registeredYear - 1 for old users
+     */
+    get financialYears(): number;
+}

package/src/lib/pipes/app-currency.pipe.d.ts

@@ -0,0 +1,11 @@
+import { PipeTransform } from '@angular/core';
+import { CurrencyPipe } from '@angular/common';
+import * as i0 from "@angular/core";
+/**
+ * extended version of currency pipe
+ */
+export declare class AppCurrencyPipe extends CurrencyPipe implements PipeTransform {
+    transform(value?: number | string | null, currencyCode?: string, display?: 'code' | 'symbol' | 'symbol-narrow' | string | boolean, digitsInfo?: string, locale?: string): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppCurrencyPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<AppCurrencyPipe, "appCurrency", true>;
+}

package/src/lib/services/event/sse.service.d.ts

@@ -0,0 +1,20 @@
+import { NgZone } from '@angular/core';
+import { Observable } from 'rxjs';
+import { JwtService } from 'taxtank-core/common';
+import * as i0 from "@angular/core";
+/**
+ * server sent events service
+ * https://symfony.com/doc/current/mercure.html
+ */
+export declare class SseService {
+    private zone;
+    private jwtService;
+    private environment;
+    constructor(zone: NgZone, jwtService: JwtService, environment: any);
+    /**
+     * list to url for server events
+     */
+    on(topic: string): Observable<object>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SseService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SseService>;
+}

package/src/lib/services/http/facebook/facebook.service.d.ts

@@ -0,0 +1,38 @@
+import { HttpClient } from '@angular/common/http';
+import { BehaviorSubject } from 'rxjs';
+import { ToastService } from '../../toast';
+import { JwtService } from 'taxtank-core/common';
+import { FacebookAuthOptions } from './facebook-auth-options.interface';
+import { Router } from '@angular/router';
+import * as i0 from "@angular/core";
+export declare class FacebookService {
+    private http;
+    private toastService;
+    private jwtService;
+    private router;
+    private environment;
+    isLoggedInSubject: BehaviorSubject<boolean>;
+    isFacebookEnabled: boolean;
+    static authOptions: FacebookAuthOptions;
+    /**
+     * @TODO when google login will be done, it needs to be moved to an abstract class
+     */
+    constructor(http: HttpClient, toastService: ToastService, jwtService: JwtService, router: Router, environment: any);
+    login(redirectUrl?: string): Promise<any>;
+    /**
+     * save user's auth tokens
+     * @TODO move to abstract class
+     */
+    private setAuth;
+    /**
+     * get facebook auth access token
+     */
+    private getAccessToken;
+    /**
+     * logout user from facebook.
+     * Need to logout when user is trying to login with facebook with manually registered email
+     */
+    private logout;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FacebookService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FacebookService>;
+}

package/src/lib/services/http/firm/employee/employee.service.d.ts

@@ -0,0 +1,20 @@
+import { RestMethod, RestService } from '../../rest';
+import { User as UserBase } from '../../../../db/Models/user/user';
+import { Observable } from 'rxjs';
+import { User } from '../../../../models';
+import { EmployeeMessagesEnum } from './employee-messages.enum';
+import { Collection } from '../../../../collections';
+import { UserRolesEnum } from 'taxtank-core/common';
+import * as i0 from "@angular/core";
+export declare class EmployeeService extends RestService<UserBase, User, Collection<User>> {
+    protected endpointUri: string;
+    modelClass: typeof User;
+    collectionClass: typeof Collection<User>;
+    disabledMethods: RestMethod[];
+    messages: typeof EmployeeMessagesEnum;
+    roles: UserRolesEnum[];
+    activateEmployee(employee: User): Observable<User>;
+    deactivateEmployee(employee: User): Observable<User>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EmployeeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EmployeeService>;
+}

package/src/lib/services/http/firm/employee-invite/employee-invite.service.d.ts

@@ -0,0 +1,25 @@
+import { EmployeeInvite as EmployeeInviteBase } from '../../../../db/Models/firm/employee-invite';
+import { Observable } from 'rxjs';
+import { EmployeeInvite } from '../../../../models/employee/employee-invite';
+import { RestService } from '../../rest';
+import { UserRolesEnum } from 'taxtank-core/common';
+import { Collection } from '../../../../collections';
+import * as i0 from "@angular/core";
+export declare class EmployeeInviteService extends RestService<EmployeeInviteBase, EmployeeInvite, Collection<EmployeeInvite>> {
+    protected endpointUri: string;
+    collectionClass: typeof Collection<EmployeeInvite>;
+    modelClass: typeof EmployeeInvite;
+    roles: UserRolesEnum[];
+    /**
+     * Import employees for firm from CSV file
+     * @param file
+     */
+    import(file: File): Observable<EmployeeInvite[]>;
+    /**
+     * Resend invitation from firm to client
+     * @param invite
+     */
+    resend(invite: EmployeeInvite): Observable<EmployeeInvite>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EmployeeInviteService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EmployeeInviteService>;
+}

package/src/lib/services/http/google/google.service.d.ts

@@ -0,0 +1,43 @@
+import { HttpClient } from '@angular/common/http';
+import { ToastService } from '../../toast';
+import { JwtService } from 'taxtank-core/common';
+import { Router } from '@angular/router';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * Google instance
+ * https://developers.google.com/identity/oauth2/web/guides/overview
+ * https://developers.google.com/identity/gsi/web/guides/overview
+ */
+export declare class GoogleService {
+    private http;
+    private toastService;
+    private jwtService;
+    private router;
+    private environment;
+    isLoggedInSubject: BehaviorSubject<boolean>;
+    isGoogleEnabled: boolean;
+    googleScope: string;
+    constructor(http: HttpClient, toastService: ToastService, jwtService: JwtService, router: Router, environment: any);
+    /**
+     * prompt for user consent and obtain an access token to work with user data
+     * requestAccessToken() method to trigger the token UX flow and obtain an access token.
+     * https://developers.google.com/identity/oauth2/web/guides/use-token-model
+     */
+    login(): void;
+    /**
+     * requestAccessToken() method to trigger the token UX flow and obtain an access token:
+     * Choose their account;
+     * sign-in to the Google Account if not already signed-in;
+     * grant consent for your web app to access each requested scope.
+     */
+    private setAuth;
+    /**
+     * When the user signs out of your website, you need to call the method
+     * google.accounts.id.disableAutoSelect to record the status in cookies.
+     * https://developers.google.com/identity/oauth2/web/guides/use-token-model
+     */
+    private logout;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GoogleService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GoogleService>;
+}

package/src/lib/services/http/holding/holding-import/holding-import.service.d.ts

@@ -0,0 +1,17 @@
+import { RestMethod, RestService } from '../../rest';
+import { Collection } from '../../../../collections';
+import { UserRolesEnum } from 'taxtank-core/common';
+import { HoldingImport as HoldingImportBase } from '../../../../db/Models/holding/holding-import';
+import { HoldingImport } from '../../../../models/holding/holding-import';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class HoldingImportService extends RestService<HoldingImportBase, HoldingImport, Collection<HoldingImport>> {
+    modelClass: typeof HoldingImport;
+    collectionClass: typeof Collection<HoldingImport>;
+    endpointUri: string;
+    disabledMethods: RestMethod[];
+    roles: UserRolesEnum[];
+    import(file: File, exchangeId: number, isTaxFree: boolean): Observable<HoldingImport>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HoldingImportService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HoldingImportService>;
+}

package/src/lib/services/http/holding/holding.service.d.ts

@@ -0,0 +1,19 @@
+import { Holding as HoldingBase } from '../../../db/Models';
+import { Holding } from '../../../models';
+import { RestMethod, RestService } from '../rest';
+import { HoldingCollection } from '../../../collections';
+import { IEventListener } from '../../../interfaces';
+import { UserRolesEnum } from 'taxtank-core/common';
+import * as i0 from "@angular/core";
+export declare class HoldingService extends RestService<HoldingBase, Holding, HoldingCollection> implements IEventListener {
+    protected environment: any;
+    modelClass: typeof Holding;
+    collectionClass: typeof HoldingCollection;
+    endpointUri: string;
+    disabledMethods: RestMethod[];
+    roles: UserRolesEnum[];
+    constructor(environment: any);
+    listenEvents(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HoldingService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HoldingService>;
+}

package/src/lib/services/http/rest/rest-old.service.d.ts

@@ -0,0 +1,117 @@
+import { Observable, ReplaySubject } from 'rxjs';
+import { HttpClient } from '@angular/common/http';
+import { EventDispatcherService } from '../../event';
+import { ToastService } from '../../toast';
+import { UserRolesEnum } from 'taxtank-core/common';
+import * as i0 from "@angular/core";
+/**
+ * Abstract base service that implements common services functionality
+ * and describe abstract methods/properties that have to be implemented in child services
+ * Model - entity service is working with
+ * BaseModel - base entity model that extends by Model
+ * @TODO TT-1777 Alex: remove when all services refactored
+ */
+export declare abstract class RestService<BaseModel, Model extends BaseModel> {
+    protected environment: any;
+    protected toastService: ToastService;
+    protected http: HttpClient;
+    protected eventDispatcherService: EventDispatcherService;
+    abstract url: string;
+    abstract modelClass: any;
+    protected cache: Model[];
+    protected cacheSubject: ReplaySubject<Model[]>;
+    messageCreated: string;
+    messageCreatedBatch: string;
+    messageUpdated: string;
+    messageUpdatedBatch: string;
+    messageDeleted: string;
+    messageDeletedBatch: string;
+    roles: UserRolesEnum[];
+    constructor(environment: any);
+    protected get apiUrl(): string;
+    /**
+     * get list of base class instances directly from backend
+     */
+    protected fetch(path?: string, cache?: boolean): Observable<Model[]>;
+    /**
+     * get cached list of all instances
+     */
+    get(path?: string): Observable<Model[]>;
+    /**
+     * get instance by id from cache
+     * @param id ID of required item
+     */
+    findById(id: number): Observable<Model>;
+    find(id: number): Model;
+    /**
+     * add new instance and update cache
+     */
+    private create;
+    /**
+     * @TODO Alex TT-1777 rename to post
+     */
+    add(model: Model, shouldUpdateCache?: boolean): Observable<Model>;
+    /**
+     * @TODO Alex TT-1777 rename to upload
+     */
+    postForm(file: File, params?: {
+        [key: string]: string;
+    }): Observable<Model>;
+    /**
+     * Add several new items
+     * @param models Array of new items for saving
+     * @param queryParams query parameters for request
+     * @TODO Alex TT-1777 rename to postBatch
+     */
+    addBatch(models: Model[], queryParams?: object): Observable<Model[]>;
+    /**
+     * Update item
+     * @param model Existing instance for updating
+     * @param queryParams query parameters for request
+     * @TODO Alex TT-1777 rename to put
+     */
+    update(model: Model, queryParams?: object): Observable<Model>;
+    /**
+     * Update several items
+     * @param models Array of items for updating
+     * @param queryParams query parameters for request
+     * TODO Alex TT-1777 rename to putBatch
+     */
+    updateBatch(models: Model[], queryParams?: object): Observable<Model[]>;
+    /**
+     * delete instance of class
+     * @param model Class instance for deleting
+     */
+    delete(model: Model): Observable<void>;
+    /**
+     * @deprecated use removeBatch
+     * delete multiple instances of class
+     * @param models Class instances array for deleting
+     */
+    deleteBatch(models: Model[]): Observable<void>;
+    /**
+     * collect array of redo transactions requests observable
+     */
+    removeBatch(models: Model[]): Observable<void>[];
+    /**
+     * clear service cache
+     */
+    refreshCache(): void;
+    setCache(data: any[], next?: boolean): void;
+    /**
+     * Update cache subject with current cache array value
+     */
+    protected updateCache(): void;
+    /**
+     * perform a shallow copy of the emitted data to make it immutable
+     */
+    getCacheSubjectObservable(): Observable<Model[]>;
+    /**
+     * @TODO use excludeExtraneousValues when all models refactored (exposed all needed properties)
+     * Create new instance of class
+     * @param model instance that we will use as constructor options
+     */
+    protected createModelInstance(model: BaseModel | object): Model;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RestService<any, any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RestService<any, any>>;
+}

package/src/lib/services/http/rest/rest.service.d.ts

@@ -0,0 +1,121 @@
+import { Observable, ReplaySubject } from 'rxjs';
+import { HttpClient } from '@angular/common/http';
+import { EventDispatcherService, SseService } from '../../event';
+import { Collection } from '../../../collections';
+import { AbstractModel, ObservableModel } from '../../../db/Models';
+import { RestMethod } from './rest-method.type';
+import { HttpMethod } from './http-method.type';
+import { DataService } from '../../data.service';
+import { UserRolesEnum } from 'taxtank-core/common';
+import { ToastService } from '../../toast';
+import * as i0 from "@angular/core";
+/**
+ * Abstract base service that implements common services functionality
+ * and describe abstract methods/properties that have to be implemented in child services
+ * Model - entity service is working with
+ * BaseModel - base entity model that extends by Model
+ * CollectionModel - entity collection class
+ */
+export declare abstract class RestService<BaseModel, Model extends AbstractModel, CollectionModel extends Collection<Model>> extends DataService<BaseModel, Model, CollectionModel> {
+    protected environment: any;
+    /**
+     * Url part for service entity API
+     */
+    protected abstract endpointUri: string;
+    /**
+     * Subject for service cache
+     */
+    protected cacheSubject: ReplaySubject<CollectionModel>;
+    /**
+     * List of methods unavailable for current API
+     * @TODO Alex: add and handle enabled methods too
+     * @TODO Alex: disable batch by default
+     */
+    disabledMethods: RestMethod[];
+    protected sseService: SseService;
+    protected toastService: ToastService;
+    protected http: HttpClient;
+    protected eventDispatcherService: EventDispatcherService;
+    roles: UserRolesEnum[];
+    mercureTopic: string;
+    constructor(environment: any);
+    protected get apiUrl(): string;
+    setCache(data: any[], next?: boolean): void;
+    /**
+     * Refresh cache with actual backend data
+     */
+    refreshCache(): void;
+    /**
+     * perform a shallow copy of the emitted data to make it immutable
+     */
+    getCacheSubjectObservable(): Observable<CollectionModel>;
+    /**
+     * Get data from backend and fill the cache
+     */
+    protected fetch(path?: string): Observable<CollectionModel>;
+    get(path?: string): Observable<CollectionModel>;
+    getBy(path: string, values: any): Observable<CollectionModel>;
+    getFirst(): Observable<Model>;
+    hasInCache(id: number): boolean;
+    getArray(): Observable<Model[]>;
+    getArrayBy(path: string, values: any): Observable<Model[]>;
+    /**
+     * Create a new Model instance in database
+     */
+    post(model: Model, path?: string): Observable<Model>;
+    /**
+     * Create multiple new Model instances in database
+     */
+    postBatch(models: Model[]): Observable<Model[]>;
+    /**
+     * Change an existing Model instance in database
+     */
+    put(model: Model, path?: string): Observable<Model>;
+    /**
+     * Change multiple existing Model instances in database
+     */
+    putBatch(models: Model[]): Observable<Model[]>;
+    /**
+     * Remove a Model instance from database
+     */
+    delete(model: Model): Observable<void>;
+    /**
+     * Remove multiple Model instances from database
+     */
+    deleteBatch(models: Model[]): Observable<void>;
+    /**
+     * Handle response data - update cache and dispatch event if it is needed
+     */
+    protected handleResponse(response: Model[], method: HttpMethod): void;
+    /**
+     * Update cache with passed items. Add/Update detects automatically, Delete via optional flag
+     */
+    protected updateCache(items: Model[], method: HttpMethod): void;
+    /**
+     * Generate and dispatch rest event
+     */
+    protected dispatchEvent(method: HttpMethod, items: ObservableModel[]): void;
+    /**
+     * Check if method is not disabled. Throw exception otherwise.
+     * Some entities does not have endpoints for all methods.
+     */
+    private handleAccessError;
+    /**
+     * Subscribe to http events and run callback.
+     * CSE - Cleint Sent Events
+     * @param modelClass
+     * @param methods The list of http methods should be listened for
+     * @param callback The function to be called when event triggered
+     */
+    protected listenCSE(modelClass: typeof ObservableModel, callback: Function, methods?: HttpMethod[]): void;
+    /**
+     * check if user has subscription role to access api
+     */
+    hasRoles(): boolean;
+    /**
+     * Listen for Server-Sent Events (SSE) on the specified Mercure topic
+     */
+    listenSSE(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RestService<any, any, any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RestService<any, any, any>>;
+}

package/src/lib/services/http/sole/sole-invoice/sole-invoice.service.d.ts

@@ -0,0 +1,24 @@
+import { RestService } from '../../rest/rest-old.service';
+import { SoleInvoice as SoleInvoiceBase } from '../../../../db/Models/sole/sole-invoice';
+import { SoleInvoice } from '../../../../models';
+import { SoleInvoiceStatusesEnum } from '../../../../db/Enums/sole-invoice-statuses.enum';
+import { Observable } from 'rxjs';
+import { UserRolesEnum } from 'taxtank-core/common';
+import * as i0 from "@angular/core";
+export declare class SoleInvoiceService extends RestService<SoleInvoiceBase, SoleInvoice> {
+    protected environment: any;
+    modelClass: typeof SoleInvoice;
+    url: string;
+    roles: UserRolesEnum[];
+    constructor(environment: any);
+    updateStatus(invoice: SoleInvoice, status: SoleInvoiceStatusesEnum): Observable<SoleInvoice>;
+    send(invoice: SoleInvoice, file: File): Observable<Object>;
+    /**
+     * @TODO use backend
+     * Return the next number from the last invoice.
+     * Basically needed to create a new invoice to show its number when the invoice has not yet been sent to the backend
+     */
+    getNewInvoiceNumber(): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SoleInvoiceService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SoleInvoiceService>;
+}

package/src/lib/services/http/user/user.service.d.ts

@@ -0,0 +1,43 @@
+import { Observable } from 'rxjs';
+import { User as UserBase } from '../../../db/Models/user/user';
+import { User } from '../../../models';
+import { RestMethod, RestService } from '../rest';
+import { Collection } from '../../../collections';
+import { AccountSetupItem } from '../../../models/account-setup/account-setup-item';
+import { IEventListener } from '../../../interfaces';
+import { MixpanelService } from 'taxtank-core/common';
+import * as i0 from "@angular/core";
+export declare class UserService extends RestService<UserBase, User, Collection<User>> implements IEventListener {
+    protected environment: any;
+    modelClass: typeof User;
+    collectionClass: typeof Collection;
+    endpointUri: string;
+    disabledMethods: RestMethod[];
+    protected mpService: MixpanelService;
+    constructor(environment: any);
+    listenEvents(): void;
+    fetch(): Observable<Collection<User>>;
+    register(data: object): Observable<object>;
+    changePassword(currentPassword: string, newPassword: string): Observable<object>;
+    recoveryPassword(email: string): Observable<object>;
+    resetPassword(newPassword: string, resetToken: string): Observable<object>;
+    resendConfirmationEmail(email: string): Observable<object>;
+    /**
+     * Confirm registered user
+     */
+    confirm(verificationCode: string): Observable<object>;
+    /**
+     * Search existing user
+     */
+    search(email: string): Observable<User>;
+    finishOnboarding(user: User): Observable<User>;
+    updatePhoto(photo: FormData): Observable<void>;
+    createBasiq(): Observable<string>;
+    skipSetupItem(item: AccountSetupItem): Observable<User>;
+    /**
+     * Update cache when user's service subscription is updated
+     */
+    private listenServiceSubscriptionUpdated;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UserService>;
+}

package/src/lib/services/http/vehicle/vehicle-claim.service.d.ts

@@ -0,0 +1,21 @@
+import { VehicleClaim as VehicleClaimBase } from '../../../db/Models/vehicle/vehicle-claim';
+import { VehicleClaim } from '../../../models';
+import { RestService } from '../rest/rest-old.service';
+import { Observable } from 'rxjs';
+import { UserRolesEnum } from 'taxtank-core/common';
+import { BestVehicleLogbookCollection } from '../../../collections';
+import * as i0 from "@angular/core";
+export declare class VehicleClaimService extends RestService<VehicleClaimBase, VehicleClaim> {
+    modelClass: typeof VehicleClaim;
+    url: string;
+    roles: UserRolesEnum[];
+    add(model: VehicleClaim): Observable<VehicleClaim>;
+    update(model: VehicleClaim, queryParams?: object): Observable<VehicleClaim>;
+    /**
+     * Update workUsage for all vehicle claims if logbook best period changed
+     * @TODO Vik: Best period move this and related logic to backend
+     */
+    updateWorkUsage(bestLogbooks: BestVehicleLogbookCollection): Observable<VehicleClaim[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VehicleClaimService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<VehicleClaimService>;
+}

package/src/lib/services/index.d.ts

@@ -0,0 +1,16 @@
+export * from './http';
+export * from './json';
+export * from './account-setup';
+export * from './asset';
+export * from './bank';
+export * from './event';
+export * from './export';
+export * from './header-title';
+export * from './intercom';
+export * from './pdf';
+export * from './preloader';
+export * from './property';
+export * from './report';
+export * from './toast';
+export * from './user';
+export * from './xlsx';

package/esm2022/lib/collections/account-setup-item.collection.mjs

@@ -1,12 +0,0 @@
-import { Collection } from './collection';
-import compact from 'lodash/compact';
-export class AccountSetupItemCollection extends Collection {
-    constructor(items) {
-        super(compact(items));
-        this.sortBy('isCompleted', 'asc');
-    }
-    isCompleted() {
-        return this.filterBy('isCompleted', true).length === this.length;
-    }
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWNjb3VudC1zZXR1cC1pdGVtLmNvbGxlY3Rpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dC1jb3JlL3NyYy9saWIvY29sbGVjdGlvbnMvYWNjb3VudC1zZXR1cC1pdGVtLmNvbGxlY3Rpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGNBQWMsQ0FBQztBQUMxQyxPQUFPLE9BQU8sTUFBTSxnQkFBZ0IsQ0FBQztBQUVyQyxNQUFNLE9BQU8sMEJBQTJCLFNBQVEsVUFBNEI7SUFDMUUsWUFBWSxLQUF5QjtRQUNuQyxLQUFLLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUM7UUFDdEIsSUFBSSxDQUFDLE1BQU0sQ0FBQyxhQUFhLEVBQUUsS0FBSyxDQUFDLENBQUE7SUFDbkMsQ0FBQztJQUVELFdBQVc7UUFDVCxPQUFPLElBQUksQ0FBQyxRQUFRLENBQUMsYUFBYSxFQUFFLElBQUksQ0FBQyxDQUFDLE1BQU0sS0FBSyxJQUFJLENBQUMsTUFBTSxDQUFDO0lBQ25FLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEFjY291bnRTZXR1cEl0ZW0gfSBmcm9tICcuLi9tb2RlbHMvYWNjb3VudC1zZXR1cC9hY2NvdW50LXNldHVwLWl0ZW0nO1xuaW1wb3J0IHsgQ29sbGVjdGlvbiB9IGZyb20gJy4vY29sbGVjdGlvbic7XG5pbXBvcnQgY29tcGFjdCBmcm9tICdsb2Rhc2gvY29tcGFjdCc7XG5cbmV4cG9ydCBjbGFzcyBBY2NvdW50U2V0dXBJdGVtQ29sbGVjdGlvbiBleHRlbmRzIENvbGxlY3Rpb248QWNjb3VudFNldHVwSXRlbT4ge1xuICBjb25zdHJ1Y3RvcihpdGVtczogQWNjb3VudFNldHVwSXRlbVtdKSB7XG4gICAgc3VwZXIoY29tcGFjdChpdGVtcykpO1xuICAgIHRoaXMuc29ydEJ5KCdpc0NvbXBsZXRlZCcsICdhc2MnKVxuICB9XG5cbiAgaXNDb21wbGV0ZWQoKTogYm9vbGVhbiB7XG4gICAgcmV0dXJuIHRoaXMuZmlsdGVyQnkoJ2lzQ29tcGxldGVkJywgdHJ1ZSkubGVuZ3RoID09PSB0aGlzLmxlbmd0aDtcbiAgfVxufVxuIl19

package/esm2022/lib/collections/allocation-group.collection.mjs

@@ -1,9 +0,0 @@
-import { Collection } from './collection';
-export class AllocationGroupCollection extends Collection {
-    constructor(items) {
-        super(items);
-        // @TODO Alex: could be useful for other collections, move to base class
-        this.sortBy('date');
-    }
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxsb2NhdGlvbi1ncm91cC5jb2xsZWN0aW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdHQtY29yZS9zcmMvbGliL2NvbGxlY3Rpb25zL2FsbG9jYXRpb24tZ3JvdXAuY29sbGVjdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sY0FBYyxDQUFDO0FBRzFDLE1BQU0sT0FBTyx5QkFBMEIsU0FBUSxVQUEyQjtJQUN4RSxZQUFZLEtBQXdCO1FBQ2xDLEtBQUssQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUViLHdFQUF3RTtRQUN4RSxJQUFJLENBQUMsTUFBTSxDQUFDLE1BQU0sQ0FBQyxDQUFDO0lBQ3RCLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbGxlY3Rpb24gfSBmcm9tICcuL2NvbGxlY3Rpb24nO1xuaW1wb3J0IHsgQWxsb2NhdGlvbkdyb3VwIH0gZnJvbSAnLi4vbW9kZWxzJztcblxuZXhwb3J0IGNsYXNzIEFsbG9jYXRpb25Hcm91cENvbGxlY3Rpb24gZXh0ZW5kcyBDb2xsZWN0aW9uPEFsbG9jYXRpb25Hcm91cD4ge1xuICBjb25zdHJ1Y3RvcihpdGVtczogQWxsb2NhdGlvbkdyb3VwW10pIHtcbiAgICBzdXBlcihpdGVtcyk7XG5cbiAgICAvLyBAVE9ETyBBbGV4OiBjb3VsZCBiZSB1c2VmdWwgZm9yIG90aGVyIGNvbGxlY3Rpb25zLCBtb3ZlIHRvIGJhc2UgY2xhc3NcbiAgICB0aGlzLnNvcnRCeSgnZGF0ZScpO1xuICB9XG59XG4iXX0=