import * as i0 from '@angular/core';
import { OnInit, ChangeDetectorRef, EventEmitter, PipeTransform } from '@angular/core';
import { Observable, BehaviorSubject } from 'rxjs';
import { HttpErrorResponse, HttpClient } from '@angular/common/http';
import { Observable as Observable$1 } from 'rxjs/internal/Observable';
import * as i19 from '@angular/forms';
import { FormGroup, FormBuilder, FormArray } from '@angular/forms';
import { Meta, SafeHtml, DomSanitizer } from '@angular/platform-browser';
import { Router, ActivatedRoute } from '@angular/router';
import * as i18 from '@angular/common';
import { Location } from '@angular/common';
import * as i20 from '@angular/material/table';
import { MatTableDataSource } from '@angular/material/table';
import * as i22 from '@angular/material/sort';
import { MatSort } from '@angular/material/sort';
import * as i21 from '@angular/material/paginator';
import { MatPaginator } from '@angular/material/paginator';
import * as i23 from '@angular/material/form-field';
import * as i24 from '@angular/material/input';
import * as i37 from 'rpx-xui-translation';
import { RpxLanguage } from 'rpx-xui-translation';

declare class PaymentLibService {
    API_ROOT: string;
    BULKSCAN_API_ROOT: string;
    REFUNDS_API_ROOT: string;
    NOTIFICATION_API_ROOT: string;
    CARDPAYMENTRETURNURL: string;
    constructor();
    setApiRootUrl(apiRoot: string): void;
    getApiRootUrl(): string;
    setBulkScanApiRootUrl(bulkscanapiRoot: string): void;
    getBulkScanApiRootUrl(): string;
    setRefundndsApiRootUrl(refundsapiRoot: string): void;
    getRefundsApiRootUrl(): string;
    setNoticationApiRootUrl(notificationapiRoot: string): void;
    getNoticationApiRootUrl(): string;
    setCardPaymentReturnUrl(cardPaymentReturnUrl: string): void;
    getCardPaymentReturnUrl(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<PaymentLibService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PaymentLibService>;
}

interface IBSPayments {
    id?: string;
    dcn_reference?: string;
    bgc_reference?: string;
    amount?: number;
    currency?: string;
    payment_method?: string;
    outbound_batch_number?: string;
    dcn_case?: string;
    case_reference?: string;
    po_box?: string;
    first_cheque_dcn_in_batch?: string;
    payer_name?: string;
    date_banked?: string;
    date_created?: string;
    date_updated?: string;
    length?: number;
    expanded?: boolean;
}

interface IOrderReferenceFee {
    orderRefId: number;
    orderTotalFees: number;
    orderStatus: string;
    orderParty: string;
    orderCCDEvent: string;
    orderCreated: Date;
    orderAddBtnEnable: boolean;
}

interface IRefundContactDetails {
    address_line?: string;
    city?: string;
    country?: string;
    county?: string;
    email?: string;
    notification_type?: string;
    postal_code?: string;
}

interface IRefundList {
    amount: number;
    ccd_case_number: string;
    date_created: string;
    date_updated: string;
    payment_reference: string;
    reason: string;
    reason_code: string;
    refund_reference: string;
    refund_status: {
        description: string;
        name: string;
    };
    contact_details: IRefundContactDetails;
    user_full_name: string;
    service_type: string;
    fee_ids: string;
    code: string;
}

interface IPaymentView {
    method: string;
    payment_group_reference: string;
    reference: string;
}

declare class OrderslistService {
    private ordersList;
    private refundView;
    private caseType;
    getcaseType: Observable<string>;
    private feeExists;
    getFeeExist: Observable<boolean>;
    private ccdCaseNumber;
    getCCDCaseNumberforRefund: Observable<string>;
    private isFromServiceRequestPage;
    getisFromServiceRequestPage: Observable<boolean>;
    private OrderRefId;
    getOrderRefId: Observable<string>;
    private navigationPage;
    getnavigationPage: Observable<string>;
    private orderRef;
    getorderRef: Observable<string>;
    private orderCCDEvent;
    getorderCCDEvent: Observable<string>;
    private orderCreated;
    getorderCreated: Observable<Date>;
    private orderParty;
    getorderParty: Observable<string>;
    private orderRemissionTotal;
    getorderRemissionTotal: Observable<number>;
    private orderFeesTotal;
    getorderFeesTotal: Observable<number>;
    private orderTotalPayments;
    getorderTotalPayments: Observable<number>;
    private rolesList;
    private orderDetail;
    private paymentPageView;
    constructor();
    setOrdersList(orderLevelFees: IOrderReferenceFee[]): void;
    getOrdersList(): BehaviorSubject<IOrderReferenceFee[]>;
    setRefundView(refundList: IRefundList): void;
    getRefundView(): BehaviorSubject<IRefundList>;
    setCaseType(caseType: string): void;
    getCaseType(): BehaviorSubject<string>;
    setCCDCaseNumber(ccdCaseNumber: string): void;
    getCCDCaseNumber(): BehaviorSubject<string>;
    setFeeExists(feeExists: boolean): void;
    getFeeExists(): BehaviorSubject<boolean>;
    setisFromServiceRequestPage(isFromServiceRequestPage: boolean): void;
    getisFromServiceRequestPages(): BehaviorSubject<boolean>;
    setOrderRefId(OrderRefId: string): void;
    getSelectedOrderRefId(): BehaviorSubject<string>;
    setnavigationPage(navigationPage: string): void;
    getnavigationPageValue(): BehaviorSubject<string>;
    setpaymentPageView(paymentpageList: IPaymentView): void;
    getpaymentPageView(): BehaviorSubject<IPaymentView>;
    setUserRolesList(rolesList: any[]): void;
    getUserRolesList(): BehaviorSubject<any[]>;
    setorderDetail(orderDetail: any[]): void;
    getorderDetail(): BehaviorSubject<any[]>;
    setOrderRef(orderRef: string): void;
    getorderRefs(): BehaviorSubject<string>;
    setorderCCDEvent(orderCCDEvent: string): void;
    getorderCCDEvents(): BehaviorSubject<string>;
    setorderCreated(orderCreated: Date): void;
    getorderCreateds(): BehaviorSubject<Date>;
    setorderParty(orderParty: string): void;
    getorderPartys(): BehaviorSubject<string>;
    setorderRemissionTotal(orderRemissionTotal: number): void;
    getorderRemissionTotals(): BehaviorSubject<number>;
    setorderFeesTotal(orderFeesTotal: number): void;
    getorderFeesTotals(): BehaviorSubject<number>;
    setorderTotalPayments(orderTotalPayments: number): void;
    getoorderTotalPaymentss(): BehaviorSubject<number>;
    static ɵfac: i0.ɵɵFactoryDeclaration<OrderslistService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<OrderslistService>;
}

interface IFee {
    code: string;
    version: string;
    volume?: number;
    calculated_amount: number;
    net_amount: number;
    description: string;
    ccd_case_number: string;
    id: number;
    jurisdiction1: string;
    jurisdiction2: string;
    reference: string;
    memo_line: string;
    fee_amount?: number;
    apportion_amount?: number;
    allocated_amount?: number;
    is_fully_apportioned?: string;
    date_apportioned?: string;
    date_created?: string;
    date_updated?: string;
    amount_due?: number;
    remission_enable?: boolean;
    add_remission?: boolean;
    over_payment?: number;
    refund_amount?: number;
    updated_volume?: number;
    selected?: any;
    issue_refund_add_refund_add_remission: boolean;
}

interface IStatusHistory {
    status: string;
    external_status: string;
    date_created: Date;
    error_code: string;
    error_message: string;
}

declare class IPaymentStatus {
    allocation_status: any;
    date_created: string;
    payment_group_reference: string;
    payment_reference: string;
    receiving_office: string;
    receiving_email_address: string;
    sending_email_address: string;
    unidentified_reason: string;
    user_id: string;
}

interface IPayment {
    amount: number;
    description: string;
    reference: string;
    currency: string;
    date_created: string;
    banked_date: string;
    document_control_number: string;
    payer_name: string;
    date_updated: string;
    ccd_case_number: string;
    case_reference: string;
    channel: string;
    method: string;
    external_provider: string;
    status: string;
    payment_allocation: IPaymentStatus[];
    external_reference: string;
    site_id: string;
    service_name: string;
    account_number: string;
    customer_reference: string;
    organisation_name: string;
    fees: IFee[];
    status_histories: IStatusHistory[];
    payment_group_reference: string;
    paymentGroupReference?: string;
    refund_enable?: boolean;
    over_payment?: number;
    issue_refund_add_refund_add_remission: boolean;
    issue_refund: boolean;
}

interface IRemission {
    remission_reference: string;
    hwf_reference: string;
    hwf_amount: number;
    beneficiary_name: string;
    ccd_case_number: string;
    fee_code: string;
    date_created: string;
    fee_id: number;
    issue_refund_add_refund_add_remission: boolean;
    add_refund: boolean;
    overall_balance: number;
    acollection_of_fess: boolean;
}

interface IPaymentGroup {
    payment_group_reference: string;
    payments: IPayment[];
    remissions: IRemission[];
    fees: IFee[];
    refunds: IRefundList[];
}

declare class AddRetroRemissionRequest {
    hwf_amount: number;
    hwf_reference: string;
    constructor(hwf_amount: number, hwf_reference: string);
}

declare class PaymentLibComponent implements OnInit {
    private paymentLibService;
    private cd;
    private OrderslistService;
    API_ROOT: string;
    BULKSCAN_API_ROOT: string;
    REFUNDS_API_ROOT: string;
    NOTIFICATION_API_ROOT: string;
    CARDPAYMENTRETURNURL: string;
    CCD_CASE_NUMBER: string;
    EXC_REFERENCE: string;
    PAYMENT_METHOD: string;
    VIEW: string;
    VIEWSERVICE: string;
    PAYMENT_GROUP_REF?: string;
    TAKEPAYMENT: boolean;
    SERVICEREQUEST: string;
    DCN_NUMBER: string;
    SELECTED_OPTION: string;
    ISBSENABLE: Boolean;
    ISSFENABLE: boolean;
    ISTURNOFF: boolean;
    CASETYPE: string;
    ISPAYMENTSTATUSENABLED: boolean;
    rootUrl: boolean;
    REFUNDLIST: string;
    USERID: string;
    LOGGEDINUSERROLES: any[];
    LOGGEDINUSEREMAIL: string;
    isFromServiceRequestPage: boolean;
    telephonySelectionEnable: boolean;
    paymentMethod: string;
    bspaymentdcn: string;
    unProcessedPaymentServiceId: string;
    paymentGroupReference: string;
    paymentReference: string;
    refundReference: string;
    isFromPayBubble: boolean;
    refundlistsource: any;
    viewName: string;
    isTurnOff: boolean;
    caseType: string;
    unProcessedPayment: IBSPayments;
    isRefundStatusView: boolean;
    isRedirectFromCaseTransactionPage: string;
    isCallFromRefundList: boolean;
    isFromRefundStatusPage: boolean;
    iscancelClicked: boolean;
    isFromPaymentDetailPage: boolean;
    pbaPayOrderRef: IPayment;
    isTakePayment: boolean;
    orderDetail: any[];
    orderRef: string;
    orderStatus: string;
    orderParty: string;
    orderCreated: Date;
    orderCCDEvent: string;
    serviceRequestValue: string;
    orderAddBtnEnable: boolean;
    orderFeesTotal: number;
    orderRemissionTotal: number;
    orderTotalPayments: number;
    orderPendingPayments: number;
    paymentGroup: IPaymentGroup;
    overPaymentAmount: number;
    refunds: IRefundList[];
    constructor(paymentLibService: PaymentLibService, cd: ChangeDetectorRef, OrderslistService: OrderslistService);
    ngAfterContentChecked(): void;
    ngOnInit(): void;
    /**
     * Adds a remission to the payment group using data from the provided form group.
     *
     * This method checks if the `paymentGroup` is not null before attempting to add the remission.
     * If the `paymentGroup` exists, a new remission is created using the values from the provided
     * form group (`currentRemissionFormGroup`), and it is pushed into the `remissions` array of the payment group.
     *
     * @param {AddRetroRemissionRequest} currentRemissionFormGroup - The form group containing remission data
     *                                                               (e.g., `hwf_amount`, `hwf_reference`).
     */
    addRemission(currentRemissionFormGroup: AddRetroRemissionRequest): void;
    /**
     * This method is used to set the paymentGroup for the add remission journey.
     * @param updatedPaymentGroup this is an updated paymentGroup version.
     */
    addPaymentGroup(updatedPaymentGroup: IPaymentGroup): void;
    /**
     * Calculates the total remission amount for the current payment group.
     *
     * This method checks if the payment group contains any remissions and, if so,
     * sums up the `hwf_amount` of all remissions using the `reduce()` method.
     * If no remissions are found, it returns a default value of 0.
     *
     * @returns {number} The total remission amount, or 0 if no remissions are present.
     */
    getTotalRemission(): number;
    /**
     * Calculates the total fee amount for the current payment group.
     *
     * This method checks if the payment group contains any fees and, if so,
     * sums up the `calculated_amount` of all fees using the `reduce()` method.
     * If no fees are found, it returns a default value of 0.
     *
     * @returns {number} The total fee amount, or 0 if no fees are present.
     */
    getTotalFees(): number;
    /**
     * Calculates the total payment amount for the current payment group.
     *
     * This method checks if the payment group contains any payments and, if so,
     * sums up the `amount` of all payments using the `reduce()` method.
     * If no payments are found, it returns a default value of 0.
     *
     * @returns {number} The total payment amount, or 0 if no payments are present.
     */
    getTotalPayments(): number;
    /**
     * This function is used to find out if the current refunds list are in progress for the fee passed as parameter
     * @param fee this is the fee used to find out if the refunds are in progress.
     */
    isTheCurrentRefundInProcessForThisFee(fee: IFee): boolean;
    /**
     * This function is used to find out if in current list of refunds all refunds has been rejected
     * for the fee passed as parameter.
     * @param feeCode this is the fee code used to find out all refunds rejected refunds.
     */
    isTheCurrentRefundRejectedForTheFee(feeCode: string): boolean;
    /**
     * Rounds very small values to zero if they fall below a specified threshold.
     *
     * This is useful for eliminating floating-point precision errors that result in
     * extremely small non-zero values (e.g., 1.1368683772161603e-13) which should
     * logically be treated as zero.
     *
     * @param value - The numeric value to evaluate and potentially round.
     * @param threshold - The minimum absolute value considered significant. Defaults to 1e-10.
     * @returns The original value if it's above the threshold, or 0 if it's below.
     *
     * @example
     * roundTinyValue(1.1368683772161603e-13); // returns 0
     * roundTinyValue(0.00001); // returns 0.00001
     */
    roundTinyValue(value: number, threshold?: number): number;
    getRoundedOverPayment(): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<PaymentLibComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PaymentLibComponent, "ccpay-payment-lib", never, { "API_ROOT": { "alias": "API_ROOT"; "required": false; }; "BULKSCAN_API_ROOT": { "alias": "BULKSCAN_API_ROOT"; "required": false; }; "REFUNDS_API_ROOT": { "alias": "REFUNDS_API_ROOT"; "required": false; }; "NOTIFICATION_API_ROOT": { "alias": "NOTIFICATION_API_ROOT"; "required": false; }; "CARDPAYMENTRETURNURL": { "alias": "CARDPAYMENTRETURNURL"; "required": false; }; "CCD_CASE_NUMBER": { "alias": "CCD_CASE_NUMBER"; "required": false; }; "EXC_REFERENCE": { "alias": "EXC_REFERENCE"; "required": false; }; "PAYMENT_METHOD": { "alias": "PAYMENT_METHOD"; "required": false; }; "VIEW": { "alias": "VIEW"; "required": false; }; "VIEWSERVICE": { "alias": "VIEWSERVICE"; "required": false; }; "PAYMENT_GROUP_REF": { "alias": "PAYMENT_GROUP_REF"; "required": false; }; "TAKEPAYMENT": { "alias": "TAKEPAYMENT"; "required": false; }; "SERVICEREQUEST": { "alias": "SERVICEREQUEST"; "required": false; }; "DCN_NUMBER": { "alias": "DCN_NUMBER"; "required": false; }; "SELECTED_OPTION": { "alias": "SELECTED_OPTION"; "required": false; }; "ISBSENABLE": { "alias": "ISBSENABLE"; "required": false; }; "ISSFENABLE": { "alias": "ISSFENABLE"; "required": false; }; "ISTURNOFF": { "alias": "ISTURNOFF"; "required": false; }; "CASETYPE": { "alias": "CASETYPE"; "required": false; }; "ISPAYMENTSTATUSENABLED": { "alias": "ISPAYMENTSTATUSENABLED"; "required": false; }; "rootUrl": { "alias": "rootUrl"; "required": false; }; "REFUNDLIST": { "alias": "REFUNDLIST"; "required": false; }; "USERID": { "alias": "USERID"; "required": false; }; "LOGGEDINUSERROLES": { "alias": "LOGGEDINUSERROLES"; "required": false; }; "LOGGEDINUSEREMAIL": { "alias": "LOGGEDINUSEREMAIL"; "required": false; }; "isFromServiceRequestPage": { "alias": "isFromServiceRequestPage"; "required": false; }; "telephonySelectionEnable": { "alias": "telephonySelectionEnable"; "required": false; }; }, {}, never, never, false, never>;
}

interface IPayments {
    payments: IPayment[];
}

declare class ErrorHandlerService {
    constructor();
    handleError(err: HttpErrorResponse): Observable<any>;
    getServerErrorMessage(isErrorExist: any, isDataNotExist?: boolean, error?: string): {
        title: string;
        body: string;
        showError: any;
    };
    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorHandlerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ErrorHandlerService>;
}

declare abstract class Logger {
    info: any;
    warn: any;
    error: any;
}
declare class LoggerService implements Logger {
    info: any;
    warn: any;
    error: any;
    invokeConsoleMethod(type: string, args?: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LoggerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LoggerService>;
}

declare class PaymentListService {
    private http;
    private logger;
    private errorHandlerService;
    private paymentLibService;
    payments: IPayments;
    constructor(http: HttpClient, logger: LoggerService, errorHandlerService: ErrorHandlerService, paymentLibService: PaymentLibService);
    getPaymentByCcdCaseNumber(ccdCaseNumber: string, paymentMethod: string): Observable$1<IPayments>;
    static ɵfac: i0.ɵɵFactoryDeclaration<PaymentListService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PaymentListService>;
}

type PaymentLibAlias$f = PaymentLibComponent;
declare class PaymentListComponent implements OnInit {
    private paymentListService;
    private paymentLibComponent;
    payments: IPayments;
    errorMessage: string;
    code: string;
    constructor(paymentListService: PaymentListService, paymentLibComponent: PaymentLibAlias$f);
    ngOnInit(): void;
    loadPaymentViewComponent(paymentGroupReference: string, paymentReference: string, paymentMethod: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PaymentListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PaymentListComponent, "ccpay-payment-list", never, {}, {}, never, never, false, never>;
}

declare class WebComponentHttpClient {
    private http;
    private meta;
    constructor(http: HttpClient, meta: Meta);
    post(url: string, body: any | null, options?: any): Observable<any>;
    put(url: string, body: any | null, options?: any): Observable<any>;
    get(url: string, options?: any): Observable<any>;
    delete(url: string, options?: any): Observable<any>;
    patch(url: string, body: any | null, options?: any): Observable<any>;
    addHeaders(options: any): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<WebComponentHttpClient, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<WebComponentHttpClient>;
}

interface IRefundReasons {
    code: string;
    description: string;
    name: string;
    recently_used: boolean;
}

interface IPatchRefundAction {
    code: string;
    reason: string;
}

declare class IssueRefundRequest {
    payment_reference: string;
    refund_reason: string;
    refund_amount: number;
    constructor(payment_reference: string, refund_reason: string, refund_amount: number);
}

declare class IResubmitRefundRequest {
    refund_reason: string;
    amount: number;
    contact_details: IRefundContactDetails;
    refund_fees: IFee[];
    constructor(refund_reason: string, amount: number, contact_details: any, refund_fees: any[]);
}

declare class IPutNotificationRequest {
    recipient_email_address?: string;
    recipient_postal_address?: IRefundContactDetails;
    constructor(contactDetails: any, notificationType: string);
}

declare class RefundsService {
    private http;
    private https;
    private errorHandlerService;
    private paymentLibService;
    private meta;
    constructor(http: HttpClient, https: WebComponentHttpClient, errorHandlerService: ErrorHandlerService, paymentLibService: PaymentLibService, meta: Meta);
    getRefundReasons(): Observable<IRefundReasons[]>;
    getRefundRejectReasons(): Observable<any>;
    getRefundActions(refundReference: string): Observable<any>;
    patchRefundActions(body: IPatchRefundAction, refundReference: string, reviewerAction: string): Observable<any>;
    getRefundList(refundstatus?: string, selfexclusive?: boolean): Observable<IRefundList[]>;
    getRefundStatusHistory(reference?: string): Observable<any>;
    getRefundStatusList(ccdCaseNumber: string): Observable<IRefundList[]>;
    getUserDetails(): Observable<any>;
    postIssueRefund(body: IssueRefundRequest): Observable<any>;
    putResendOrEdit(body: IPutNotificationRequest, refundRef: string, notificationType: string): Observable<any>;
    patchResubmitRefund(body: IResubmitRefundRequest, refund_reference: string): Observable<any>;
    postResetRefund(refund_reference: string): Observable<any>;
    downloadRefundsReport(startDate: string, endDate: string): Observable<any>;
    addHeaders(options: any): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<RefundsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RefundsService>;
}

interface IRefundAction {
    code: string;
    label: string;
}

interface IRefundRejectReason {
    code: string;
    name: string;
}

interface IRefundsNotifications {
    contact_details: {
        address_line: string;
        city: string;
        country: string;
        county: string;
        date_created: string;
        date_updated: string;
        email: string;
        postal_code: string;
    };
    date_created: string;
    date_updated: string;
    notification_type: string;
    reference: string;
}

declare class NotificationPreviewRequest {
    notification_type?: string;
    payment_channel?: string;
    payment_method?: string;
    payment_reference?: string;
    personalisation?: {
        ccd_case_number?: string;
        refund_amount?: number;
        refund_reason?: string;
        refund_reference?: string;
        customer_reference?: string;
    };
    recipient_email_address?: string;
    recipient_postal_address?: {
        address_line?: string;
        city?: string;
        county?: string;
        country?: string;
        postal_code?: string;
    };
    service_name?: string;
    constructor(payment: IPayment, contactDetails: IRefundContactDetails, refund_reason: string, refund_amount: number, refund_reference: string, payment_reference: string);
}

declare class NotificationService {
    private http;
    private https;
    private errorHandlerService;
    private paymentLibService;
    constructor(http: HttpClient, https: WebComponentHttpClient, errorHandlerService: ErrorHandlerService, paymentLibService: PaymentLibService);
    getRefundNotification(reference: string): Observable<IRefundsNotifications>;
    getAddressByPostcode(postcode: string): Observable<any>;
    getNotificationPreview(body: NotificationPreviewRequest): Observable<any>;
    getNotificationInstructionType(paymentChannel: string, paymentMethod: string): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<NotificationService>;
}

declare class AddRemissionRequest {
    beneficiary_name: string;
    ccd_case_number: string;
    fee: IFee;
    hwf_amount: number;
    hwf_reference: string;
    payment_group_reference: string;
    case_type: string;
    constructor(ccd_case_number: string, fee: IFee, hwf_amount: number, hwf_reference: string, caseType: string);
}

declare class PaymentToPayhubRequest {
    currency: string;
    description: string;
    channel: string;
    provider: string;
    case_type: string;
    ccd_case_number: string;
    amount: number;
    telephony_system: string;
    constructor(ccd_case_number: string, amount: number, caseType: string, telephony_system: string);
}

declare class TelephonyToPayhubRequest {
    currency: string;
    case_type: string;
    ccd_case_number: string;
    amount: number;
    telephony_system: string;
    constructor(ccd_case_number: string, amount: number, caseType: string, telephony_system: string);
}

declare class UnidentifiedPaymentsRequest {
    payment_allocation_status: any;
    payment_group_reference: string;
    payment_reference: string;
    unidentified_reason: string;
    constructor(payment_group_reference: string, payment_reference: string, unidentified_reason: any);
}

declare class UnsolicitedPaymentsRequest {
    payment_allocation_status: any;
    payment_group_reference: string;
    payment_reference: string;
    receiving_office: string;
    receiving_email_address: string;
    sending_email_address: string;
    unidentified_reason: string;
    constructor(payment_group_reference: string, payment_reference: string, reason: string, responsible_office: string, responsible_person: string, email_id: string);
}

declare class AllocatePaymentRequest {
    amount: Number;
    banked_date: String;
    ccd_case_number: String;
    exception_record: string;
    currency: String;
    document_control_number: String;
    external_provider: String;
    giro_slip_no: String;
    payer_name: String;
    payment_channel: Object;
    payment_status: Object;
    payment_method: String;
    case_type: String;
    payment_allocation_dto?: {
        allocation_reason: String;
        allocation_status: String;
        explanation: String;
        payment_allocation_status: Object;
        payment_group_reference: String;
        payment_reference: String;
        reason: String;
        receiving_office: String;
        unidentified_reason: String;
        user_id: String;
        user_name: String;
        case_type: String;
    };
    constructor(ccd_case_number: string, unAllocatedPayment: IBSPayments, caseType: string, exceptionRecord: string, allocatedRequest?: any);
}

declare class IAllocationPaymentsRequest {
    payment_allocation_status: any;
    payment_group_reference: string;
    payment_reference: string;
    reason: string;
    explanation: string;
    user_name: string;
    constructor(payment_group_reference: string, payment_reference: string, reason?: string, explanation?: string, userName?: string);
}

declare class IserviceRequestPbaPayment {
    account_number: string;
    amount: string;
    currency: string;
    customer_reference: string;
    organisation_name: string;
    constructor(account_number: string, amount: string, customer_reference: string, orgName: string);
}

declare class IserviceRequestCardPayment {
    amount: string;
    currency: string;
    language: string;
    constructor(amount: string, language: string);
}

declare class PostRefundRetroRemission {
    ccd_case_number: string;
    payment_reference: string;
    refund_reason: string;
    total_refund_amount: any;
    fees: any[];
    is_over_payment: boolean;
    contact_details: IRefundContactDetails;
    constructor(contact_details: any, fees: any[], payment_reference: string, refund_reason: string, total_refund_amount: any, is_over_payment: string);
}

declare class PostIssueRefundRetroRemission {
    remissionReference: string;
    contact_details: IRefundContactDetails;
    constructor(remissionReference: string, contactDeatils: any);
}

declare class PaymentViewService {
    private http;
    private https;
    private logger;
    private errorHandlerService;
    private paymentLibService;
    private ordersList;
    private meta;
    constructor(http: HttpClient, https: WebComponentHttpClient, logger: LoggerService, errorHandlerService: ErrorHandlerService, paymentLibService: PaymentLibService);
    getPaymentDetails(paymentReference: string, paymentMethod?: string): Observable$1<IPayment>;
    getPaymentGroupDetails(paymentGroupReference: string): Observable$1<IPaymentGroup>;
    getApportionPaymentDetails(paymentReference: string): Observable$1<IPaymentGroup>;
    getPBAaccountDetails(): Observable$1<any>;
    postWays2PayCardPayment(serviceRef: string, body: IserviceRequestCardPayment): Observable$1<any>;
    postPBAaccountPayment(serviceRef: string, body: IserviceRequestPbaPayment): Observable$1<any>;
    postBSPayments(body: AllocatePaymentRequest): Observable$1<any>;
    postBSUnidentifiedPayments(body: UnidentifiedPaymentsRequest): Observable$1<any>;
    postBSUnsolicitedPayments(body: UnsolicitedPaymentsRequest): Observable$1<any>;
    postBSAllocationPayments(body: IAllocationPaymentsRequest): Observable$1<any>;
    postPaymentGroupWithRemissions(paymentGroupReference: string, feeId: number, body: AddRemissionRequest): Observable$1<any>;
    deleteFeeFromPaymentGroup(feeId: number): Observable$1<any>;
    postPaymentToPayHub(body: PaymentToPayhubRequest, paymentGroupRef: string): Observable$1<any>;
    postTelephonyPaymentToPayHub(body: TelephonyToPayhubRequest, paymentGroupRef: string): Observable$1<any>;
    downloadSelectedReport(reportName: string, startDate: string, endDate: string): Observable$1<any>;
    downloadFailureReport(startDate: string, endDate: string): Observable$1<any>;
    downloadTelephonyPaymentsReport(startDate: string, endDate: string): Observable$1<any>;
    getBSfeature(): Observable$1<any>;
    getSiteID(): Observable$1<any>;
    getPartyDetails(caseNumber: string): Observable$1<any>;
    setOrdersList(orderLevelFees: IOrderReferenceFee[]): void;
    getOrdersList(): BehaviorSubject<IOrderReferenceFee[]>;
    postRefundsReason(body: PostRefundRetroRemission): Observable$1<any>;
    postPaymentGroupWithRetroRemissions(paymentGroupReference: string, feeId: number, body: AddRetroRemissionRequest): Observable$1<any>;
    postRefundRetroRemission(body: PostIssueRefundRetroRemission): Observable$1<any>;
    getPaymentFailure(paymentReference: string): Observable$1<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<PaymentViewService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PaymentViewService>;
}

interface INotificationPreview {
    template_id: string;
    template_type: string;
    from: {
        from_email_address: string;
        from_mail_address: {
            address_line: string;
            city: string;
            county: string;
            country: string;
            postal_code: String;
        };
    };
    recipient_contact: {
        recipient_email_address: string;
        recipient_mail_address: {
            address_line: string;
            city: string;
            county: string;
            country: string;
            postal_code: String;
        };
    };
    subject: string;
    body: string;
    html: string;
}

type PaymentLibAlias$e = PaymentLibComponent;
declare class ProcessRefundComponent implements OnInit {
    private RefundsService;
    private paymentViewService;
    private formBuilder;
    private OrderslistService;
    private notificationService;
    private paymentLibComponent;
    private router;
    private activeRoute;
    refundReference: string;
    refundlistsource: IRefundList;
    processRefundForm: FormGroup;
    errorMessage: {
        title: string;
        body: string;
        showError: any;
    };
    sendmeback: string;
    viewStatus: string;
    refundActionList: IRefundAction[];
    refundRejectReasonList: IRefundRejectReason[];
    isSendMeBackClicked: boolean;
    isRejectClicked: boolean;
    isOtherClicked: boolean;
    isSuccesspageEnable: boolean;
    refundActionsHasError: boolean;
    refundRejectReasonHasError: boolean;
    isReasonFieldEmpty: boolean;
    isReasonFieldInvalid: boolean;
    reasonFieldMinHasError: boolean;
    reasonFieldMaxHasError: boolean;
    isReasonEmpty: boolean;
    isReasonInvalid: boolean;
    successMsg: string;
    navigationpage: string;
    ccdCaseNumber: string;
    isFromRefundListPage: boolean;
    cpoDetails: any;
    isCPODown: boolean;
    isConfirmButtondisabled: boolean;
    paymentObj: IPayment;
    templateInstructionType: string;
    notificationPreview: boolean;
    notificationPreviewObj: INotificationPreview;
    constructor(RefundsService: RefundsService, paymentViewService: PaymentViewService, formBuilder: FormBuilder, OrderslistService: OrderslistService, notificationService: NotificationService, paymentLibComponent: PaymentLibAlias$e, router: Router, activeRoute: ActivatedRoute);
    ngOnInit(): void;
    checkRefundActions(code: string): void;
    getNotificationPreviewObj(notificationPreviewObj: INotificationPreview): void;
    processRefundSubmit(): void;
    getErrorMessage(isErrorExist: any, status: any, errorMsg: any, err: any): {
        title: string;
        body: string;
        showError: any;
    };
    loadRefundListPage(): void;
    loadRefundsHomePage(): void;
    redirecttoRefundListPage(): void;
    loadCaseTransactionPage(): void;
    resetForm(vals: any, field: any): void;
    goToCaseReview(): void;
    getTemplateInstructionType(payment: IPayment, paymentReference: string): void;
    showNotificationPreview(): void;
    hideNotificationPreview(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ProcessRefundComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ProcessRefundComponent, "ccpay-process-refund", never, { "refundReference": { "alias": "refundReference"; "required": false; }; "refundlistsource": { "alias": "refundlistsource"; "required": false; }; }, {}, never, never, false, never>;
}

declare class RefundListComponent implements OnInit {
    private refundService;
    USERID: string;
    LOGGEDINUSERROLES: any[];
    LOGGEDINUSEREMAIL: string;
    constructor(refundService: RefundsService);
    tableApprovalHeader: string;
    tableRejectedHeader: string;
    submittedRefundList: IRefundList[];
    rejectedRefundList: IRefundList[];
    approvalStatus: string;
    rejectStatus: string;
    errorMessage: any;
    isApproveTableVisible: boolean;
    isRejectTableVisible: boolean;
    dropdownvalue: string;
    isAuthorized: boolean;
    userLst: any;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RefundListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RefundListComponent, "ccpay-refund-list", never, { "USERID": { "alias": "USERID"; "required": false; }; "LOGGEDINUSERROLES": { "alias": "LOGGEDINUSERROLES"; "required": false; }; "LOGGEDINUSEREMAIL": { "alias": "LOGGEDINUSEREMAIL"; "required": false; }; }, {}, never, never, false, never>;
}

interface ICardDetails {
    card_brand: string;
    cardholder_name: string;
    email: string;
    expiry_date: string;
    last_digits_card_number: string;
}

declare class CardDetailsService {
    private http;
    private logger;
    private errorHandlerService;
    private paymentLibService;
    constructor(http: HttpClient, logger: LoggerService, errorHandlerService: ErrorHandlerService, paymentLibService: PaymentLibService);
    getCardDetails(paymentReference: string): Observable$1<ICardDetails>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CardDetailsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CardDetailsService>;
}

declare class CardDetailsComponent implements OnInit {
    private cardDetailsService;
    private paymentLibComponent;
    pageTitle: string;
    cardDetails: ICardDetails;
    paymentReference: string;
    errorMessage: string;
    constructor(cardDetailsService: CardDetailsService, paymentLibComponent: PaymentLibComponent);
    ngOnInit(): void;
    get getPaymentReference(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<CardDetailsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CardDetailsComponent, "ccpay-card-details", never, {}, {}, never, never, false, never>;
}

declare class PageNotFoundComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<PageNotFoundComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PageNotFoundComponent, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class BulkScaningPaymentService {
    private http;
    private https;
    private errorHandlerService;
    private paymentLibService;
    constructor(http: HttpClient, https: WebComponentHttpClient, errorHandlerService: ErrorHandlerService, paymentLibService: PaymentLibService);
    getBSPaymentsByCCD(ccdCaseNumber: string): Observable<IBSPayments>;
    getBSPaymentsByDCN(dcn: string): Observable<IBSPayments>;
    postBSAllocatePayment(body: AllocatePaymentRequest, paymentRef: string): Observable<any>;
    postBSPaymentStrategic(body: AllocatePaymentRequest, paymentGroupRef: string): Observable<any>;
    postBSWoPGStrategic(body: AllocatePaymentRequest): Observable<any>;
    patchBSChangeStatus(dcnNumber: string, status: string): Observable<any>;
    calculateOutStandingAmount(paymentGroup: IPaymentGroup): number;
    removeUnwantedString(input: string, replaceText: string): string;
    downloadSelectedReport(reportName: string, startDate: string, endDate: string): Observable<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<BulkScaningPaymentService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<BulkScaningPaymentService>;
}

type PaymentLibAlias$d = PaymentLibComponent;
declare class MarkUnidentifiedPaymentComponent implements OnInit {
    private formBuilder;
    private paymentViewService;
    private paymentLibComponent;
    private bulkScaningPaymentService;
    caseType: string;
    markPaymentUnidentifiedForm: FormGroup;
    viewStatus: string;
    ccdCaseNumber: string;
    bspaymentdcn: string;
    isInvesticationDetailEmpty: boolean;
    investicationDetailHasError: boolean;
    investicationDetailMinHasError: boolean;
    investicationDetailMaxHasError: boolean;
    errorMessage: {
        title: string;
        body: string;
        showError: any;
    };
    unassignedRecord: IBSPayments;
    siteID: string;
    investigationComment: string;
    isConfirmButtondisabled: Boolean;
    ccdReference: string;
    exceptionReference: string;
    isStrategicFixEnable: boolean;
    constructor(formBuilder: FormBuilder, paymentViewService: PaymentViewService, paymentLibComponent: PaymentLibAlias$d, bulkScaningPaymentService: BulkScaningPaymentService);
    ngOnInit(): void;
    getUnassignedPayment(): void;
    trimUnderscore(method: string): string;
    saveAndContinue(): void;
    resetForm(val: any): void;
    confirmPayments(): void;
    cancelMarkUnidentifiedPayments(type?: string): void;
    gotoCasetransationPage(): void;
    getErrorMessage(isErrorExist: any): {
        title: string;
        body: string;
        showError: any;
    };
    static ɵfac: i0.ɵɵFactoryDeclaration<MarkUnidentifiedPaymentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MarkUnidentifiedPaymentComponent, "app-mark-unidentified-payment", never, { "caseType": { "alias": "caseType"; "required": false; }; }, {}, never, never, false, never>;
}

type PaymentLibAlias$c = PaymentLibComponent;
declare class MarkUnsolicitedPaymentComponent implements OnInit {
    private formBuilder;
    private paymentViewService;
    private paymentLibComponent;
    private bulkScaningPaymentService;
    caseType: string;
    markPaymentUnsolicitedForm: FormGroup;
    viewStatus: string;
    reasonHasError: boolean;
    isReasonEmpty: boolean;
    reasonMinHasError: boolean;
    reasonMaxHasError: boolean;
    responsibleOfficeHasError: boolean;
    isResponsibleOfficeEmpty: boolean;
    errorMessage: {
        title: string;
        body: string;
        showError: any;
    };
    ccdCaseNumber: string;
    bspaymentdcn: string;
    unassignedRecord: IBSPayments;
    siteID: string;
    reason: string;
    responsiblePerson: string;
    responsibleOffice: string;
    emailId: string;
    isConfirmButtondisabled: Boolean;
    isContinueButtondisabled: Boolean;
    ccdReference: string;
    exceptionReference: string;
    selectedSiteId: string;
    selectedSiteName: string;
    isStrategicFixEnable: boolean;
    siteIDList: any;
    constructor(formBuilder: FormBuilder, paymentViewService: PaymentViewService, paymentLibComponent: PaymentLibAlias$c, bulkScaningPaymentService: BulkScaningPaymentService);
    ngOnInit(): void;
    trimUnderscore(method: string): string;
    confirmPayments(): void;
    saveAndContinue(): void;
    resetForm(val: any, field: any): void;
    cancelMarkUnsolicitedPayments(type?: string): void;
    checkingFormValue(): boolean;
    gotoCasetransationPage(): void;
    getUnassignedPayment(): void;
    getErrorMessage(isErrorExist: any, status: any, errorMsg: any, err: any): {
        title: string;
        body: string;
        showError: any;
    };
    selectchange(args: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MarkUnsolicitedPaymentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MarkUnsolicitedPaymentComponent, "app-mark-unsolicited-payment", never, { "caseType": { "alias": "caseType"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ProcessedPaymentsComponent implements OnInit {
    private router;
    private bulkScaningPaymentService;
    NONPAYMENTS: IPayment[];
    goToPaymentViewComponent: EventEmitter<any>;
    constructor(router: Router, bulkScaningPaymentService: BulkScaningPaymentService);
    ngOnInit(): void;
    trimUnderscore(method: string): string;
    redirectToPaymentViewPage(paymentGroupReference: string, paymentReference: string, paymentMethod: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ProcessedPaymentsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ProcessedPaymentsComponent, "ccpay-app-processed-payments", never, { "NONPAYMENTS": { "alias": "NONPAYMENTS"; "required": false; }; }, { "goToPaymentViewComponent": "goToPaymentViewComponent"; }, never, never, false, never>;
}

declare class CaseTransactionsService {
    private http;
    private logger;
    private errorHandlerService;
    private paymentLibService;
    constructor(http: HttpClient, logger: LoggerService, errorHandlerService: ErrorHandlerService, paymentLibService: PaymentLibService);
    getPaymentGroups(ccdCaseNumber: string): Observable<IPaymentGroup[]>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaseTransactionsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CaseTransactionsService>;
}

type PaymentLibAlias$b = PaymentLibComponent;
declare class AllocatePaymentsComponent implements OnInit {
    private errorHandlerService;
    private caseTransactionsService;
    private formBuilder;
    private paymentViewService;
    private paymentLibComponent;
    private bulkScaningPaymentService;
    private OrderslistService;
    isTurnOff: boolean;
    caseType: string;
    reasonEventEmitter: EventEmitter<string>;
    explanationEventEmitter: EventEmitter<string>;
    overUnderPaymentForm: FormGroup;
    viewStatus: string;
    ccdCaseNumber: string;
    bspaymentdcn: string;
    recordId: string;
    feedbackUrlLabel: string;
    unAllocatedPayment: IBSPayments;
    siteID: string;
    errorMessage: any;
    paymentGroup: IPaymentGroup;
    paymentGroups: IPaymentGroup[];
    remainingAmount: number;
    isRemainingAmountGtZero: boolean;
    isMoreDetailsBoxHide: boolean;
    isRemainingAmountLtZero: boolean;
    afterFeeAllocateOutstanding: number;
    amountForAllocation: number;
    isConfirmButtondisabled: boolean;
    isContinueButtondisabled: boolean;
    otherPaymentExplanation: string;
    selectedOption: string;
    isFeeAmountZero: boolean;
    paymentReasonHasError: boolean;
    paymentExplanationHasError: boolean;
    isPaymentDetailsEmpty: boolean;
    isPaymentDetailsInvalid: boolean;
    paymentDetailsMinHasError: boolean;
    paymentDetailsMaxHasError: boolean;
    isUserNameEmpty: boolean;
    isUserNameInvalid: boolean;
    ccdReference: string;
    exceptionReference: string;
    paymentReason: string;
    paymentExplanation: string;
    userName: string;
    paymentSectionLabel: any;
    paymentRef: string;
    isStrategicFixEnable: boolean;
    orderLevelFees: IOrderReferenceFee[];
    cookieUserName: string[];
    enCookieUserName: any;
    userNameField: string;
    reasonList: {
        [key: string]: {
            [key: string]: string;
        };
    };
    explanationList: {
        overPayment: {
            referRefund: string;
            noRefund: string;
            noCase: string;
            other: string;
        };
        shortFall: {
            holdCase: string;
            heldCase: string;
            other: string;
        };
    };
    refund: {
        reason: {
            duplicate: string;
            humanerror: string;
            caseWithdrawn: string;
            other: string;
        };
    };
    constructor(errorHandlerService: ErrorHandlerService, caseTransactionsService: CaseTransactionsService, formBuilder: FormBuilder, paymentViewService: PaymentViewService, paymentLibComponent: PaymentLibAlias$b, bulkScaningPaymentService: BulkScaningPaymentService, OrderslistService: OrderslistService);
    ngOnInit(): void;
    getGroupOutstandingAmount(paymentGroup: IPaymentGroup): number;
    getExplanationValue(inputValue: string): void;
    getReasonValue(inputValue: string): void;
    getPaymentGroupDetails(): void;
    selectedPaymentGroup(paymentGroup: IPaymentGroup): void;
    gotoCasetransationPage(): void;
    gotoSummaryPage(event: any): void;
    cancelAllocatePayment(event: any): void;
    confirmAllocatePayement(): void;
    resetForm(vals: any, field: any): void;
    finalServiceCall(): void;
    saveAndContinue(): void;
    getUnassignedPayment(): void;
    selectRadioButton(key: any, type: any): void;
    OrderListSelectEvent(orderef: any): void;
    redirectToOrderFeeSearchPage(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AllocatePaymentsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AllocatePaymentsComponent, "app-allocate-payments", never, { "isTurnOff": { "alias": "isTurnOff"; "required": false; }; "caseType": { "alias": "caseType"; "required": false; }; }, { "reasonEventEmitter": "reasonEventEmitter"; "explanationEventEmitter": "explanationEventEmitter"; }, never, never, false, never>;
}

declare class PbaDetailsComponent implements OnInit {
    payment: IPayment;
    constructor();
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PbaDetailsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PbaDetailsComponent, "ccpay-pba-details", never, { "payment": { "alias": "payment"; "required": false; }; }, {}, never, never, false, never>;
}

type PaymentLibAlias$a = PaymentLibComponent;
declare class FeeSummaryComponent implements OnInit {
    private router;
    private bulkScaningPaymentService;
    private location;
    private paymentViewService;
    private paymentLibComponent;
    private OrderslistService;
    paymentGroupRef: string;
    ccdCaseNumber: string;
    isTurnOff: string;
    caseType: string;
    telephonySelectionEnable: boolean;
    paymentMethod: string;
    bsPaymentDcnNumber: string;
    paymentGroup: IPaymentGroup;
    errorMessage: string;
    viewStatus: string;
    currentFee: IFee;
    totalFee: number;
    payhubHtml: SafeHtml;
    service: string;
    upPaymentErrorMessage: string;
    selectedOption: string;
    isBackButtonEnable: boolean;
    outStandingAmount: number;
    isFeeAmountZero: boolean;
    totalAfterRemission: number;
    isConfirmationBtnDisabled: boolean;
    isRemoveBtnDisabled: boolean;
    isPaymentExist: boolean;
    isRemissionsExist: Boolean;
    isRemissionsMatch: boolean;
    isStrategicFixEnable: boolean;
    constructor(router: Router, bulkScaningPaymentService: BulkScaningPaymentService, location: Location, paymentViewService: PaymentViewService, paymentLibComponent: PaymentLibAlias$a, OrderslistService: OrderslistService);
    ngOnInit(): void;
    getUnassignedPaymentlist(): void;
    getRemissionByFeeCode(feeCode: string): IRemission;
    addRemission(fee: IFee): void;
    getPaymentGroup(): void;
    confirmRemoveFee(fee: IFee): void;
    removeFee(fee: any): void;
    loadCaseTransactionPage(): void;
    cancelRemission(): void;
    redirectToFeeSearchPage(event: any, page?: string): void;
    takePayment(): void;
    goToAllocatePage(outStandingAmount: number, isFeeAmountZero: Boolean): void;
    isCheckAmountdueExist(amountDue: any): amountDue is undefined;
    getKervValue(): string;
    getPaymentMethod(): string;
    isTakePaymentButtonDisabled(): boolean;
    isTelephonySelectionEnable(): boolean;
    isTelephonySelectionEnableNull(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FeeSummaryComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FeeSummaryComponent, "ccpay-fee-summary", never, { "paymentGroupRef": { "alias": "paymentGroupRef"; "required": false; }; "ccdCaseNumber": { "alias": "ccdCaseNumber"; "required": false; }; "isTurnOff": { "alias": "isTurnOff"; "required": false; }; "caseType": { "alias": "caseType"; "required": false; }; "telephonySelectionEnable": { "alias": "telephonySelectionEnable"; "required": false; }; }, {}, never, never, false, never>;
}

declare class keyValuePipe implements PipeTransform {
    constructor();
    transform(input: any): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<keyValuePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<keyValuePipe, "keyValue", false>;
}

declare class SanitizeHtmlPipe implements PipeTransform {
    private sanitizer;
    constructor(sanitizer: DomSanitizer);
    transform(value: any): SafeHtml;
    static ɵfac: i0.ɵɵFactoryDeclaration<SanitizeHtmlPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SanitizeHtmlPipe, "sanitizeHtml", false>;
}

declare class XlFileService {
    constructor();
    exportAsExcelFile(json: any[], excelFileName: string): void;
    private autoFitColumns;
    private addRowData;
    private setDataLossReportHeaders;
    private setUnprocessedReportHeaders;
    private setProcessedUnallocatedReportHeaders;
    private setPaymentFailureReportHeaders;
    private setShortFallReportHeaders;
    private setTelphonyPaymentsReportHeaders;
    private setRefundsReportHeaders;
    private sanitizeString;
    static ɵfac: i0.ɵɵFactoryDeclaration<XlFileService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<XlFileService>;
}

type PaymentLibAlias$9 = PaymentLibComponent;
declare class ReportsComponent implements OnInit {
    private xlFileService;
    private errorHandlerService;
    private formBuilder;
    private bulkScaningPaymentService;
    private paymentLibComponent;
    private paymentViewService;
    private refundsService;
    ISPAYMENTSTATUSENABLED: boolean;
    fmt: string;
    loc: string;
    reportsForm: FormGroup;
    startDate: string;
    endDate: string;
    errorMeaagse: string;
    ccdCaseNumber: string;
    isDownLoadButtondisabled: Boolean;
    isStartDateLesthanEndDate: Boolean;
    isDateBetwnMonth: Boolean;
    isDateRangeBetnWeek: Boolean;
    errorMessage: any;
    paymentGroups: IPaymentGroup[];
    constructor(xlFileService: XlFileService, errorHandlerService: ErrorHandlerService, formBuilder: FormBuilder, bulkScaningPaymentService: BulkScaningPaymentService, paymentLibComponent: PaymentLibAlias$9, paymentViewService: PaymentViewService, refundsService: RefundsService);
    ngOnInit(): void;
    getToday(): string;
    getSelectedFromDate(): void;
    validateDates(reportName: any): void;
    fromValidation(): void;
    downloadReport(): void;
    getFileName(selectedOption: string, startDate: string, endDate: string): string;
    tranformDate(strDate: string): string;
    getTwodigit(input: number): string;
    getCamelCaseString(selectedOption: any): any;
    applyDateFormat(res: any): any;
    multiDateFormater(dateStr: any): any;
    convertToFloatValue(amt: any): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<ReportsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ReportsComponent, "ccpay-reports", never, { "ISPAYMENTSTATUSENABLED": { "alias": "ISPAYMENTSTATUSENABLED"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ErrorBannerComponent implements OnInit {
    errorMessage: any;
    constructor();
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorBannerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ErrorBannerComponent, "ccpay-error-banner", never, { "errorMessage": { "alias": "errorMessage"; "required": false; }; }, {}, never, never, false, never>;
}

type PaymentLibAlias$8 = PaymentLibComponent;
declare class TableComponent {
    private paymentLibComponent;
    private cdRef;
    private OrderslistService;
    private router;
    private activeRoute;
    DATASOURCE: any[];
    STATUS: string;
    errorMessage: string;
    isApprovalFlow: boolean;
    displayedColumns: string[];
    dataSource: MatTableDataSource<any>;
    userLst: any;
    serviceLst: any;
    actualcount: number;
    count: number;
    refundList: IRefundList[];
    paginator: MatPaginator;
    sort: MatSort;
    constructor(paymentLibComponent: PaymentLibAlias$8, cdRef: ChangeDetectorRef, OrderslistService: OrderslistService, router: Router, activeRoute: ActivatedRoute);
    ngOnInit(): void;
    /**
     * Set the paginator and sort after the view init since this component will
     * be able to query its view for the initialized paginator and sort.
     */
    ngAfterViewInit(): void;
    applyFilter(filterValue: string): void;
    selectchange(args: any): void;
    goToRefundProcessComponent(refundReference: string, refundData: IRefundList): void;
    goToRefundViewComponent(refundReference: string, refundData: IRefundList): void;
    goToCaseReview(ccdCaseNumber: string, refundData: IRefundList): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableComponent, "ccpay-table", never, { "DATASOURCE": { "alias": "DATASOURCE"; "required": false; }; "STATUS": { "alias": "STATUS"; "required": false; }; "errorMessage": { "alias": "errorMessage"; "required": false; }; }, {}, never, never, false, never>;
}

declare class CcdHyphensPipe implements PipeTransform {
    constructor();
    transform(value: any, args?: any): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<CcdHyphensPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<CcdHyphensPipe, "ccdHyphens", true>;
}

declare class CapitalizePipe implements PipeTransform {
    constructor();
    transform(s: any, args?: any): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<CapitalizePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<CapitalizePipe, "capitalize", true>;
}

interface IPaymentFailure {
    additional_reference: string;
    disputed_amount: number;
    failure_event_date_time: string;
    failure_reason: string;
    failure_reference: string;
    failure_type: string;
    payment_reference: string;
    representment_date: string;
    representment_status: string;
    has_amount_debited?: string;
    status: string;
}

type PaymentLibAlias$7 = PaymentLibComponent;
declare class PaymentViewComponent implements OnInit {
    private paymentViewService;
    private notificationService;
    private paymentLibComponent;
    private cd;
    private OrderslistService;
    isTurnOff: boolean;
    isTakePayment: boolean;
    caseType: boolean;
    orderRef: string;
    orderStatus: string;
    orderTotalPayments: number;
    payment: IPayment;
    LOGGEDINUSERROLES: string[];
    ISPAYMENTSTATUSENABLED: string;
    orderParty: string;
    orderCreated: Date;
    orderCCDEvent: string;
    orderFeesTotal: number;
    orderRemissionTotal: number;
    orderDetail: any[];
    fees: any;
    isFullyRefund: boolean;
    isServiceRequest: string;
    errorMsg: string;
    paymentGroup: IPaymentGroup;
    errorMessage: string;
    ccdCaseNumber: string;
    selectedOption: string;
    dcnNumber: string;
    isStatusAllocated: boolean;
    isRemissionsMatch: boolean;
    feeId: IFee;
    viewStatus: string;
    isRefundRemission: boolean;
    isStrategicFixEnable: boolean;
    isAddFeeBtnEnabled: boolean;
    isIssueRefunfBtnEnable: boolean;
    allowedRolesToAccessRefund: string[];
    remissions: IRemission[];
    allPaymentsFailure: IPaymentFailure[];
    selectedPaymentsStatus: IPaymentFailure;
    remissionFeeAmt: number;
    isRefundRemissionBtnEnable: boolean;
    serviceReference: string;
    isFromServiceRequestPage: boolean;
    isFromPaymentDetailPage: boolean;
    paymentFees: IFee[];
    paymentType: string;
    isContinueBtnDisabled: boolean;
    viewCompStatus: string;
    contactDetailsObj: IRefundContactDetails;
    notification: any;
    isConfirmationBtnDisabled: boolean;
    refundReference: string;
    refundAmount: string;
    templateInstructionType: string;
    notificationPreview: boolean;
    constructor(paymentViewService: PaymentViewService, notificationService: NotificationService, paymentLibComponent: PaymentLibAlias$7, cd: ChangeDetectorRef, OrderslistService: OrderslistService);
    ngAfterContentChecked(): void;
    ngOnInit(): void;
    get isCardPayment(): boolean;
    get isTelephonyPayment(): boolean;
    goToPaymentList(): void;
    getOverPaymentValue(): number;
    goToServiceRequestPage(): void;
    goToCaseTransationPage(event: any): void;
    addRemission(fee: IFee): void;
    checkForFees(paymentGroup: any): boolean;
    processRefund(): void;
    gotoAddressPage(note?: IRefundContactDetails): void;
    addRefundForRemission(payment: IPayment, remission: IRemission[], fees: any): void;
    goToPaymentViewComponent(): void;
    issueRefund(paymentgrp: IPaymentGroup): void;
    isAnyRefundsForThisCase(): boolean;
    showOverPayment(): void;
    showIssueRefundPage(paymentgrp: IPaymentGroup): void;
    getBalanceToBePaid(): number;
    getRemissionByFeeCode(feeCode: string, remissions: IRemission[]): IRemission;
    chkIsIssueRefundBtnEnable(payment: IPayment): boolean;
    chkIsAddRefundBtnEnable(remission: IRemission): boolean;
    canItBeRefunded(remission: IRemission): boolean;
    chkIsAddRemissionBtnEnable(fee: IFee): boolean;
    selectPymentOption(paymentType: string): void;
    continuePayment(paymentgrp: IPaymentGroup): void;
    gotoPaymentSelectPage(event: Event): void;
    getContactDetails(obj: IRefundContactDetails): void;
    resetOrderData(): void;
    goToPaymentFailuePage(payment: any): void;
    goBackToPaymentView(event: any): void;
    getTemplateInstructionType(payment: IPayment): void;
    showNotificationPreview(): void;
    hideNotificationPreview(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PaymentViewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PaymentViewComponent, "ccpay-payment-view", never, { "isTurnOff": { "alias": "isTurnOff"; "required": false; }; "isTakePayment": { "alias": "isTakePayment"; "required": false; }; "caseType": { "alias": "caseType"; "required": false; }; "orderRef": { "alias": "orderRef"; "required": false; }; "orderStatus": { "alias": "orderStatus"; "required": false; }; "orderTotalPayments": { "alias": "orderTotalPayments"; "required": false; }; "payment": { "alias": "payment"; "required": false; }; "LOGGEDINUSERROLES": { "alias": "LOGGEDINUSERROLES"; "required": false; }; "ISPAYMENTSTATUSENABLED": { "alias": "ISPAYMENTSTATUSENABLED"; "required": false; }; "orderParty": { "alias": "orderParty"; "required": false; }; "orderCreated": { "alias": "orderCreated"; "required": false; }; "orderCCDEvent": { "alias": "orderCCDEvent"; "required": false; }; "orderFeesTotal": { "alias": "orderFeesTotal"; "required": false; }; "orderRemissionTotal": { "alias": "orderRemissionTotal"; "required": false; }; "orderDetail": { "alias": "orderDetail"; "required": false; }; "isServiceRequest": { "alias": "isServiceRequest"; "required": false; }; }, {}, never, never, true, never>;
}

type PaymentLibAlias$6 = PaymentLibComponent;
declare class ContactDetailsComponent implements OnInit {
    private formBuilder;
    private notificationService;
    private paymentLibComponent;
    isEditOperation: boolean;
    isEditOperationInRefundList: boolean;
    addressObj: any;
    assignContactDetails: EventEmitter<any>;
    assignContactDetailsInFefundsList: EventEmitter<any>;
    redirectToIssueRefund: EventEmitter<any>;
    pageTitle: string;
    errorMessage: string;
    isEmailSAddressClicked: boolean;
    isShowPickAddress: boolean;
    isPostcodeClicked: boolean;
    isManualAddressClicked: boolean;
    emailAddressForm: FormGroup;
    postCodeForm: FormGroup;
    manualAddressForm: FormGroup;
    addressPostcodeList: any[];
    postcodeAddress: any;
    isAddressBoxEmpty: boolean;
    isEmailEmpty: boolean;
    emailHasError: boolean;
    isPostcodeEmpty: boolean;
    postcodeHasError: boolean;
    isaddressLine1Empty: boolean;
    addressLine1HasError: boolean;
    addressLine2HasError: boolean;
    isTownOrCityEmpty: boolean;
    townOrCityHasError: boolean;
    isCountyEmpty: boolean;
    countyHasError: boolean;
    isMPostcodeEmpty: boolean;
    mpostcodeHasError: boolean;
    isCountryEmpty: boolean;
    constructor(formBuilder: FormBuilder, notificationService: NotificationService, paymentLibComponent: PaymentLibAlias$6);
    ngOnInit(): void;
    setEditDetails(): void;
    selectContactOption(type: any, isLinkedClied: any): void;
    finalFormSubmit(): void;
    postcodeValidation(str: any): void;
    redirection(event: any): void;
    resetForm(val: any, field: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ContactDetailsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ContactDetailsComponent, "ccpay-contact-details", never, { "isEditOperation": { "alias": "isEditOperation"; "required": false; }; "isEditOperationInRefundList": { "alias": "isEditOperationInRefundList"; "required": false; }; "addressObj": { "alias": "addressObj"; "required": false; }; }, { "assignContactDetails": "assignContactDetails"; "assignContactDetailsInFefundsList": "assignContactDetailsInFefundsList"; "redirectToIssueRefund": "redirectToIssueRefund"; }, never, never, true, never>;
}

type PaymentLibAlias$5 = PaymentLibComponent;
declare class AddRemissionComponent implements OnInit {
    private formBuilder;
    private router;
    private paymentViewService;
    private notificationService;
    private paymentLibComponent;
    private refundService;
    private cd;
    private OrderslistService;
    fee: IFee;
    fees: any[];
    payment: IPayment;
    remission: IRemission;
    ccdCaseNumber: string;
    caseType: string;
    viewCompStatus: string;
    paymentGroupRef: string;
    isTurnOff: boolean;
    isRefundRemission: boolean;
    isStrategicFixEnable: boolean;
    paidAmount: any;
    isFromRefundListPage: boolean;
    isFromPaymentDetailPage: boolean;
    isFromServiceRequestPage: boolean;
    isFullyRefund: boolean;
    feeamount: number;
    refundPaymentReference: string;
    isFromRefundStatusPage: boolean;
    changeRefundReason: string;
    isServiceRequest: string;
    LOGGEDINUSERROLES: string[];
    orderDetail: any[];
    orderRef: string;
    orderStatus: string;
    orderParty: string;
    orderCreated: Date;
    orderCCDEvent: string;
    takePayment: boolean;
    orderFeesTotal: number;
    orderTotalPayments: number;
    orderRemissionTotal: number;
    cancelRemission: EventEmitter<void>;
    refundListReason: EventEmitter<{
        reason: string;
        code: string;
    }>;
    refundListAmount: EventEmitter<string>;
    refundFees: EventEmitter<IFee[]>;
    refund: {
        reason: {
            duplicate: string;
            humanerror: string;
            caseWithdrawn: string;
            other: string;
        };
    };
    contactDetailsObj: IRefundContactDetails;
    notification: any;
    remissionForm: FormGroup;
    hasErrors: boolean;
    viewStatus: string;
    errorMessage: any;
    option: string;
    isConfirmationBtnDisabled: boolean;
    bsPaymentDcnNumber: string;
    selectedValue: string;
    amount: any;
    retroRemission: boolean;
    remissionReference: string;
    refundReference: string;
    refundAmount: string;
    paymentExplanationHasError: boolean;
    refundReason: string;
    selectedRefundReason: string;
    selectedRefundReasonCode: string;
    displayRefundReason: string;
    refundCode: string;
    remessionPayment: IPayment;
    isRemissionCodeEmpty: boolean;
    remissionCodeHasError: boolean;
    isAmountEmpty: boolean;
    isReasonEmpty: boolean;
    amountHasError: boolean;
    isRemissionLessThanFeeError: boolean;
    refundHasError: boolean;
    isPaymentSuccess: boolean;
    isRemissionApplied: boolean;
    remissionamt: number;
    elementId: any;
    commonRefundReasons: any[];
    showReasonText: boolean;
    isRefundReasonsSelected: boolean;
    default: string;
    reasonLength: number;
    refundReasons: IRefundReasons[];
    pattern1: string;
    pattern2: string;
    sendOrderDetail: any[];
    sendOrderRef: string;
    paymentReference: string;
    class: string;
    errorMsg: any[];
    totalRefundAmount: number;
    quantityUpdated: number;
    fullRefund: boolean;
    allowedRefundAmount: number;
    isRemissionsMatch: boolean;
    paymentFees: IFee[];
    paymentGroup: IPaymentGroup;
    isStatusAllocated: boolean;
    isFromCheckAnsPage: boolean;
    refundAmtForFeeVolumes: number;
    paymentObj: IPayment;
    templateInstructionType: string;
    notificationPreview: boolean;
    component: {
        account_number: string;
        amount: number;
        case_reference: string;
        ccd_case_number: string;
        channel: string;
        currency: string;
        customer_reference: string;
        date_created: string;
        date_updated: string;
        description: string;
        method: string;
        organisation_name: string;
        payment_allocation: any[];
        reference: string;
        service_name: string;
        site_id: string;
        status: string;
    };
    constructor(formBuilder: FormBuilder, router: Router, paymentViewService: PaymentViewService, notificationService: NotificationService, paymentLibComponent: PaymentLibAlias$5, refundService: RefundsService, cd: ChangeDetectorRef, OrderslistService: OrderslistService);
    ngOnInit(): void;
    goToPaymentViewComponent(): void;
    refundFeesList(): void;
    get feesList(): FormArray;
    noneSelected(): boolean;
    calculateRefundAmount(index: any, AppAmt: any): any;
    check_en(i: any, v1: any, AppAmt: any, Volume: any): void;
    addRemission(): void;
    confirmRemission(): void;
    resetRemissionForm(val: any, field: any): void;
    addRemissionCode(): void;
    gotoAddRetroRemissionCodePage(): void;
    gotoCheckRetroRemissionPage(payment: IPayment): void;
    gotoAmountRetroRemission(): void;
    gotoProcessRetroRemissionPage(): void;
    gotoProcessRetroRemission(note?: IRefundContactDetails): void;
    confirmRetroRemission(): void;
    processRefund(): void;
    gotoIssueRefundConfirmation(payment: IPayment): void;
    gotoIssueRefundPage(): void;
    gotoIssuePage(isFullyRefund: any): void;
    calAmtToRefund(value: any, amount: any, volume: any, i: any): void;
    gotoContactDetailsPage(note?: IRefundContactDetails): void;
    getRefundReasons(): void;
    getErrorClass(elementId: any): void;
    changeIssueRefundReason(): void;
    confirmIssueRefund(isFullyRefund: any): void;
    gotoRefundReasonPage(): void;
    selectRadioButton(key: any, value: any): void;
    selectchange(args: any): void;
    getContactDetails(obj: IRefundContactDetails, type: any): void;
    gotoPartialFeeRefundScreen(): void;
    gotoServiceRequestPage(event: any): void;
    gotoAddressPage(note?: IRefundContactDetails): void;
    gotoRemissionSuccess(event: Event): void;
    gotoCasetransationPage(): void;
    gotoCasetransationPageCancelBtnClicked(event: Event): void;
    canRefundBeApplied(): boolean;
    resetOrderData(): void;
    changeRefundAmount(): void;
    getFormattedCurrency(currency: number): string | number;
    showNotificationPreview(): void;
    hideNotificationPreview(): void;
    getTemplateInstructionType(paymentReference: string, payment?: IPayment): void;
    getRefundAmountToBeDisplayed(remission: IRemission): string;
    getRefundAmountToBeDisplayedForContinueJourney(): string;
    getRemissionAmountToBeDisplayed(remission: IRemission): string;
    isRemissionEnabled(feeCode: string): boolean;
    isRemissionEnabledForFeeCode(feeCode: string): boolean;
    getRemissions(feeCode: string): IRemission;
    getRemissionsHwfAmount(feeCode: string): string;
    getNetAmountFee(hwfAmount: number, feeAmount: number): number;
    getRemissionValueForFullyRefund(): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<AddRemissionComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AddRemissionComponent, "ccpay-add-remission", never, { "fee": { "alias": "fee"; "required": false; }; "fees": { "alias": "fees"; "required": false; }; "payment": { "alias": "payment"; "required": false; }; "remission": { "alias": "remission"; "required": false; }; "ccdCaseNumber": { "alias": "ccdCaseNumber"; "required": false; }; "caseType": { "alias": "caseType"; "required": false; }; "viewCompStatus": { "alias": "viewCompStatus"; "required": false; }; "paymentGroupRef": { "alias": "paymentGroupRef"; "required": false; }; "isTurnOff": { "alias": "isTurnOff"; "required": false; }; "isRefundRemission": { "alias": "isRefundRemission"; "required": false; }; "isStrategicFixEnable": { "alias": "isStrategicFixEnable"; "required": false; }; "paidAmount": { "alias": "paidAmount"; "required": false; }; "isFromRefundListPage": { "alias": "isFromRefundListPage"; "required": false; }; "isFromPaymentDetailPage": { "alias": "isFromPaymentDetailPage"; "required": false; }; "isFromServiceRequestPage": { "alias": "isFromServiceRequestPage"; "required": false; }; "isFullyRefund": { "alias": "isFullyRefund"; "required": false; }; "feeamount": { "alias": "feeamount"; "required": false; }; "refundPaymentReference": { "alias": "refundPaymentReference"; "required": false; }; "isFromRefundStatusPage": { "alias": "isFromRefundStatusPage"; "required": false; }; "changeRefundReason": { "alias": "changeRefundReason"; "required": false; }; "isServiceRequest": { "alias": "isServiceRequest"; "required": false; }; "LOGGEDINUSERROLES": { "alias": "LOGGEDINUSERROLES"; "required": false; }; "orderDetail": { "alias": "orderDetail"; "required": false; }; "orderRef": { "alias": "orderRef"; "required": false; }; "orderStatus": { "alias": "orderStatus"; "required": false; }; "orderParty": { "alias": "orderParty"; "required": false; }; "orderCreated": { "alias": "orderCreated"; "required": false; }; "orderCCDEvent": { "alias": "orderCCDEvent"; "required": false; }; "takePayment": { "alias": "takepayment"; "required": false; }; "orderFeesTotal": { "alias": "orderFeesTotal"; "required": false; }; "orderTotalPayments": { "alias": "orderTotalPayments"; "required": false; }; "orderRemissionTotal": { "alias": "orderRemissionTotal"; "required": false; }; }, { "cancelRemission": "cancelRemission"; "refundListReason": "refundListReason"; "refundListAmount": "refundListAmount"; "refundFees": "refundFees"; }, never, never, true, never>;
}

type PaymentLibAlias$4 = PaymentLibComponent;
declare class ServiceRequestComponent implements OnInit {
    private paymentLibComponent;
    private paymentViewService;
    private OrderslistService;
    private notificationService;
    private cd;
    private router;
    LOGGEDINUSERROLES: string[];
    viewStatus: string;
    orderDetail: any[];
    orderRef: string;
    orderStatus: string;
    orderParty: string;
    orderCreated: Date;
    orderCCDEvent: string;
    orderFeesTotal: number;
    orderTotalPayments: number;
    orderRemissionTotal: number;
    paymentGroupList: IPaymentGroup;
    takePayment: boolean;
    ccdCaseNumber: boolean;
    isServiceRequest: string;
    goToServiceRquestComponent: EventEmitter<any>;
    viewCompStatus: any;
    servicerequest: string;
    paymentType: string;
    excReference: string;
    paymentGroups: any[];
    payments: IPayment[];
    nonPayments: IPayment[];
    allPayments: IPayment[];
    remissions: IRemission[];
    paymentFees: IFee[];
    fees: any;
    errorMessage: string;
    totalFees: number;
    totalPayments: number;
    totalNonOffPayments: number;
    totalRemissions: number;
    selectedOption: string;
    dcnNumber: string;
    paymentRef: string;
    isTurnOff: boolean;
    isRefundRemission: boolean;
    isStrategicFixEnable: boolean;
    isAddFeeBtnEnabled: boolean;
    isExceptionRecord: boolean;
    isUnprocessedRecordSelected: boolean;
    exceptionRecordReference: string;
    isAnyFeeGroupAvilable: boolean;
    isHistoricGroupAvailable: boolean;
    isBulkScanEnable: any;
    isRemissionsMatch: boolean;
    isRemoveBtnDisabled: boolean;
    feeId: IFee;
    clAmountDue: number;
    unprocessedRecordCount: number;
    isFeeRecordsExist: boolean;
    isGrpOutstandingAmtPositive: boolean;
    totalRefundAmount: Number;
    caseType: String;
    isConfirmationBtnDisabled: boolean;
    refundReference: string;
    refundAmount: string;
    payment: IPayment;
    paymentGroup: IPaymentGroup;
    paymentView: IPaymentView;
    isAddRemissionEnable: boolean;
    orderRemissionDetails: any[];
    orderLevelFees: IOrderReferenceFee[];
    cpoDetails: any[];
    serviceRequestValue: string;
    orderAddBtnEnable: boolean;
    isFromPaymentDetailPage: boolean;
    contactDetailsObj: IRefundContactDetails;
    notification: any;
    isCPODown: boolean;
    test: boolean;
    isPBA: boolean;
    isIssueRefunfBtnEnable: boolean;
    isAddRemissionBtnEnabled: boolean;
    isRefundRemissionBtnEnable: boolean;
    allowedRolesToAccessRefund: string[];
    isFromServiceRequestPage: boolean;
    navigationpage: string;
    remissionFeeAmt: number;
    isContinueBtnDisabled: boolean;
    isFullyRefund: boolean;
    templateInstructionType: string;
    notificationPreview: boolean;
    constructor(paymentLibComponent: PaymentLibAlias$4, paymentViewService: PaymentViewService, OrderslistService: OrderslistService, notificationService: NotificationService, cd: ChangeDetectorRef, router: Router);
    ngOnInit(): void;
    goToServiceRequestPage(): void;
    goToCaseTransationPage(event: any): void;
    addRemission(fee: IFee): void;
    addRefundForRemission(payment: IPayment, remission: IRemission[], fees: any): void;
    cancelRemoval(): void;
    removeFee(fee: any): void;
    issueRefund(payment: IPayment): void;
    isAnyRefundsForThisCase(): boolean;
    showOverPayment(paymentgrp: IPaymentGroup, payment: any): void;
    showIssueRefundPage(paymentgrp: IPaymentGroup, payment: any): void;
    getBalanceToBePaid(): number;
    goToPayementView(paymentGroupReference: string, paymentReference: string, paymentMethod: string): void;
    goToPaymentViewComponent(paymentGroup: any): void;
    chkIsIssueRefundBtnEnable(payment: IPayment): boolean;
    chkIsAddRefundBtnEnable(remission: IRemission): boolean;
    canItBeRefunded(remission: IRemission): boolean;
    chkIsAddRemissionBtnEnable(fee: IFee): boolean;
    resetOrderData(): void;
    selectPymentOption(paymentType: string): void;
    goToPaymentViewComp(): void;
    continuePayment(paymentgrp: IPaymentGroup): void;
    getContactDetails(obj: IRefundContactDetails): void;
    gotoPaymentSelectPage(event: Event): void;
    gotoAddressPage(note?: IRefundContactDetails): void;
    processRefund(): void;
    getOverPaymentValue(): number;
    getTemplateInstructionType(payment: IPayment): void;
    showNotificationPreview(): void;
    hideNotificationPreview(): void;
    hasPaymentsRole(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ServiceRequestComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ServiceRequestComponent, "ccpay-service-request", never, { "LOGGEDINUSERROLES": { "alias": "LOGGEDINUSERROLES"; "required": false; }; "viewStatus": { "alias": "viewStatus"; "required": false; }; "orderDetail": { "alias": "orderDetail"; "required": false; }; "orderRef": { "alias": "orderRef"; "required": false; }; "orderStatus": { "alias": "orderStatus"; "required": false; }; "orderParty": { "alias": "orderParty"; "required": false; }; "orderCreated": { "alias": "orderCreated"; "required": false; }; "orderCCDEvent": { "alias": "orderCCDEvent"; "required": false; }; "orderFeesTotal": { "alias": "orderFeesTotal"; "required": false; }; "orderTotalPayments": { "alias": "orderTotalPayments"; "required": false; }; "orderRemissionTotal": { "alias": "orderRemissionTotal"; "required": false; }; "paymentGroupList": { "alias": "paymentGroupList"; "required": false; }; "takePayment": { "alias": "takePayment"; "required": false; }; "ccdCaseNumber": { "alias": "ccdCaseNumber"; "required": false; }; "isServiceRequest": { "alias": "isServiceRequest"; "required": false; }; }, { "goToServiceRquestComponent": "goToServiceRquestComponent"; }, never, never, true, never>;
}

declare class NotificationPreviewComponent implements OnInit {
    private errorHandlerService;
    private notificationService;
    payment: IPayment;
    contactDetails: IRefundContactDetails;
    refundReason: string;
    refundAmount: number;
    paymentReference: string;
    refundReference: string;
    previewJourney: string;
    notificationSent: INotificationPreview;
    notificationPreviewEvent: EventEmitter<INotificationPreview>;
    notification: INotificationPreview;
    notificationPreviewRequest: NotificationPreviewRequest;
    today: number;
    errorMessage: any;
    constructor(errorHandlerService: ErrorHandlerService, notificationService: NotificationService);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationPreviewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NotificationPreviewComponent, "app-notification-preview", never, { "payment": { "alias": "payment"; "required": false; }; "contactDetails": { "alias": "contactDetails"; "required": false; }; "refundReason": { "alias": "refundReason"; "required": false; }; "refundAmount": { "alias": "refundAmount"; "required": false; }; "paymentReference": { "alias": "paymentReference"; "required": false; }; "refundReference": { "alias": "refundReference"; "required": false; }; "previewJourney": { "alias": "previewJourney"; "required": false; }; "notificationSent": { "alias": "notificationSent"; "required": false; }; }, { "notificationPreviewEvent": "notificationPreviewEvent"; }, never, never, true, never>;
}

type PaymentLibAlias$3 = PaymentLibComponent;
declare class CaseTransactionsComponent implements OnInit {
    private router;
    private paymentViewService;
    private bulkScaningPaymentService;
    private caseTransactionsService;
    private paymentLibComponent;
    private OrderslistService;
    LOGGEDINUSERROLES: string[];
    isTakePayment: boolean;
    isFromServiceRequestPage: boolean;
    takePayment: boolean;
    ccdCaseNumber: string;
    excReference: string;
    paymentGroups: any[];
    payments: IPayment[];
    nonPayments: IPayment[];
    allPayments: IPayment[];
    remissions: IRemission[];
    fees: IFee[];
    errorMessage: string;
    totalFees: number;
    totalPayments: number;
    totalNonOffPayments: number;
    totalRemissions: number;
    selectedOption: string;
    dcnNumber: string;
    paymentRef: string;
    isTurnOff: boolean;
    isRefundRemission: boolean;
    isStrategicFixEnable: boolean;
    isAddFeeBtnEnabled: boolean;
    isExceptionRecord: boolean;
    isUnprocessedRecordSelected: boolean;
    exceptionRecordReference: string;
    isAnyFeeGroupAvilable: boolean;
    isHistoricGroupAvailable: boolean;
    isBulkScanEnable: any;
    isRemissionsMatch: boolean;
    viewStatus: string;
    isRemoveBtnDisabled: boolean;
    feeId: IFee;
    clAmountDue: number;
    overPaymentAmount: number;
    unprocessedRecordCount: number;
    isFeeRecordsExist: boolean;
    isGrpOutstandingAmtPositive: boolean;
    totalRefundAmount: number;
    caseType: String;
    payment: IPayment;
    paymentGroup: IPaymentGroup;
    paymentView: IPaymentView;
    orderDetail: any[];
    isAddRemissionEnable: boolean;
    orderRemissionDetails: any[];
    orderLevelFees: IOrderReferenceFee[];
    ispaymentGroupApisuccess: boolean;
    cpoDetails: any[];
    orderRef: string;
    orderStatus: string;
    orderParty: string;
    orderCreated: Date;
    orderCCDEvent: string;
    serviceRequestValue: string;
    orderAddBtnEnable: boolean;
    orderFeesTotal: number;
    orderRemissionTotal: number;
    orderTotalPayments: number;
    orderPendingPayments: number;
    isCPODown: boolean;
    test: boolean;
    isPBA: boolean;
    isIssueRefunfBtnEnable: boolean;
    isAddRemissionBtnEnabled: boolean;
    isRefundRemissionBtnEnable: boolean;
    allowedRolesToAccessRefund: string[];
    isEligible4PBAPayment: string[];
    currentDate: Date;
    navigationpage: string;
    remissionFeeAmt: number;
    constructor(router: Router, paymentViewService: PaymentViewService, bulkScaningPaymentService: BulkScaningPaymentService, caseTransactionsService: CaseTransactionsService, paymentLibComponent: PaymentLibAlias$3, OrderslistService: OrderslistService);
    ngOnInit(): void;
    setDefaults(): void;
    getAllocationStatus(payments: any): any;
    checkForExceptionRecord(): void;
    calculateOrderFeesAmounts(): void;
    resetOrderVariables(): void;
    goToOrderViewDetailSection(orderReferenceObj: any): void;
    redirectToOrderFeeSearchPage(event: any, orderef: any): void;
    calculateAmounts(): void;
    isThereRemissions(): boolean;
    calculateOverpaymentBasedOnRemission(): void;
    getOrderFeesTotalOrTotalFees(): number;
    getNumberOfFeesPerCaseTransaction(): number;
    calculateAmountDueTo(): void;
    validateAmountDueTo(): void;
    calculateOverpaymentBaseOnAcceptedRefund(): void;
    canItCalculateAmountDueForRemission(): boolean;
    calculateRefundAmount(): number;
    getGroupOutstandingAmount(paymentGroup: IPaymentGroup): number;
    redirectToFeeSearchPage(event: any): void;
    addRemission(fee: IFee): void;
    addRefundForRemission(payment: IPayment, remission: IRemission[], fees: any): void;
    redirectToremissionPage(event: any): void;
    goToServiceRequestPage(): void;
    redirectToReportsPage(event: any): void;
    loadFeeSummaryPage(paymentGroup: IPaymentGroup): void;
    goToPaymentViewComponent(paymentGroup: any): void;
    goToPayementView(paymentGroupReference: string, paymentReference: string, paymentMethod: string): void;
    selectedUnprocessedFeeEvent(unprocessedRecordId: string): void;
    getUnprocessedFeeCount(unProcessedRecordCount: number): void;
    calculateAmountDue(fee: IFee): number | "0.00";
    confirmRemoveFee(fee: IFee): void;
    cancelRemoval(): void;
    removeFee(fee: any): void;
    isCheckAmountdueExist(amountDue: any): amountDue is undefined;
    issueRefund(payment: IPayment): void;
    chkForAddRemission(feeCode: string): boolean;
    chkForPBAPayment(): boolean;
    chkIssueRefundBtnEnable(payment: IPayment): boolean;
    chkIsRefundRemissionBtnEnable(): boolean;
    check4AllowedRoles2AccessRefund: () => boolean;
    check4AllowedRoles2AccessPBApayment: () => boolean;
    allowFurtherAccessAfter4Days: (payment: IPayment) => boolean;
    loadPBAAccountPage(orderRef: IPayment): void;
    setBspaymentdcn(dcn: string): void;
    setViewName(viewName: string): void;
    setUnProcessedPaymentServiceId(serviceId: string): void;
    setPaymentGroupReference(paymentGroupRef: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaseTransactionsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaseTransactionsComponent, "ccpay-case-transactions", never, { "LOGGEDINUSERROLES": { "alias": "LOGGEDINUSERROLES"; "required": false; }; "isTakePayment": { "alias": "isTakePayment"; "required": false; }; "isFromServiceRequestPage": { "alias": "isFromServiceRequestPage"; "required": false; }; }, {}, never, never, true, never>;
}

declare class UnprocessedPaymentsComponent implements OnInit {
    private router;
    private bulkScaningPaymentService;
    private paymentViewService;
    private OrderslistService;
    FEE_RECORDS_EXISTS: boolean;
    PAYMENTREF: string;
    ISTURNOFF: boolean;
    IS_BUTTON_ENABLE: boolean;
    IS_OS_AMT_AVAILABLE: boolean;
    ISSFENABLE: boolean;
    PAYMENTSLENGTH: Number;
    LEVEL: Number;
    CCD_CASE_NUMBER: string;
    SELECTED_OPTION: string;
    DCN_NUMBER: string;
    ISBSENABLE: boolean;
    CASETYPE: string;
    selectedUnprocessedFeeEvent: EventEmitter<string>;
    getUnprocessedFeeCount: EventEmitter<string>;
    setBspaymentdcn: EventEmitter<string>;
    setViewName: EventEmitter<string>;
    setUnProcessedPaymentServiceId: EventEmitter<string>;
    setPaymentGroupReference: EventEmitter<string>;
    viewStatus: string;
    unassignedRecordList: IBSPayments;
    upPaymentErrorMessage: string;
    ccdCaseNumber: string;
    recordId: string;
    isRecordExist: boolean;
    dcnNumber: string;
    selectedOption: string;
    isUnprocessedRecordSelected: boolean;
    isAllocateToExistingFeebtnEnabled: boolean;
    isMarkAsUnidentifiedbtnEnabled: boolean;
    isAllocatedToNewFeebtnEnabled: boolean;
    isExceptionCase: boolean;
    serviceId: string;
    isBulkScanEnable: any;
    isTurnOff: boolean;
    isStFixEnable: any;
    unassignedRecordSelectedList: IBSPayments;
    unassignedRecordListLength: number;
    showContent: boolean;
    constructor(router: Router, bulkScaningPaymentService: BulkScaningPaymentService, paymentViewService: PaymentViewService, OrderslistService: OrderslistService);
    ngOnInit(): void;
    getUnassignedPaymentlist(): void;
    setValuesForUnassignedRecord(unassignedPayments: any): void;
    formatUnassignedRecordId(ID: Number): string;
    trimUnderscore(method: string): string;
    redirectToFeeSearchPage(event: any, dcn_reference: any): void;
    loadUnsolicitedPage(viewName: string, dcn_reference: any): void;
    unprocessedPaymentSelectEvent(selectedRecordReference: any): void;
    resetButtons(): void;
    goToAllocatePage(dcn_reference: any): void;
    validateButtons(): void;
    unprocessedPaymentUnSelectEvent(event: any): void;
    showDetailRow(event: any, obj: any, i: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<UnprocessedPaymentsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<UnprocessedPaymentsComponent, "ccpay-app-unprocessed-payments", never, { "FEE_RECORDS_EXISTS": { "alias": "FEE_RECORDS_EXISTS"; "required": false; }; "PAYMENTREF": { "alias": "PAYMENTREF"; "required": false; }; "ISTURNOFF": { "alias": "ISTURNOFF"; "required": false; }; "IS_BUTTON_ENABLE": { "alias": "IS_BUTTON_ENABLE"; "required": false; }; "IS_OS_AMT_AVAILABLE": { "alias": "IS_OS_AMT_AVAILABLE"; "required": false; }; "ISSFENABLE": { "alias": "ISSFENABLE"; "required": false; }; "PAYMENTSLENGTH": { "alias": "PAYMENTSLENGTH"; "required": false; }; "LEVEL": { "alias": "LEVEL"; "required": false; }; "CCD_CASE_NUMBER": { "alias": "CCD_CASE_NUMBER"; "required": false; }; "SELECTED_OPTION": { "alias": "SELECTED_OPTION"; "required": false; }; "DCN_NUMBER": { "alias": "DCN_NUMBER"; "required": false; }; "ISBSENABLE": { "alias": "ISBSENABLE"; "required": false; }; "CASETYPE": { "alias": "CASETYPE"; "required": false; }; }, { "selectedUnprocessedFeeEvent": "selectedUnprocessedFeeEvent"; "getUnprocessedFeeCount": "getUnprocessedFeeCount"; "setBspaymentdcn": "setBspaymentdcn"; "setViewName": "setViewName"; "setUnProcessedPaymentServiceId": "setUnProcessedPaymentServiceId"; "setPaymentGroupReference": "setPaymentGroupReference"; }, never, never, true, never>;
}

interface IRefundStatus {
    date_created: string;
    created_by: string;
    id: number;
    notes: string;
    refunds_id: number;
    status: string;
}

interface IRefundFee {
    fee_id: number;
    code: string;
    version: string;
    volume: number;
    refund_amount: number;
}

type PaymentLibAlias$2 = PaymentLibComponent;
declare class RefundStatusComponent implements OnInit {
    private formBuilder;
    private refundService;
    private notificationService;
    private paymentLibComponent;
    private OrderslistService;
    private paymentViewService;
    LOGGEDINUSERROLES: string[];
    API_ROOT: string;
    ccdCaseNumber: string;
    isTurnOff: boolean;
    orderParty: string;
    refundStatusForm: FormGroup;
    selectedRefundReason: string;
    rejectedRefundList: IRefundList[];
    notificationList: any;
    notification: any;
    approvalStatus: string;
    rejectStatus: string;
    errorMessage: any;
    viewName: string;
    refundReason: string;
    refundlist: IRefundList;
    bsPaymentDcnNumber: string;
    isCallFromRefundList: boolean;
    refundButtonState: string;
    isAmountEmpty: boolean;
    isReasonEmpty: boolean;
    amountHasError: boolean;
    isRemissionLessThanFeeError: boolean;
    refundHasError: boolean;
    refundReasons: any[];
    refundStatusHistories: IRefundStatus[];
    refundNotifications: IRefundStatus[];
    isResendOperationSuccess: boolean;
    isEditDetailsClicked: boolean;
    isEditAddressDeatilsClicked: boolean;
    addressDetails: IRefundContactDetails;
    refundReference: string;
    refundAmount: string;
    refundCode: string;
    isRefundBtnDisabled: boolean;
    isFromPayBubble: boolean;
    oldRefundReason: string;
    refundreason: string;
    navigationpage: string;
    isLastUpdatedByCurrentUser: boolean;
    isProcessRefund: boolean;
    changedAmount: number;
    isRemissionsMatch: boolean;
    payment: IPayment;
    changeRefundReason: string;
    fees: IFee[];
    refundFees: IRefundFee[];
    paymentObj: IPayment;
    templateInstructionType: string;
    notificationSentViewIndex: number;
    notificationPreview: boolean;
    notificationSentView: boolean;
    allowedRolesToAccessRefund: string[];
    isRefundStatusResetBtnDisabled: boolean;
    constructor(formBuilder: FormBuilder, refundService: RefundsService, notificationService: NotificationService, paymentLibComponent: PaymentLibAlias$2, OrderslistService: OrderslistService, paymentViewService: PaymentViewService);
    ngOnInit(): void;
    getRefundsStatusHistoryList(): void;
    getRefundsNotification(): void;
    goToRefundView(refundlist: IRefundList, navigationpage: string): void;
    loadCaseTransactionPage(): void;
    loadRefundListPage(): void;
    gotoReviewDetailsPage(event: any): void;
    gotoReviewAndReSubmitPage(): void;
    gotoRefundReasonPage(refundReason: string): void;
    gotoAmountPage(): void;
    goToReviewAndSubmitView(): void;
    resetRemissionForm(val: any, field: any): void;
    selectRadioButton(key: any, value: any): void;
    getRefundListReason(refundListReason: any): void;
    getRefundAmount(amount: number): void;
    getRefundFees(fees: IFee[]): void;
    gotoReviewRefundConfirmationPage(): void;
    gotoEditAddressDetails(note: IRefundsNotifications): void;
    getContactDetails(obj: IRefundContactDetails): void;
    getContactDetailsForRefundList(obj: IRefundContactDetails): void;
    gotoEditDetailsPage(note?: any, view?: string): void;
    submitEditDetail(): void;
    putResend(notification: IRefundsNotifications): void;
    gotoRefundViewPageCancelBtnClicked(event: Event): void;
    gotoRefundReviewAndSubmitViewPageCancelBtnClicked(event: Event): void;
    goToRefundProcessComponent(refundReference: string, refundList: IRefundList): void;
    getTemplateInstructionType(payment: IPayment, paymentReference: string): void;
    showNotificationPreview(): void;
    hideNotificationPreview(): void;
    showNotificationSentView(index: number): void;
    hideNotificationSentView(): void;
    displayResetRefundConfirmation(): void;
    redirectToRefundListPage(): void;
    postResetRefund(): void;
    isCurrentRefundVisibleForReset(): boolean;
    hasValidRefundRoles(): boolean;
    isCurrentRefundInProcess(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<RefundStatusComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RefundStatusComponent, "ccpay-refund-status", never, { "LOGGEDINUSERROLES": { "alias": "LOGGEDINUSERROLES"; "required": false; }; "API_ROOT": { "alias": "API_ROOT"; "required": false; }; "ccdCaseNumber": { "alias": "ccdCaseNumber"; "required": false; }; "isTurnOff": { "alias": "isTurnOff"; "required": false; }; "orderParty": { "alias": "orderParty"; "required": false; }; }, {}, never, never, true, never>;
}

type PaymentLibAlias$1 = PaymentLibComponent;
declare class PbaPaymentComponent implements OnInit {
    private paymentLibComponent;
    private paymentViewService;
    pbaPayOrderRef: any;
    viewStatus: string;
    pbaAccountList: string[];
    isPBAAccountHold: boolean;
    errorMsg: any;
    isCardPaymentSuccess: boolean;
    isInSufficiantFund: boolean;
    isPBAAccountNotExist: boolean;
    isPBAServerError: boolean;
    isGetPBAAccountSucceed: boolean;
    selectedPbaAccount: string;
    pbaAccountRef: string;
    isPbaAccountSelected: boolean;
    isCardPaymentSelected: boolean;
    isPBADropdownSelected: boolean;
    isContinueButtondisabled: boolean;
    isPBAAccountPaymentSuccess: boolean;
    pbaAccountrPaymentResult: any;
    orgName: string;
    constructor(paymentLibComponent: PaymentLibAlias$1, paymentViewService: PaymentViewService);
    ngOnInit(): void;
    getPersistedLanguage(): RpxLanguage;
    buttonCheck(): void;
    selectpbaaccount(args: any): void;
    saveAndContinue(): void;
    cardPayment(): void;
    selectPaymentMethod(type: string): void;
    gotoCasetransationPage(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PbaPaymentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PbaPaymentComponent, "ccpay-pba-payment", never, { "pbaPayOrderRef": { "alias": "pbaPayOrderRef"; "required": false; }; }, {}, never, never, true, never>;
}

interface IStatusHistories {
    amount: number;
    reference: string;
    status: string;
    status_histories: IStatusHistory[];
}

declare class StatusHistoryService {
    private http;
    private logger;
    private errorHandlerService;
    private paymentLibService;
    constructor(http: HttpClient, logger: LoggerService, errorHandlerService: ErrorHandlerService, paymentLibService: PaymentLibService);
    getPaymentStatusesByReference(paymentReference: string, paymentMethod: string): Observable$1<IStatusHistories>;
    static ɵfac: i0.ɵɵFactoryDeclaration<StatusHistoryService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StatusHistoryService>;
}

type PaymentLibAlias = PaymentLibComponent;
declare class StatusHistoryComponent implements OnInit {
    private statusHistoryService;
    private paymentViewService;
    private paymentLibComponent;
    isTakePayment: boolean;
    pageTitle: string;
    statuses: IStatusHistories;
    isDisplayFailureReasonColumn: boolean;
    isDisplayReasons: boolean[];
    errorMessage: string;
    constructor(statusHistoryService: StatusHistoryService, paymentViewService: PaymentViewService, paymentLibComponent: PaymentLibAlias);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StatusHistoryComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StatusHistoryComponent, "ccpay-payment-statuses", never, { "isTakePayment": { "alias": "isTakePayment"; "required": false; }; }, {}, never, never, true, never>;
}

declare class PaymentLibModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PaymentLibModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PaymentLibModule, [typeof PaymentLibComponent, typeof PaymentListComponent, typeof ProcessRefundComponent, typeof RefundListComponent, typeof CardDetailsComponent, typeof PageNotFoundComponent, typeof MarkUnidentifiedPaymentComponent, typeof MarkUnsolicitedPaymentComponent, typeof ProcessedPaymentsComponent, typeof AllocatePaymentsComponent, typeof PbaDetailsComponent, typeof FeeSummaryComponent, typeof keyValuePipe, typeof SanitizeHtmlPipe, typeof ReportsComponent, typeof ErrorBannerComponent, typeof TableComponent], [typeof i18.CommonModule, typeof i19.FormsModule, typeof i19.ReactiveFormsModule, typeof i20.MatTableModule, typeof i21.MatPaginatorModule, typeof i22.MatSortModule, typeof i23.MatFormFieldModule, typeof i24.MatInputModule, typeof CcdHyphensPipe, typeof CapitalizePipe, typeof PaymentViewComponent, typeof ContactDetailsComponent, typeof AddRemissionComponent, typeof ServiceRequestComponent, typeof NotificationPreviewComponent, typeof CaseTransactionsComponent, typeof UnprocessedPaymentsComponent, typeof RefundStatusComponent, typeof PbaPaymentComponent, typeof StatusHistoryComponent, typeof i37.RpxTranslationModule], [typeof PaymentLibComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PaymentLibModule>;
}

interface ICasePayments {
    'caseNumber': string;
    'payments': IPayment[];
}

interface IPaymentHistory {
    'paymentStatus': string;
    'paymentAmount': string;
    'dateCreated': string;
}

interface IPaymentDetails {
    'payment': IPayment;
    'fees': IFee;
    'cardDetails': ICardDetails;
    'paymentHistories': IPaymentHistory[];
    'caseNumber': string;
}

interface IRefundNotification {
    amount: number;
    ccd_case_number: string;
    date_created: string;
    date_updated: string;
    payment_reference: string;
    reason: string;
    refund_reference: string;
    refund_status: {
        description: string;
        name: string;
    };
    user_full_name: string;
}

interface IRefundStatusHistory {
    iRefundStatus: IRefundStatus[];
    lastUpdatedByCurrentUser: boolean;
}

interface IUnprocessedRecords {
    beneficiary_name: string;
    ccd_case_number: string;
    fee: string;
    hwf_amount: number;
    hwf_reference: string;
    payment_group_reference: string;
    site_id: string;
}

declare class RefundsRequest {
    payment_reference: string;
    refund_reason: string;
    constructor(payment_reference: string, refund_reason: string);
}

export { AddRemissionRequest, AddRetroRemissionRequest, AllocatePaymentRequest, IAllocationPaymentsRequest, IPaymentStatus, IPutNotificationRequest, IResubmitRefundRequest, IserviceRequestCardPayment, IserviceRequestPbaPayment, IssueRefundRequest, NotificationPreviewRequest, PaymentLibComponent, PaymentLibModule, PaymentLibService, PaymentToPayhubRequest, PostIssueRefundRetroRemission, PostRefundRetroRemission, RefundsRequest, TelephonyToPayhubRequest, UnidentifiedPaymentsRequest, UnsolicitedPaymentsRequest };
export type { IBSPayments, ICardDetails, ICasePayments, IFee, INotificationPreview, IOrderReferenceFee, IPatchRefundAction, IPayment, IPaymentDetails, IPaymentFailure, IPaymentGroup, IPaymentHistory, IPaymentView, IPayments, IRefundAction, IRefundContactDetails, IRefundFee, IRefundList, IRefundNotification, IRefundReasons, IRefundRejectReason, IRefundStatus, IRefundStatusHistory, IRefundsNotifications, IRemission, IStatusHistories, IStatusHistory, IUnprocessedRecords };