@portone/browser-sdk 0.0.2 → 0.0.4

package/dist/v2/loadPaymentUI.d.ts

@@ -0,0 +1,36 @@
+import { Entity, PaymentError, PaymentResponse } from './index.js';
+import { PaymentUIType } from './entity/index.js';
+import { Prettify } from '../utils.js';
+export declare function loadPaymentUI(request: LoadPaymentUIRequest, callbacks: {
+    onPaymentSuccess: (response: PaymentResponse) => void;
+    onPaymentFail: (error: PaymentError) => void;
+}): Promise<void>;
+export type LoadPaymentUIRequest = Prettify<{
+    uiType: PaymentUIType;
+    storeId: string;
+    paymentId: string;
+    orderName: string;
+    totalAmount: number;
+    channelKey: string;
+    pgProvider?: Entity.PgProvider;
+    isTestChannel?: boolean;
+    taxFreeAmount?: number;
+    vatAmount?: number;
+    customer?: Entity.Customer;
+    redirectUrl?: string;
+    noticeUrls?: string[];
+    confirmUrl?: string;
+    appScheme?: string;
+    isEscrow?: boolean;
+    products?: Entity.Product[];
+    isCulturalExpense?: boolean;
+    currency: Entity.Currency;
+    locale?: Entity.Locale;
+    customData?: Record<string, any>;
+    offerPeriod?: Entity.OfferPeriod;
+    productType?: Entity.ProductType;
+    storeDetails?: Entity.StoreDetails;
+    bypass?: Entity.LoadPaymentUIBypass;
+    country?: Entity.Country;
+    shippingAddress?: Entity.Address;
+}>;

package/dist/v2/loader.d.ts

@@ -0,0 +1,31 @@
+import type { IdentityVerificationRequest, IdentityVerificationResponse } from './requestIdentityVerification.js';
+import type { IssueBillingKeyAndPayRequest, IssueBillingKeyAndPayResponse } from './requestIssueBillingKeyAndPay.js';
+import type { IssueBillingKeyRequest, IssueBillingKeyResponse } from './requestIssueBillingKey.js';
+import type { PaymentRequest, PaymentResponse } from './requestPayment.js';
+import { LoadPaymentUIRequest } from './loadPaymentUI.js';
+import { LoadIssueBillingKeyUIRequest } from './loadIssueBillingKeyUI.js';
+import { IssueBillingKeyError, PaymentError } from './exception/index.js';
+declare global {
+    interface Window {
+        PortOne: PortOne | undefined;
+    }
+}
+interface PortOne {
+    requestPayment(request: PaymentRequest): Promise<PaymentResponse>;
+    requestIssueBillingKeyAndPay(request: IssueBillingKeyAndPayRequest): Promise<IssueBillingKeyAndPayResponse>;
+    requestIssueBillingKey(request: IssueBillingKeyRequest): Promise<IssueBillingKeyResponse>;
+    requestIdentityVerification(request: IdentityVerificationRequest): Promise<IdentityVerificationResponse>;
+    loadPaymentUI(request: LoadPaymentUIRequest, callbacks: {
+        onPaymentSuccess: (response: PaymentResponse) => void;
+        onPaymentFail: (error: PaymentError) => void;
+    }): Promise<void>;
+    loadIssueBillingKeyUI(request: LoadIssueBillingKeyUIRequest, callbacks: {
+        onIssueBillingKeySuccess: (response: IssueBillingKeyResponse) => void;
+        onIssueBillingKeyFail: (error: IssueBillingKeyError) => void;
+    }): Promise<void>;
+    updateLoadPaymentUIRequest(request: LoadPaymentUIRequest): Promise<void>;
+    updateLoadIssueBillingKeyUIRequest(request: LoadIssueBillingKeyUIRequest): Promise<void>;
+}
+export declare function loadScript(): Promise<PortOne>;
+export declare function setPortOneJsSdkUrl(url: string): string;
+export {};

package/dist/v2/requestIdentityVerification.d.ts

@@ -0,0 +1,25 @@
+import { Entity } from './index.js';
+export declare function requestIdentityVerification(request: IdentityVerificationRequest): Promise<IdentityVerificationResponse | undefined>;
+export type IdentityVerificationRequest = {
+    storeId: string;
+    identityVerificationId: string;
+    channelKey?: string;
+    pgProvider?: Entity.PgProvider;
+    isTestChannel?: boolean;
+    customer?: Entity.Customer;
+    windowType?: Entity.WindowTypes;
+    redirectUrl?: string;
+    customData?: string;
+    bypass?: Entity.IdentityVerificationBypass;
+};
+/**
+ * iframe/popup 방식으로 PG사 창이 렌더링 된 경우
+ * 프로세스 종료 후, 콜백 함수로 전달 될 본인인증 정보 데이터
+ */
+export type IdentityVerificationResponse = {
+    transactionType: typeof Entity.TransactionType.IDENTITY_VERIFICATION;
+    identityVerificationId?: string;
+    identityVerificationTxId: string;
+    code?: string;
+    message?: string;
+};

package/dist/{types/v2/request/IssueBillingKey.d.ts → v2/requestIssueBillingKey.d.ts}

@@ -1,11 +1,7 @@
-import { CapsToCamel } from '../../utils.js';
-import { Entity } from '../index.js';
-type BillingKeyMethodOptions<Method extends Entity.BillingKeyMethod, T> = {
-    billingKeyMethod: Method;
-} & {
-    [K in Method as CapsToCamel<K>]?: T;
-};
-type IssueBillingKeyRequest = {
+import { CapsToCamel } from '../utils.js';
+import { Entity } from './index.js';
+export declare function requestIssueBillingKey(request: IssueBillingKeyRequest): Promise<IssueBillingKeyResponse | undefined>;
+export type IssueBillingKeyRequest = {
     displayAmount?: number;
     currency?: Entity.Currency;
     storeId: string;
@@ -23,8 +19,24 @@ type IssueBillingKeyRequest = {
     customData?: Record<string, any>;
     appScheme?: string;
     noticeUrls?: string[];
+    productType?: Entity.ProductType;
     bypass?: Entity.IssueBillingKeyBypass;
 } & (BillingKeyMethodOptions<'CARD', Card> | BillingKeyMethodOptions<'MOBILE', Mobile> | BillingKeyMethodOptions<'EASY_PAY', EasyPay> | BillingKeyMethodOptions<'PAYPAL', Paypal>);
+/**
+ * iframe/popup 방식으로 PG사 창이 렌더링 된 경우
+ * 프로세스 종료 후, 콜백 함수로 전달 될 빌링키 발급 정보 데이터
+ */
+export type IssueBillingKeyResponse = {
+    transactionType: typeof Entity.TransactionType.ISSUE_BILLING_KEY;
+    billingKey: string;
+    code?: string;
+    message?: string;
+};
+type BillingKeyMethodOptions<Method extends Entity.BillingKeyMethod, T> = {
+    billingKeyMethod: Method;
+} & {
+    [K in Method as CapsToCamel<K>]?: T;
+};
 type Card = {
     cardCompany?: Entity.CardCompany;
 };
@@ -33,6 +45,7 @@ type EasyPay = {
 };
 type Mobile = {
     carrier?: Entity.Carrier;
+    availableCarriers?: Entity.Carrier[];
 };
 type Paypal = Record<string, never>;
-export default IssueBillingKeyRequest;
+export {};

package/dist/v2/requestIssueBillingKeyAndPay.d.ts

@@ -0,0 +1,51 @@
+import { CapsToCamel } from '../utils.js';
+import { Entity } from './index.js';
+export declare function requestIssueBillingKeyAndPay(request: IssueBillingKeyAndPayRequest): Promise<IssueBillingKeyAndPayResponse>;
+export type IssueBillingKeyAndPayRequest = {
+    storeId: string;
+    paymentId: string;
+    orderName: string;
+    totalAmount: number;
+    channelKey?: string;
+    pgProvider?: Entity.PgProvider;
+    isTestChannel?: boolean;
+    taxFreeAmount?: number;
+    vatAmount?: number;
+    customer?: Entity.Customer;
+    billingKeyAndPayMethod: Entity.BillingKeyAndPayMethod;
+    windowType?: Entity.WindowTypes;
+    redirectUrl?: string;
+    noticeUrls?: string[];
+    confirmUrl?: string;
+    locale?: Entity.Locale;
+    isCulturalExpense?: boolean;
+    customData?: Record<string, any>;
+    offerPeriod?: Entity.OfferPeriod;
+    appScheme?: string;
+    productType?: Entity.ProductType;
+    storeDetails?: Entity.StoreDetails;
+    country?: Entity.Country;
+    bypass?: Entity.IssueBillingKeyAndPayBypass;
+} & BillingKeyAndPayMethodOptions<'MOBILE', Mobile>;
+/**
+ * iframe/popup 방식으로 PG사 창이 렌더링 된 경우
+ * 프로세스 종료 후, 콜백 함수로 전달 될 빌링키 발급 및 결제 정보 데이터
+ */
+export type IssueBillingKeyAndPayResponse = {
+    transactionType: typeof Entity.TransactionType.ISSUE_BILLING_KEY_AND_PAY;
+    txId: string;
+    paymentId: string;
+    billingKey: string;
+    code?: string;
+    message?: string;
+};
+type BillingKeyAndPayMethodOptions<Method extends Entity.BillingKeyAndPayMethod, T> = {
+    billingKeyAndPayMethod: Method;
+} & {
+    [K in Method as CapsToCamel<K>]?: T;
+};
+type Mobile = {
+    carrier?: Entity.Carrier;
+    availableCarriers?: Entity.Carrier[];
+};
+export {};

package/dist/{types/v2/request/Payment.d.ts → v2/requestPayment.d.ts}

@@ -1,11 +1,7 @@
-import { CapsToCamel, OneOfType } from '../../utils.js';
-import { Entity } from '../index.js';
-type PayMethodOptions<Method extends Entity.PayMethod, T> = {
-    payMethod: Method;
-} & {
-    [K in Method as CapsToCamel<K>]?: T;
-};
-type PaymentRequest = {
+import { CapsToCamel, OneOfType } from '../utils.js';
+import { Entity } from './index.js';
+export declare function requestPayment(request: PaymentRequest): Promise<PaymentResponse | undefined>;
+export type PaymentRequest = {
     storeId: string;
     paymentId: string;
     orderName: string;
@@ -13,6 +9,7 @@ type PaymentRequest = {
     channelKey?: string;
     pgProvider?: Entity.PgProvider;
     isTestChannel?: boolean;
+    channelGroupId?: string;
     taxFreeAmount?: number;
     vatAmount?: number;
     customer?: Entity.Customer;
@@ -33,7 +30,23 @@ type PaymentRequest = {
     bypass?: Entity.PaymentBypass;
     country?: Entity.Country;
     shippingAddress?: Entity.Address;
-} & (PayMethodOptions<'CARD', Card> | PayMethodOptions<'VIRTUAL_ACCOUNT', VirtualAccount> | PayMethodOptions<'TRANSFER', Transfer> | PayMethodOptions<'MOBILE', Mobile> | PayMethodOptions<'GIFT_CERTIFICATE', GiftCertificate> | PayMethodOptions<'EASY_PAY', EasyPay> | PayMethodOptions<'PAYPAL', Paypal>);
+} & (PayMethodOptions<'CARD', Card> | PayMethodOptions<'VIRTUAL_ACCOUNT', VirtualAccount> | PayMethodOptions<'TRANSFER', Transfer> | PayMethodOptions<'MOBILE', Mobile> | PayMethodOptions<'GIFT_CERTIFICATE', GiftCertificate> | PayMethodOptions<'EASY_PAY', EasyPay> | PayMethodOptions<'PAYPAL', Paypal> | PayMethodOptions<'ALIPAY', Alipay>);
+/**
+ * iframe/popup 방식으로 PG사 창이 렌더링 된 경우
+ * 프로세스 종료 후, 콜백 함수로 전달 될 결제 정보 데이터
+ */
+export type PaymentResponse = {
+    transactionType: typeof Entity.TransactionType.PAYMENT;
+    txId: string;
+    paymentId?: string;
+    code?: string;
+    message?: string;
+};
+type PayMethodOptions<Method extends Entity.PayMethod, T> = {
+    payMethod: Method;
+} & {
+    [K in Method as CapsToCamel<K>]?: T;
+};
 type Card = {
     cardCompany?: Entity.CardCompany;
     installment?: Entity.Installment;
@@ -41,6 +54,7 @@ type Card = {
     useAppCardOnly?: boolean;
     availableCards?: Entity.CardCompany[];
     useFreeInterestFromMall?: boolean;
+    useInstallment?: boolean;
 };
 type VirtualAccount = {
     cashReceiptType?: Entity.CashReceiptType;
@@ -62,6 +76,7 @@ type Transfer = {
 };
 type Mobile = {
     carrier?: Entity.Carrier;
+    availableCarriers?: Entity.Carrier[];
 };
 type GiftCertificate = {
     giftCertificateType?: Entity.GiftCertificateType;
@@ -74,6 +89,9 @@ type EasyPay = {
     cashReceiptType?: Entity.CashReceiptType;
     customerIdentifier?: string;
     useCardPoint?: boolean;
+    availablePayMethods?: Entity.EasyPayPaymentMethod[];
+    useInstallment?: boolean;
 };
 type Paypal = Record<string, never>;
-export default PaymentRequest;
+type Alipay = Record<string, never>;
+export {};

package/dist/v2/updateLoadIssueBillingKeyUIRequest.d.ts

@@ -0,0 +1,2 @@
+import { LoadIssueBillingKeyUIRequest } from './index.js';
+export declare function updateLoadIssueBillingKeyUIRequest(request: LoadIssueBillingKeyUIRequest): Promise<void>;

package/dist/v2/updateLoadPaymentUIRequest.d.ts

@@ -0,0 +1,2 @@
+import { LoadPaymentUIRequest } from './index.js';
+export declare function updateLoadPaymentUIRequest(request: LoadPaymentUIRequest): Promise<void>;

package/dist/{chunk-f7332846.js → v2.cjs}

@@ -1,4 +1,88 @@
-import { T as TransactionType } from './chunk-ced8f127.js';
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _a;
+let promise = null;
+const portone = {
+    jsSdkUrl: (_a = '/v2/browser-sdk.js') !== null && _a !== void 0 ? _a : 'https://cdn.portone.io/v2/browser-sdk.js',
+};
+function findScript() {
+    return document.querySelector(`script[src="${portone.jsSdkUrl}"]`);
+}
+function injectScript() {
+    const script = document.createElement('script');
+    script.src = portone.jsSdkUrl;
+    const headOrBody = document.head || document.body;
+    if (!headOrBody)
+        throw new Error('[PortOne] Expected document.body not to be null');
+    return headOrBody.appendChild(script);
+}
+function loadScript() {
+    if (promise != null) {
+        // SDK is already loaded
+        return promise;
+    }
+    return (promise = new Promise((resolve, reject) => {
+        if (window.PortOne) {
+            // window.PortOne is already injected by CDN
+            return resolve(window.PortOne);
+        }
+        try {
+            // window.PortOne will be injected by @portone/browser-sdk
+            const script = findScript() || injectScript();
+            script.addEventListener('load', () => {
+                // script has just loaded
+                if (window.PortOne) {
+                    // window.PortOne is successfully injected @portone/browser-sdk
+                    return resolve(window.PortOne);
+                }
+                reject(new Error('[PortOne] Failed to load window.PortOne'));
+            });
+            script.addEventListener('error', () => {
+                reject(new Error('[PortOne] Failed to load window.PortOne'));
+            });
+        }
+        catch (error) {
+            return reject(error);
+        }
+    }));
+}
+function setPortOneJsSdkUrl(url) {
+    return (portone.jsSdkUrl = url);
+}
+
+function requestIdentityVerification(request) {
+    return loadScript().then((sdk) => sdk.requestIdentityVerification(request));
+}
+
+function requestIssueBillingKeyAndPay(request) {
+    return loadScript().then((sdk) => sdk.requestIssueBillingKeyAndPay(request));
+}
+
+function requestIssueBillingKey(request) {
+    return loadScript().then((sdk) => sdk.requestIssueBillingKey(request));
+}
+
+function requestPayment(request) {
+    return loadScript().then((sdk) => sdk.requestPayment(request));
+}
+
+function loadPaymentUI(request, callbacks) {
+    return loadScript().then((sdk) => sdk.loadPaymentUI(request, callbacks));
+}
+
+function loadIssueBillingKeyUI(request, callbacks) {
+    return loadScript().then((sdk) => sdk.loadIssueBillingKeyUI(request, callbacks));
+}
+
+function updateLoadPaymentUIRequest(request) {
+    return loadScript().then((sdk) => sdk.updateLoadPaymentUIRequest(request));
+}
+
+function updateLoadIssueBillingKeyUIRequest(request) {
+    return loadScript().then((sdk) => sdk.updateLoadIssueBillingKeyUIRequest(request));
+}
 
 // 계좌이체, 가상계좌 발급시 사용되는 은행 코드
 const Bank = {
@@ -80,6 +164,11 @@ const Bank = {
     CAPE_INVESTMENT_CERTIFICATE: 'BANK_CAPE_INVESTMENT_CERTIFICATE', // 케이프투자증권
 };
 
+// 빌링키 발급 및 결제 수단
+const BillingKeyAndPayMethod = {
+    MOBILE: 'MOBILE', // 휴대폰
+};
+
 // 빌링키 발급 수단
 const BillingKeyMethod = {
     CARD: 'CARD',
@@ -493,7 +582,6 @@ const Currency = {
     MWK: 'CURRENCY_MWK',
     MXN: 'CURRENCY_MXN',
     MXV: 'CURRENCY_MXV',
-    MYR: 'CURRENCY_MYR',
     MZN: 'CURRENCY_MZN',
     NAD: 'CURRENCY_NAD',
     NGN: 'CURRENCY_NGN',
@@ -586,10 +674,7 @@ const EasyPayProvider = {
     APPLEPAY: 'EASY_PAY_PROVIDER_APPLEPAY',
     PINPAY: 'EASY_PAY_PROVIDER_PINPAY',
     SKPAY: 'EASY_PAY_PROVIDER_SKPAY',
-    NAVERPAY_CARD: 'EASY_PAY_PROVIDER_NAVERPAY_CARD',
-    NAVERPAY_POINT: 'EASY_PAY_PROVIDER_NAVERPAY_POINT',
-    SSGPAY_POINT: 'EASY_PAY_PROVIDER_SSGPAY_POINT',
-    SSGPAY_BANK: 'EASY_PAY_PROVIDER_SSGPAY_BANK',
+    TOSS_BRANDPAY: 'EASY_PAY_PROVIDER_TOSS_BRANDPAY',
 };
 
 // 구매자 성별
@@ -605,6 +690,7 @@ const GiftCertificateType = {
     SMART_MUNSANG: 'GIFT_CERTIFICATE_TYPE_SMART_MUNSANG',
     CULTURELAND: 'GIFT_CERTIFICATE_TYPE_CULTURELAND',
     HAPPYMONEY: 'GIFT_CERTIFICATE_TYPE_HAPPYMONEY',
+    CULTURE_GIFT: 'GIFT_CERTIFICATE_TYPE_CULTURE_GIFT',
 };
 
 // PG사 창 언어 설정
@@ -657,6 +743,22 @@ const PgProvider = {
     SMARTRO_V2: 'PG_PROVIDER_SMARTRO_V2',
     NICE_V2: 'PG_PROVIDER_NICE_V2',
     TOSS_BRANDPAY: 'PG_PROVIDER_TOSS_BRANDPAY',
+    WELCOME: 'PG_PROVIDER_WELCOME',
+    TOSSPAY_V2: 'PG_PROVIDER_TOSSPAY_V2',
+};
+
+/**
+ * 트랜잭션 유형
+ * - PAYMENT: 결제
+ * - ISSUE_BILLING_KEY: 빌링키 발급
+ * - IDENTITY_VERIFICATION: 본인 인증
+ * - ISSUE_BILLING_KEY_AND_PAY: 빌링키 발급과 동시에 결제
+ */
+const TransactionType = {
+    PAYMENT: 'PAYMENT',
+    ISSUE_BILLING_KEY: 'ISSUE_BILLING_KEY',
+    IDENTITY_VERIFICATION: 'IDENTITY_VERIFICATION',
+    ISSUE_BILLING_KEY_AND_PAY: 'ISSUE_BILLING_KEY_AND_PAY',
 };
 
 /**
@@ -670,9 +772,18 @@ const WindowType = {
     UI: 'UI',
 };
 
+const PaymentUIType = {
+    PAYPAL_SPB: 'PAYPAL_SPB',
+};
+
+const IssueBillingKeyUIType = {
+    PAYPAL_RT: 'PAYPAL_RT',
+};
+
 var index = /*#__PURE__*/Object.freeze({
     __proto__: null,
     Bank: Bank,
+    BillingKeyAndPayMethod: BillingKeyAndPayMethod,
     BillingKeyMethod: BillingKeyMethod,
     CardCompany: CardCompany,
     Carrier: Carrier,
@@ -681,10 +792,156 @@ var index = /*#__PURE__*/Object.freeze({
     EasyPayProvider: EasyPayProvider,
     Gender: Gender,
     GiftCertificateType: GiftCertificateType,
+    IssueBillingKeyUIType: IssueBillingKeyUIType,
     Locale: Locale,
+    PaymentUIType: PaymentUIType,
     PgProvider: PgProvider,
     TransactionType: TransactionType,
     WindowType: WindowType
 });
 
-export { Bank as B, CardCompany as C, EasyPayProvider as E, Gender as G, Locale as L, PgProvider as P, WindowType as W, BillingKeyMethod as a, Carrier as b, Country as c, Currency as d, GiftCertificateType as e, index as i };
+function isIdentityVerificationError(error) {
+    return (isPortOneError(error) &&
+        error.__portOneErrorType === 'IdentityVerificationError');
+}
+class IdentityVerificationError extends Error {
+    constructor({ code, message, identityVerificationId, identityVerificationTxId, }) {
+        super(message);
+        this.__portOneErrorType = 'IdentityVerificationError';
+        this.transactionType = TransactionType.IDENTITY_VERIFICATION;
+        this.code = code;
+        this.message = message;
+        this.identityVerificationId = identityVerificationId;
+        this.identityVerificationTxId = identityVerificationTxId;
+    }
+}
+
+function isIssueBillingKeyAndPayError(error) {
+    return (isPortOneError(error) &&
+        error.__portOneErrorType === 'IssueBillingKeyAndPayError');
+}
+class IssueBillingKeyAndPayError extends Error {
+    constructor({ txId, paymentId, billingKey, code, message, }) {
+        super(message);
+        this.__portOneErrorType = 'IssueBillingKeyAndPayError';
+        this.transactionType = TransactionType.ISSUE_BILLING_KEY_AND_PAY;
+        this.txId = txId;
+        this.paymentId = paymentId;
+        this.billingKey = billingKey;
+        this.code = code;
+        this.message = message;
+    }
+}
+
+function isIssueBillingKeyError(error) {
+    return (isPortOneError(error) && error.__portOneErrorType === 'IssueBillingKeyError');
+}
+class IssueBillingKeyError extends Error {
+    constructor({ code, message, billingKey, }) {
+        super(message);
+        this.__portOneErrorType = 'IssueBillingKeyError';
+        this.transactionType = TransactionType.ISSUE_BILLING_KEY;
+        this.code = code;
+        this.message = message;
+        this.billingKey = billingKey;
+    }
+}
+
+function isModuleError(error) {
+    return isPortOneError(error) && error.__portOneErrorType === 'ModuleError';
+}
+class ModuleError extends Error {
+    constructor({ code, message }) {
+        super(message);
+        this.__portOneErrorType = 'ModuleError';
+        this.code = code;
+        this.message = message;
+    }
+}
+
+function isPaymentError(error) {
+    return isPortOneError(error) && error.__portOneErrorType === 'PaymentError';
+}
+class PaymentError extends Error {
+    constructor({ code, message, txId, paymentId, }) {
+        super(message);
+        this.__portOneErrorType = 'PaymentError';
+        this.transactionType = TransactionType.PAYMENT;
+        this.code = code;
+        this.message = message;
+        this.txId = txId;
+        this.paymentId = paymentId;
+    }
+}
+
+function isLoadIssueBillingKeyUIError(error) {
+    return (isPortOneError(error) &&
+        error.__portOneErrorType === 'LoadIssueBillingKeyUIError');
+}
+class LoadIssueBillingKeyUIError extends Error {
+    constructor({ code, message, }) {
+        super(message);
+        this.__portOneErrorType = 'LoadIssueBillingKeyUIError';
+        this.transactionType = TransactionType.ISSUE_BILLING_KEY;
+        this.code = code;
+        this.message = message;
+    }
+}
+
+function isLoadPaymentUIError(error) {
+    return (isPortOneError(error) && error.__portOneErrorType === 'LoadPaymentUIError');
+}
+class LoadPaymentUIError extends Error {
+    constructor({ code, message, }) {
+        super(message);
+        this.__portOneErrorType = 'LoadPaymentUIError';
+        this.transactionType = TransactionType.PAYMENT;
+        this.code = code;
+        this.message = message;
+    }
+}
+
+function isPortOneError(error) {
+    return (error != null &&
+        typeof error === 'object' &&
+        '__portOneErrorType' in error &&
+        typeof error.__portOneErrorType === 'string');
+}
+
+const PortOne = {
+    requestIdentityVerification,
+    requestIssueBillingKeyAndPay,
+    requestIssueBillingKey,
+    requestPayment,
+    loadPaymentUI,
+    loadIssueBillingKeyUI,
+    updateLoadPaymentUIRequest,
+    updateLoadIssueBillingKeyUIRequest,
+};
+
+exports.Entity = index;
+exports.IdentityVerificationError = IdentityVerificationError;
+exports.IssueBillingKeyAndPayError = IssueBillingKeyAndPayError;
+exports.IssueBillingKeyError = IssueBillingKeyError;
+exports.LoadIssueBillingKeyUIError = LoadIssueBillingKeyUIError;
+exports.LoadPaymentUIError = LoadPaymentUIError;
+exports.ModuleError = ModuleError;
+exports.PaymentError = PaymentError;
+exports.__INTERNAL__setPortOneSdkUrl = setPortOneJsSdkUrl;
+exports.default = PortOne;
+exports.isIdentityVerificationError = isIdentityVerificationError;
+exports.isIssueBillingKeyAndPayError = isIssueBillingKeyAndPayError;
+exports.isIssueBillingKeyError = isIssueBillingKeyError;
+exports.isLoadIssueBillingKeyUIError = isLoadIssueBillingKeyUIError;
+exports.isLoadPaymentUIError = isLoadPaymentUIError;
+exports.isModuleError = isModuleError;
+exports.isPaymentError = isPaymentError;
+exports.isPortOneError = isPortOneError;
+exports.loadIssueBillingKeyUI = loadIssueBillingKeyUI;
+exports.loadPaymentUI = loadPaymentUI;
+exports.requestIdentityVerification = requestIdentityVerification;
+exports.requestIssueBillingKey = requestIssueBillingKey;
+exports.requestIssueBillingKeyAndPay = requestIssueBillingKeyAndPay;
+exports.requestPayment = requestPayment;
+exports.updateLoadIssueBillingKeyUIRequest = updateLoadIssueBillingKeyUIRequest;
+exports.updateLoadPaymentUIRequest = updateLoadPaymentUIRequest;