taxtank-core 2.0.1 → 2.0.3

package/src/lib/models/transaction/allocation-rule-transaction.d.ts

@@ -0,0 +1,28 @@
+import { AllocationRuleTransaction as AllocationRuleTransactionBase } from '../../db/Models/transaction/allocation-rule-transaction';
+import { ChartAccounts } from '../chart-accounts';
+import { AllocationRuleTransactionMetaField } from './allocation-rule-transaction-meta-field';
+import { BankTransaction, Loan, Property, SoleBusiness, Transaction } from '../../models';
+import { IncomeSource } from '../income-source';
+export declare class AllocationRuleTransaction extends AllocationRuleTransactionBase {
+    chartAccounts: ChartAccounts;
+    property: Property;
+    loan: Loan;
+    incomeSource?: IncomeSource;
+    business: SoleBusiness;
+    metaFields: AllocationRuleTransactionMetaField[];
+    parentTransaction: AllocationRuleTransaction;
+    childTransactions: AllocationRuleTransaction[];
+    claimPercent: number;
+    tax: number;
+    amount: number;
+    get amountPercentCoefficient(): number;
+    calculateClaimPercent(): number;
+    /**
+     * If rule transaction has amount then split enabled. There is 0 when split disabled
+     */
+    isSplit(): boolean;
+    /**
+     * Create Transaction instance based on passed bank transaction and rule transaction
+     */
+    toTransaction(bankTransaction?: BankTransaction): Transaction;
+}

package/src/lib/models/transaction/allocation-rule.d.ts

@@ -0,0 +1,42 @@
+import { AllocationRule as AllocationRuleBase } from '../../db/Models/transaction/allocation-rule';
+import { BankAccount, BankTransaction } from '../bank';
+import { AllocationRuleCondition } from './allocation-rule-condition';
+import { AllocationRuleTransaction } from './allocation-rule-transaction';
+import { AllocationRuleConditionOperatorEnum, AllocationRuleTypeEnum } from '../../db/Enums';
+import { Transaction } from './transaction';
+export declare class AllocationRule extends AllocationRuleBase {
+    bankAccount?: BankAccount;
+    conditions?: AllocationRuleCondition[];
+    transaction?: AllocationRuleTransaction;
+    transferBankAccount?: BankAccount;
+    type: AllocationRuleTypeEnum;
+    conditionOperator: AllocationRuleConditionOperatorEnum;
+    autoAllocate: boolean;
+    get typeLabel(): string;
+    isIncome(): boolean;
+    isExpense(): boolean;
+    isTransfer(): boolean;
+    isPropertyTank(): boolean;
+    isWorkTank(): boolean;
+    isSoleTank(): boolean;
+    isPropertyIncome(): boolean;
+    isWorkIncome(): boolean;
+    isSoleIncome(): boolean;
+    /**
+     * @TODO Alex: move to collection
+     */
+    matchBankTransaction(bankTransaction: BankTransaction): boolean;
+    createTransaction(bankTransaction: BankTransaction): Transaction;
+    /**
+     * Rule is matched when all conditions matched
+     */
+    private checkAnd;
+    /**
+     * Rule is matched when at least one condition matched
+     */
+    private checkOr;
+    /**
+     * Create allocation rule based on bank transaction (just prefill rule fields with bank transaction values)
+     */
+    static fromBankTransaction(bankTransaction: BankTransaction): AllocationRule;
+}

package/src/lib/models/transaction/income-amount-type.enum.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Enum with income amount types (Net or Gross)
+ */
+export declare enum IncomeAmountTypeEnum {
+    NET = 0,
+    GROSS = 1
+}

package/src/lib/models/transaction/index.d.ts

@@ -0,0 +1,8 @@
+export * from './allocation-rule';
+export * from './allocation-rule-transaction';
+export * from './allocation-rule-transaction-meta-field';
+export * from './income-amount-type.enum';
+export * from './transaction';
+export * from './transaction-allocation';
+export * from './transaction-category.enum';
+export * from './transaction-meta-field';

package/src/lib/models/transaction/transaction-allocation.d.ts

@@ -0,0 +1,12 @@
+import { TransactionAllocation as TransactionAllocationBase } from '../../db/Models/transaction/transaction-allocation';
+import { BankTransaction } from '../bank';
+import { Transaction } from './transaction';
+export declare class TransactionAllocation extends TransactionAllocationBase {
+    bankTransaction: BankTransaction;
+    transaction: Transaction;
+    /**
+     * Create a new instance of transaction allocation
+     * transaction could be empty since we can POST allocation inside a new transaction
+     */
+    static create(amount: number, bankTransaction: BankTransaction, transaction?: Transaction): TransactionAllocation;
+}

package/src/lib/models/transaction/transaction-category.enum.d.ts

@@ -0,0 +1,6 @@
+export declare enum TransactionCategoryEnum {
+    PROPERTY = 0,
+    WORK = 1,
+    SOLE = 2,
+    PERSONAL = 3
+}

package/src/lib/models/transaction/transaction-meta-field.d.ts

@@ -0,0 +1,8 @@
+import { TransactionMetaField as TransactionMetaFieldBase } from '../../db/Models/transaction/transaction-meta-field';
+import { ChartAccountsMetaField } from '../chart-accounts';
+import { Transaction } from '../../db/Models';
+export declare class TransactionMetaField extends TransactionMetaFieldBase {
+    metaField: ChartAccountsMetaField;
+    transaction: Transaction;
+    chartAccountsMetaField: ChartAccountsMetaField;
+}

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

@@ -0,0 +1,101 @@
+import { Transaction as TransactionBase } from '../../db/Models/transaction/transaction';
+import { ChartAccountsMetaFieldListEnum } from '../../db/Enums';
+import { TransactionOperationEnum } from '../../db/Enums/transaction-operation.enum';
+import { Property } from '../property';
+import { ChartAccounts } from '../chart-accounts';
+import { IncomeSource } from '../income-source';
+import { TransactionMetaField } from './transaction-meta-field';
+import { Loan } from '../loan';
+import { TransactionAllocation } from './transaction-allocation';
+import { TransactionAllocationCollection } from '../../collections';
+import { Depreciation } from '../depreciation';
+import { Expense } from '../../interfaces';
+import { SoleBusiness, SoleInvoiceItem } from '../sole';
+export declare class Transaction extends TransactionBase implements Expense {
+    static className: string;
+    /**
+     * @TODO rename to childTransactions
+     */
+    transactions: Transaction[];
+    property: Property;
+    chartAccounts: ChartAccounts;
+    incomeSource: IncomeSource;
+    metaFields: TransactionMetaField[];
+    transfer: Transaction;
+    loan: Loan;
+    date: Date;
+    allocations: TransactionAllocation[];
+    invoiceItem: SoleInvoiceItem;
+    business: SoleBusiness;
+    tax: number;
+    operation: TransactionOperationEnum;
+    claimPercent: number;
+    amount: number;
+    get invoiceId(): number;
+    isDebit(): boolean;
+    isCredit(): boolean;
+    /**
+     * @TODO move to base collection
+     */
+    isIncome(): boolean;
+    /**
+     * @TODO move to base collection
+     */
+    isExpense(): boolean;
+    isPersonal(): boolean;
+    isInterest(): boolean;
+    /**
+     * Check if transaction type is vehicle
+     */
+    isVehicleTransaction(): boolean;
+    get taxFreeComponent(): number;
+    get frankingCredit(): number;
+    get eligibleForReduction(): number;
+    get untaxedElement(): number;
+    /**
+     * Check if transaction reconcile operation if TRANSFER
+     * @TODO bad usage of get (and all is* methods), getter should sound like a noun
+     */
+    get isTransfer(): boolean;
+    isFindAndMatch(): boolean;
+    get debit(): number;
+    get credit(): number;
+    /**
+     * Get value of transaction meta field
+     * @param field for which value should be returned
+     * @Todo modify 'metaFields' property from array to Collection
+     */
+    getMetaFieldValue(field: ChartAccountsMetaFieldListEnum): number;
+    isCash(): boolean;
+    canFindAndMatch(allocations: TransactionAllocationCollection): boolean;
+    /**
+     * Create Depreciation instance based on Transaction
+     */
+    toDepreciation(): Depreciation;
+    /**
+     * Check if transaction is completely allocated
+     */
+    isAllocated(allocations: TransactionAllocationCollection): boolean;
+    getAllocatedAmount(allocations: TransactionAllocationCollection): number;
+    getUnallocatedAmount(allocations: TransactionAllocationCollection): number;
+    /**
+     * Total transaction amount including taxes and other additional amounts
+     */
+    get grossAmount(): number;
+    get grossAmountWithoutGst(): number;
+    get grossClaimAmountWithoutGst(): number;
+    /**
+     * @TODO vik confusing logic demanded by Nicole, we need a better ux to fix it
+     * netAmount matches received payment (bankTransaction amount), includes gst and salary included adjustments
+     * ie user received 1000$ salary including 100$ tips. NetAmount=1000$, amount=900$, tips=100$
+     */
+    get netAmount(): number;
+    /**
+     * most of the transactions could have only positive or negative amount depends on chartAccounts, so we ignore
+     * user's choice and transform amount, but there are exceptions like advance (negative or positive amount)
+     */
+    ignoreSign(): boolean;
+    setParent(transaction: Transaction): void;
+    isEditable(): boolean;
+    get claimableTax(): number;
+}

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

@@ -0,0 +1,10 @@
+export * from './my-account-history-initiated-by.enum';
+export * from './my-account-history-status.enum';
+export * from './my-account-history-type.enum';
+export * from './my-account-history';
+export * from './occupation';
+export * from './user-roles.const';
+export * from './user-to-register';
+export * from './user-work-position.const';
+export * from './user';
+export * from './mfa-details';

package/src/lib/models/user/mfa-details/index.d.ts

@@ -0,0 +1,2 @@
+export * from './mfa-details';
+export * from './mfa-details.interface';

package/src/lib/models/user/mfa-details/mfa-details.d.ts

@@ -0,0 +1,11 @@
+import { MfaDetailsInterface } from './mfa-details.interface';
+import { AbstractModel } from '../../../db/Models';
+export declare class MfaDetails extends AbstractModel implements MfaDetailsInterface {
+    googleAuthenticatorSecret: string;
+    googleAuthenticatorEnabled: boolean;
+    email: string;
+    emailAuthEnabled: string;
+    otpAuthUri: string;
+    provider: string;
+    isGoogleProvider(): boolean;
+}

package/src/lib/models/user/mfa-details/mfa-details.interface.d.ts

@@ -0,0 +1,6 @@
+export interface MfaDetailsInterface {
+    googleAuthenticatorSecret: string;
+    googleAuthenticatorEnabled: boolean;
+    email: string;
+    emailAuthEnabled: string;
+}

package/src/lib/models/user/my-account-history-initiated-by.enum.d.ts

@@ -0,0 +1,4 @@
+export declare enum MyAccountHistoryInitiatedByEnum {
+    OWNER = 0,
+    ACCOUNTANT = 1
+}

package/src/lib/models/user/my-account-history-status.enum.d.ts

@@ -0,0 +1,4 @@
+export declare enum MyAccountHistoryStatusEnum {
+    SUCCESS = 0,
+    ERROR = 1
+}

package/src/lib/models/user/my-account-history-type.enum.d.ts

@@ -0,0 +1,5 @@
+export declare enum MyAccountHistoryTypeEnum {
+    REVIEW = 0,
+    UPGRADE_PLAN = 1,
+    UPLOAD_DOCUMENT = 2
+}

package/src/lib/models/user/my-account-history.d.ts

@@ -0,0 +1,11 @@
+import { MyAccountHistoryTypeEnum } from './my-account-history-type.enum';
+import { MyAccountHistoryInitiatedByEnum } from './my-account-history-initiated-by.enum';
+import { MyAccountHistoryStatusEnum } from './my-account-history-status.enum';
+export declare class MyAccountHistory {
+    id: number;
+    name: string;
+    type: MyAccountHistoryTypeEnum;
+    initiatedBy: MyAccountHistoryInitiatedByEnum;
+    date: Date;
+    status: MyAccountHistoryStatusEnum;
+}

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

@@ -0,0 +1,3 @@
+import { Occupation as OccupationBase } from '../../db/Models/client/occupation';
+export declare class Occupation extends OccupationBase {
+}

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-to-register.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Class with basic information about registering user
+ */
+export declare class UserToRegister {
+    firstName: string;
+    email: string;
+}

package/src/lib/models/user/user-work-position.const.d.ts

@@ -0,0 +1,3 @@
+export declare const USER_WORK_POSITION: {
+    [key: string]: string;
+};

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

@@ -0,0 +1,60 @@
+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 { SoleDetails } from '../sole';
+import { AppFile } from '../file';
+import { AccountSetupItem } from '../account-setup';
+import { TankTypeEnum } from '../../db/Enums/tank-type.enum';
+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;
+    addRoles(roles?: UserRolesEnum[]): void;
+    /**
+     * search roles including hierarchy
+     */
+    hasRoles(roles: UserRolesEnum | UserRolesEnum[]): boolean;
+    getTankTypes(): TankTypeEnum[];
+    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;
+    isTopManager(): boolean;
+    isManager(): boolean;
+    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;
+    get firmBranchNames(): string;
+}

package/src/lib/models/user-event/user-event-setting-field.enum.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Enum with user event setting fields
+ */
+export declare enum UserEventSettingFieldEnum {
+    BY_EMAIL = "byEmail",
+    BY_NOTIFICATION = "byNotification",
+    FREQUENCY = "frequency"
+}

package/src/lib/models/user-event/user-event-setting.d.ts

@@ -0,0 +1,6 @@
+import { UserEventSetting as UserEventSettingBase } from '../../db/Models/user/user-event-setting';
+import { UserEventType } from './user-event-type';
+export declare class UserEventSetting extends UserEventSettingBase {
+    type: UserEventType;
+    isUpdating?: boolean;
+}

package/src/lib/models/user-event/user-event-type-category.d.ts

@@ -0,0 +1,3 @@
+import { UserEventTypeCategory as UserEventTypeCategoryBase } from '../../db/Models/user/user-event-type-category';
+export declare class UserEventTypeCategory extends UserEventTypeCategoryBase {
+}

package/src/lib/models/user-event/user-event-type.d.ts

@@ -0,0 +1,8 @@
+import { UserEventType as UserEventTypeBase } from '../../db/Models/user/user-event-type';
+import { UserEventTypeCategory } from './user-event-type-category';
+import { UserEventSetting } from './user-event-setting';
+export declare class UserEventType extends UserEventTypeBase {
+    category: UserEventTypeCategory;
+    toSetting(): UserEventSetting;
+    get frequencyLabel(): string;
+}

package/src/lib/models/vehicle/index.d.ts

@@ -0,0 +1,4 @@
+export * from './vehicle';
+export * from './vehicle-claim';
+export * from './vehicle-claim-details';
+export * from './vehicle-logbook';

package/src/lib/models/vehicle/vehicle-claim-details.d.ts

@@ -0,0 +1,14 @@
+import { VehicleClaimDetails as VehicleClaimDetailsBase } from '../../db/Models/vehicle/vehicle-claim-details';
+import { User } from '../user';
+import { VehicleClaimDetailsMethodEnum } from '../../db/Enums/vehicle-claim-details-method.enum';
+export declare class VehicleClaimDetails extends VehicleClaimDetailsBase {
+    /**
+     * Init default values for the new instances
+     */
+    isManual: boolean;
+    method: VehicleClaimDetailsMethodEnum;
+    financialYear: number;
+    user: User;
+    isLogbookMethod(): boolean;
+    isKmsMethod(): boolean;
+}

package/src/lib/models/vehicle/vehicle-claim.d.ts

@@ -0,0 +1,32 @@
+import { VehicleClaim as VehicleClaimBase } from '../../db/Models/vehicle/vehicle-claim';
+import { TankTypeEnum } from '../../db/Enums/tank-type.enum';
+import { TransactionCollection } from '../../collections';
+import { VehicleClaimDetails } from './vehicle-claim-details';
+import { SoleBusiness } from '../sole';
+export declare class VehicleClaim extends VehicleClaimBase {
+    /**
+     * limit for kms claim method
+     */
+    static totalKmsLimit: number;
+    /**
+     * limit for work usage claim method
+     */
+    static totalWorkUsagePercent: number;
+    details: VehicleClaimDetails;
+    business: SoleBusiness;
+    kilometers: number;
+    workUsage: number;
+    isWorkTank(): boolean;
+    isSoleTank(): boolean;
+    get tankType(): TankTypeEnum;
+    /**
+     * Claim amount for KMs method. Exists only for KMs method.
+     */
+    getKMSClaimAmount(vehicleClaimRate: number): number;
+    /**
+     * Get logbook claim amount. Exists only for logbook method.
+     * ClaimAmount = WorkUsage * transaction/depreciation amount
+     */
+    getLogbookClaimAmount(transactions: TransactionCollection): number;
+    getAverageWeeklyKMS(): number;
+}

package/src/lib/models/vehicle/vehicle-logbook.d.ts

@@ -0,0 +1,9 @@
+import { VehicleLogbook as VehicleLogbookBase } from '../../db/Models/vehicle/vehicle-logbook';
+import { SoleBusiness } from '../sole';
+import { TankTypeEnum } from '../../db/Enums/tank-type.enum';
+export declare class VehicleLogbook extends VehicleLogbookBase {
+    date: Date;
+    business: SoleBusiness;
+    get kilometers(): number;
+    get tankType(): TankTypeEnum;
+}

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

@@ -0,0 +1,5 @@
+import { Vehicle as VehicleBase } from '../../db/Models/vehicle/vehicle';
+import { VehicleLogbook } from './vehicle-logbook';
+export declare class Vehicle extends VehicleBase {
+    logbook: VehicleLogbook[];
+}

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/pipes/app-percent.pipe.d.ts

@@ -0,0 +1,8 @@
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class AppPercentPipe implements PipeTransform {
+    private percentagePipe;
+    transform(value: number, total?: number, floor?: boolean): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppPercentPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<AppPercentPipe, "percentage", true>;
+}

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

@@ -0,0 +1,3 @@
+export * from './app-currency.pipe';
+export * from './safe-url.pipe';
+export * from './app-percent.pipe';

package/src/lib/pipes/safe-url.pipe.d.ts

@@ -0,0 +1,10 @@
+import { PipeTransform } from '@angular/core';
+import { DomSanitizer, SafeResourceUrl } from '@angular/platform-browser';
+import * as i0 from "@angular/core";
+export declare class SafeUrlPipe implements PipeTransform {
+    private sanitizer;
+    constructor(sanitizer: DomSanitizer);
+    transform(url: string): SafeResourceUrl;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SafeUrlPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SafeUrlPipe, "safeUrl", true>;
+}

package/src/lib/resolvers/business/business.resolver.d.ts

@@ -0,0 +1,11 @@
+import { Observable } from 'rxjs';
+import { SoleDetails } from '../../models';
+import { SoleDetailsService } from '../../services';
+import * as i0 from "@angular/core";
+export declare class BusinessResolver {
+    private soleDetailsService;
+    constructor(soleDetailsService: SoleDetailsService);
+    resolve(): Observable<SoleDetails>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BusinessResolver, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BusinessResolver>;
+}

package/src/lib/resolvers/business/sole-details.resolver.d.ts

@@ -0,0 +1,11 @@
+import { Observable } from 'rxjs';
+import { SoleDetails } from '../../models';
+import { SoleDetailsService } from '../../services';
+import * as i0 from "@angular/core";
+export declare class SoleDetailsResolver {
+    private soleDetails;
+    constructor(soleDetails: SoleDetailsService);
+    resolve(): Observable<SoleDetails>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SoleDetailsResolver, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SoleDetailsResolver>;
+}

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

@@ -0,0 +1,2 @@
+export * from './business/business.resolver';
+export * from './business/sole-details.resolver';

package/src/lib/services/account-setup/account-setup.service.d.ts

@@ -0,0 +1,74 @@
+import { BankAccount, Property, SoleBusiness, User } from '../../models';
+import { AllocationRuleService, BankAccountService, BankConnectionService, BankTransactionService, ClientInviteService, ClientMovementService, DepreciationService, EmployeeInviteService, EmployeeService, FirmService, HoldingTradeService, HomeOfficeClaimService, IncomeSourceService, LoanService, PropertyService, PropertyShareService, SharesightDetailsService, SoleBusinessService, TransactionAllocationService, TransactionService, UserService, VehicleClaimService } from '../http';
+import { AccountSetupItemCollection } from '../../collections';
+import { Observable } from 'rxjs';
+import { SetupItemService } from '../http/setup-item/setup-item.service';
+import * as i0 from "@angular/core";
+/**
+ * Service handling user's account setup process.
+ * Checks required steps and their completion
+ */
+export declare class AccountSetupService {
+    private setupItemService;
+    private propertyService;
+    private incomeSourceService;
+    private bankConnectionService;
+    private bankAccountsService;
+    private bankTransactionService;
+    private loanService;
+    private allocationRuleService;
+    private transactionAllocationService;
+    private vehicleClaimService;
+    private homeOfficeClaimService;
+    private transactionService;
+    private depreciationService;
+    private businessService;
+    private holdingService;
+    private userService;
+    private clientMovementService;
+    private clientInviteService;
+    private employeeService;
+    private employeeInviteService;
+    private firmService;
+    private sharesightDetailsService;
+    private propertyShareService;
+    items: AccountSetupItemCollection;
+    user: User;
+    constructor(setupItemService: SetupItemService, propertyService: PropertyService, incomeSourceService: IncomeSourceService, bankConnectionService: BankConnectionService, bankAccountsService: BankAccountService, bankTransactionService: BankTransactionService, loanService: LoanService, allocationRuleService: AllocationRuleService, transactionAllocationService: TransactionAllocationService, vehicleClaimService: VehicleClaimService, homeOfficeClaimService: HomeOfficeClaimService, transactionService: TransactionService, depreciationService: DepreciationService, businessService: SoleBusinessService, holdingService: HoldingTradeService, userService: UserService, clientMovementService: ClientMovementService, clientInviteService: ClientInviteService, employeeService: EmployeeService, employeeInviteService: EmployeeInviteService, firmService: FirmService, sharesightDetailsService: SharesightDetailsService, propertyShareService: PropertyShareService);
+    /**
+     * Get list of account setup items for current user/firm
+     */
+    get(property?: Property, business?: SoleBusiness, bankAccount?: BankAccount): Observable<AccountSetupItemCollection>;
+    setItemsStatus(property?: Property, business?: SoleBusiness, bankAccount?: BankAccount): Observable<AccountSetupItemCollection>;
+    /**
+     * Check and update isCompleted flag for passed item
+     */
+    private setItemStatus;
+    private getAllocations;
+    private getTransactions;
+    private getCoOwners;
+    /**
+     * AccountSetupItemsEnum.FIRM_CLIENTS completed when client invites sent or accepted
+     */
+    private getClients;
+    /**
+     * AccountSetupItemsEnum.FIRM_EMPLOYEES completed when employee invites sent or accepted
+     */
+    private getEmployees;
+    /**
+     * AccountSetupItemsEnum.FIRM_DETAILS when firm data filled
+     */
+    private getFirms;
+    /**
+     * @TODO Alex: work with collection when services refactored
+     * @TODO Vik: waiting for income sources refactoring
+     */
+    private getIncomeSources;
+    private getVehicleClaims;
+    private getHomeOfficeClaims;
+    private getBankAccounts;
+    private getDepreciations;
+    private getSharesightDetails;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AccountSetupService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AccountSetupService>;
+}

package/src/lib/services/account-setup/index.d.ts

@@ -0,0 +1 @@
+export * from './account-setup.service';