@paypay/mini-app-js-sdk 2.40.0 → 2.46.0

package/dist/model/bridge/getPlatformInformation.d.ts

@@ -1,3 +1,3 @@
 import { NativeParams } from '../../jsbridge-core/jsbridge';
 import { GetPlatformInformationResult } from '../../types/getPlatformInformation';
-export declare function getPlatformInformation(params: NativeParams<GetPlatformInformationResult>): Promise<void>;
+export declare function getPlatformInformation(params: NativeParams<GetPlatformInformationResult>): void;

package/dist/model/bridge/renderPayButton.d.ts

@@ -1,11 +1,5 @@
 import { RenderSmartButtonParams, SmartButtonParam } from '../../types';
 export declare function getRenderPayInfo(params: RenderSmartButtonParams): Promise<{
-    renderParams: RenderSmartButtonParams;
-    data: SmartButtonParam;
-    preferredLanguage: string;
-    isLoggedIn?: undefined;
-    isJustLoggedIn?: undefined;
-} | {
     renderParams: RenderSmartButtonParams;
     data: SmartButtonParam;
     isLoggedIn: boolean;

package/dist/model/miniAppError.d.ts

@@ -67,9 +67,6 @@ export declare enum MiniAppErrorType {
     unexpectedOperation = "UNEXPECTED_OP",
     merchantTimeout = "MERCHANT_TIMEOUT",
     rateLimitExceeded = "RATE_LIMIT_EXCEEDED",
-    sdkUpgradeRequired = "SDK_UPGRADE_REQUIRED"
-}
-export declare class MiniAppError extends Error {
-    constructor(type: MiniAppErrorType);
-    toString(): string;
+    sdkUpgradeRequired = "SDK_UPGRADE_REQUIRED",
+    authorizationNeeded = "AUTHORIZATION_NEEDED"
 }

package/dist/resources/locales/topup/index.d.ts

@@ -5,6 +5,7 @@ declare const _default: {
             charge: string;
             minAmount: string;
             maxAmount: string;
+            maxErrorWithAmount: string;
             moneyLabel: string;
             noMethod: string;
             loading: string;
@@ -57,6 +58,7 @@ declare const _default: {
             charge: string;
             minAmount: string;
             maxAmount: string;
+            maxErrorWithAmount: string;
             moneyLabel: string;
             noMethod: string;
             loading: string;

package/dist/resources/locales/topup/ja.d.ts

@@ -4,6 +4,7 @@ declare const _default: {
         charge: string;
         minAmount: string;
         maxAmount: string;
+        maxErrorWithAmount: string;
         moneyLabel: string;
         noMethod: string;
         loading: string;

package/dist/types/checkPaymentMethod.d.ts

@@ -1,5 +1,5 @@
 import { NativeParams } from '../jsbridge-core/jsbridge';
-import { PaymentMethodNameType } from '../model/makePayment';
+import { PaymentMethodNameType } from '../types/makePayment';
 export declare const AvailableCheckPaymentMethod: {
     readonly acquiring: "ACQUIRING";
     readonly topup: "TOPUP";

package/dist/types/getKycInformation.d.ts

@@ -40,11 +40,11 @@ export interface KycData {
     job?: string;
 }
 export declare type GetKycInformationResult = {
-    status: KycStatusType | string;
+    status: KycStatusType;
     kycAt?: string;
     kycInfo?: KycData;
-    type?: KycMethodType | string;
-    eKycDocuments?: EKycDocumentType | string;
+    type?: KycMethodType;
+    eKycDocuments?: EKycDocumentType;
     ngReason?: string;
     jws: string;
 };

package/dist/types/getKycPassportInfo.d.ts

@@ -13,8 +13,8 @@ export declare type GetKycPassportInfoResult = {
     status: 'COMPLETED';
     kycAt: string;
     kycInfo: KycData;
-    type: KycMethodType | string;
-    eKycDocuments: EKycDocumentType | string;
+    type: KycMethodType;
+    eKycDocuments: EKycDocumentType;
     jws: string;
     possessionAuthResult: 'SUCCESS';
     nonce: string;

package/dist/types/getPlatformInformation.d.ts

@@ -1,6 +1,5 @@
 export declare type GetPlatformInformationResult = {
     appVersion: string | null;
-    sdkVersion: string | null;
     preferredLanguage: string;
     fontSize: FontSize;
 };

package/dist/types/init.d.ts

@@ -31,7 +31,7 @@ export declare const PPEnv: {
 };
 export declare type PPEnvType = (typeof PPEnv)[keyof typeof PPEnv];
 export declare type InitResult = {
-    statusCode: InitStatusCodeType | string;
+    statusCode: InitStatusCodeType;
 };
 export declare const InitStatusCode: {
     readonly initialized: "INITIALIZED";
@@ -39,5 +39,6 @@ export declare const InitStatusCode: {
     readonly tokenExpired: "TOKEN_EXPIRED";
     readonly sdkNotInitialized: "SDK_NOT_INITIALIZED";
     readonly tokenNotFound: "TOKEN_NOT_FOUND";
+    readonly authorizationNeeded: "AUTHORIZATION_NEEDED";
 };
 export declare type InitStatusCodeType = (typeof InitStatusCode)[keyof typeof InitStatusCode];

package/dist/types/makePayment.d.ts

@@ -1,5 +1,7 @@
 import { NativeParams } from '../jsbridge-core/jsbridge';
 import { Address } from '../types/getUserAddress';
+import { UIComponentsError } from '../model/uiComponents';
+import { MiniAppErrorType } from '../model/miniAppError';
 export declare const Order: {
     readonly ACQUIRING: "ACQUIRING";
     readonly REMITTANCE: "REMITTANCE";
@@ -53,3 +55,420 @@ export declare const PaymentConsultResultCode: {
     EKYC_REQUIRED: string;
     INSUFFICIENT_BALANCE_AND_NO_AVAILABLE_TOPUP_METHOD: string;
 };
+export declare type PaymentQuery = {
+    merchant?: string;
+    agreeSimilarTransaction: boolean;
+};
+export interface PaymentBody {
+    merchantPaymentId: string;
+    amount: Amount;
+    orderReceiptNumber?: string;
+    orderDescription?: string;
+    orderItems?: Array<OrderItem>;
+    metaData?: unknown;
+    storeId?: string;
+    paymentMethodId: string;
+    terminalId?: number | string;
+    merchantAlias?: string;
+    requestedAt?: number;
+    productType?: string;
+    storeInfo?: string;
+    metadata?: unknown;
+    expiresAt?: number;
+    merchant?: string;
+}
+export declare type Balance = {
+    balance: number;
+    currency: 'JPY';
+    usable: boolean;
+};
+export declare const PaymentMethodName: {
+    readonly WALLET: "WALLET";
+    readonly CREDIT_CARD: "CREDIT_CARD";
+    readonly BANK: "BANK";
+    readonly YMONEY_BANK: "YMONEY_BANK";
+    readonly SBID_CARRIER_BILLING: "SBID_CARRIER_BILLING";
+    readonly PAY_LATER: "PAY_LATER";
+    readonly PAY_LATER_CC: "PAY_LATER_CC";
+};
+export declare type PaymentMethodNameType = (typeof PaymentMethodName)[keyof typeof PaymentMethodName];
+declare type GlobalLimitInfo = {
+    topup?: {
+        min: number;
+        max: number;
+        formattedMax: string;
+        formattedMin: string;
+    };
+};
+declare type MethodBase = {
+    paymentMethodId: string;
+    paymentMethodType: PaymentMethodNameType;
+    descriptionBannerInfo?: BannerInfo;
+    walletInfo?: unknown;
+    creditCardInfo?: unknown;
+    bankInfo?: unknown;
+    sbidCarrierBillingInfo?: unknown;
+    payLaterCcInfo?: unknown;
+    paymentMethodDescriptionInfo?: {
+        statusDescription: DescriptionInfo | null;
+        additionalDescription: DescriptionInfo | null;
+        detailDescription: DescriptionInfo | null;
+        label?: DescriptionInfo | null;
+        amountInfo?: {
+            label: string;
+            amount: number;
+            currency: string;
+        };
+    };
+    feeInfo?: TopupFeeInfo;
+    globalLimitInfo?: GlobalLimitInfo;
+};
+export declare type DescriptionInfo = {
+    text: string;
+    linkUrl?: string;
+    headerIcon?: string;
+    isBold: boolean;
+    color: string;
+    backgroundColor?: string;
+};
+export declare type BannerInfo = {
+    label?: string;
+    title?: string;
+    iconImageUrl?: string;
+    displayResponse?: UIComponentsError;
+};
+export declare type WalletMethod = MethodBase & {
+    paymentMethodType: 'WALLET';
+    walletInfo?: {
+        cashBackBalanceInfo?: Balance;
+        cashBackExpirableBalanceInfo?: Balance;
+        emoneyBalanceInfo?: Balance;
+        prepaidBalanceInfo?: Balance;
+        isPreTransactionAutoChargeEnabled?: boolean;
+        walletSummary?: {
+            totalBalanceInfo: Balance;
+            payoutableBalanceInfo: Balance;
+            transferableBalanceInfo: Balance;
+        };
+        walletDetail?: {
+            emoneyBalanceInfo?: Balance;
+            totalEmoneyBalanceInfo?: Balance;
+            prepaidBalanceInfo?: Balance;
+            cashBackBalanceInfo?: Balance;
+            cashBackExpirableBalanceInfo?: Balance;
+        };
+    };
+};
+export declare enum CreditTypes {
+    VISA = "VISA",
+    MASTER = "MASTER",
+    JCB = "JCB",
+    DINERS = "D",
+    AMEX = "A",
+    OTHER = "O"
+}
+export declare enum PaymentMethodStatus {
+    ACTIVATED = "ACTIVATED",
+    OFF = "OFF",
+    APPLYING = "APPLYING",
+    MAINTENANCE = "MAINTENANCE",
+    BUSY = "BUSY",
+    SUSPENDED = "SUSPENDED"
+}
+export declare enum PayPayCardType {
+    GOLD = "GOLD",
+    REGULAR = "REGULAR"
+}
+export declare type CreditCardInfo = {
+    brand?: CreditTypes;
+    isAuthenticated?: boolean;
+    isExpired?: boolean;
+    isYjCard?: boolean;
+    last4digits?: string;
+    ccType?: string;
+    paymentMethodStatus?: PaymentMethodStatus;
+    preTransactionAutoChargeSupported?: boolean;
+    paymentMethodStatusLabel?: string;
+};
+export declare type CreditMethod = MethodBase & {
+    paymentMethodType: 'CREDIT_CARD';
+    creditCardInfo?: CreditCardInfo;
+};
+export declare enum bankCode {
+    MIZUHO_BANK_CODE = "0001",
+    MUFJ_BANK_CODE = "0005",
+    SMBC_BANK_CODE = "0009",
+    RESONA_BANK_CODE = "0010",
+    S_RESONA_BANK_CODE = "0017",
+    JNB_BANK_CODE = "0033",
+    YUCHO_BANK_CODE = "9900",
+    AEON_BANK_CODE = "0040",
+    JIBUN_BANK_CODE = "0039",
+    SBI_BANK_CODE = "0038"
+}
+export declare const status: Readonly<{
+    ACTIVATED: string;
+    OFF: string;
+    APPLYING: string;
+    MAINTENANCE: string;
+    BUSY: string;
+    SUSPENDED: string;
+}>;
+export declare type BankInfo = {
+    paymentMethodStatusLabel?: string;
+    paymentMethodStatus?: PaymentMethodStatus;
+    bankName?: string;
+    bankLogoUrl?: string;
+    bankCode?: string;
+    bankCardImage?: {
+        cardUrl: string;
+        textColor: string;
+        uiColor: string;
+    };
+    bankBranchName?: string;
+    bankBranchCode?: string;
+    bankAccountType?: string;
+    bankAccountNumberLast2digits?: string;
+    preTransactionAutoChargeSupported?: boolean;
+    showAmount?: boolean;
+};
+export declare type BankMethod = MethodBase & {
+    paymentMethodType: 'BANK' | 'YMONEY_BANK';
+    bankInfo?: BankInfo;
+};
+export declare type SbidBankMethod = MethodBase & {
+    paymentMethodType: 'SBID_CARRIER_BILLING';
+    sbidCarrierBillingInfo?: SbidBankInfo;
+};
+export declare type SbidBankInfo = {
+    paymentMethodStatus?: PaymentMethodStatus;
+    paymentMethodStatusLabel?: string;
+};
+declare type PayLaterCCMethodAdditionalInfo = {
+    showCardDetails?: boolean;
+};
+export declare type PayLaterCCMethod = MethodBase & PayLaterCCMethodAdditionalInfo & {
+    paymentMethodType: 'PAY_LATER_CC';
+    payLaterCcInfo?: PayLaterCCInfo;
+};
+export declare type PayLaterCCInfo = {
+    cardName?: string;
+    last4digits?: string;
+    linkedCardBrand?: Exclude<CreditTypes, CreditTypes.AMEX | CreditTypes.DINERS | CreditTypes.OTHER>;
+    linkedCardType?: PayPayCardType;
+    availableAmount?: number;
+    paymentMethodStatus?: PaymentMethodStatus;
+    paymentMethodStatusLabel?: string;
+};
+declare type PayLaterMethod = MethodBase & {
+    paymentMethodType: 'PAY_LATER';
+};
+export declare type ResponseBase = {
+    status: number;
+    signed: {
+        jws?: string;
+    };
+    uiComponents?: {
+        displayErrorResponse: UIComponentsError;
+    };
+    unsigned: {
+        resultInfo: {
+            code: MiniAppErrorType;
+        };
+    };
+};
+export declare type PaymentMethod = WalletMethod | CreditMethod | BankMethod | SbidBankMethod | PayLaterCCMethod | PayLaterMethod;
+export declare type TopupFeeInfo = {
+    feePercentage?: number;
+    label: string;
+    zeroFeeText?: string;
+};
+declare type PaymentMethodPreference = {
+    preTransactionAutoChargeEnabled: boolean;
+    prioritizedPaymentMethodsEnabled: boolean;
+};
+declare type OverdraftBalanceInfo = {
+    balance: number;
+    currency: string;
+};
+export declare type InfoBanner = {
+    text: string;
+    additionalText: string;
+    link: string;
+    linkText: string;
+    type: string;
+};
+export declare type GetPaymentMethodsResponse = ResponseBase & {
+    unsigned: {
+        data: {
+            payload: {
+                paymentMethodList: PaymentMethod[];
+                appealDescription: AppealDescription | null;
+                paymentMethodPreference: PaymentMethodPreference | null;
+                overdraftBalanceInfo?: OverdraftBalanceInfo;
+                infoBannerList?: InfoBanner[];
+            };
+        };
+    };
+};
+export declare type PaymentResult = {
+    requestedAt: number;
+    storeId: string;
+    amount: Amount;
+    statusLabelString: string;
+    statusLabelColor: string;
+    userAuthorizationId: string;
+    acceptedAt: number;
+    merchantName: string;
+    orderDescription: string;
+    status: 'COMPLETED' | 'AUTHORIZED';
+    paymentId: string;
+    expiresAt: number;
+};
+export declare type MakePaymentResponse = ResponseBase & {
+    signed: {
+        jws: string;
+    };
+    unsigned: {
+        data: PaymentResult;
+    };
+};
+export declare type AppealDescription = {
+    backgroundColor?: string;
+    color: string;
+    headerIcon?: string | null;
+    isBold: boolean;
+    linkUrl?: string;
+    text: string;
+};
+export declare type InsufficientBalanceInfo = {
+    appealDescription: AppealDescription;
+    insufficientAmount: number;
+    paymentMethodList: PaymentMethod[];
+    prepaidOnly: boolean | null;
+    recommendedTopupAmount: number;
+    totalBalanceInfo: {
+        balance: number;
+        currency: 'JPY';
+    };
+    overdraftBalanceInfo?: OverdraftBalanceInfo;
+    infoBannerList?: InfoBanner[];
+};
+export declare type ConsultError = {
+    backendResultCode: string;
+    displayErrorResponse?: UIComponentsError;
+    insufficientAmount: number;
+    insufficientBalanceInfo: InsufficientBalanceInfo;
+    paymentMethodList: PaymentMethod[];
+    recommendedTopupAmount: number;
+};
+export declare type ConsultResponse = ResponseBase & {
+    unsigned: {
+        resultInfo: unknown;
+        data: {
+            error?: ConsultError;
+            header: {
+                resultCode: string;
+            };
+        };
+    };
+};
+export declare type PaymentObject = {
+    methodId: string;
+    methodType: string;
+    amount: number;
+    currency: string;
+};
+interface CashBackDetailHelpLink {
+    label: string;
+    url: string;
+    googleAnalyticsInfo: unknown;
+}
+interface CashBackDetailItem {
+    campaignId: string;
+    bannerId: string | null;
+    campaignName: string;
+    campaignNameColor: string;
+    optionalText: string | null;
+    optionalTextColor: string | null;
+    amountText: string;
+    amountTextColor: string;
+    couponIdText: string | null;
+    couponIdTextColor: string | null;
+    status: string;
+    isMeti: boolean;
+    deeplinkUrl: string | null;
+    googleAnalyticsInfo: unknown;
+}
+interface CouponCashbackDetail {
+    title: string;
+    iconImageUrl: string;
+    cashBackDetailLinkLabel: string;
+    cashBackDetailLinkTarget: string;
+    googleAnalyticsInfo: unknown;
+}
+interface CashBackDetail {
+    cashBackDetailListDescription: string | null;
+    cashBackDetailHelpLink: CashBackDetailHelpLink | null;
+    cashBackDetailList: Array<CashBackDetailItem>;
+    googleAnalyticsInfo: unknown;
+}
+export interface CashBackComponent {
+    cashBackAmount: number;
+    currencyText: string;
+    cashBackAmountText: string | null;
+    cashBackDescription: string;
+    animationUrl: string;
+    optionalText: string | null;
+    cashBackDetailLinkLabel: string;
+    couponCashbackDetail: CouponCashbackDetail;
+    cashBackDetail: CashBackDetail;
+}
+export interface AnimationCard {
+    cardId: string;
+    campaignId: string | null;
+    cardType: string;
+    animationUrl: string;
+    amount: number | null;
+    soundUrl: string | null;
+    duration: number | null;
+    title: string | null;
+    description: string | null;
+    showAgeConfirmFlag?: boolean | null;
+    backgroundColor: string | null;
+}
+export interface StackAnimationCardInfo {
+    totalAnimationCards: number;
+    animationCardList: Array<AnimationCard>;
+}
+export interface CashBackDetailResponsePayload {
+    cashBackComponent: CashBackComponent;
+    stackAnimationCardInfo: StackAnimationCardInfo | null;
+    cashBackDescriptionForShareLink: string;
+}
+export declare type CashBackDetailResponse = ResponseBase & {
+    unsigned: {
+        data: {
+            payload: CashBackDetailResponsePayload;
+        };
+    };
+};
+export declare type SendAgePayload = {
+    month: number;
+    orderId: string;
+    year: number;
+    orderType: 'ACQUIRING';
+    amount: number;
+    date: number;
+    campaignId: string;
+};
+export declare type SendAgeResponse = ResponseBase & {
+    unsigned: {
+        data: {
+            payload: {
+                isEligibleForCashBack: boolean;
+            };
+        };
+    };
+};
+export {};

package/dist/types/topup.d.ts

@@ -1,6 +1,6 @@
 import { NativeParams } from '../jsbridge-core/jsbridge';
 import { MiniAppErrorResultType } from '../types';
-import { PaymentMethodNameType } from '../model/makePayment';
+import { PaymentMethodNameType } from '../types/makePayment';
 export interface TopupParams extends NativeParams<TopupResult, MiniAppErrorResultType & {
     jws?: string;
 }> {

package/dist/types.d.ts

@@ -286,7 +286,8 @@ export declare enum PpLocalStorageKey {
     debugMode = "ppjssdk.debugMode",
     claimCouponImmediately = "ppjssdk.claimCouponImmediately",
     merchant = "ppjssdk.merchant",
-    consumedOTT = "ppjssdk.consumedOTT"
+    consumedOTT = "ppjssdk.consumedOTT",
+    initializedAt = "ppjssdk.initializedAt"
 }
 export declare enum RenderType {
     COVER = "cover",
@@ -488,7 +489,12 @@ export interface PayPayCallStackParamsType {
     complete?: () => void;
     [index: string]: unknown;
 }
-export declare type PayPayCallStackType = Array<[string, PayPayCallStackParamsType]>;
+declare type PromiseResolve<T> = (value?: T | PromiseLike<T>) => void;
+export declare type PayPayCallStackType = Array<[
+    string,
+    PayPayCallStackParamsType,
+    PromiseResolve<unknown>
+]>;
 declare global {
     interface Window {
         _ppcs?: PayPayCallStackType;

package/dist/utils/analytics.d.ts

@@ -15,6 +15,7 @@ interface EventParams {
     hashed_ott?: string;
     has_rt?: string;
     has_cv?: string;
+    incognito?: string;
 }
 interface Options {
     env?: PPEnvType;

package/dist/utils/api.d.ts

@@ -328,5 +328,4 @@ export declare function getUserLocationRequest(params: {
     validTimeMinutes: number;
 }): Promise<import("./fetch").PPFetchResult<UserLocationResponse, Record<string, unknown>>>;
 export declare function getExpectedCashbackInfo(orderInfo: SmartPayParams): Promise<import("./fetch").PPFetchResult<CashbackResponse, Record<string, unknown>>>;
-export declare function isValidUrl(urlChallenge: string): boolean;
 export {};

package/dist/utils/helper.d.ts

@@ -1,11 +1,10 @@
 import { MiniAppErrorType } from '../model/miniAppError';
-import { BankInfo, CreditCardInfo, SbidBankInfo, PayLaterCCInfo, PaymentMethod, InfoBanner } from '../model/makePayment';
 import { UIComponentsErrorButton } from '../model/uiComponents';
 import { ErrorSheetButton, PaymentLabelType, SmartPayParams } from '../types';
 import { FontSize } from '../types/getPlatformInformation';
 import { NativeParams } from '../jsbridge-core/jsbridge';
 import { App } from 'vue';
-import { OrderType, MakePaymentParams } from '../types/makePayment';
+import { OrderType, MakePaymentParams, BankInfo, CreditCardInfo, InfoBanner, PayLaterCCInfo, PaymentMethod, SbidBankInfo } from '../types/makePayment';
 export declare function isDef<T>(val: T): val is NonNullable<T>;
 export declare function isFunction(val: unknown): val is () => void;
 export declare function isNumeric(val: string | number): val is string;
@@ -91,4 +90,5 @@ export declare function checkIfSdkUpgradeNeededForRemittance(orderType?: OrderTy
 export declare function isMobileSize(width: number): boolean;
 export declare function isDesktopSize(width: number): boolean;
 export declare function getOverDraftInfoBanner(banners?: Array<InfoBanner>): InfoBanner | undefined;
+export declare function isValidUrl(urlChallenge: string): boolean;
 export {};

package/dist/utils/minimumAppVersion.d.ts

@@ -1,9 +1,4 @@
 export declare const MinVersion: {
-    PRE_TRANSACTION_AUTO_CHARGE: string;
-    FALLBACK_PAYMENT_METHOD: string;
-    OS_HOME_SCREEN_ICON: string;
-    START_MULTIFACTOR_AUTH_ANDROID_FIX: string;
-    KYC_PASSPORT: string;
     PERFORMANCE_MEASUREMENT: string;
     START_MULTIFACTOR_AUTH_PIN_FALLBACK: string;
 };

package/dist/utils/minimumJSSDKVersion.d.ts

@@ -2,4 +2,5 @@ export declare const MinJSSDKVersion: {
     ORDER_TYPE_REMITTANCE: string;
     CLIENT_STORAGE_FUNCTIONS: string;
     CLIENT_QUERY_PARAM_REMOVAL: string;
+    HANDLE_MARK_AS_READY_CORE: string;
 };

package/dist/utils/windowBridge.d.ts

@@ -1,6 +1,26 @@
+declare enum MessageType {
+    request = "request",
+    response = "response"
+}
 declare type GetTargetWindowFunctionType = () => Promise<Window | undefined | null> | Window | undefined | null;
-declare type FunctionType = (...args: Array<any>) => unknown;
-declare type FunctionsCollection = Record<string, FunctionType>;
+interface MessageBaseType {
+    forWindowBridge: true;
+    key: string;
+    functionName: string;
+}
+interface PartialMessageRequestType {
+    type: MessageType.request;
+    params: Array<unknown>;
+}
+export declare type MessageRequestType = MessageBaseType & PartialMessageRequestType;
+export declare type Params = Array<any>;
+export interface FunctionType {
+    (...args: Params): unknown;
+    middlewares?: Array<Middleware>;
+}
+export declare type FunctionsCollection = Record<string, FunctionType>;
+export declare type NextCallback = (args: Params) => Promise<unknown>;
+export declare type Middleware = (message: MessageEvent<MessageRequestType>, params: Params, next: NextCallback) => unknown;
 export declare type WindowBridgeFunctions<T extends FunctionsCollection> = {
     [K in keyof T]: Parameters<T[K]>[0] extends undefined ? () => Promise<Awaited<ReturnType<T[K]>>> : (params: Parameters<T[K]>[0]) => Promise<Awaited<ReturnType<T[K]>>>;
 };
@@ -9,6 +29,7 @@ export declare class WindowBridge {
     private deferredCallbacks;
     private functions;
     private allowedOrigins?;
+    private middlewares;
     private constructor();
     private subscribeToMessageEvent;
     private unsubscribeToMessageEvent;
@@ -18,7 +39,7 @@ export declare class WindowBridge {
     private sendErrorResponse;
     private sendSuccessResponse;
     private sendResponse;
-    static init(functions: FunctionsCollection, allowedOrigins?: Array<string>): WindowBridge;
+    static init(functions: FunctionsCollection, allowedOrigins?: Array<string>, middlewares?: Array<Middleware>): WindowBridge;
     static destroy(): void;
     static getBridge(): WindowBridge;
     static getTargetWindowFunctionProxy<T extends FunctionsCollection = FunctionsCollection>(getTargetWindow: GetTargetWindowFunctionType, targetWindowOrigin: string): T;