@xsolla/payment-client-core 0.2.44 → 0.2.46

package/lib/core/extended-window.interface.d.ts

@@ -1,4 +1,4 @@
-import { ApplePaySession } from 'braintree-web';
+import { ApplePaySession } from './sdk-payment-systems/apple-pay/apple-pay-session.interface';
 import { GooglePayLibrary } from './sdk-payment-systems/google-pay/google-pay-library.interface';
 export interface ExtendedWindow extends Window {
     PerformanceObserver?: typeof PerformanceObserver;

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

@@ -4,8 +4,8 @@ export interface Action<T = string, D = object> {
     type: T;
     data: D;
 }
-export interface ActionCreator<T = string, D = unknown> {
+export interface ActionCreator<R = SubmitResponse, T = string, D = unknown> {
     type: T;
-    isSuitable(response?: SubmitResponse): boolean;
+    isSuitable(response?: R): boolean;
     getActionData(actionData?: D): NextAction;
 }

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

@@ -1,7 +1,7 @@
 import { Injector } from '@angular/core';
 import { Observable } from 'rxjs';
-import { NextAction } from './next-action.interface';
 import { SubmitResponse } from '../submit/response/submit-response.class';
+import { NextAction } from './next-action.interface';
 import { NextActionTokens } from './next-actions';
 import { ShowErrorsActionCreator } from './show-errors/show-errors.action.class';
 import * as i0 from "@angular/core";

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

@@ -1,6 +1,6 @@
 import { InjectionToken, ProviderToken } from '@angular/core';
 import { ActionCreator } from './action.interface';
 export type NextActionTokens = Array<ProviderToken<ActionCreator>>;
-export declare const nextActionsToken: InjectionToken<ActionCreator<string, unknown>>;
+export declare const nextActionsToken: InjectionToken<ActionCreator<import("../submit/response/submit-response.class").SubmitResponse, string, unknown>>;
 export declare const nextActions: NextActionTokens;
 export declare const flowUpdateNextActions: NextActionTokens;

package/lib/core/payment/field-names.enum.d.ts

@@ -21,6 +21,7 @@ export declare enum FieldNames {
     description = "description",
     email = "email",
     psEmail = "psEmail",
+    psAccountCountry = "psAccountCountry",
     bazitemail = "bazitemail",
     euCheck = "eu_check",
     extraCvv = "extra_cvv",
@@ -75,5 +76,7 @@ export declare enum FieldNames {
     isSandbox = "isSandbox",
     payInstanceAccountId = "payInstanceAccountId",
     getApplePaySessionUrl = "getApplePaySessionUrl",
-    payViaCheckoutUrl = "payViaCheckoutUrl"
+    payViaCheckoutUrl = "payViaCheckoutUrl",
+    googlePayInitData = "googlePayInitData",
+    googlePayPaymentData = "googlePayPaymentData"
 }

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

@@ -14,7 +14,7 @@ export interface Field {
     regex?: string;
     validation_error_msg?: string;
     label_hint?: string;
-    javascript: {
+    javascript?: {
         change: {
             mutableFields: string[];
             staticParams: {

package/lib/core/payment/finance-details/finance-details.service.d.ts

@@ -14,6 +14,7 @@ export declare class FinanceDetailsService extends EmitDataService<FinanceDetail
     constructor(sessionService: SessionService, summaryFinanceDetailsAdapterService: SummaryFinanceDetailsAdapterService, statusFinanceDetailsAdapterService: StatusFinanceDetailsAdapterService);
     emitWithSummary(summary?: XpsSummary): void;
     emitWithStatus(status?: Status): void;
+    getDetailsFromSummary(summary: XpsSummary): FinanceDetails;
     static ɵfac: i0.ɵɵFactoryDeclaration<FinanceDetailsService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<FinanceDetailsService>;
 }

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

@@ -0,0 +1,11 @@
+import { InitializeNextAction } from '../initialize-actions/next-action.interface';
+import { InitializeResponse } from '../initialize/response/initialize-response.class';
+export interface InitializeAction<T = string, D = object> {
+    type: T;
+    data: D;
+}
+export interface InitializeActionCreator<R = InitializeResponse, T = string, D = unknown> {
+    type: T;
+    isSuitable(response?: R): boolean;
+    getActionData(actionData?: D): InitializeNextAction;
+}

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

@@ -0,0 +1,16 @@
+import { Injector } from '@angular/core';
+import { InitializeResponse } from '../initialize/response/initialize-response.class';
+import { InitializeNextActionTokens } from './initialize-next-actions';
+import { InitializeNextAction } from './next-action.interface';
+import * as i0 from "@angular/core";
+export declare class InitializeNextActionService {
+    private readonly initializeNextActionTokens;
+    private readonly injector;
+    private readonly initializeNextActionsList;
+    constructor(initializeNextActionTokens: InitializeNextActionTokens, injector: Injector);
+    getNextAction(response: InitializeResponse): InitializeNextAction | null;
+    private fillNextActionsList;
+    private findNextAction;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InitializeNextActionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InitializeNextActionService>;
+}

package/lib/core/payment/initialize-actions/initialize-next-actions.d.ts

@@ -0,0 +1,5 @@
+import { InjectionToken, ProviderToken } from '@angular/core';
+import { InitializeActionCreator } from './action.interface';
+export type InitializeNextActionTokens = Array<ProviderToken<InitializeActionCreator>>;
+export declare const initializeNextActionsToken: InjectionToken<InitializeActionCreator<import("../initialize/response/initialize-response.class").InitializeResponse, string, unknown>>;
+export declare const initializeNextActions: InitializeNextActionTokens;

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

@@ -0,0 +1,2 @@
+import { InitializeSpecialButtonAction } from './special-button/special-button.action.type';
+export type InitializeNextAction = InitializeSpecialButtonAction;

package/lib/core/payment/initialize-actions/special-button/special-button.action.class.d.ts

@@ -0,0 +1,17 @@
+import { ElkLoggerService } from '../../../exceptions-handling/elk/elk-logger.service';
+import { InitializeResponse } from '../../initialize/response/initialize-response.class';
+import { InitializeActionCreator } from '../action.interface';
+import { InitializeSpecialButtonAction, SpecialButtonActionType } from './special-button.action.type';
+import * as i0 from "@angular/core";
+export declare class InitializeSpecialButtonActionCreator implements InitializeActionCreator {
+    private readonly elkLoggerService;
+    type: SpecialButtonActionType;
+    private readonly pids;
+    private readonly sdkPaymentMethodsName;
+    constructor(elkLoggerService: ElkLoggerService);
+    getActionData(response: InitializeResponse): InitializeSpecialButtonAction;
+    isSuitable(response: InitializeResponse): boolean;
+    private getPaymentMethodName;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InitializeSpecialButtonActionCreator, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InitializeSpecialButtonActionCreator>;
+}

package/lib/core/payment/initialize-actions/special-button/special-button.action.type.d.ts

@@ -0,0 +1,6 @@
+import { InitializeAction } from '../action.interface';
+export type SpecialButtonActionType = 'special_button';
+export interface SpecialButtonActionData {
+    buttonName: string;
+}
+export type InitializeSpecialButtonAction = InitializeAction<SpecialButtonActionType, SpecialButtonActionData>;

package/lib/core/payment/initialized-form.inteface.d.ts

@@ -1,5 +1,7 @@
 import { Field } from './field.interface';
+import { InitializeNextAction } from './initialize-actions/next-action.interface';
 export interface InitializedForm {
     fields: Field[];
     isFormAutoSubmitted: boolean;
+    nextAction: InitializeNextAction | null;
 }

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

@@ -1,5 +1,6 @@
 import { Observable } from 'rxjs';
 import { FormControlStatus, UntypedFormGroup } from '@angular/forms';
+import { SubmitResponse } from './submit/response/submit-response.class';
 import { FormService } from './form/form.service';
 import { InitializeService } from './initialize/initialize.service';
 import { Status } from './status/status.interface';
@@ -7,6 +8,7 @@ import { SubmitService } from './submit/submit.service';
 import { SyncService } from './sync/sync.service';
 import { StatusService } from './status/status.service';
 import { NextActionService } from './actions/next-action.service';
+import { InitializeNextActionService } from './initialize-actions/initialize-next-action.service';
 import { ControlConfig } from './form/controls/control-config';
 import { ControlConfigService } from './form/controls/control-config.service';
 import { FinanceDetails } from './finance-details/finance-details.interface';
@@ -31,8 +33,11 @@ import { ControlStatus } from './form/control-status.interface';
 import { InitializedForm } from './initialized-form.inteface';
 import { CashPaymentData } from './cash-payment-data.interface';
 import { PrintInstructionService } from '../xsolla-number/api/print-instruction/print-instruction.service';
+import { SyncResponse } from './sync/response/sync-response.class';
+import { ElkLoggerService } from '../exceptions-handling/elk/elk-logger.service';
 import * as i0 from "@angular/core";
 export declare class PaymentService {
+    private readonly elkLoggerService;
     private readonly initializeService;
     private readonly submitService;
     private readonly syncService;
@@ -41,6 +46,7 @@ export declare class PaymentService {
     private readonly financeDetailsService;
     private readonly creditCardStateService;
     private readonly nextActionService;
+    private readonly initializeNextActionService;
     private readonly controlConfigService;
     private readonly threeDsService;
     private readonly formMessagesService;
@@ -64,17 +70,19 @@ export declare class PaymentService {
     private readonly formFieldsStatusSubject;
     private readonly _formResponse$;
     private isSavingMethodMode;
-    constructor(initializeService: InitializeService, submitService: SubmitService, syncService: SyncService, formService: FormService, statusService: StatusService, financeDetailsService: FinanceDetailsService, creditCardStateService: CreditCardStateService, nextActionService: NextActionService, controlConfigService: ControlConfigService, threeDsService: ThreeDsService, formMessagesService: FormMessagesService, settingsService: SettingsService, countryService: CountryService, checkStatusActionCreator: CheckStatusActionCreator, printInstructionService: PrintInstructionService);
+    constructor(elkLoggerService: ElkLoggerService, initializeService: InitializeService, submitService: SubmitService, syncService: SyncService, formService: FormService, statusService: StatusService, financeDetailsService: FinanceDetailsService, creditCardStateService: CreditCardStateService, nextActionService: NextActionService, initializeNextActionService: InitializeNextActionService, controlConfigService: ControlConfigService, threeDsService: ThreeDsService, formMessagesService: FormMessagesService, settingsService: SettingsService, countryService: CountryService, checkStatusActionCreator: CheckStatusActionCreator, printInstructionService: PrintInstructionService);
     initialize(config: PaymentConfiguration): Promise<InitializedForm>;
     submit(): Promise<NextAction | null | void>;
+    submitWithFields(fields?: Field[]): Promise<SubmitResponse>;
     getFields(): Field[];
     getControlStatus(name: FieldNames): ControlStatus | null;
-    getInitialDataForSdkPaymentSystems(): SdkPaymentSystemsInitialData;
+    getInitialDataForSdkPaymentSystems(): Promise<SdkPaymentSystemsInitialData>;
     getQrCode(): string;
     getCashPaymentData(): CashPaymentData;
     getPid(): number | null;
     getSubmitButtonText(): string | null;
     validate(field: Field): Promise<ValidationErrors | null>;
+    calculateField(changedField: Field, fields: Field[]): Promise<SyncResponse>;
     runThreeDs(): void;
     getFinanceDetails(): FinanceDetails | null;
     updateFieldFormState(fieldName: string, formState: FormState): void;
@@ -97,6 +105,7 @@ export declare class PaymentService {
     private emitFormResponse;
     private getInitializeMessages;
     private canAutoSubmit;
+    private getSdkPaymentDataFromResponse;
     static ɵfac: i0.ɵɵFactoryDeclaration<PaymentService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<PaymentService>;
 }

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

@@ -40,7 +40,7 @@ export declare class SyncService extends EmitDataService<XpsResponse> {
     reset(): void;
     validate(field: Field, delay?: number): Promise<ValidationErrors | null>;
     getSyncValidationErrors(field: Field): ValidationErrors | null;
-    protected request(field: Field): Promise<SyncResponse>;
+    request(field: Field, fields?: Field[], form?: UntypedFormGroup): Promise<SyncResponse>;
     private isReadyField;
     private getPrevFieldSyncState;
     private setPrevFieldSyncState;

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

@@ -3,5 +3,6 @@ export interface XpsError {
     code: number;
     message: string;
     element_name?: string;
+    title?: string;
     alternative_instances?: PaymentMethodApi[];
 }

package/lib/core/sdk-payment-systems/apple-pay/apple-pay-integration.type.d.ts

@@ -1 +1,5 @@
-export type ApplePayIntegration = 'redirect' | 'none';
+export declare enum ApplePayIntegrationType {
+    redirect = "redirect",
+    native = "native"
+}
+export type ApplePayIntegration = ApplePayIntegrationType;

package/lib/core/sdk-payment-systems/apple-pay/apple-pay-params-builder.service.d.ts

@@ -0,0 +1,15 @@
+import { PaymentForm } from '../../payment/payment-form.interface';
+import { XpsSummary } from '../../payment/xps-summary.interface';
+import { ApplePayParams } from './apple-pay-params.interface';
+import * as i0 from "@angular/core";
+export declare class ApplePayParamsBuilderService {
+    private readonly agreementFieldsNames;
+    buildParams(paymentForm: PaymentForm): ApplePayParams | null;
+    updateParams(params: ApplePayParams, summary: XpsSummary): ApplePayParams;
+    private getJsonValueFromField;
+    private getAppleToken;
+    private getTotalAmount;
+    private getTotalCurrency;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ApplePayParamsBuilderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ApplePayParamsBuilderService>;
+}

package/lib/core/sdk-payment-systems/apple-pay/apple-pay-session.interface.d.ts

@@ -0,0 +1,135 @@
+export declare class ApplePaySession {
+    static STATUS_SUCCESS: number;
+    static STATUS_FAILURE: number;
+    onvalidatemerchant: (this: ApplePaySession, event: ApplePayValidEvent) => void;
+    onpaymentauthorized: (this: ApplePaySession, event: ApplePayPaymentAuthorizedEvent) => void;
+    onshippingcontactselected: (this: ApplePaySession, event: ApplePayOnShippingContactSelectedEvent) => void;
+    onshippingmethodselected: (this: ApplePaySession, event: ApplePayOnShippingMethodSelectedEvent) => void;
+    completeShippingContactSelection: (this: ApplePaySession, shippingContactUpdate: ApplePayShippingContactUpdate) => void;
+    oncancel: (this: ApplePaySession, event?: ApplePayOnCancelEvent) => void;
+    constructor(version: number, paymentRequest: ApplePayPaymentRequest);
+    static supportsVersion(version: number): boolean;
+    static canMakePayments(): boolean;
+    completeMerchantValidation(merchantSession: ApplePayMerchantSession): void;
+    completePayment(status: number): void;
+    abort(): void;
+    begin(): void;
+}
+export interface ApplePayValidEvent {
+    validationURL: string;
+}
+export interface ApplePayPaymentAuthorizedEvent {
+    payment: ApplePayPayment;
+}
+export interface ApplePayOnShippingContactSelectedEvent {
+    shippingContact: {
+        locality: string;
+        country: string;
+        postalCode: string;
+        administrativeArea: string;
+        countryCode: string;
+    };
+}
+export interface ApplePayOnShippingMethodSelectedEvent {
+    shippingMethod: {
+        label: string;
+        detail: string;
+        amount: string;
+        identifier: string;
+        dateComponentsRange: {
+            startDateComponents: {
+                years: number;
+                months: number;
+                days: number;
+                hours: number;
+            };
+            endDateComponents: {
+                years: number;
+                months: number;
+                days: number;
+                hours: number;
+            };
+        };
+    };
+}
+export interface ApplePayShippingContactUpdate {
+    status: 'STATUS_SUCCESS' | 'STATUS_FAILURE';
+    newTotal: ApplePayLineItem;
+    newLineItems?: ApplePayLineItem[];
+}
+export interface ApplePayOnCancelEvent {
+    type: string;
+    sessionError: {
+        code: string;
+        info?: {
+            [key: string]: unknown;
+        };
+    };
+}
+export interface ApplePayPayment {
+    token: ApplePayPaymentToken;
+    billingContact?: ApplePayPaymentContact;
+    shippingContact?: ApplePayPaymentContact;
+}
+export interface ApplePayPaymentToken {
+    paymentMethod: {
+        displayName: string;
+        network: string;
+        type: string;
+    };
+    transactionIdentifier: string;
+}
+export interface ApplePayPaymentRequest {
+    countryCode: string;
+    currencyCode: string;
+    supportedNetworks: string[] | undefined;
+    merchantCapabilities: string[] | undefined;
+    total: ApplePayLineItem;
+    lineItems?: ApplePayLineItem[];
+    requiredShippingContactFields?: string[];
+    requiredBillingContactFields?: string[];
+    shippingMethods?: ApplePayShippingMethod[];
+    shippingType?: string;
+}
+export interface ApplePayLineItem {
+    amount: string;
+    label: string;
+    type?: 'final' | 'pending';
+    paymentTiming?: 'immediate' | 'recurring' | 'deferred' | 'automaticReload';
+    recurringPaymentStartDate?: Date;
+    recurringPaymentIntervalUnit?: 'year' | 'month' | 'day' | 'hour' | 'minute';
+    recurringPaymentIntervalCount?: number;
+    recurringPaymentEndDate?: Date;
+    deferredPaymentDate?: Date;
+    automaticReloadPaymentThresholdAmount?: string;
+}
+export interface ApplePayShippingMethod {
+    identifier: string;
+    label: string;
+    detail: string;
+    amount: string;
+}
+export interface ApplePayMerchantSession {
+    merchantIdentifier: string;
+    displayName: string;
+    signature: string;
+    nonce: string;
+    epochTimestamp: number;
+}
+export interface GetMerchantSessionResponse {
+    merchantSession: ApplePayMerchantSession;
+}
+export interface ApplePayPaymentContact {
+    emailAddress?: string;
+    phoneNumber?: string;
+    givenName?: string;
+    familyName?: string;
+    addressLines?: string[];
+    locality?: string;
+    subLocality?: string;
+    administrativeArea?: string;
+    subAdministrativeArea?: string;
+    postalCode?: string;
+    country?: string;
+    countryCode?: string;
+}

package/lib/core/sdk-payment-systems/apple-pay/apple-pay.errors.enum.d.ts

@@ -1,4 +1,7 @@
 export declare enum ApplePayErrors {
-    paymentError = "paymentError",
-    deviceIsNotCapableError = "deviceIsNotCapableError"
+    paymentError = "Apple Pay: payment error",
+    deviceIsNotCapableError = "Apple Pay: device is not capable",
+    cancelled = "Apple Pay: payment cancelled",
+    merchantValidationError = "Apple Pay: merchant validation error",
+    braintreeInitializeError = "Apple Pay: Braintree library is not initialized"
 }

package/lib/core/sdk-payment-systems/apple-pay/apple-pay.service.d.ts

@@ -1,16 +1,24 @@
 import { Observable } from 'rxjs';
-import { ApplePayParams } from './apple-pay-params.interface';
 import { ExtendedWindow } from '../../extended-window.interface';
-import { ApplePayErrors } from './apple-pay.errors.enum';
+import { SummaryFinanceDetailsAdapterService } from '../../payment/finance-details/summary/summary-finance-details-adapter.service';
 import { UserAgentService } from '../../user-agent/user-agent.service';
 import { ApplePayIntegration } from './apple-pay-integration.type';
-import { SummaryFinanceDetailsAdapterService } from '../../payment/finance-details/summary/summary-finance-details-adapter.service';
+import { ApplePayParams } from './apple-pay-params.interface';
+import { ApplePayErrors } from './apple-pay.errors.enum';
+import { BraintreeHandler } from './session-handlers/braintree.handler';
+import { CheckoutHandler } from './session-handlers/checkout.handler';
+import { PaymentForm } from '../../payment/payment-form.interface';
+import { ApplePayParamsBuilderService } from './apple-pay-params-builder.service';
+import { ElkLoggerService } from '../../exceptions-handling/elk/elk-logger.service';
 import * as i0 from "@angular/core";
 export declare class ApplePayService {
     private readonly window;
     private readonly userAgentService;
     private readonly summaryFinanceDetailsAdapterService;
-    private readonly agreementFieldsNames;
+    private readonly braintreeHandler;
+    private readonly checkoutHandler;
+    private readonly appleParamsBuilder;
+    private readonly elkLoggerService;
     private readonly payment;
     private readonly error;
     private readonly integrationType;
@@ -22,24 +30,27 @@ export declare class ApplePayService {
     get payment$(): Observable<string>;
     get error$(): Observable<ApplePayErrors>;
     get integrationType$(): Observable<ApplePayIntegration>;
-    constructor(window: ExtendedWindow, userAgentService: UserAgentService, summaryFinanceDetailsAdapterService: SummaryFinanceDetailsAdapterService);
-    setApplePayParams(data: unknown): void;
-    initLibrary(tokenKey: string): Promise<void>;
+    constructor(window: ExtendedWindow, userAgentService: UserAgentService, summaryFinanceDetailsAdapterService: SummaryFinanceDetailsAdapterService, braintreeHandler: BraintreeHandler, checkoutHandler: CheckoutHandler, appleParamsBuilder: ApplePayParamsBuilderService, elkLoggerService: ElkLoggerService);
+    setApplePayParams(data: {
+        paymentForm: PaymentForm;
+    }): void;
+    initBraintreeLibrary(tokenKey: string): Promise<void>;
     redirectToPaymentPage(parameters: ApplePayParams, token: string, isSandbox?: boolean): string | undefined;
-    setOrder(data: unknown): void;
-    isDeviceCapable(): boolean;
+    setOrder(data: {
+        paymentForm: PaymentForm;
+    }): void;
+    get isDeviceCapable(): boolean;
     getTokenNonceFieldData(tokenNonce: string): {
         name: string;
         value: string;
     };
     updateApplePayParams(data: unknown): void;
+    proceedCheckout(parameters: ApplePayParams, iframeIntegrationEnabled?: boolean): void;
+    private getSessionHandler;
     private loadBraintree;
-    private getAppleToken;
-    private getTotalAmount;
-    private getTotalCurrency;
-    private getJsonValueFromField;
     private emitError;
     private emitIntegrationType;
+    private subscribeToHandlers;
     static ɵfac: i0.ɵɵFactoryDeclaration<ApplePayService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ApplePayService>;
 }

package/lib/core/sdk-payment-systems/apple-pay/checkout-params.interface.d.ts

@@ -13,4 +13,5 @@ export interface ApplePayCheckoutParams {
     payInstanceAccountId: string;
     getApplePaySessionUrl: string;
     payViaCheckoutUrl: string;
+    topLevelDomain?: string;
 }

package/lib/core/sdk-payment-systems/apple-pay/session-handlers/braintree.handler.d.ts

@@ -0,0 +1,16 @@
+import { ApplePay } from 'braintree-web';
+import { ElkLoggerService } from '../../../exceptions-handling/elk/elk-logger.service';
+import { ExtendedWindow } from '../../../extended-window.interface';
+import { ApplePayParams } from '../apple-pay-params.interface';
+import { ApplePaySessionHandlerAbstract } from './session-handler.abstract';
+import * as i0 from "@angular/core";
+export declare class BraintreeHandler extends ApplePaySessionHandlerAbstract {
+    private readonly window;
+    private readonly elkLoggerService;
+    private paymentClient;
+    constructor(window: ExtendedWindow, elkLoggerService: ElkLoggerService);
+    setClient(client: ApplePay): void;
+    startSession(params: ApplePayParams, iframeIntegrationEnabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BraintreeHandler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BraintreeHandler>;
+}

package/lib/core/sdk-payment-systems/apple-pay/session-handlers/checkout.handler.d.ts

@@ -0,0 +1,13 @@
+import { HttpClient } from '@angular/common/http';
+import { ExtendedWindow } from '../../../extended-window.interface';
+import { ApplePayParams } from '../apple-pay-params.interface';
+import { ApplePaySessionHandlerAbstract } from './session-handler.abstract';
+import * as i0 from "@angular/core";
+export declare class CheckoutHandler extends ApplePaySessionHandlerAbstract {
+    private readonly window;
+    private readonly http;
+    constructor(window: ExtendedWindow, http: HttpClient);
+    startSession(params: ApplePayParams, iframeIntegrationEnabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CheckoutHandler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CheckoutHandler>;
+}

package/lib/core/sdk-payment-systems/apple-pay/session-handlers/session-handler.abstract.d.ts

@@ -0,0 +1,13 @@
+import { Observable, Subject } from 'rxjs';
+import { ApplePayParams } from '../apple-pay-params.interface';
+import { ApplePayErrors } from '../apple-pay.errors.enum';
+import { ApplePayPaymentRequest } from '../apple-pay-session.interface';
+export declare abstract class ApplePaySessionHandlerAbstract {
+    protected readonly payment: Subject<string>;
+    private readonly _errorSubject;
+    get error$(): Observable<ApplePayErrors>;
+    get payment$(): Observable<string>;
+    abstract startSession(params: ApplePayParams, iframe: boolean): void;
+    protected emitError(error: ApplePayErrors): void;
+    protected buildPaymentRequest(params: ApplePayParams): ApplePayPaymentRequest;
+}

package/lib/core/sdk-payment-systems/apple-pay/session-handlers/session-handler.type.d.ts

@@ -0,0 +1,3 @@
+import { BraintreeHandler } from './braintree.handler';
+import { CheckoutHandler } from './checkout.handler';
+export type ApplePaySessionHandler = BraintreeHandler | CheckoutHandler;

package/lib/core/sdk-payment-systems/google-pay/check-payment-device-data.interface.d.ts

@@ -0,0 +1,9 @@
+import { Field } from '../../payment/field.interface';
+import { SubmitResponse } from '../../payment/submit/response/submit-response.class';
+import { XpsSummary } from '../../payment/xps-summary.interface';
+export interface CheckPaymentDeviceData {
+    base64checkoutData: string | null;
+    submitResponse: SubmitResponse | null;
+    fields: Field[];
+    summary: XpsSummary | null;
+}

package/lib/core/sdk-payment-systems/google-pay/google-pay-init-params.interface.d.ts

@@ -1,4 +1,10 @@
+import { Field } from '../../payment/field.interface';
+import { PaymentAuthorizedHandler, PaymentDataChangedHandler } from './google-pay-library.interface';
 export interface GooglePayInitParams {
     isSandbox: boolean;
+    isInstantPayFlow: boolean;
     country: string;
+    fields: Field[];
+    onPaymentDataChanged: PaymentDataChangedHandler;
+    onPaymentAuthorized: PaymentAuthorizedHandler;
 }