@xsolla/payment-client-core 0.0.4 → 0.0.6

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

@@ -0,0 +1,39 @@
+import { Field } from './field.interface';
+import { Invoice } from './invoice.interface';
+import { StatusEnum } from './status/status.enum';
+import { XpsResponse } from './xps-response.interface';
+export interface PaymentForm {
+    totalAmount: string;
+    currency: string;
+    fields: Field[];
+    taxDisclaimer: string | null;
+    number: number;
+    barcode: unknown;
+    offers: unknown;
+    instruction: string;
+    errors: XpsResponse['errors'];
+    error?: {
+        fields: {
+            [key: string]: string;
+        };
+    };
+    restrictions: unknown;
+    info: string;
+    buyData: XpsResponse['buyData'];
+    pid: XpsResponse['pid'];
+    messages: XpsResponse['messages'];
+    title: string;
+    summary: XpsResponse['summary'];
+    skipForm: XpsResponse['skipForm'];
+    isSavedMethodPayment?: boolean;
+    couponCode?: string;
+    publicId: XpsResponse['public_id'];
+    koreaNotification?: Field;
+    skipCheckout: XpsResponse['skipCheckout'];
+    isCheckout: XpsResponse['isCheckout'];
+    categories: XpsResponse['categories'];
+    hasFatalErrors?: boolean;
+    userSession?: Invoice;
+    statusText?: StatusEnum | null;
+    country: string | null;
+}

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

@@ -1,14 +1,18 @@
-import { NextAction } from './actions/next-action.type';
-import { Field } from './field.interface';
-import { FinanceDetails } from './finance-details.interface';
+import { UntypedFormGroup, ValidationErrors } from '@angular/forms';
+import { Observable } from 'rxjs';
+import { NextAction } from './actions/next-action.interface';
 import { Status } from './status/status.interface';
-import { XpsResponse } from './xps-response.interface';
+import { StatusParams } from './status/status-params.interface';
+import { FinanceDetails } from './finance-details.interface';
+import { Field } from './field.interface';
 export interface Payment {
-    initialize(): Promise<XpsResponse>;
-    submit(): NextAction;
+    initialize(): Promise<Field[]>;
+    submit(fields: Field[], form: UntypedFormGroup): Promise<NextAction | null>;
     getFields(): Field[];
-    validate(field: Field): boolean;
+    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

@@ -1,22 +1,37 @@
-import { NextAction } from './actions/next-action.type';
+import { UntypedFormGroup, ValidationErrors } from '@angular/forms';
+import { NextAction } from './actions/next-action.interface';
 import { Field } from './field.interface';
 import { FinanceDetails } from './finance-details.interface';
-import { InitializeService } from './initialize.service';
+import { FormService } from './form/form.service';
+import { InitializeService } from './initialize/initialize.service';
 import { PaymentConfig } from './payment-config.interface';
 import { Status } from './status/status.interface';
-import { XpsResponse } from './xps-response.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 {
     private readonly initializeService;
+    private readonly submitService;
+    private readonly syncService;
+    private readonly formService;
+    private readonly statusService;
+    private readonly nextActionService;
+    form: UntypedFormGroup | null;
     private data;
-    constructor(initializeService: InitializeService);
-    initialize(config: PaymentConfig): Promise<XpsResponse>;
-    submit(): NextAction;
+    private fields;
+    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): boolean;
+    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/submit/request/submit-request.class.d.ts

@@ -0,0 +1,13 @@
+import { Field } from '../../field.interface';
+import { UntypedFormGroup } from '@angular/forms';
+import { XpsApiPartRequest } from '../../xps-api-part-request.abstract';
+export declare class SubmitRequest extends XpsApiPartRequest {
+    readonly access_token: string;
+    readonly xps_dfp_hash?: string;
+    constructor(parameters: {
+        token: string | null;
+        fields: Field[];
+        form: UntypedFormGroup;
+        dfpHash: string | null;
+    });
+}

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

@@ -0,0 +1,6 @@
+import { InjectionToken, ValueProvider } from '@angular/core';
+import { SubmitRequest } from './submit-request.class';
+export type SubmitRequestParameters = ConstructorParameters<typeof SubmitRequest>;
+export type SubmitRequestFactory = (...args: SubmitRequestParameters) => SubmitRequest;
+export declare const submitRequestFactoryToken: InjectionToken<SubmitRequestFactory>;
+export declare const submitRequestFactoryProvider: ValueProvider;

package/lib/core/payment/submit/response/submit-response.class.d.ts

@@ -0,0 +1,26 @@
+import { XpsResponse } from '../../xps-response.interface';
+import { Field } from '../../field.interface';
+import { Invoice } from '../../invoice.interface';
+import { XpsCommand } from '../../xps-comand.enum';
+export declare class SubmitResponse {
+    readonly responseNumber: number;
+    readonly parameters: XpsResponse;
+    readonly fields: Field[];
+    onlineBanking?: {
+        url: string;
+    };
+    readonly data?: unknown;
+    isNeedRedirect: boolean;
+    buyData: XpsResponse['buyData'];
+    signature?: string;
+    fixInvoice?: string;
+    hasFatalErrors?: boolean;
+    userSession?: Invoice;
+    pid: XpsResponse['pid'];
+    errors: XpsResponse['errors'];
+    summary: XpsResponse['summary'];
+    title: string;
+    currentCommand: XpsCommand | null;
+    messages: XpsResponse['messages'];
+    constructor(parameters: XpsResponse, responseNumber?: number);
+}

package/lib/core/payment/submit/response/submit-response.token.d.ts

@@ -0,0 +1,6 @@
+import { InjectionToken, ValueProvider } from '@angular/core';
+import { SubmitResponse } from './submit-response.class';
+export type SubmitResponseParameters = ConstructorParameters<typeof SubmitResponse>;
+export type SubmitResponseFactory = (...args: SubmitResponseParameters) => SubmitResponse;
+export declare const submitResponseFactoryToken: InjectionToken<SubmitResponseFactory>;
+export declare const submitResponseFactoryProvider: ValueProvider;

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

@@ -0,0 +1,21 @@
+import { Field } from '../field.interface';
+import { SubmitRequestFactory } from './request/submit-request.token';
+import { SubmitResponseFactory } from './response/submit-response.token';
+import { SettingsService } from '../../settings/settings.service';
+import { SubmitResponse } from './response/submit-response.class';
+import { UntypedFormGroup } from '@angular/forms';
+import { DeviceFingerPrintService } from '../../device-finger-print/device-finger-print.service';
+import { SecureApiClient } from '../../http/secure-api/secure-api.service';
+import * as i0 from "@angular/core";
+export declare class SubmitService {
+    private readonly requestFactory;
+    private readonly responseFactory;
+    private readonly settingsService;
+    private readonly deviceFingerPrintService;
+    private readonly secureApi;
+    private readonly directPaymentApiRoute;
+    constructor(requestFactory: SubmitRequestFactory, responseFactory: SubmitResponseFactory, settingsService: SettingsService, deviceFingerPrintService: DeviceFingerPrintService, secureApi: SecureApiClient);
+    request(fields: Field[], form: UntypedFormGroup): Promise<SubmitResponse>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SubmitService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SubmitService>;
+}

package/lib/core/payment/sync/field-sync-state.interface.d.ts

@@ -0,0 +1,5 @@
+import { ValidationErrors } from '@angular/forms';
+export interface FieldSyncState {
+    value: unknown;
+    result: Promise<ValidationErrors | null>;
+}

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

@@ -0,0 +1,15 @@
+import { UntypedFormGroup } from '@angular/forms';
+import { Field } from '../field.interface';
+import { XpsRequest } from '../xps-request.abstract';
+export declare class SyncRequest extends XpsRequest {
+    readonly access_token: string;
+    readonly xps_fix_command = "calculate";
+    constructor(parameters: {
+        token: string;
+        changedField: Field;
+        fields: Field[];
+        form: UntypedFormGroup;
+    });
+    private getFieldsValues;
+    private getFieldsMap;
+}

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

@@ -0,0 +1,6 @@
+import { InjectionToken, ValueProvider } from '@angular/core';
+import { SyncRequest } from './sync-request.class';
+export type SyncRequestParameters = ConstructorParameters<typeof SyncRequest>;
+export type SyncRequestFactory = (...args: SyncRequestParameters) => SyncRequest;
+export declare const syncRequestFactoryToken: InjectionToken<SyncRequestFactory>;
+export declare const syncRequestFactoryProvider: ValueProvider;

package/lib/core/payment/sync/sync-response.class.d.ts

@@ -0,0 +1,11 @@
+import { Field } from '../field.interface';
+import { XpsResponse } from '../xps-response.interface';
+export declare class SyncResponse {
+    readonly rewritableError?: {
+        code: number;
+        message: string;
+    };
+    readonly fields: Field[];
+    readonly parameters: XpsResponse;
+    constructor(changedField: Field, response: XpsResponse);
+}

package/lib/core/payment/sync/sync-response.token.d.ts

@@ -0,0 +1,6 @@
+import { InjectionToken, ValueProvider } from '@angular/core';
+import { SyncResponse } from './sync-response.class';
+export type SyncResponseParameters = ConstructorParameters<typeof SyncResponse>;
+export type SyncResponseFactory = (...args: SyncResponseParameters) => SyncResponse;
+export declare const syncResponseFactoryToken: InjectionToken<SyncResponseFactory>;
+export declare const syncResponseFactoryProvider: ValueProvider;

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

@@ -0,0 +1,27 @@
+import { UntypedFormGroup, ValidationErrors } from '@angular/forms';
+import { SecureApiClient } from '../../http/secure-api/secure-api.service';
+import { SettingsService } from '../../settings/settings.service';
+import { Field } from '../field.interface';
+import { SyncRequestFactory } from './sync-request.token';
+import { SyncResponseFactory } from './sync-response.token';
+import * as i0 from "@angular/core";
+export declare class SyncService {
+    private readonly requestFactory;
+    private readonly responseFactory;
+    private readonly secureApi;
+    private readonly settingsService;
+    private readonly apiRoute;
+    private prevFieldSyncStates;
+    private form;
+    private fields;
+    constructor(requestFactory: SyncRequestFactory, responseFactory: SyncResponseFactory, secureApi: SecureApiClient, settingsService: SettingsService);
+    setup(form: UntypedFormGroup, fields: Field[]): void;
+    reset(): void;
+    validate(field: Field): Promise<ValidationErrors | null>;
+    private request;
+    private isReadyField;
+    private getPrevFieldSyncState;
+    private setPrevFieldSyncState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SyncService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SyncService>;
+}

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

@@ -0,0 +1,6 @@
+export declare abstract class XpsApiPartRequest {
+    [fieldName: `xps_${string}`]: unknown;
+    protected addXpsParameters(parameters: {
+        [key: string]: unknown;
+    }): void;
+}

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/payment/xps-error.interface.d.ts

@@ -2,5 +2,6 @@ import { PaymentMethodApi } from '../payment-methods/payment-method-api.interfac
 export interface XpsError {
     code: number;
     message: string;
+    element_name?: string;
     alternative_instances?: PaymentMethodApi[];
 }

package/lib/core/payment/xps-request.abstract.d.ts

@@ -0,0 +1,6 @@
+export declare abstract class XpsRequest {
+    [fieldName: `xps_${string}`]: unknown;
+    protected addXpsParameters(parameters: {
+        [key: string]: unknown;
+    }): void;
+}

package/lib/core/payment/xps-response.interface.d.ts

@@ -1,4 +1,4 @@
-import { BooleanString } from '../boolean-string.enum';
+import { XpsBoolean } from '../xps-boolean.enum';
 import { CheckoutItem } from './checkout-item.interface';
 import { Field } from './field.interface';
 import { Invoice } from './invoice.interface';
@@ -97,7 +97,7 @@ export interface XpsResponse {
         isMandatory: null | boolean;
         isPakets: null | boolean;
         isReadonly: null | boolean;
-        isVisible: BooleanString;
+        isVisible: XpsBoolean;
         label_hint: null | string;
         name: string;
         options: null | unknown[];
@@ -111,12 +111,9 @@ export interface XpsResponse {
     };
     accountXsolla: string;
     public_id: string;
-    idCardType: string | null;
-    switch_card_icon: string | null;
     form: {
         [key: string]: Field;
     };
-    isShortForm: BooleanString;
     taxDisclaimer: string | null;
     number: number;
     barcode: unknown;
@@ -137,7 +134,7 @@ export interface XpsResponse {
             [key: string]: string;
         };
     };
-    invoiceCreated: BooleanString;
+    invoiceCreated: XpsBoolean;
     messages?: XpsMessage[];
     status?: StatusEnum | XpsStatus | null;
     final?: boolean;

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

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