@tonder.io/ionic-full-sdk 0.0.61 → 0.0.62-beta.DEV-2106.99e3729

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tonder.io/ionic-full-sdk",
-  "version": "0.0.61",
+  "version": "0.0.62-beta.DEV-2106.99e3729",
   "description": "Tonder ionic full SDK",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -10,13 +10,14 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@tonder.io/ionic-lite-sdk": "^0.0.67",
+    "@tonder.io/ionic-lite-sdk": "0.0.68-beta.DEV-2106.48d18dd",
     "accordion-js": "^3.4.0",
     "crypto-js": "^4.1.1",
     "lodash.get": "^4.4.2",
     "skyflow-js": "2.5.0"
   },
   "devDependencies": {
+    "@rollup/plugin-replace": "^6.0.3",
     "@rollup/plugin-terser": "^0.4.4",
     "@rollup/plugin-typescript": "^11.1.6",
     "@types/crypto-js": "^4.2.2",

package/rollup.config.js

@@ -1,15 +1,25 @@
 const typescript = require('@rollup/plugin-typescript');
 const terser = require('@rollup/plugin-terser');
 const postcss = require('rollup-plugin-postcss');
+const replace = require('@rollup/plugin-replace');
+const packageJson = require('./package.json');
 
 module.exports = {
   input: './src/index.ts',
-  output: {
+  output:
+  {
     dir: 'dist',
     format: 'es',
     plugins: [terser()]
   },
   plugins: [
+    replace({
+      preventAssignment: true,
+      values: {
+        '__SDK_NAME__': JSON.stringify(packageJson.name),
+        '__SDK_VERSION__': JSON.stringify(packageJson.version)
+      }
+    }),
     typescript({
       exclude: ["tests/**", "jest.config.ts"]
     }),

package/src/classes/inlineCheckout.ts

@@ -5,15 +5,18 @@ import {
   mapCards,
 } from '../helpers/utils';
 import {initSkyflow, initUpdateSkyflow} from '../helpers/skyflow'
-import { ErrorResponse } from '@tonder.io/ionic-lite-sdk/dist/classes/errorResponse';
 import { CustomerRegisterResponse } from '@tonder.io/ionic-lite-sdk/dist/types/responses';
-import {BaseInlineCheckout} from "@tonder.io/ionic-lite-sdk";
+import { BaseInlineCheckout } from "@tonder.io/ionic-lite-sdk";
 import {IProcessPaymentRequest} from "@tonder.io/ionic-lite-sdk/dist/types/checkout";
 import {ISaveCardInternalResponse, ISaveCardSkyflowRequest} from "@tonder.io/ionic-lite-sdk/dist/types/card";
 import {ITonderPaymentMethod} from "@tonder.io/ionic-lite-sdk/dist/types/paymentMethod";
 import type { SkyflowCollectFields, SkyflowCollectResponse } from "@tonder.io/ionic-lite-sdk/dist/types/cardOnFile";
 import {IEvents, IInlineCheckoutOptions, IInlineCustomizationOptions, InCollectorContainer} from "../types/commons";
 import {IInlineCheckout} from "../types/inlineCheckout";
+import { buildPublicAppError } from "../shared/utils/appError";
+import { ErrorKeyEnum } from "../shared/enums/ErrorKeyEnum";
+import { MESSAGES_EN, MESSAGES_ES } from "../shared/constants/messages";
+import { SDK_INFO } from "../helpers/sdkInfo";
 import get from "lodash.get";
 // @ts-ignore
 import Accordion from "accordion-js";
@@ -63,15 +66,18 @@ export class InlineCheckout extends BaseInlineCheckout<IInlineCustomizationOptio
     customization,
     events
   }: IInlineCheckoutOptions) {
-    super({
+    const baseOptions = {
       apiKey: apiKey,
       returnUrl: returnUrl,
       mode: mode,
       callBack: callBack,
       customization: customization,
       tdsIframeId: collectorIds && 'tdsIframe' in collectorIds ? collectorIds?.tdsIframe : "tdsIframe",
-      tonderPayButtonId: collectorIds ? collectorIds?.tonderPayButton : "tonderPayButton"
-    });
+      tonderPayButtonId: collectorIds ? collectorIds?.tonderPayButton : "tonderPayButton",
+      sdkInfo: SDK_INFO,
+    };
+    super(baseOptions);
+
     this.renderPaymentButton = renderPaymentButton || false;
     this.renderSaveCardButton = renderSaveCardButton;
     this.customStyles = styles
@@ -334,6 +340,14 @@ export class InlineCheckout extends BaseInlineCheckout<IInlineCustomizationOptio
       this.#mountPayButton(container_radio_id)
     }catch (e){
       console.error("Ha ocurrido un error", e);
+      this.reportSdkError(e, {
+        feature: "handle-open-card-accordion",
+        process_id: container_radio_id,
+        metadata: {
+          step: "#handleOpenCardAccordion",
+          type,
+        },
+      });
     }
     await this.#handleRadioButtonClick(radio_card, null, type);
   }
@@ -386,8 +400,8 @@ export class InlineCheckout extends BaseInlineCheckout<IInlineCustomizationOptio
   async #handlePaymentClick() {
     try {
       await this.payment({} as IProcessPaymentRequest);
-    } catch (error) {
-      console.error("Payment error:", error);
+    } catch (error: any) {
+      console.error("Payment error:", error?.message, error?.code, error?.details);
     }
   }
 
@@ -677,7 +691,7 @@ export class InlineCheckout extends BaseInlineCheckout<IInlineCustomizationOptio
       try{
         if(this.merchantData!) {
           const cardTokensSkyflowTonder: any = await this.#getCardTokens(this.collectorIds.tonderSaveCardButton!);
-          const customerResponse : CustomerRegisterResponse | ErrorResponse = await this._getCustomer() as CustomerRegisterResponse;
+          const customerResponse : CustomerRegisterResponse = await this._getCustomer() as CustomerRegisterResponse;
 
           if("auth_token" in customerResponse && this.secureToken) {
             // @ts-ignore
@@ -702,23 +716,35 @@ export class InlineCheckout extends BaseInlineCheckout<IInlineCustomizationOptio
 
               // 2. Process card on file
               const cardOnFile = await this._initializeCardOnFile();
-              const result = await cardOnFile.process({
-                cardTokens: {
-                  name: cardTokensSkyflowTonder.cardholder_name,
-                  number: cardTokensSkyflowTonder.card_number,
-                  expiryMonth: cardTokensSkyflowTonder.expiration_month,
-                  expiryYear: cardTokensSkyflowTonder.expiration_year,
-                  cvv: cardTokensSkyflowTonder.cvv,
-                },
-                cardBin,
-                contactDetails: {
-                  firstName: first_name || '',
-                  lastName: last_name || '',
-                  email: email || '',
-                },
-                customerId: authToken,
-                currency: this.currency || 'MXN',
-              });
+              let result: { subscriptionId: string };
+              try {
+                result = await cardOnFile.process({
+                  cardTokens: {
+                    name: cardTokensSkyflowTonder.cardholder_name,
+                    number: cardTokensSkyflowTonder.card_number,
+                    expiryMonth: cardTokensSkyflowTonder.expiration_month,
+                    expiryYear: cardTokensSkyflowTonder.expiration_year,
+                    cvv: cardTokensSkyflowTonder.cvv,
+                  },
+                  cardBin,
+                  contactDetails: {
+                    firstName: first_name || '',
+                    lastName: last_name || '',
+                    email: email || '',
+                  },
+                  customerId: authToken,
+                  currency: this.currency || 'MXN',
+                });
+              } catch (processError) {
+                throw buildPublicAppError(
+                  {
+                    errorCode: ErrorKeyEnum.CARD_ON_FILE_DECLINED,
+                    lockErrorCode: true,
+                    message: MESSAGES_EN[ErrorKeyEnum.CARD_ON_FILE_DECLINED],
+                  },
+                  processError,
+                );
+              }
 
               // 3. Save card with subscription_id
               await this.#handleSaveCard(
@@ -749,8 +775,21 @@ export class InlineCheckout extends BaseInlineCheckout<IInlineCustomizationOptio
         if(cardId && auth_token){
             await this._removeCustomerCard(auth_token, this.merchantData!.business.pk, cardId)
         }
+        this.reportSdkError(error, {
+          feature: "save-card",
+          process_id: cardId,
+          metadata: {
+            step: "#validateAndSaveCard",
+          },
+        });
         const exist_msg_error = typeof error === "object" && error !== null && "message" in error;
-        showError(exist_msg_error ? error?.message as string:"Ha ocurrido un error", this.radioChecked, this.collectorIds.msgError)
+        const visualMessage =
+          (error as any)?.code === ErrorKeyEnum.CARD_ON_FILE_DECLINED
+            ? MESSAGES_ES[ErrorKeyEnum.CARD_ON_FILE_DECLINED]
+            : exist_msg_error
+              ? (error?.message as string)
+              : "Ha ocurrido un error";
+        showError(visualMessage, this.radioChecked, this.collectorIds.msgError)
         throw error;
       } finally {}
     }
@@ -786,23 +825,46 @@ export class InlineCheckout extends BaseInlineCheckout<IInlineCustomizationOptio
               throw new Error("Card BIN not returned from save card");
           }
 
-          const result = await cardOnFile.process({
-              cardTokens: {
-                  name: cardFields.cardholder_name,
-                  number: cardFields.card_number,
-                  expiryMonth: cardFields.expiration_month,
-                  expiryYear: cardFields.expiration_year,
-                  cvv: cardFields.cvv,
-              },
-              cardBin,
-              contactDetails: {
-                  firstName: first_name || '',
-                  lastName: last_name || '',
-                  email: email || '',
+          let result: { subscriptionId: string };
+          try {
+              result = await cardOnFile.process({
+                  cardTokens: {
+                      name: cardFields.cardholder_name,
+                      number: cardFields.card_number,
+                      expiryMonth: cardFields.expiration_month,
+                      expiryYear: cardFields.expiration_year,
+                      cvv: cardFields.cvv,
+                  },
+                  cardBin,
+                  contactDetails: {
+                      firstName: first_name || '',
+                      lastName: last_name || '',
+                      email: email || '',
+                  },
+                  customerId: auth_token,
+                  currency: this.currency || 'MXN',
+              });
+          } catch (processError) {
+            console.error("Error processing card-on-file payment=====", processError);
+            this.reportSdkError(processError, {
+              feature: "payment",
+              process_id: cardId,
+              metadata: {
+                step: "#processCardOnFilePayment_cardOnFile.process",
               },
-              customerId: auth_token,
-              currency: this.currency || 'MXN',
-          });
+            });
+              throw buildPublicAppError(
+                  {
+                      errorCode: ErrorKeyEnum.CARD_ON_FILE_DECLINED,
+                      lockErrorCode: true,
+                      message: MESSAGES_EN[ErrorKeyEnum.CARD_ON_FILE_DECLINED],
+                      details: {
+                          cardId,
+                      },
+                  },
+                  processError,
+              );
+          }
 
           // Update saved card with subscription_id
           await this.#handleSaveCard(
@@ -817,7 +879,25 @@ export class InlineCheckout extends BaseInlineCheckout<IInlineCustomizationOptio
 
           return { subscriptionId: result.subscriptionId, cardId: saveCardResponse.skyflow_id };
       }catch (error) {
-          return { subscriptionId: null, cardId };
+          this.reportSdkError(error, {
+            feature: "payment",
+            process_id: cardId,
+            metadata: {
+              step: "#processCardOnFilePayment",
+              error,
+            },
+          });
+          throw buildPublicAppError(
+            {
+              errorCode: ErrorKeyEnum.CARD_ON_FILE_DECLINED,
+              lockErrorCode: true,
+              message: MESSAGES_EN[ErrorKeyEnum.CARD_ON_FILE_DECLINED],
+              details: {
+                cardId,
+              },
+            },
+            error,
+          );
       }
   }
 
@@ -906,7 +986,18 @@ export class InlineCheckout extends BaseInlineCheckout<IInlineCustomizationOptio
             await this._removeCustomerCard(auth_token, this.merchantData!.business.pk, cardIdSaved)
             await this.#loadCardsList(auth_token)
         }
-      showError("Ha ocurrido un error", this.radioChecked, this.collectorIds.msgError)
+      this.reportSdkError(error, {
+        feature: "payment",
+        process_id: cardIdSaved || this.radioChecked || this.getCustomerId(),
+        metadata: {
+          step: "_checkout",
+        },
+      });
+      const visualMessage =
+        (error as any)?.code === ErrorKeyEnum.CARD_ON_FILE_DECLINED
+          ? MESSAGES_ES[ErrorKeyEnum.CARD_ON_FILE_DECLINED]
+          : "Ha ocurrido un error";
+      showError(visualMessage, this.radioChecked, this.collectorIds.msgError)
       throw error;
     } finally {
       this.#updatePayButton({cardId: this.radioChecked, disabled: false});
@@ -916,7 +1007,7 @@ export class InlineCheckout extends BaseInlineCheckout<IInlineCustomizationOptio
   async #handleSaveCard(
     authToken: string,
     businessId: string | number,
-    cardTokens: ISaveCardSkyflowRequest & { subscription_id?: string },
+    cardTokens: ISaveCardSkyflowRequest,
     options: { forceSave?: boolean; showNotification?: boolean; appOrigin?: boolean; refreshCards?: boolean } = {}
   ): Promise<ISaveCardInternalResponse | undefined> {
     // Validate required data
@@ -944,6 +1035,13 @@ export class InlineCheckout extends BaseInlineCheckout<IInlineCustomizationOptio
           showError("No se han configurado los datos de seguridad para guardar tarjeta", this.radioChecked, this.collectorIds.msgError);
         }
       } catch (error) {
+        this.reportSdkError(error, {
+          feature: "save-card",
+          process_id: cardTokens.skyflow_id || this.getCustomerId(),
+          metadata: {
+            step: "#handleSaveCard",
+          },
+        });
         const exist_msg_error = typeof error === "object" && error !== null && "message" in error;
         if (exist_msg_error && error?.message !== 'Error') {
           showError(error?.message as string, this.radioChecked, this.collectorIds.msgError);

package/src/helpers/sdkInfo.ts

@@ -0,0 +1,11 @@
+/**
+ * SDK information injected from package.json at build time
+ * Values are replaced by Rollup's replace plugin
+ */
+declare const __SDK_NAME__: string;
+declare const __SDK_VERSION__: string;
+
+export const SDK_INFO = Object.freeze({
+  name: __SDK_NAME__,
+  version: __SDK_VERSION__,
+});

package/src/shared/constants/messages.ts

@@ -0,0 +1,13 @@
+import { ErrorKeyEnum } from "../enums/ErrorKeyEnum";
+
+export const MESSAGES_EN: Record<string, string> = {
+  [ErrorKeyEnum.CARD_ON_FILE_DECLINED]:
+    "Transaction declined. Please verify your card details.",
+  [ErrorKeyEnum.UNKNOWN_ERROR]: 'An unexpected error occurred.',
+};
+
+export const MESSAGES_ES: Record<string, string> = {
+  [ErrorKeyEnum.CARD_ON_FILE_DECLINED]:
+    "Transaccion declinada. Verique los datos de su tarjeta.",
+  [ErrorKeyEnum.UNKNOWN_ERROR]: 'Ocurrió un error inesperado.',
+};

package/src/shared/enums/ErrorKeyEnum.ts

@@ -0,0 +1,6 @@
+export enum ErrorKeyEnum {
+  SAVE_CARD_ERROR = "SAVE_CARD_ERROR",
+  PAYMENT_PROCESS_ERROR = "PAYMENT_PROCESS_ERROR",
+  CARD_ON_FILE_DECLINED = "CARD_ON_FILE_DECLINED",
+  UNKNOWN_ERROR = 'UNKNOWN_ERROR'
+}

package/src/shared/utils/appError.ts

@@ -0,0 +1,304 @@
+import { MESSAGES_EN } from '../constants/messages';
+import { ErrorKeyEnum } from '../enums/ErrorKeyEnum';
+
+const DEFAULT_SYSTEM_ERROR = 'APP_INTERNAL_001';
+const LOCK_ERROR_CODE_KEY = '__tonderLockErrorCode__';
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+    return typeof value === 'object' && value !== null;
+}
+
+export interface IAppErrorInput {
+    errorCode: string;
+    message?: string;
+    statusCode?: number;
+    details?: Record<string, unknown>;
+    originalError?: unknown;
+    lockErrorCode?: boolean;
+}
+
+export class AppError extends Error {
+    public readonly status: 'error' = 'error';
+    public readonly code: string;
+    public readonly statusCode: number;
+    public readonly originalError?: unknown;
+    public details: Record<string, unknown>;
+
+    constructor(error: IAppErrorInput) {
+        const resolvedStatusCode = AppError.resolveStatusCode(
+            error.statusCode,
+            error.originalError,
+        );
+        const resolvedMessage = AppError.resolveMessage(
+            error.errorCode,
+            error.message,
+        );
+        const resolvedSystemError = AppError.resolveSystemError(
+            error.details?.systemError,
+            error.originalError,
+        );
+
+        super(resolvedMessage);
+
+        Object.setPrototypeOf(this, new.target.prototype);
+
+        this.name = 'TonderError';
+        this.code = error.errorCode;
+        this.statusCode = resolvedStatusCode;
+        this.originalError = error.originalError;
+        this.details = {
+            code: error.errorCode,
+            statusCode: resolvedStatusCode,
+            systemError: resolvedSystemError,
+        };
+
+        if (error.lockErrorCode) {
+            Object.defineProperty(this, LOCK_ERROR_CODE_KEY, {
+                value: true,
+                enumerable: false,
+                configurable: true,
+            });
+        }
+
+        Error.captureStackTrace?.(this, AppError);
+    }
+
+    private static isRecord(value: unknown): value is Record<string, unknown> {
+        return typeof value === 'object' && value !== null;
+    }
+
+    public static parseStatusCode(code: unknown): number {
+        const parsed = Number(code);
+        if (!Number.isFinite(parsed)) return 500;
+        if (parsed < 100 || parsed > 599) return 500;
+        return Math.trunc(parsed);
+    }
+
+    public static resolveStatusCode(
+        explicitStatusCode: unknown,
+        originalError?: unknown,
+    ): number {
+        const candidates: unknown[] = [explicitStatusCode];
+
+        if (AppError.isRecord(originalError)) {
+            candidates.push(
+                originalError.statusCode,
+                originalError.status,
+            );
+
+            const body = AppError.isRecord(originalError.body)
+                ? originalError.body
+                : null;
+            if (body) {
+                candidates.push(body.statusCode, body.status);
+            }
+        }
+
+        for (const candidate of candidates) {
+            if (AppError.isHttpStatusCode(candidate)) {
+                return Math.trunc(Number(candidate));
+            }
+        }
+
+        return 500;
+    }
+
+    public static resolveMessage(errorCode: string, message?: string): string {
+        if (message) return message;
+        return (
+            MESSAGES_EN[errorCode] ||
+            MESSAGES_EN[ErrorKeyEnum.UNKNOWN_ERROR] ||
+            'An unexpected error occurred.'
+        );
+    }
+
+    public static isHttpStatusCode(value: unknown): boolean {
+        const parsed = Number(value);
+        return Number.isFinite(parsed) && parsed >= 100 && parsed <= 599;
+    }
+
+    public static normalizeSystemError(value: unknown): string | null {
+        if (typeof value !== 'string') return null;
+        const trimmed = value.trim();
+        return trimmed || null;
+    }
+
+    public static resolveSystemError(
+        explicitSystemError: unknown,
+        originalError?: unknown,
+    ): string {
+        const candidates: unknown[] = [explicitSystemError];
+
+        if (AppError.isRecord(originalError)) {
+            const details = AppError.isRecord(originalError.details)
+                ? originalError.details
+                : null;
+            const body = AppError.isRecord(originalError.body)
+                ? originalError.body
+                : null;
+            const bodyDetails = body && AppError.isRecord(body.details)
+                ? body.details
+                : null;
+
+            candidates.push(
+                originalError.systemError,
+                originalError.code,
+                details?.systemError,
+                details?.code,
+                body?.systemError,
+                body?.code,
+                bodyDetails?.systemError,
+                bodyDetails?.code,
+            );
+        }
+
+        for (const candidate of candidates) {
+            const resolved = AppError.normalizeSystemError(candidate);
+            if (resolved) return resolved;
+        }
+
+        return DEFAULT_SYSTEM_ERROR;
+    }
+}
+
+export interface IBuildPublicAppErrorInput {
+    errorCode: string;
+    message?: string;
+    details?: Record<string, unknown>;
+    statusCode?: number;
+    response?: Response;
+    lockErrorCode?: boolean;
+}
+
+function markErrorCodeLocked(error: Record<string, unknown>): void {
+    Object.defineProperty(error, LOCK_ERROR_CODE_KEY, {
+        value: true,
+        enumerable: false,
+        configurable: true,
+    });
+}
+
+function hasLockedErrorCode(error: unknown): boolean {
+    return isRecord(error) && error[LOCK_ERROR_CODE_KEY] === true;
+}
+
+function isTonderAppErrorLike(error: unknown): error is AppError {
+    return (
+        isRecord(error) &&
+        error.name === 'TonderError' &&
+        typeof error.code === 'string'
+    );
+}
+
+function getOriginalError(error: unknown): unknown {
+    if (error instanceof AppError) {
+        return error.originalError !== undefined ? error.originalError : error;
+    }
+
+    return error;
+}
+
+async function parseResponseBody(response: Response): Promise<unknown> {
+    try {
+        return await response.clone().json();
+    } catch (_) {
+        // Ignore JSON parsing errors and fallback to text.
+    }
+
+    try {
+        const text = await response.text();
+        return text || undefined;
+    } catch (_) {
+        return undefined;
+    }
+}
+
+function buildPublicAppErrorSync(
+    data: IBuildPublicAppErrorInput,
+    error?: unknown,
+): AppError {
+    if (!data?.errorCode) {
+        throw new Error('buildPublicAppError requires errorCode');
+    }
+
+    const explicitSystemError = data.details?.systemError;
+    const hasExplicitOverrides =
+        !!data.message ||
+        data.statusCode !== undefined ||
+        explicitSystemError !== undefined;
+
+    if (isTonderAppErrorLike(error)) {
+        if (data.lockErrorCode) {
+            markErrorCodeLocked(error as unknown as Record<string, unknown>);
+        }
+
+        if (!hasExplicitOverrides) {
+            if (data.errorCode === error.code || hasLockedErrorCode(error)) {
+                return error;
+            }
+        }
+    }
+
+    return new AppError({
+        errorCode: data.errorCode,
+        message: data.message,
+        statusCode: data.statusCode,
+        details:
+            explicitSystemError !== undefined
+                ? { systemError: explicitSystemError }
+                : undefined,
+        originalError: getOriginalError(error),
+        lockErrorCode: data.lockErrorCode || hasLockedErrorCode(error),
+    });
+}
+
+async function buildPublicAppErrorFromHttpResponse(
+    data: IBuildPublicAppErrorInput & { response: Response },
+): Promise<AppError> {
+    const body = await parseResponseBody(data.response);
+
+    const originalError: Record<string, unknown> = {
+        status: data.response.status,
+    };
+
+    if (data.response.statusText) {
+        originalError.statusText = data.response.statusText;
+    }
+
+    if (body !== undefined) {
+        originalError.body = body;
+    }
+
+    return new AppError({
+        errorCode: data.errorCode,
+        message: data.message,
+        statusCode: data.statusCode ?? data.response.status,
+        details:
+            data.details?.systemError !== undefined
+                ? { systemError: data.details.systemError }
+                : undefined,
+        originalError,
+        lockErrorCode: data.lockErrorCode,
+    });
+}
+
+export function buildPublicAppError(
+    data: IBuildPublicAppErrorInput & { response: Response },
+    error?: unknown,
+): Promise<AppError>;
+export function buildPublicAppError(
+    data: IBuildPublicAppErrorInput,
+    error?: unknown,
+): AppError;
+export function buildPublicAppError(
+    data: IBuildPublicAppErrorInput,
+    error?: unknown,
+): AppError | Promise<AppError> {
+    if (data?.response) {
+        return buildPublicAppErrorFromHttpResponse(
+            data as IBuildPublicAppErrorInput & { response: Response },
+        );
+    }
+
+    return buildPublicAppErrorSync(data, error);
+}

package/src/types/inlineCheckout.ts

@@ -1,7 +1,6 @@
 import {IConfigureCheckout} from "@tonder.io/ionic-lite-sdk/dist/types/commons";
 import {
     IProcessPaymentRequest,
-    IStartCheckoutErrorResponse,
     IStartCheckoutResponse
 } from "@tonder.io/ionic-lite-sdk/dist/types/checkout";
 import {ITransaction} from "@tonder.io/ionic-lite-sdk/dist/types/transaction";
@@ -32,7 +31,6 @@ export interface IInlineCheckout {
      *
      * @throws {Error} Throws an error if the checkout process fails. The error object contains
      * additional `details` property with the response from the server if available.
-     * @property {IStartCheckoutErrorResponse} error.details - The response body from the server when an error occurs.
      *
      * @public
      */