tf-checkout-react 1.7.30 → 2.0.0-beta.0

package/src/xendit.ts

@@ -0,0 +1,438 @@
+/**
+ * Web (xendit.js) binding for Xendit CARD tokenization — the inline,
+ * natively-styled equivalent of the React Native WebView sheet. It loads
+ * xendit.js into the page, tokenizes the card the consumer rendered via
+ * `<XenditCardInput/>`, and runs the 3DS challenge in a full-screen overlay.
+ * The engine charges the returned token server-side.
+ *
+ * The consumer's app must allow `https://js.xendit.co` in its CSP.
+ */
+
+const XENDIT_JS = 'https://js.xendit.co/v1/xendit.min.js'
+
+/** How long to wait for xendit.js to call our callback even ONCE before giving
+ *  up. The SDK can stall after its `payer/init` + `fingerprint/scans` warmup
+ *  without ever POSTing `/v2/credit_card_tokens`; without this the promise
+ *  never settles and the buyer stares at a blank 3DS overlay forever. */
+const FIRST_RESPONSE_TIMEOUT_MS = 45_000
+
+interface XenditToken {
+  status: 'VERIFIED' | 'IN_REVIEW' | 'FAILED' | string
+  payer_authentication_url?: string
+  [k: string]: unknown
+}
+
+interface XenditGlobal {
+  setPublishableKey(key: string): void
+  card: {
+    createToken(
+      data: Record<string, unknown>,
+      cb: (err: XenditError | null, token: XenditToken) => void
+    ): void
+    /** xendit.js ships its own validators — use them so the rules match exactly
+     *  what `createToken` will accept, instead of re-deriving them here. */
+    validateCardNumber(number: string): boolean
+    validateExpiry(month: string, year: string): boolean
+    validateCvn(cvn: string): boolean
+  }
+}
+
+/** Luhn — the fallback used only before xendit.js has finished loading. */
+const luhn = (digits: string): boolean => {
+  let sum = 0
+  let double = false
+  for (let i = digits.length - 1; i >= 0; i -= 1) {
+    let d = digits.charCodeAt(i) - 48
+    if (d < 0 || d > 9) return false
+    if (double) {
+      d *= 2
+      if (d > 9) d -= 9
+    }
+    sum += d
+    double = !double
+  }
+  return sum % 10 === 0
+}
+
+const xenditGlobal = (): XenditGlobal | undefined =>
+  typeof window === 'undefined'
+    ? undefined
+    : (window as unknown as { Xendit?: XenditGlobal }).Xendit
+
+/**
+ * Field-level card checks, matching what `createToken` enforces. Prefers
+ * xendit.js's own validators and falls back to equivalent local rules while the
+ * script is still loading, so a form can validate on blur from the first
+ * keystroke. `expYear` accepts "YY" or "YYYY".
+ */
+export const xenditCardChecks = {
+  number: (value: string): boolean => {
+    const digits = value.replace(/\D/g, '')
+    if (digits.length < 12) return false
+    const X = xenditGlobal()
+    return X?.card?.validateCardNumber
+      ? X.card.validateCardNumber(digits)
+      : digits.length <= 19 && luhn(digits)
+  },
+  expiry: (month: string, year: string): boolean => {
+    const mm = month.trim()
+    const yyyy = year.trim().length === 2 ? `20${year.trim()}` : year.trim()
+    if (!/^\d{1,2}$/.test(mm) || !/^\d{4}$/.test(yyyy)) return false
+    const X = xenditGlobal()
+    if (X?.card?.validateExpiry) return X.card.validateExpiry(mm, yyyy)
+    const m = Number(mm)
+    const y = Number(yyyy)
+    if (m < 1 || m > 12) return false
+    const now = new Date()
+    return y > now.getFullYear() || (y === now.getFullYear() && m >= now.getMonth() + 1)
+  },
+  cvn: (value: string): boolean => {
+    const digits = value.replace(/\D/g, '')
+    const X = xenditGlobal()
+    return X?.card?.validateCvn
+      ? X.card.validateCvn(digits)
+      : digits.length >= 3 && digits.length <= 4
+  },
+}
+
+/**
+ * Human copy for Xendit's `failure_reason` codes — the same map the hosted PHP
+ * checkout shows (`XenditHelper::FAILURE_REASONS`). Without it a decline
+ * surfaces as a bare code like `INVALID_CVV`, which means nothing to a buyer.
+ */
+export const XENDIT_FAILURE_REASONS: Record<string, string> = {
+  EXPIRED_CARD: 'This card has expired. Please use a different card.',
+  ISSUER_SUSPECT_FRAUD:
+    'Your bank declined this card as a suspected fraud risk. Please use a different card.',
+  DECLINED_BY_PROCESSOR:
+    'This card was declined by the payment processor. Please use a different card.',
+  INSUFFICIENT_BALANCE: 'This card does not have enough balance to complete the payment.',
+  STOLEN_CARD: 'This card has been reported lost or stolen.',
+  INACTIVE_OR_UNAUTHORIZED_CARD:
+    'This card is inactive, or not authorised for this type of payment.',
+  PROCESSOR_ERROR:
+    'The payment could not be processed by your bank. Please try again shortly.',
+  INVALID_CVV: 'The security code (CVC) does not match this card.',
+  DECLINED_BY_ISSUER: 'Your bank declined this payment. Please use a different card.',
+  AUTHENTICATION_FAILED:
+    'Card authentication failed. Please try again or use a different card.',
+  ENROLLMENT_STATUS_UNAVAILABLE:
+    'Your bank could not verify this card right now. Please try again or use a different card.',
+  DEFAULT: 'Your payment was not accepted. Please try again or use a different card.',
+}
+
+/**
+ * Xendit accepts only ASCII + Latin-1 in `card_holder_*` names, and requires a
+ * letter first:
+ *   /^[A-Za-z][\x20-\x7EÀ-ÖØ-öø-ÿ]*$/
+ * A name with an emoji or non-Latin script ("Babken 🇦🇲", "Բաբկեն") is rejected
+ * with API_VALIDATION_ERROR and the whole payment fails. Strip what Xendit
+ * can't take and keep the rest; the group is optional, so a name that reduces
+ * to nothing is dropped instead of blocking the buyer.
+ */
+const XENDIT_NAME_BODY = /[^\x20-\x7EÀ-ÖØ-öø-ÿ]/g
+
+export const sanitizeXenditHolderName = (value: string): string => {
+  const stripped = (value ?? '').replace(XENDIT_NAME_BODY, '').trim()
+  // Must begin with a plain A–Z letter — trim any leading punctuation/digits.
+  const fromFirstLetter = stripped.replace(/^[^A-Za-z]+/, '')
+  return fromFirstLetter.trim()
+}
+
+/** The error shape xendit.js hands back, including per-field validation rows. */
+interface XenditError {
+  message?: string
+  error_code?: string
+  errors?: Array<{
+    message?: string
+    path?: string[]
+    context?: { key?: string }
+  }>
+}
+
+/** Field key → buyer-facing sentence, for API_VALIDATION_ERROR responses. */
+const VALIDATION_FIELD_COPY: Record<string, string> = {
+  card_number: 'Card number is invalid',
+  card_exp_month: 'Card expiry date is invalid',
+  card_exp_year: 'Card expiry date is invalid',
+  card_cvn: 'Card security code is invalid',
+  card_holder_first_name: 'Please check the first name on the card.',
+  card_holder_last_name: 'Please check the last name on the card.',
+  card_holder_email: 'Please check the email address.',
+  card_holder_phone_number: 'Please check the phone number.',
+  amount: 'This order could not be charged. Please refresh and try again.',
+}
+
+/**
+ * Turn a raw xendit.js error into something a buyer can act on. Xendit's own
+ * `message` for a rejected field is "There was an error with the format
+ * submitted to the server", which says nothing — the useful detail is in
+ * `errors[].context.key`.
+ */
+export const describeXenditError = (err: XenditError): string => {
+  const first = Array.isArray(err.errors) ? err.errors[0] : undefined
+  const key = first?.context?.key ?? first?.path?.[first.path.length - 1]
+  if (key && VALIDATION_FIELD_COPY[key]) return VALIDATION_FIELD_COPY[key]
+  if (err.error_code && XENDIT_FAILURE_REASONS[err.error_code]) {
+    return XENDIT_FAILURE_REASONS[err.error_code]
+  }
+  // Xendit's generic format message is noise — prefer our own wording.
+  if (!err.message || /format submitted to the server/i.test(err.message)) {
+    return XENDIT_FAILURE_REASONS.DEFAULT
+  }
+  return err.message
+}
+
+/** Raw card field values, read at tokenize time (never held in JS state). */
+export interface XenditCardFields {
+  number: string
+  /** "MM" */
+  expMonth: string
+  /** "YY" or "YYYY" — 2-digit is expanded to 20YY. */
+  expYear: string
+  cvn: string
+}
+
+export interface WebXenditTokenizer {
+  /** `<XenditCardInput/>` registers a getter for its live field values (or
+   *  null on unmount). */
+  registerFields(getFields: (() => XenditCardFields) | null): void
+  /** Tokenizes the registered card (running inline 3DS when the bank asks) and
+   *  resolves with the token the engine charges. Rejects on validation error,
+   *  decline, or a failed 3DS challenge. */
+  tokenize(params: {
+    publishableKey: string
+    amount: string | number
+    billing: { firstName: string; lastName: string; email: string; phone?: string }
+    onBehalfOf?: string | null
+  }): Promise<Record<string, unknown>>
+}
+
+let scriptPromise: Promise<XenditGlobal> | null = null
+
+const loadXendit = (): Promise<XenditGlobal> => {
+  if (scriptPromise) return scriptPromise
+  scriptPromise = new Promise<XenditGlobal>((resolve, reject) => {
+    const w = window as unknown as { Xendit?: XenditGlobal }
+    if (w.Xendit) {
+      return resolve(w.Xendit)
+    }
+    const script = document.createElement('script')
+    script.src = XENDIT_JS
+    script.async = true
+    script.onload = () => {
+      if (w.Xendit) {
+        resolve(w.Xendit)
+      } else {
+        reject(new Error('The payment service could not be loaded.'))
+      }
+    }
+    script.onerror = () => {
+      reject(new Error('The payment service could not be loaded.'))
+    }
+    document.head.appendChild(script)
+  })
+  return scriptPromise
+}
+
+/** Warm xendit.js so field validation uses Xendit's own rules immediately. */
+export const preloadXendit = (): void => {
+  void loadXendit().catch(() => {
+    // Pre-warming is best-effort; tokenize() surfaces a real load failure.
+  })
+}
+
+export const createWebXenditTokenizer = (): WebXenditTokenizer => {
+  let getFields: (() => XenditCardFields) | null = null
+
+  /**
+   * Full-screen overlay hosting the 3DS challenge iframe. Returns a disposer.
+   *
+   * The iframe is layered OVER a status strip rather than shown bare: an
+   * issuer page that is slow, blank (frictionless auth), or blocked would
+   * otherwise leave the buyer staring at a plain white rectangle with no way
+   * out — indistinguishable from a crash. `onCancel` gives them that way out.
+   */
+  const showThreeDs = (url: string, onCancel: () => void): (() => void) => {
+    const overlay = document.createElement('div')
+    overlay.setAttribute(
+      'style',
+      'position:fixed;inset:0;z-index:2147483647;background:#fff;display:flex;flex-direction:column'
+    )
+
+    const bar = document.createElement('div')
+    bar.setAttribute(
+      'style',
+      'display:flex;align-items:center;gap:12px;padding:12px 16px;border-bottom:1px solid #e7e7f0;font:14px system-ui,sans-serif;color:#16162e;flex:none'
+    )
+    const status = document.createElement('span')
+    status.textContent = 'Verifying with your bank…'
+    const cancel = document.createElement('button')
+    cancel.type = 'button'
+    cancel.textContent = 'Cancel'
+    cancel.setAttribute(
+      'style',
+      'margin-left:auto;padding:6px 14px;border:1px solid #e7e7f0;border-radius:8px;background:#fff;font:inherit;cursor:pointer'
+    )
+    cancel.onclick = () => {
+      onCancel()
+    }
+    bar.append(status, cancel)
+
+    const frame = document.createElement('iframe')
+    frame.setAttribute('style', 'width:100%;flex:1;border:0')
+    // Assigning src is what starts the challenge — it must run unconditionally.
+    frame.src = url
+
+    overlay.append(bar, frame)
+    document.body.appendChild(overlay)
+    return () => overlay.remove()
+  }
+
+  return {
+    registerFields: (fn) => {
+      getFields = fn
+    },
+
+    tokenize: async ({ publishableKey, amount, billing, onBehalfOf }) => {
+      if (!getFields) {
+        throw new Error('Render <XenditCardInput/> before paying with a Xendit card.')
+      }
+      const f = getFields()
+      const number = f.number.replace(/\s+/g, '')
+      const expMonth = f.expMonth.trim()
+      let expYear = f.expYear.trim()
+      if (expYear.length === 2) expYear = '20' + expYear
+      const cvn = f.cvn.trim()
+      if (!number || !expMonth || !expYear || !cvn) {
+        throw new Error('Please fill in your card details.')
+      }
+
+      const Xendit = await loadXendit()
+      Xendit.setPublishableKey(publishableKey)
+
+      // Check the fields with Xendit's own validators before spending a network
+      // round trip, so the buyer is told WHICH field is wrong rather than
+      // getting a generic decline back from the API.
+      if (!xenditCardChecks.number(number)) {
+        throw new Error('Card number is invalid')
+      }
+      if (!xenditCardChecks.expiry(expMonth, expYear)) {
+        throw new Error('Card expiry date is invalid')
+      }
+      if (!xenditCardChecks.cvn(cvn)) {
+        throw new Error('Card security code is invalid')
+      }
+
+      return new Promise<Record<string, unknown>>((resolve, reject) => {
+        let dismissThreeDs: (() => void) | null = null
+        let settled = false
+        let answered = false
+        const finish = (fn: () => void) => {
+          if (settled) return
+          settled = true
+          clearTimeout(watchdog)
+          dismissThreeDs?.()
+          fn()
+        }
+
+        // xendit.js can complete its `payer/init` + `fingerprint/scans` warmup
+        // and then never POST /v2/credit_card_tokens — no callback, no error.
+        // Fail loudly instead of hanging on a blank overlay forever.
+        const watchdog = setTimeout(() => {
+          if (answered) return
+          finish(() =>
+            reject(
+              new Error(
+                'The payment service did not respond. Please try again — if it keeps happening, try a different card or browser.'
+              )
+            )
+          )
+        }, FIRST_RESPONSE_TIMEOUT_MS)
+
+        // The Xendit SDK re-invokes this handler after the 3DS challenge, so
+        // IN_REVIEW then VERIFIED/FAILED all flow through here.
+        const handler = (err: XenditError | null, token: XenditToken) => {
+          answered = true
+          if (err) {
+            finish(() => reject(new Error(describeXenditError(err))))
+            return
+          }
+          // A callback with neither an error nor a token would throw on
+          // `token.status` INSIDE xendit.js, where the try/catch below can't
+          // reach it — leaving the promise permanently unsettled.
+          if (!token || typeof token !== 'object') {
+            finish(() =>
+              reject(new Error('The payment service returned an unexpected response.'))
+            )
+            return
+          }
+          if (token.status === 'VERIFIED') {
+            finish(() => resolve(token as Record<string, unknown>))
+            return
+          }
+          if (token.status === 'IN_REVIEW' && token.payer_authentication_url) {
+            // The buyer now drives the bank's challenge — no fixed deadline.
+            clearTimeout(watchdog)
+            dismissThreeDs?.()
+            dismissThreeDs = showThreeDs(token.payer_authentication_url, () =>
+              finish(() => reject(new Error('Payment was cancelled')))
+            )
+            return
+          }
+          // Translate Xendit's failure_reason the way the hosted checkout does
+          // — a bare code like INVALID_CVV tells the buyer nothing.
+          const code =
+            typeof token.failure_reason === 'string' ? token.failure_reason : ''
+          finish(() =>
+            reject(
+              new Error(XENDIT_FAILURE_REASONS[code] ?? XENDIT_FAILURE_REASONS.DEFAULT)
+            )
+          )
+        }
+        try {
+          // card_holder_* fields are ALL-OR-NOTHING peers in Xendit's
+          // validation ("card_holder_first_name missing required peer
+          // card_holder_phone_number" — observed live): send the group only
+          // when every field is present, else omit it entirely (it's optional
+          // as a whole).
+          // …and the names must additionally satisfy Xendit's Latin-only
+          // pattern, so strip anything it rejects (emoji, non-Latin scripts).
+          const holderFirst = sanitizeXenditHolderName(billing.firstName)
+          const holderLast = sanitizeXenditHolderName(billing.lastName)
+          const holder =
+            holderFirst && holderLast && billing.email && billing.phone
+              ? {
+                  card_holder_first_name: holderFirst,
+                  card_holder_last_name: holderLast,
+                  card_holder_email: billing.email,
+                  card_holder_phone_number: billing.phone,
+                }
+              : {}
+          Xendit.card.createToken(
+            {
+              amount: String(amount),
+              card_number: number,
+              card_exp_month: expMonth,
+              card_exp_year: expYear,
+              card_cvn: cvn,
+              is_multiple_use: false,
+              should_authenticate: true,
+              ...holder,
+              ...(onBehalfOf ? { on_behalf_of: onBehalfOf } : {}),
+            },
+            handler
+          )
+        } catch (e) {
+          finish(() =>
+            reject(
+              e instanceof Error
+                ? e
+                : new Error('Something went wrong. Please try again.')
+            )
+          )
+        }
+      })
+    },
+  }
+}

package/dist/adapters/customFields.d.ts

@@ -1,12 +0,0 @@
-import { IGroupItem } from '../types';
-export declare const optionsAdapter: (options: any) => {
-    id: any;
-    label: any;
-    value: any;
-}[];
-export declare const fieldDataAdapter: (field: IGroupItem) => IGroupItem;
-export declare const customFieldsDataAdapter: (data: any) => {
-    ticketsFields: IGroupItem[];
-    orderFields: IGroupItem[];
-    addOnFields: IGroupItem[];
-};

package/dist/adapters/index.d.ts

@@ -1 +0,0 @@
-export { customFieldsDataAdapter } from './customFields';

package/dist/api/auth.d.ts

@@ -1,27 +0,0 @@
-export declare const authorize: (data: IAuthorizeRequestData) => Promise<IProfileResponse>;
-export declare const signUp: (data: ISignupRequestData) => Promise<IProfileResponse>;
-export declare const register: (data: FormData) => Promise<IProfileResponse>;
-export declare const getProfileData: () => Promise<IProfileResponse>;
-export declare const logout: () => Promise<IAxiosResponseData>;
-/**
- * Checks whether a given email address already exists via the `/ajax/contact-email` endpoint.
- *
- * The underlying API is expected to return a JSON object containing:
- * - `exists`: `1` if the email exists, `0` otherwise
- * - `error`: `1` if an error occurred, `0` otherwise
- * - `message`: an optional error message when `error === 1`
- *
- * This function normalizes that response to an object with:
- * - `exists`: a boolean indicating whether the email exists
- * - `error`: an optional string containing an error message, if any
- *
- * On network or unexpected errors, it returns `{ exists: false, error: 'Failed to check email' }`.
- *
- * @param {string} email - The email address to check for existence.
- * @returns {Promise<{ exists: boolean; error?: string }>} A promise that resolves to the normalized
- *          result of the email existence check.
- */
-export declare const checkEmailExists: (email: string) => Promise<{
-    exists: boolean;
-    error?: string;
-}>;

package/dist/api/cart.d.ts

@@ -1,2 +0,0 @@
-export declare const addToCart: (id: string | number, data: ICartRequestData) => Promise<ICartResponse>;
-export declare const getCart: () => Promise<IGetCartResponse>;

package/dist/api/checkout.d.ts

@@ -1,3 +0,0 @@
-import { ICheckoutResponse } from '../types/api/checkout';
-export declare const postOnCheckout: (data: any, freeTicket?: boolean) => Promise<ICheckoutResponse>;
-export declare const updateCheckout: (data: any) => Promise<ICheckoutResponse>;

package/dist/api/common.d.ts

@@ -1,11 +0,0 @@
-export declare const getEvent: (id: string | number, pk?: string | undefined) => Promise<IEventResponse>;
-export declare const getTickets: (eventId: string | number, promoCode: string, pk?: string | undefined) => Promise<ITicketsAdaptedResponse>;
-export declare const getTimeSlotsByDate: (eventId: string | number, date: string, promoCode?: string | undefined, pk?: string | undefined) => Promise<ITimeslotsAdaptedResponse>;
-export declare const getCountries: () => Promise<ICountriesResponse>;
-export declare const getStates: (countryId: string | number) => Promise<IStatesResponse>;
-export declare const sendRSVPInfo: (eventId: number, data: {
-    data: IRSVPRequestData;
-}) => Promise<IRSVPResponse>;
-export declare const addToWaitingList: (id: number, data: IWaitingListRequestData) => Promise<IWaitingListResponse>;
-export declare const postReferralVisits: (eventId: string, referralId: string) => Promise<IAxiosResponseData>;
-export declare const validatePhoneNumber: (phone: string) => Promise<IAxiosResponseData>;

package/dist/api/guestTicketDelegation.d.ts

@@ -1,47 +0,0 @@
-export declare const getCustomerExistsData: (accessHash: string) => Promise<ICheckCustomerExistsData>;
-interface IDelegationTicketType {
-    delegationMaxQuantity: number | string;
-}
-interface IIssueTicketResponseData {
-    delegationName: string;
-    eventImage: string;
-    eventName: string;
-    ticketTypes: {
-        [key: number]: IDelegationTicketType;
-    };
-}
-interface IIssueTicketResponse {
-    data: {
-        attributes: IIssueTicketResponseData;
-        relationships: Array<any>;
-        type: string;
-        message: string;
-    };
-}
-export interface IDelegationsTicketType {
-    [key: number]: {
-        delegationMaxQuantity: string | number;
-        delegationQuantityIssued: string | number;
-        matrixRecordId: string | number;
-        optionValue: string | number;
-    };
-}
-export interface IDelegationsData {
-    delegationName: string;
-    eventImage: string;
-    eventName: string;
-    ticketTypes: IDelegationsTicketType;
-    tickets: Array<any>;
-}
-interface IDelegationsResponse {
-    data: {
-        data: {
-            attributes: IDelegationsData;
-            relationships: Array<any>;
-            type: string;
-        };
-    };
-}
-export declare const getDelegationTickets: (accessHash: string) => Promise<IDelegationsResponse>;
-export declare const issueTicket: (accessHash: string, data: ITicketIssueData) => Promise<IIssueTicketResponse>;
-export {};

package/dist/api/index.d.ts

@@ -1,82 +0,0 @@
-import './interceptors';
-import { AxiosRequestConfig, AxiosResponse } from 'axios';
-import { GetNetverifyUrlResponseData, UpdateVerificationStatusResponseData, VerificationStatusResponseData } from '../types/verification';
-export { authorize, getProfileData, signUp, register, logout, checkEmailExists } from './auth';
-export { setAxiosHeader, setBaseUrl } from './publicRequest';
-export { getOrders, getOrderDetails } from './orders';
-export { addToCart, getCart } from './cart';
-export { postOnCheckout } from './checkout';
-export { getEvent, getTickets, getCountries, getStates, addToWaitingList, sendRSVPInfo, postReferralVisits, validatePhoneNumber, } from './common';
-export { getPaymentData, getConditions, handlePaymentSuccess, handleFreeSuccess, getConfirmationData, } from './payment';
-export { resaleTicket, removeFromResale, processTicket, declineInvitation, } from './resale';
-export { issueTicket, getDelegationTickets } from './guestTicketDelegation';
-export declare const setCustomHeader: (response: any) => void;
-export declare const handlePaymentData: (orderHash: string, data: any) => Promise<AxiosResponse<any, any>>;
-export declare const createPaymentPlan: (orderHash: string, stripePaymentMethodId: string) => Promise<AxiosResponse<any, any>>;
-export declare const forgotPassword: (email: string) => Promise<AxiosResponse<any, any>>;
-interface IResetPasswordData {
-    token: string;
-    password: string;
-    confirmPassword: string;
-}
-export declare const resetPassword: (data: IResetPasswordData) => Promise<AxiosResponse<any, any>>;
-export declare const getAddons: (eventId: string) => Promise<any>;
-export declare const selectAddons: (data: any) => void;
-export interface AttributesConfig {
-    has_add_on: boolean;
-    names_required: boolean;
-    phone_required: boolean;
-    minimum_age?: any;
-    age_required: boolean;
-    hide_phone_field: boolean;
-    event_id: string;
-    free_ticket: boolean;
-    collect_mandatory_wallet_address: boolean;
-    collect_optional_wallet_address: boolean;
-    collect_mandatory_company: boolean;
-    collect_optional_company: boolean;
-    collect_mandatory_job_title: boolean;
-    collect_optional_job_title: boolean;
-    collect_mandatory_business_category: boolean;
-    collect_optional_business_category: boolean;
-    collect_mandatory_instagram: boolean;
-    collect_optional_instagram: boolean;
-    skip_billing_page: boolean;
-    addon_max_quantity_groups: number | null;
-    cart: ICart[];
-}
-export interface ConfigsData {
-    attributes: AttributesConfig;
-    relationships: any[];
-    type: string;
-}
-export interface ResponseConfigs {
-    data: ConfigsData;
-    success: boolean;
-    error: boolean;
-    message: string;
-    status: number;
-}
-export declare const getCheckoutPageConfigs: () => Promise<ResponseConfigs>;
-export declare const getCustomFields: (eventId: string) => Promise<{
-    ticketsFields: import("../types").IGroupItem[];
-    orderFields: import("../types").IGroupItem[];
-    addOnFields: import("../types").IGroupItem[];
-}>;
-export declare const updateOrderCustomFields: (eventId: string, orderId: string, customFieldsData: Record<string, any>) => Promise<AxiosResponse<any, any>>;
-export declare const updateTicketHoldersCustomFields: (eventId: string, customFieldsData: Record<string, any>, ticketHash: string) => Promise<AxiosResponse<any, any>>;
-export declare const confirmPreRegistration: (eventId: string | number, data: IConfirmPreRegistrationRequestData) => Promise<any>;
-export declare const getSeatMapData: (eventId: string | number) => Promise<SeatMapDataResponse>;
-export declare const getSeatMapStatuses: (eventId: string | number) => Promise<SeatMapStatusesResponse>;
-export declare const reserveSeat: (eventId: string | number, tierId: string, seatId: string) => Promise<any>;
-export declare const removeSeatReserve: (eventId: string | number, tierId: string, seatIds: string[]) => Promise<any>;
-export declare function getPixelScript(id: string | number, pageOptions: any): Promise<AxiosResponse<any, any>>;
-export declare const getNetverifyUrl: () => Promise<GetNetverifyUrlResponseData>;
-export declare const checkVerificationStatus: () => Promise<{
-    data: VerificationStatusResponseData;
-}>;
-export declare const updateVerificationStatus: () => Promise<{
-    data: UpdateVerificationStatusResponseData;
-}>;
-export declare const checkCustomerOrder: (orderHash: string) => Promise<any>;
-export declare const refreshSeatReservation: (eventId: string, orderId: string) => Promise<AxiosResponse<any, AxiosRequestConfig<any>>>;

package/dist/api/interceptors.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/api/orders.d.ts

@@ -1,2 +0,0 @@
-export declare const getOrders: (page: number, limit: number, eventSlug: string) => Promise<IOrdersResponse>;
-export declare const getOrderDetails: (orderId: string) => Promise<IOrderResponse>;

package/dist/api/payment.d.ts

@@ -1,5 +0,0 @@
-export declare const getPaymentData: (hash: string) => Promise<IPaymentDataResponse>;
-export declare const handlePaymentSuccess: (orderHash: string) => Promise<IPaymentSuccessDataResponse>;
-export declare const handleFreeSuccess: (orderHash: string) => Promise<IFreeRegistrationDataResponse>;
-export declare const getConfirmationData: (orderHash: string) => Promise<ICheckoutCompleteDataResponse>;
-export declare const getConditions: (eventId: string) => Promise<IConditionsAdaptedDataResponse>;

package/dist/api/preRegistrationComplete.d.ts

@@ -1,3 +0,0 @@
-export declare const getPreRegistrationInfluencers: (data: IInfluancersRequestData) => Promise<IInfluancersResponseData>;
-export declare const getPreRegistrationShareOptions: (data: IShareOptionsRequestData) => Promise<IShareOptionsResponseData>;
-export declare const submitShareAction: (data: ISubmitShareActionRequestData) => Promise<ISubmitShareActionResponseData>;

package/dist/api/publicRequest.d.ts

@@ -1,9 +0,0 @@
-import { AxiosInstance } from 'axios';
-export declare const setAxiosHeader: (key: string, value: string | number) => void;
-interface IPublicRequest extends AxiosInstance {
-    setBaseUrl: (baseUrl: string) => void;
-    setGuestToken: (guestToken: string) => void;
-}
-export declare const publicRequest: IPublicRequest;
-export declare const setBaseUrl: (baseUrl: string) => void;
-export {};

package/dist/api/resale.d.ts

@@ -1,5 +0,0 @@
-import { AxiosResponse } from 'axios';
-export declare const resaleTicket: (data: FormData, hash: string) => Promise<IResaleTicketResponse>;
-export declare const removeFromResale: (hash: string) => Promise<IRemoveFromResaleResponse>;
-export declare const processTicket: (hash: string) => Promise<AxiosResponse<any, any>>;
-export declare const declineInvitation: (hash: string) => Promise<AxiosResponse<any, any>>;

package/dist/components/account-settings/index.d.ts

@@ -1,3 +0,0 @@
-/// <reference types="react" />
-import './style.css';
-export declare const AccountSettings: () => JSX.Element;