@xsolla/payment-client-core 0.0.5 → 0.0.7

package/lib/core/exceptions-handling/elk/additional-info.interface.d.ts

@@ -0,0 +1,19 @@
+export interface AdditionalInfo {
+    location: {
+        url: string;
+    };
+    user_agent?: string;
+    project: {
+        id: number;
+    };
+    referrer: {
+        url: string;
+    };
+    viewport: {
+        width: number;
+        height: number;
+    };
+    cdn_address: string;
+    country: string;
+    local: string;
+}

package/lib/core/exceptions-handling/elk/elk-logger.service.d.ts

@@ -0,0 +1,27 @@
+import { ErrorHandler, NgZone } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { SettingsService } from '../../settings/settings.service';
+import { ExtendedWindow } from '../../extended-window.interface';
+import { ErrorTags } from '../errors/elk-error-types.enum';
+import * as i0 from "@angular/core";
+export declare class ElkLoggerService implements ErrorHandler {
+    private readonly window;
+    private readonly settingsService;
+    private readonly http;
+    private readonly ngZone;
+    private readonly stackTrace;
+    private readonly vendors;
+    constructor(window: ExtendedWindow, settingsService: SettingsService, http: HttpClient, ngZone: NgZone);
+    handleError(error: Error): void;
+    log(message: string, tags: ErrorTags[], extra?: {
+        [key: string]: unknown;
+    }): void;
+    private parseError;
+    private loadStackTrace;
+    private getErrorTrace;
+    private getAdditionalInfo;
+    private removeErrorMetaFields;
+    private sendLog;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ElkLoggerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ElkLoggerService>;
+}

package/lib/core/exceptions-handling/elk/error-without-meta-fields.interface.d.ts

@@ -0,0 +1,8 @@
+import { AdditionalInfo } from './additional-info.interface';
+import { HttpErrorData } from '../http-interceptor/http-error-data.interface';
+export interface ErrorWithoutMetaFields {
+    message: string;
+    trace: string;
+    additionalInfo: AdditionalInfo;
+    httpErrorData?: HttpErrorData;
+}

package/lib/core/exceptions-handling/elk/log-message.interface.d.ts

@@ -0,0 +1,8 @@
+import { AdditionalInfo } from './additional-info.interface';
+export interface LogMessage {
+    additionalInfo: AdditionalInfo;
+    message: string;
+    extra?: {
+        [key: string]: unknown;
+    };
+}

package/lib/core/exceptions-handling/errors/elk-error-types.enum.d.ts

@@ -0,0 +1,11 @@
+export declare enum ErrorTags {
+    APP = "appError",
+    HTTP = "httpError",
+    JS = "jsError",
+    WS = "webSocket",
+    ENCRYPT = "encrypt",
+    APPLEPAY = "applepay",
+    HEADLESS_UI = "headlessUi",
+    GOOGLEPAY = "googlepay",
+    PAYTM = "paytm"
+}

package/lib/core/exceptions-handling/errors/tagged-error.class.d.ts

@@ -0,0 +1,10 @@
+import { ErrorTags } from './elk-error-types.enum';
+import { AdditionalInfo } from '../elk/additional-info.interface';
+export declare class TaggedError extends Error {
+    childTag: ErrorTags;
+    trace: string;
+    tags: ErrorTags[];
+    additionalInfo: AdditionalInfo;
+    private readonly parentTag;
+    constructor(message: string, tags?: ErrorTags[]);
+}

package/lib/core/exceptions-handling/errors/ws-error.class.d.ts

@@ -0,0 +1,5 @@
+import { ErrorTags } from './elk-error-types.enum';
+import { TaggedError } from './tagged-error.class';
+export declare class WsError extends TaggedError {
+    constructor(message: string, channelName: string, tags?: ErrorTags[]);
+}

package/lib/core/payment/actions/check-status/check-status.action.class.d.ts

@@ -0,0 +1,8 @@
+import { SubmitResponse } from '../../submit/response/submit-response.class';
+import { Action } from '../action.interface';
+import { CheckStatusActionData, CheckStatusActionType } from './check-status.action.type';
+export declare class CheckStatusAction implements Action {
+    type: CheckStatusActionType;
+    data: CheckStatusActionData;
+    constructor(submitResponse: SubmitResponse);
+}

package/lib/core/payment/actions/check-status/check-status.action.token.d.ts

@@ -0,0 +1,4 @@
+import { InjectionToken, ValueProvider } from '@angular/core';
+import { ActionFactoryValue } from '../action-factory-value.interface';
+export declare const checkStatusActionFactoryToken: InjectionToken<ActionFactoryValue>;
+export declare const checkStatusActionFactoryProvider: ValueProvider;

package/lib/core/payment/actions/check-status/check-status.action.type.d.ts

@@ -1,12 +1,12 @@
 import { Action } from '../action.interface';
-type CheckStatusActionType = 'check_status';
-interface CheckStatusActionData {
-    order: object;
-    invoiceId: number;
-    status: {
-        type: string;
-        isFinalStatus: boolean;
-    };
+export type CheckStatusActionType = 'check_status';
+export interface CheckStatusActionData {
+    invoice: number;
+    signature: string;
+    locale: string;
+    testProject?: string;
+    testPs?: string;
+    testXsolla?: string;
+    userReturnStatus?: string;
 }
 export type CheckStatusAction = Action<CheckStatusActionType, CheckStatusActionData>;
-export {};

package/lib/core/payment/actions/next-action.interface.d.ts

@@ -1,3 +1,4 @@
 import { CheckStatusAction } from './check-status/check-status.action.type';
 import { ShowFieldsAction } from './show-fields/show-fields.action.type';
-export type NextAction = CheckStatusAction | ShowFieldsAction;
+import { StatusUpdatedAction } from './status-updated/status-updated.action.type';
+export type NextAction = CheckStatusAction | ShowFieldsAction | StatusUpdatedAction;

package/lib/core/payment/actions/next-action.service.d.ts

@@ -2,13 +2,17 @@ import { Injector } from '@angular/core';
 import { NextAction } from './next-action.interface';
 import { SubmitResponse } from '../submit/response/submit-response.class';
 import { NextActionTokens } from './next-actions';
+import { Observable } from 'rxjs';
 import * as i0 from "@angular/core";
 export declare class NextActionService {
     private readonly nextActionTokens;
     private readonly injector;
+    private readonly flowUpdatesSubject;
     private readonly nextActionsMap;
+    get flowUpdates$(): Observable<NextAction>;
     constructor(nextActionTokens: NextActionTokens, injector: Injector);
     getNextAction(submitResponse: SubmitResponse): NextAction | null;
+    emitFlowUpdates(action: NextAction): void;
     private fillNextActionsMap;
     private findNextAction;
     static ɵfac: i0.ɵɵFactoryDeclaration<NextActionService, never>;

package/lib/core/payment/actions/status-updated/status-updated.action.class.d.ts

@@ -0,0 +1,8 @@
+import { Action } from '../action.interface';
+import { StatusUpdatedActionData, StatusUpdatedActionType } from './status-updated.action.type';
+import { StatusResponse } from '../../status/status-request/response/status-response.class';
+export declare class StatusUpdatedAction implements Action {
+    type: StatusUpdatedActionType;
+    data: StatusUpdatedActionData;
+    constructor(statusResponse: StatusResponse);
+}

package/lib/core/payment/actions/status-updated/status-updated.action.token.d.ts

@@ -0,0 +1,4 @@
+import { InjectionToken, ValueProvider } from '@angular/core';
+import { ActionFactoryValue } from '../action-factory-value.interface';
+export declare const statusUpdatedActionFactoryToken: InjectionToken<ActionFactoryValue>;
+export declare const statusUpdatedActionFactoryProvider: ValueProvider;

package/lib/core/payment/actions/status-updated/status-updated.action.type.d.ts

@@ -0,0 +1,11 @@
+import { Action } from '../action.interface';
+import { StatusEnum } from '../../status/status.enum';
+export type StatusUpdatedActionType = 'status_updated';
+export interface StatusUpdatedActionData {
+    statusState: StatusEnum;
+    group: string;
+    isCanceled?: boolean;
+    isSuccess?: boolean;
+    invoice?: number;
+}
+export type StatusUpdatedAction = Action<StatusUpdatedActionType, StatusUpdatedActionData>;

package/lib/core/payment/payment.interface.d.ts

@@ -1,8 +1,10 @@
 import { UntypedFormGroup, ValidationErrors } from '@angular/forms';
+import { Observable } from 'rxjs';
 import { NextAction } from './actions/next-action.interface';
-import { Field } from './field.interface';
-import { FinanceDetails } from './finance-details.interface';
 import { Status } from './status/status.interface';
+import { StatusParams } from './status/status-params.interface';
+import { FinanceDetails } from './finance-details.interface';
+import { Field } from './field.interface';
 export interface Payment {
     initialize(): Promise<Field[]>;
     submit(fields: Field[], form: UntypedFormGroup): Promise<NextAction | null>;
@@ -10,6 +12,7 @@ export interface Payment {
     validate(field: Field): Promise<ValidationErrors | null>;
     getFinanceDetails(): FinanceDetails;
     runThreeDs(): NextAction;
-    getStatus(): Status;
+    getStatus(params: StatusParams): Promise<Status>;
     changeFieldValue(name: string, value: string): void;
+    flowUpdates$: Observable<NextAction>;
 }

package/lib/core/payment/payment.service.d.ts

@@ -8,6 +8,8 @@ import { PaymentConfig } from './payment-config.interface';
 import { Status } from './status/status.interface';
 import { SubmitService } from './submit/submit.service';
 import { SyncService } from './sync/sync.service';
+import { StatusService } from './status/status.service';
+import { StatusParams } from './status/status-params.interface';
 import { NextActionService } from './actions/next-action.service';
 import * as i0 from "@angular/core";
 export declare class PaymentService {
@@ -15,18 +17,20 @@ export declare class PaymentService {
     private readonly submitService;
     private readonly syncService;
     private readonly formService;
+    private readonly statusService;
     private readonly nextActionService;
     form: UntypedFormGroup | null;
     private data;
     private fields;
-    constructor(initializeService: InitializeService, submitService: SubmitService, syncService: SyncService, formService: FormService, nextActionService: NextActionService);
+    private config;
+    constructor(initializeService: InitializeService, submitService: SubmitService, syncService: SyncService, formService: FormService, statusService: StatusService, nextActionService: NextActionService);
     initialize(config: PaymentConfig): Promise<Field[]>;
     submit(fields: Field[], form: UntypedFormGroup): Promise<NextAction | null>;
     getFields(): Field[];
     validate(field: Field): Promise<ValidationErrors | null>;
     runThreeDs(): NextAction;
     getFinanceDetails(): FinanceDetails;
-    getStatus(): Status;
+    getStatus(params: StatusParams): Promise<Status>;
     changeFieldValue(name: string, value: string): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<PaymentService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<PaymentService>;

package/lib/core/payment/status/check-status/check-status.service.d.ts

@@ -0,0 +1,20 @@
+import { SecureApiClient } from '../../../http/secure-api/secure-api.service';
+import { SettingsService } from '../../../settings/settings.service';
+import { CheckStatusRequestFactory } from './request/check-status-request.token';
+import { CheckStatusResponseFactory } from './response/check-status-response.token';
+import { XpsApiPart } from '../../xps-api-part.abstract';
+import { CheckStatusResponse } from './response/check-status-response.class';
+import * as i0 from "@angular/core";
+export declare class CheckStatusService extends XpsApiPart<CheckStatusResponse> {
+    private readonly secureApiClient;
+    private readonly settingsService;
+    private readonly requestFactory;
+    private readonly responseFactory;
+    private readonly apiRoute;
+    private invoice;
+    constructor(secureApiClient: SecureApiClient, settingsService: SettingsService, requestFactory: CheckStatusRequestFactory, responseFactory: CheckStatusResponseFactory);
+    setRequestParams(invoice: number): void;
+    request(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CheckStatusService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CheckStatusService>;
+}

package/lib/core/payment/status/check-status/request/check-status-request.class.d.ts

@@ -0,0 +1,8 @@
+import { XpsApiPartRequest } from '../../../xps-api-part-request.abstract';
+export declare class CheckStatusRequest extends XpsApiPartRequest {
+    readonly access_token: string;
+    readonly xps_fix_command = "status";
+    readonly invoice: number;
+    readonly section = "getstatus";
+    constructor(token: string | null, invoice: number);
+}

package/lib/core/payment/status/check-status/request/check-status-request.token.d.ts

@@ -0,0 +1,6 @@
+import { InjectionToken, ValueProvider } from '@angular/core';
+import { CheckStatusRequest } from './check-status-request.class';
+export type CheckStatusRequestParameters = ConstructorParameters<typeof CheckStatusRequest>;
+export type CheckStatusRequestFactory = (...args: CheckStatusRequestParameters) => CheckStatusRequest;
+export declare const checkStatusRequestFactoryToken: InjectionToken<CheckStatusRequestFactory>;
+export declare const checkStatusRequestFactoryProvider: ValueProvider;

package/lib/core/payment/status/check-status/response/check-status-response.class.d.ts

@@ -0,0 +1,8 @@
+import { Properties } from '../../../../properties.type';
+import { StatusEnum } from '../../status.enum';
+export declare class CheckStatusResponse {
+    readonly status?: StatusEnum;
+    readonly final?: boolean;
+    readonly isPaymentAccountAttached?: boolean;
+    constructor(parameters: Properties<CheckStatusResponse>);
+}

package/lib/core/payment/status/check-status/response/check-status-response.token.d.ts

@@ -0,0 +1,7 @@
+import { InjectionToken, ValueProvider } from '@angular/core';
+import { CheckStatusResponse } from './check-status-response.class';
+type ResponseParameters = ConstructorParameters<typeof CheckStatusResponse>;
+export type CheckStatusResponseFactory = (...args: ResponseParameters) => CheckStatusResponse;
+export declare const checkStatusResponseFactoryToken: InjectionToken<CheckStatusResponseFactory>;
+export declare const checkStatusResponseFactoryProvider: ValueProvider;
+export {};

package/lib/core/payment/status/listen-status/listen-status.service.d.ts

@@ -0,0 +1,28 @@
+import { Observable } from 'rxjs';
+import { StatusRequestService } from '../status-request/status-request.service';
+import { CheckStatusService } from '../check-status/check-status.service';
+import { WebsocketStatusService } from '../websocket-status/websocket-status.service';
+import { StatusSettings } from '../status-settings.interface';
+import { StatusUpdated } from '../status-updated.interface';
+import * as i0 from "@angular/core";
+export declare class ListenStatusService {
+    private readonly statusService;
+    private readonly checkStatusService;
+    private readonly websocketStatusService;
+    isListening: boolean;
+    private readonly websocketOpenedSubject;
+    private readonly statusUpdatedSubject;
+    private readonly statusDoneSubject;
+    private destroy$;
+    get websocketOpened$(): Observable<StatusSettings>;
+    get statusUpdated$(): Observable<StatusUpdated>;
+    constructor(statusService: StatusRequestService, checkStatusService: CheckStatusService, websocketStatusService: WebsocketStatusService);
+    listen(invoice: number): Observable<StatusSettings>;
+    stopListening(): void;
+    private subscribeStatusUpdate;
+    private subscribeCheckStatusUpdate;
+    private subscribeWebsocketEvent;
+    private openWebsocket;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListenStatusService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ListenStatusService>;
+}

package/lib/core/payment/status/status-groups.d.ts

@@ -0,0 +1,5 @@
+export declare enum StatusGroups {
+    troubled = "troubled",
+    done = "done",
+    invoice = "invoice"
+}

package/lib/core/payment/status/status-params.interface.d.ts

@@ -0,0 +1,9 @@
+export interface StatusParams {
+    invoice: number;
+    signature: string;
+    locale: string;
+    testProject?: number;
+    testPs?: number;
+    testXsolla?: number;
+    userReturnStatus?: string;
+}

package/lib/core/payment/status/status-request/request/status-request.class.d.ts

@@ -0,0 +1,17 @@
+import { XpsApiPartRequest } from '../../../xps-api-part-request.abstract';
+import { StatusRequestParams } from '../status-request-params.interface';
+export declare class StatusRequest extends XpsApiPartRequest {
+    readonly access_token: string;
+    readonly xps_fix_command = "status";
+    readonly xps_fix_invoice: number;
+    readonly xps_fix_pid: number;
+    readonly xps_signature: string;
+    readonly xps_locale: string;
+    readonly xps_fix_testProject: number | undefined;
+    readonly xps_fix_testPs: number | undefined;
+    readonly xps_fix_testXsolla: number | undefined;
+    readonly xps_fix_userReturnStatus: string | undefined;
+    constructor(parameters: {
+        token: string | null;
+    } & StatusRequestParams);
+}

package/lib/core/payment/status/status-request/request/status-request.token.d.ts

@@ -0,0 +1,6 @@
+import { InjectionToken, ValueProvider } from '@angular/core';
+import { StatusRequest } from './status-request.class';
+export type StatusRequestParameters = ConstructorParameters<typeof StatusRequest>;
+export type StatusRequestFactory = (...args: StatusRequestParameters) => StatusRequest;
+export declare const statusRequestFactoryToken: InjectionToken<StatusRequestFactory>;
+export declare const statusRequestFactoryProvider: ValueProvider;

package/lib/core/payment/status/status-request/response/status-response.class.d.ts

@@ -0,0 +1,14 @@
+import { Status } from '../../status.interface';
+import { XpsResponse, XpsStatus } from '../../../xps-response.interface';
+export declare class StatusResponse {
+    readonly status: Status;
+    private readonly error?;
+    constructor(parameters: {
+        status: XpsStatus | null;
+        errors: XpsResponse['errors'];
+        form?: XpsResponse['form'];
+    });
+    private getUserReturnStatus;
+    private getProjectAmount;
+    private getAdditionalBackButton;
+}

package/lib/core/payment/status/status-request/response/status-response.token.d.ts

@@ -0,0 +1,7 @@
+import { InjectionToken, ValueProvider } from '@angular/core';
+import { StatusResponse } from './status-response.class';
+type ResponseParameters = ConstructorParameters<typeof StatusResponse>;
+export type StatusResponseFactory = (...args: ResponseParameters) => StatusResponse;
+export declare const statusResponseFactoryToken: InjectionToken<StatusResponseFactory>;
+export declare const statusResponseFactoryProvider: ValueProvider;
+export {};

package/lib/core/payment/status/status-request/status-request-params.interface.d.ts

@@ -0,0 +1,10 @@
+export interface StatusRequestParams {
+    pid: number;
+    invoice: number;
+    signature: string;
+    locale: string;
+    testProject?: number;
+    testPs?: number;
+    testXsolla?: number;
+    userReturnStatus?: string;
+}

package/lib/core/payment/status/status-request/status-request.service.d.ts

@@ -0,0 +1,21 @@
+import { SettingsService } from '../../../settings/settings.service';
+import { SecureApiClient } from '../../../http/secure-api/secure-api.service';
+import { XpsApiPart } from '../../xps-api-part.abstract';
+import { StatusRequestFactory } from './request/status-request.token';
+import { StatusResponseFactory } from './response/status-response.token';
+import { StatusRequestParams } from './status-request-params.interface';
+import { StatusResponse } from './response/status-response.class';
+import * as i0 from "@angular/core";
+export declare class StatusRequestService extends XpsApiPart<StatusResponse> {
+    private readonly secureApiClient;
+    private readonly settingsService;
+    private readonly requestFactory;
+    private readonly responseFactory;
+    private readonly apiRoute;
+    private requestParams;
+    constructor(secureApiClient: SecureApiClient, settingsService: SettingsService, requestFactory: StatusRequestFactory, responseFactory: StatusResponseFactory);
+    setRequestParams(params: StatusRequestParams): void;
+    request(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StatusRequestService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StatusRequestService>;
+}

package/lib/core/payment/status/status-settings.interface.d.ts

@@ -0,0 +1,13 @@
+import { WebSocketClientType } from '../../web-socket/web-socket-client-type.enum';
+import { StatusEnum } from './status.enum';
+import { Status } from './status.interface';
+export interface StatusSettings {
+    statusState: StatusEnum;
+    isCancelUser: boolean;
+    needWebSocket: boolean;
+    backUrlSettings: Status['backUrlSettings'];
+    autoRedirect?: Status['autoRedirect'];
+    webSocketUrl: string;
+    webSocketChannelName: string;
+    webSocketClientType: WebSocketClientType;
+}

package/lib/core/payment/status/status-updated.interface.d.ts

@@ -0,0 +1,6 @@
+import { StatusResponse } from './status-request/response/status-response.class';
+import { StatusSettings } from './status-settings.interface';
+export interface StatusUpdated {
+    statusResponse: StatusResponse;
+    statusSettings: StatusSettings;
+}

package/lib/core/payment/status/status.interface.d.ts

@@ -47,7 +47,6 @@ export interface Status {
     titleClass: TitleClass;
     isSuccess?: boolean;
     isCanceled?: boolean;
-    babkaLink: string;
     paymentCountryIso: string;
     order?: {
         lineitems?: LineItem[];

package/lib/core/payment/status/status.service.d.ts

@@ -0,0 +1,16 @@
+import { StatusRequestService } from './status-request/status-request.service';
+import { StatusRequestParams } from './status-request/status-request-params.interface';
+import { ListenStatusService } from './listen-status/listen-status.service';
+import { Status } from './status.interface';
+import { NextActionService } from '../actions/next-action.service';
+import * as i0 from "@angular/core";
+export declare class StatusService {
+    private readonly statusRequestService;
+    private readonly listenStatusService;
+    private readonly nextActionService;
+    constructor(statusRequestService: StatusRequestService, listenStatusService: ListenStatusService, nextActionService: NextActionService);
+    getStatus(params: StatusRequestParams): Promise<Status>;
+    private startWaitingStatusUpdates;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StatusService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StatusService>;
+}

package/lib/core/payment/status/websocket-status/websocket-status.enum.d.ts

@@ -0,0 +1,4 @@
+export declare enum WebSocketStatus {
+    statusChanged = "status_changed",
+    troubledStatus = "troubled_status"
+}

package/lib/core/payment/status/websocket-status/websocket-status.service.d.ts

@@ -0,0 +1,24 @@
+import { Observable } from 'rxjs';
+import { WebSocketFactory } from '../../../web-socket/web-socket.factory';
+import { WebSocketClientType } from '../../../web-socket/web-socket-client-type.enum';
+import * as i0 from "@angular/core";
+export declare class WebsocketStatusService {
+    private readonly webSocketFactory;
+    private webSocketSubscription;
+    private webSocketReconnectionSubscription;
+    private readonly reinsuranceCheckStatus;
+    private readonly needCheckStatusSubject;
+    private readonly statusChangedSubject;
+    private webSocketClient;
+    get needCheckStatus$(): Observable<void>;
+    get statusChanged$(): Observable<void>;
+    constructor(webSocketFactory: WebSocketFactory);
+    checkStatusWithWebSocket(webSocketUrl: string, webSocketChannelName: string, webSocketClientType: WebSocketClientType): Promise<void>;
+    closeWebSocket(): void;
+    startReinsuranceCheckTimeout(): void;
+    private clearReinsuranceCheckTimeout;
+    private statusProcessing;
+    private removeSubscription;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WebsocketStatusService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WebsocketStatusService>;
+}

package/lib/core/payment/xps-api-part.abstract.d.ts

@@ -0,0 +1,8 @@
+import { Observable } from 'rxjs';
+export declare abstract class XpsApiPart<Response> {
+    get response$(): Observable<Response>;
+    private readonly response;
+    emitResponse(response: Response | null): void;
+    get currentValue(): Response | null;
+    protected abstract request(...args: any[]): void | Promise<Response | void> | Promise<Response> | Observable<Response>;
+}

package/lib/core/properties.type.d.ts

@@ -0,0 +1,3 @@
+export type Properties<T> = {
+    [P in keyof T]: T[P];
+};

package/lib/core/web-socket/centrifugo-web-socket.service.d.ts

@@ -0,0 +1,41 @@
+import { Observable, Subscription } from 'rxjs';
+import { ElkLoggerService } from '../exceptions-handling/elk/elk-logger.service';
+import { WebSocketClient } from './web-socket.interface';
+import { WebSocketClientType } from './web-socket-client-type.enum';
+import * as i0 from "@angular/core";
+export declare class CentrifugoWebSocketService implements WebSocketClient {
+    private readonly elkLoggerService;
+    static readonly reconnectionTimeoutIncrementFactor = 2;
+    type: WebSocketClientType;
+    private static readonly timeoutsMs;
+    private reconnectionTimeoutMs;
+    private reconnectionTimerId;
+    private readonly openConnectionTimerId;
+    private connection;
+    private subscription;
+    private subscriptionPosition?;
+    private isConnectionOpen;
+    private isConnecting;
+    private url;
+    private channel;
+    private prevSubscribedChannel?;
+    private readonly incomingMessages$;
+    private readonly successfulReconnectionEventsProxy$;
+    constructor(elkLoggerService: ElkLoggerService);
+    open(url: string, channel: string): Promise<void>;
+    close(): void;
+    get messages$(): Observable<string>;
+    subscribeOnSuccessfulReconnection(next?: () => void): Subscription;
+    private clearReconnectionTimer;
+    private setFirstReconnectionTimeout;
+    private incrementReconnectionTimeout;
+    private getCentrifugoClient;
+    private createConnection;
+    private onConnect;
+    private onDisconnect;
+    private reconnect;
+    private waitWhileNotReconnect;
+    private getSubscriptionOptions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CentrifugoWebSocketService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CentrifugoWebSocketService>;
+}

package/lib/core/web-socket/nchan-web-socket.service.d.ts

@@ -0,0 +1,30 @@
+import { Observable, Subscription } from 'rxjs';
+import { WebSocketClient } from './web-socket.interface';
+import { WebSocketClientType } from './web-socket-client-type.enum';
+import * as i0 from "@angular/core";
+export declare class NchanWebSocketService implements WebSocketClient {
+    static readonly reconnectionTimeoutIncrementFactor = 2;
+    url: string;
+    type: WebSocketClientType;
+    private static readonly timeoutsMs;
+    private openPromise;
+    private reconnectionTimeoutMs;
+    private reconnectionTimerId;
+    private readonly openConnectionTimerId;
+    private connection;
+    private readonly incomingMessages$;
+    private readonly successfulReconnectionEventsProxy$;
+    open(): Promise<unknown>;
+    close(): void;
+    get messages$(): Observable<string>;
+    subscribeOnSuccessfulReconnection(next?: () => void): Subscription;
+    private isClosed;
+    private clearReconnectionTimer;
+    private setFirstReconnectionTimeout;
+    private incrementReconnectionTimeout;
+    private createConnection;
+    private reconnect;
+    private waitWhileNotReconnect;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NchanWebSocketService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NchanWebSocketService>;
+}

package/lib/core/web-socket/web-socket-client-type.enum.d.ts

@@ -0,0 +1,4 @@
+export declare enum WebSocketClientType {
+    nchan = "nchan",
+    centrifugo = "centrifugo"
+}

package/lib/core/web-socket/web-socket.factory.d.ts

@@ -0,0 +1,13 @@
+import { NchanWebSocketService } from './nchan-web-socket.service';
+import { CentrifugoWebSocketService } from './centrifugo-web-socket.service';
+import { WebSocketClient } from './web-socket.interface';
+import { WebSocketClientType } from './web-socket-client-type.enum';
+import * as i0 from "@angular/core";
+export declare class WebSocketFactory {
+    private readonly nchanWebSocket;
+    private readonly centrifugoWebSocket;
+    constructor(nchanWebSocket: NchanWebSocketService, centrifugoWebSocket: CentrifugoWebSocketService);
+    createWebSocketClient(url: string, clientType: WebSocketClientType): WebSocketClient;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WebSocketFactory, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WebSocketFactory>;
+}