taxtank-core 0.0.2 → 0.0.3

package/lib/models/tax-review/tax-review.d.ts

@@ -0,0 +1,52 @@
+import { TaxReview as TaxReviewBase } from '../../db/Models/tax-review';
+import { TaxReviewStatusEnum } from '../../db/Enums/tax-review-status.enum';
+import { User } from '../user/user';
+export declare class TaxReview extends TaxReviewBase {
+    client: User;
+    employee: User;
+    status: TaxReviewStatusEnum;
+    /**
+     * if tax review status is 'Cancelled'
+     */
+    isCancelled(): boolean;
+    /**
+     * if tax review status is 'New'
+     */
+    isNew(): boolean;
+    /**
+     * if tax review status is 'In progress'
+     */
+    isInProgress(): boolean;
+    /**
+     * if tax review status is 'Waiting for client'
+     */
+    isWaitingForClient(): boolean;
+    /**
+     * if tax review status is 'Waiting for approval'
+     */
+    isWaitingForApproval(): boolean;
+    /**
+     * if tax review status is 'Approved'
+     */
+    isApproved(): boolean;
+    /**
+     * if tax review status is 'Completed'
+     */
+    isCompleted(): boolean;
+    /**
+     * if tax review status is 'Sent'
+     */
+    isSent(): boolean;
+    /**
+     * if tax review status is 'Amend'
+     */
+    isAmend(): boolean;
+    /**
+     * If tax review is inactive
+     */
+    isInactive(): boolean;
+    /**
+     * If tax review is active
+     */
+    isActive(): boolean;
+}

package/lib/models/tax-summary/tax-return-category-item-details.d.ts

@@ -0,0 +1,13 @@
+import { TaxReturnCategorySectionEnum } from '../../db/Enums/tax-return-category-section.enum';
+/**
+ * Used in tax summary reports to show specific details relating to an amount in the report.
+ * See structure in TaxReturnCategoryItem class.
+ * Example an amount of $550 for property income could be comprised of 2 different property amounts of $300 and $250.
+ * This is useful in providing drill-down information for the tax summary report.
+ */
+export declare class TaxReturnCategoryItemDetails {
+    amount: number;
+    name: string;
+    type: number;
+    section: TaxReturnCategorySectionEnum;
+}

package/lib/models/tax-summary/tax-return-category-item.d.ts

@@ -0,0 +1,18 @@
+import { TaxReturnCategory } from '../../db/Models/tax-return-category';
+import { TaxReturnCategoryItemDetails } from './tax-return-category-item-details';
+/**
+ * Used in tax summary reports to show amounts relating to a tax return category entity and details of what this
+ * amount is comprised of. Example here shows an amount of $951.96 and also details of what this amount is comprised of:
+ */
+export declare class TaxReturnCategoryItem {
+    amount: number;
+    details: TaxReturnCategoryItemDetails[];
+    items: TaxReturnCategoryItem[];
+    taxReturnCategory: TaxReturnCategory;
+    taxWithheld: number;
+    /**
+     * Get amount for one income source
+     * @param name Name of income source for filter
+     */
+    getAmountByIncomeSourceName(name: string): number;
+}

package/lib/models/tax-summary/tax-summary-section.d.ts

@@ -0,0 +1,12 @@
+import { TaxSummarySectionEnum } from '../../db/Enums/tax-summary-section.enum';
+import { TaxReturnCategoryItemCollection } from '../../collections/tax-return-category-item.collection';
+/**
+ * Base class for each sections of Tax Summary report, contains common properties/methods
+ * See also TaxSummary model
+ */
+export declare class TaxSummarySection {
+    section: TaxSummarySectionEnum;
+    netAmount: number;
+    items: TaxReturnCategoryItemCollection;
+    id?: string;
+}

package/lib/models/tax-summary/tax-summary-type.enum.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Enum for tax summary types
+ */
+export declare enum TaxSummaryTypeEnum {
+    ACTUALS = "actuals",
+    FORECASTS = "forecasts"
+}

package/lib/models/tax-summary/tax-summary.d.ts

@@ -0,0 +1,44 @@
+import { TaxSummarySection } from './tax-summary-section';
+/**
+ * @Todo refactor with base model when it will be provided
+ * Tax summary report structure
+ */
+export declare class TaxSummary {
+    work: TaxSummarySection;
+    property: TaxSummarySection;
+    otherIncome: TaxSummarySection;
+    summary: TaxSummarySection;
+    projectedTaxPosition: number;
+    get sections(): TaxSummarySection[];
+    get taxPercent(): number;
+    /**
+     * Work Net Cash = Income - tax withheld - expenses - interest
+     * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/217677990/Dashboard+Main
+     */
+    get workNetCash(): number;
+    /**
+     * Work Net Total = Income - expenses - interest
+     * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/217677990/Dashboard+Main
+     */
+    get workNetTotal(): number;
+    /**
+     * Property Net Cash (Cash Position) = Rental Income - expenses - interest
+     * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/217677990/Dashboard+Main
+     */
+    get propertyNetCash(): number;
+    /**
+     * Property Net Total (Tax Position) = Rental Income - expenses - interest - depreciation
+     * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/217677990/Dashboard+Main
+     */
+    get propertyNetTotal(): number;
+    /**
+     * Other Net Cash = gross income – expenses – tax withheld - tax instalments
+     * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/217677990/Dashboard+Main
+     */
+    get otherNetCash(): number;
+    /**
+     * Other Net Total = Gross income - expenses + tax offsets + tax instalments + franking credits
+     * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/217677990/Dashboard+Main
+     */
+    get otherNetTotal(): number;
+}

package/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/lib/models/transaction/transaction-allocation.d.ts

@@ -0,0 +1,12 @@
+import { TransactionAllocation as TransactionAllocationBase } from '../../db/Models/transaction-allocation';
+import { BankTransaction } from '../bank/bank-transaction';
+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/lib/models/transaction/transaction-metadata.d.ts

@@ -0,0 +1,5 @@
+import { TransactionMetadata as TransactionMetadataBase } from '../../db/Models/transaction-metadata';
+import { ChartAccountsMetadata } from '../chart-accounts/chart-accounts-metadata';
+export declare class TransactionMetadata extends TransactionMetadataBase {
+    metadata: ChartAccountsMetadata;
+}

package/lib/models/transaction/transaction-receipt.d.ts

@@ -0,0 +1,8 @@
+import { TransactionReceipt as TransactionReceiptBase } from '../../db/Models/transaction-receipt';
+import { IAsset } from '../../interfaces/asset.interface';
+import { AssetTypeEnum } from '../../interfaces/asset-type.enum';
+import { AssetEntityTypeEnum } from '../../interfaces/asset-entity-type.enum';
+export declare class TransactionReceipt extends TransactionReceiptBase implements IAsset {
+    type: AssetTypeEnum;
+    entityType: AssetEntityTypeEnum;
+}

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

@@ -0,0 +1,98 @@
+import { Transaction as TransactionBase } from '../../db/Models/transaction';
+import { ChartAccountsCategoryEnum } from '../../db/Enums/chart-accounts-category.enum';
+import { TransactionOperationEnum } from '../../db/Enums/transaction-operation.enum';
+import { Property } from '../property/property';
+import { TransactionReceipt } from './transaction-receipt';
+import { ChartAccounts } from '../chart-accounts/chart-accounts';
+import { IncomeSource } from '../income-source/income-source';
+import { TransactionMetadata } from './transaction-metadata';
+import { Loan } from '../loan/loan';
+import { TransactionAllocation } from './transaction-allocation';
+import { IReceipt } from '../../interfaces/receipt.interface';
+import { ITank } from '../../interfaces/tank.interface';
+import { TransactionAllocationCollection } from '../../collections/transaction-allocation.collection';
+import { Depreciation } from '../depreciation/depreciation';
+export declare class Transaction extends TransactionBase implements IReceipt, ITank {
+    transactions: Transaction[];
+    property: Property;
+    receipt: TransactionReceipt;
+    chartAccounts: ChartAccounts;
+    incomeSource: IncomeSource;
+    metadata: TransactionMetadata[];
+    transfer: Transaction;
+    loan: Loan;
+    date: Date;
+    allocations: TransactionAllocation[];
+    file: File;
+    tax: number;
+    operation: TransactionOperationEnum;
+    allocatedAmount: number;
+    unallocatedAmount: number;
+    isSelected: boolean;
+    claimPercent: number;
+    amount: number;
+    isDebit(): boolean;
+    isCredit(): boolean;
+    isIncome(): boolean;
+    isExpense(): boolean;
+    isPersonal(): boolean;
+    get chartAccountsCategories(): ChartAccountsCategoryEnum[];
+    /**
+     * Check if transaction has 'Klms travelled for work' chart accounts category
+     */
+    get isKlmsChartAccountsCategory(): boolean;
+    /**
+     * Get transaction date
+     */
+    getDate(): Date;
+    /**
+     * Check if transaction type is vehicle
+     */
+    isVehicleTransaction(): boolean;
+    /**
+     * Get net amount (clean amount after all deductions)
+     */
+    getNetAmount(): number;
+    /**
+     * Get gross income amount
+     */
+    getGrossIncome(): number;
+    /**
+     * find franking credits metadata and return value
+     */
+    get frankingCredit(): 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;
+    /**
+     * Get value of transaction metadata field
+     * @param field for which value should be returned
+     */
+    private getMetadataFieldValue;
+    /**
+     * Returns Net or Gross income amount based on provided income type
+     * @param incomeType by which amount should be returned
+     */
+    private getIncomeAmountByType;
+    isInterest(): boolean;
+    isCash(): boolean;
+    /**
+     * Create Depreciation instance based on Transaction
+     */
+    toDepreciation(): Depreciation;
+    /**
+     * Check if transaction is completely allocated
+     */
+    isAllocated(allocations: TransactionAllocationCollection): boolean;
+    /**
+     * Get transaction allocated amount
+     */
+    getAllocatedAmount(allocations: TransactionAllocationCollection): number;
+    /**
+     * Get transaction unallocated amount
+     */
+    getUnallocatedAmount(allocations: TransactionAllocationCollection): number;
+}

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

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

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

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

package/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/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/lib/models/user/occupation.d.ts

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

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

@@ -0,0 +1,4 @@
+import { UserRolesEnum } from '../../db/Enums/user-roles.enum';
+export declare const USER_ROLES: {
+    [key: string]: UserRolesEnum[];
+};

package/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/lib/models/user/user-work-position.const.d.ts

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

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

@@ -0,0 +1,64 @@
+import { User as BaseUser } from '../../db/Models/user';
+import { UserRolesEnum } from '../../db/Enums/user-roles.enum';
+import { Address } from '../address/address';
+import { ClientDetails } from '../client/client-details';
+import { EmployeeDetails } from '../employee/employee-details';
+import { Phone } from '../phone/phone';
+import { ServiceSubscription } from '../service-subscription/service-subscription';
+import { ServiceSubscriptionItem } from '../service-subscription/service-subscription-item';
+import { Photoable } from '../../interfaces/photoable';
+export declare class User extends BaseUser implements Photoable {
+    subscriptions: ServiceSubscription[];
+    clientDetails: ClientDetails;
+    employeeDetails: EmployeeDetails;
+    address: Address;
+    phone: Phone;
+    createdAt: Date;
+    clients: User[];
+    get fullName(): string;
+    get activeSubscription(): ServiceSubscription;
+    get lastSubscription(): ServiceSubscription;
+    /**
+     * @TODO refactor
+     *
+     */
+    get position(): string;
+    hasRole(role: UserRolesEnum): boolean;
+    isOnboarding(): 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;
+    /**
+     * Get user's photo link
+     */
+    getPhoto(): string;
+    /**
+     * get user's initials
+     */
+    getInitials(): string;
+}

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

@@ -0,0 +1,8 @@
+import { UserEventCategoryEnum } from './user-event-category.enum';
+/**
+ * Category of user event type
+ */
+export declare class UserEventCategory {
+    name: string;
+    type: UserEventCategoryEnum;
+}

package/lib/models/user-event/user-event-category.enum.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Enum with user event categories
+ */
+export declare enum UserEventCategoryEnum {
+    USER = 1,
+    CO_OWNER = 2,
+    FIRM = 3,
+    BASIQ = 4
+}

package/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/lib/models/user-event/user-event-setting.d.ts

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

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

@@ -0,0 +1,5 @@
+import { UserEventType as UserEventTypeBase } from '../../db/Models/user-event-type';
+import { UserEventCategory } from './user-event-category';
+export declare class UserEventType extends UserEventTypeBase {
+    category: UserEventCategory;
+}

package/lib/services/address/address.service.d.ts

@@ -0,0 +1,14 @@
+import { HttpClient } from '@angular/common/http';
+import { Observable, ReplaySubject } from 'rxjs';
+import { Country } from '../../models/address/country';
+import * as i0 from "@angular/core";
+export declare class AddressService {
+    private http;
+    private environment;
+    _countries: Country[];
+    countriesSubject: ReplaySubject<Country[]>;
+    constructor(http: HttpClient, environment: any);
+    getCountries(): Observable<Country[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AddressService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AddressService>;
+}

package/lib/services/asset/assets.service.d.ts

@@ -0,0 +1,34 @@
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { IAsset } from '../../interfaces/asset.interface';
+import { UserSwitcherService } from '../user/user-switcher.service';
+import * as i0 from "@angular/core";
+/**
+ * Service to work with assets (documents, receipts, e.t.c.)
+ */
+export declare class AssetsService {
+    private http;
+    private userSwitcherService;
+    private environment;
+    impersonatedClient: string;
+    constructor(http: HttpClient, userSwitcherService: UserSwitcherService, environment: any);
+    /**
+     * Get asset link
+     * @param asset to get the link for
+     */
+    getLink(asset: IAsset): Observable<any>;
+    /**
+     * Download asset
+     * @param asset which should be downloaded
+     * @TODO refactor
+     */
+    download(asset: IAsset): string;
+    /**
+     * Delete asset
+     * @param entityId: id of asset main entity (property, folder, transaction, e.t.c.)
+     * @param asset which should be deleted
+     */
+    delete(entityId: number, asset: IAsset): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AssetsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AssetsService>;
+}

package/lib/services/auth/auth.service.d.ts

@@ -0,0 +1,17 @@
+import { BehaviorSubject } from 'rxjs';
+import { HttpClient } from '@angular/common/http';
+import { JwtService } from './jwt.service';
+import * as i0 from "@angular/core";
+export declare class AuthService {
+    private http;
+    private jwtService;
+    private environment;
+    isLoggedInSubject: BehaviorSubject<boolean>;
+    constructor(http: HttpClient, jwtService: JwtService, environment: any);
+    setAuth(response: any): void;
+    login(username: string, password: string): import("rxjs").Observable<any>;
+    refresh(refreshToken: string): import("rxjs").Observable<any>;
+    logoutFront(url?: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthService>;
+}

package/lib/services/auth/jwt.service.d.ts

@@ -0,0 +1,16 @@
+import { JwtHelperService } from '@auth0/angular-jwt';
+import { User } from '../../models/user/user';
+import * as i0 from "@angular/core";
+export declare class JwtService extends JwtHelperService {
+    getToken(): string;
+    getRefreshToken(): string;
+    saveTokens(tokens: {
+        token: string;
+        refreshToken: string;
+    }): void;
+    destroyTokens(): void;
+    getUser(): User;
+    isMe(userId: number): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<JwtService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<JwtService>;
+}

package/lib/services/bank/bank-account-calculation.service.d.ts

@@ -0,0 +1,19 @@
+import { BankAccountCollection } from '../../collections/bank-account.collection';
+import { BankTransactionCollection } from '../../collections/bank-transaction.collection';
+import { TransactionAllocationCollection } from '../../collections/transaction-allocation.collection';
+import { BankTransactionCalculationService } from './bank-transaction-calculation.service';
+import * as i0 from "@angular/core";
+export declare class BankAccountCalculationService {
+    private bankTransactionCalculationService;
+    constructor(bankTransactionCalculationService: BankTransactionCalculationService);
+    /**
+     * Sum of bank accounts opening balances and their bank transactions allocated amounts
+     */
+    getTaxTankBalance(bankAccounts: BankAccountCollection, bankTransactions: BankTransactionCollection, allocations: TransactionAllocationCollection): number;
+    /**
+     * get difference between total loans amount and total cash amount
+     */
+    getNetPosition(bankAccounts: BankAccountCollection, bankTransactions: BankTransactionCollection, allocations: TransactionAllocationCollection): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BankAccountCalculationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BankAccountCalculationService>;
+}

package/lib/services/bank/bank-account.service.d.ts

@@ -0,0 +1,47 @@
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { BankAccount as BankAccountBase } from '../../db/Models/bank-account';
+import { BaseRestService } from '../base-rest.service';
+import { BankAccount } from '../../models/bank/bank-account';
+import { EventDispatcherService } from '../event/event-dispatcher.service';
+import * as i0 from "@angular/core";
+/**
+ * Service that handling user's bank accounts logic
+ */
+export declare class BankAccountService extends BaseRestService<BankAccountBase, BankAccount> {
+    protected http: HttpClient;
+    protected eventDispatcherService: EventDispatcherService;
+    protected environment: any;
+    url: string;
+    modelClass: typeof BankAccount;
+    constructor(http: HttpClient, eventDispatcherService: EventDispatcherService, environment: any);
+    /**
+     * Listen system notifications and update cache when got basiq notification received
+     */
+    listenEvents(): void;
+    /**
+     * Created manual bank account
+     * @param bankAccounts
+     * @param queryParams
+     */
+    addBatch(bankAccounts: BankAccount[], queryParams?: object): Observable<BankAccount[]>;
+    /**
+     * Update bank account and fire event
+     */
+    update(bankAccount: BankAccount): Observable<BankAccount>;
+    /**
+     * Update bank account opening balance
+     * @param bankAccount Bank account for balance updating
+     */
+    updateOpeningBalance(bankAccount: BankAccount): Observable<any>;
+    /**
+     * Update bank account current balance
+     */
+    updateCurrentBalance(bankAccount: BankAccount): Observable<BankAccount>;
+    /**
+     * Listen to EventDispatcherService event related to updated Property Owner Updated
+     */
+    private listenToPropertyOwnerUpdated;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BankAccountService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BankAccountService>;
+}

package/lib/services/bank/bank-connection.service.d.ts

@@ -0,0 +1,22 @@
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { BankConnection as BankConnectionBase } from '../../db/Models/bank-connection';
+import { EventDispatcherService } from '../event/event-dispatcher.service';
+import { BankConnection } from '../../models/bank/bank-connection';
+import { BaseRestService } from '../base-rest.service';
+import * as i0 from "@angular/core";
+/**
+ * BankConnection means user account at specific bank (usually each user has only one at the same bank)
+ * service handles BankConnection management
+ */
+export declare class BankConnectionService extends BaseRestService<BankConnectionBase, BankConnection> {
+    protected http: HttpClient;
+    protected eventDispatcherService: EventDispatcherService;
+    protected environment: any;
+    modelClass: typeof BankConnection;
+    url: string;
+    constructor(http: HttpClient, eventDispatcherService: EventDispatcherService, environment: any);
+    post(bankConnection: BankConnection): Observable<BankConnection>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BankConnectionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BankConnectionService>;
+}