import { PublicKey, Transaction, VersionedTransaction, Signer, Connection } from '@solana/web3.js'; import { Properties } from 'csstype'; import * as i0 from '@angular/core'; import { EventEmitter, ElementRef, OnDestroy, SimpleChanges, OnInit } from '@angular/core'; import { SafeResourceUrl, DomSanitizer } from '@angular/platform-browser'; import * as _coinflowlabs_angular from '@coinflowlabs/angular'; declare enum Currency { USD = "USD", AED = "AED", AFN = "AFN", ALL = "ALL", AMD = "AMD", ANG = "ANG", AOA = "AOA", ARS = "ARS", AUD = "AUD", AWG = "AWG", AZN = "AZN", BAM = "BAM", BBD = "BBD", BDT = "BDT", BGN = "BGN", BHD = "BHD", BIF = "BIF", BMD = "BMD", BND = "BND", BOB = "BOB", BRL = "BRL", BSD = "BSD", BTN = "BTN", BWP = "BWP", BYN = "BYN", BZD = "BZD", CAD = "CAD", CHF = "CHF", CLF = "CLF", CLP = "CLP", CNY = "CNY", COP = "COP", CRC = "CRC", CUP = "CUP", CVE = "CVE", CZK = "CZK", DJF = "DJF", DKK = "DKK", DOP = "DOP", DZD = "DZD", EGP = "EGP", ETB = "ETB", EUR = "EUR", FJD = "FJD", GBP = "GBP", GEL = "GEL", GHS = "GHS", GMD = "GMD", GNF = "GNF", GTQ = "GTQ", GYD = "GYD", HKD = "HKD", HNL = "HNL", HTG = "HTG", HUF = "HUF", IDR = "IDR", ILS = "ILS", INR = "INR", IQD = "IQD", IRR = "IRR", ISK = "ISK", JMD = "JMD", JOD = "JOD", JPY = "JPY", KES = "KES", KGS = "KGS", KHR = "KHR", KMF = "KMF", KRW = "KRW", KWD = "KWD", KYD = "KYD", KZT = "KZT", LAK = "LAK", LBP = "LBP", LKR = "LKR", LRD = "LRD", LSL = "LSL", LYD = "LYD", MAD = "MAD", MDL = "MDL", MGA = "MGA", MKD = "MKD", MMK = "MMK", MNT = "MNT", MOP = "MOP", MRU = "MRU", MUR = "MUR", MWK = "MWK", MVR = "MVR", MXN = "MXN", MYR = "MYR", MZN = "MZN", NAD = "NAD", NGN = "NGN", NIO = "NIO", NOK = "NOK", NPR = "NPR", NZD = "NZD", OMR = "OMR", PAB = "PAB", PEN = "PEN", PGK = "PGK", PHP = "PHP", PKR = "PKR", PLN = "PLN", PYG = "PYG", QAR = "QAR", RON = "RON", RSD = "RSD", RWF = "RWF", SAR = "SAR", SCR = "SCR", SDG = "SDG", SEK = "SEK", SGD = "SGD", SLE = "SLE", SLL = "SLL", SOS = "SOS", SRD = "SRD", STN = "STN", SVC = "SVC", SYP = "SYP", SZL = "SZL", THB = "THB", TJS = "TJS", TMT = "TMT", TND = "TND", TOP = "TOP", TRY = "TRY", TTD = "TTD", TWD = "TWD", TZS = "TZS", UAH = "UAH", UGX = "UGX", UYU = "UYU", UZS = "UZS", VND = "VND", VUV = "VUV", WST = "WST", XAF = "XAF", XCD = "XCD", XOF = "XOF", XPF = "XPF", YER = "YER", ZAR = "ZAR", ZMW = "ZMW", ZWL = "ZWL", CDF = "CDF", ERN = "ERN", FKP = "FKP", KPW = "KPW", RUB = "RUB", SBD = "SBD", SHP = "SHP", SSP = "SSP", VES = "VES" } declare const CurrencyToISO4217: Record; type WithdrawCurrency = Currency.USD | Currency.EUR | Currency.GBP | Currency.BRL | Currency.CAD; declare const WithdrawCurrencies: { readonly USD: Currency.USD; readonly EUR: Currency.EUR; readonly GBP: Currency.GBP; readonly BRL: Currency.BRL; readonly CAD: Currency.CAD; }; declare function isWithdrawCurrency(currency: Currency): currency is WithdrawCurrency; type BankingCurrency = Currency.USD | Currency.EUR | Currency.GBP | Currency.CAD | Currency.BRL; declare const BankingCurrencies: { readonly USD: Currency.USD; readonly EUR: Currency.EUR; readonly GBP: Currency.GBP; readonly CAD: Currency.CAD; readonly BRL: Currency.BRL; }; declare function isBankingCurrency(currency: Currency): currency is BankingCurrency; declare function getCurrencyDecimals(currency: Currency): number; interface Cents { /** * @isInt Cents must be an integer * @minimum 0 Minimum Cents is 0 */ cents: number; } interface CurrencyCents extends Cents { currency: Currency; } interface RemainingLimit extends CurrencyCents { type: 'single transaction' | 'daily' | 'monthly'; } interface TypedCurrencyCents extends Cents { currency: T; } declare function isTypedCurrencyCents(cents: CurrencyCents, currency: T): cents is TypedCurrencyCents; interface ExchangeRate { base: Currency; rate: number; to: T; } declare function invertRate(ex: { base: T; rate: number; to: Currency; }): ExchangeRate; interface TokenSubtotal { /** * The tokens address * * Solana - Token Mint Address * Evm - Token Contract Address */ address: string; /** * Number of tokens */ amount: number | string; /** * Number of decimals for the token */ decimals?: number; } type Subtotal = CurrencyCents | Cents | TokenSubtotal; /** * Address structure */ interface CartItemAddress { /** * Country code specified as a two letter code according to ISO 3166 Alpha-2 * Between 2 and 2 characters * Example: US * Pattern: ^[A-Z]{2}$ */ country?: string; /** * The state or province * Example: PA */ state?: string; /** * The city or locality * Example: Pittsburgh */ city?: string; /** * The street name * Example: Baker St */ street?: string; /** * The address postal code */ postalCode?: string; } /** * Phone information structure */ interface PhoneInfo { /** * The mobile carrier * Example: T-Mobile */ carrier?: string; /** * The country code (leading `+` is optional) * Example: 42 * Pattern: ^\+?[0-9]+$ */ countryCode: string; /** * The phone number without the country code or hyphens * Example: 2025550169 * Pattern: ^[0-9]+$ */ phone: string; } /** * Common currency amount structure */ interface CurrencyAmount { /** * The amount in the currency, which is specified in the `currency` property * Example: 90 */ valueInCurrency: number; /** * Currency specified as a three letter code according to ISO 4217 * Example: USD */ currency: string; } interface RecipientInfo { /** * The ID of the account that will receive the purchased goods */ accountId?: string; /** * Date of birth, formatted as YYYY-MM-DD. If only the year is known, use YYYY * Pattern: ^\d{4}(-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01]))?$ */ dob?: string; /** * Email * Example: lois.lane@dailyplanet.com */ email?: string | null; /** * First name * Example: Lois */ firstName?: string; /** * Gender * Example: female */ gender?: string; /** * Last name * Example: Lois */ lastName?: string; /** * The message that the recipient will receive */ message?: string; /** * A phone number descriptor */ phoneInfo?: PhoneInfo; /** * Shipping address */ shippingAddress?: CartItemAddress; /** * The crypto wallet that will receive the funds */ wallet?: { /** * The crypto wallet address that will receive the funds */ address: string; /** * The blockchain on which the transaction was made * Example: BTC * Pattern: ^[A-Z0-9-]+$ */ blockchain: string; /** * The type of the wallet * Allowed values: custodial, nonCustodial, unknown * Example: custodial */ custodialType: 'custodial' | 'nonCustodial' | 'unknown'; }; } interface SellerInfo { /** * Id of the seller */ id?: string; /** * Email * Example: lois.lane@dailyplanet.com */ email?: string | null; /** * First name * Example: Lois */ firstName?: string; /** * Last name * Example: Lois */ lastName?: string; /** * Date of birth, formatted as YYYY-MM-DD. If only the year is known, use YYYY * Pattern: ^\d{4}(-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01]))?$ */ dob?: string; /** * Additional raw data about the seller * Example: {"FeedbackCount":100,"FeedbackScore":99.5,"FirstSeenTimestamp":1731841819965,"LatestWithdrawal":3263,"OrderCount":101,"DisputeCount":2} */ rawSellerData?: Record; } interface GiftCardCartItem { itemClass: 'giftCard'; productType: 'giftCard'; /** * The cart items’s unique ID */ id: string; /** * The number of units sold */ quantity: number; /** * How the product was fulfilled. */ itemFulfillment: 'digital' | 'physical'; sellingPrice: { valueInCurrency: number; currency: string; }; /** * Any additional product data which can be provided, e.g. description, link to image, etc */ rawProductData?: Record; /** * The stock-keeping unit (SKU) number */ sku?: string; /** * The name of the brand */ brand?: string; /** * The category in the site/app in which the item was classified (e.g., fashion) */ categories?: string[]; listPrice?: { valueInCurrency: number; currency: string; }; isGift?: boolean; /** * The user's personal info */ recipientInfo?: RecipientInfo; /** * The item's selling price */ seller?: SellerInfo; /** * The expected delay in delivery, in hours */ expectedDeliveryDelay?: number; /** * Represents whether the item amount is taken from a preset list, e.g. 25, 50, 100, etc. or whether it was a different amount, e.g. 27 */ isPresetAmount?: boolean; } type AnyObject = { [key: string]: any; } & { example?: string; }; type TransactionHistoryItem = { txHash: string; blockNumber: number; txTime: string; assetID: string; registryContract: string; from: string; to: string; paymentToken: string; paymentAmount: string; chain: string; txType: string; }; type productType = 'inGameProduct' | 'gameOfSkill' | 'dataStorage' | 'computingResources' | 'sportsTicket' | 'eSportsTicket' | 'musicTicket' | 'conferenceTicket' | 'virtualSportsTicket' | 'virtualESportsTicket' | 'virtualMusicTicket' | 'virtualConferenceTicket' | 'alcohol' | 'DLC' | 'subscription' | 'fundACause' | 'realEstate' | 'computingContract' | 'digitalArt' | 'topUp' | 'ownershipContract' | 'inGameCurrency' | 'digitalCollectibles' | 'digitalCollectiblesMarketplace' | 'digitalGiftingMarketplace' | 'sweepstakes' | 'virtualSportsEvents' | 'contractInvoicing' | 'onlineCasino' | 'cryptoOnramp' | 'gaming' | 'travelDocuments' | 'musicStreaming' | 'digitalContent' | 'eBooks' | 'digitalSubscriptionContent'; /** * An nft cart item */ type nftCartItem = { /** * Denotes the cart item class. The item schema is chosen based on this value */ itemClass: 'nft'; /** * The name of the related product * * @minLength 1 */ productName: string; /** * The product type. Possible values include: inGameProduct, gameOfSkill, dataStorage, computingResources, sportsTicket, eSportsTicket, musicTicket, conferenceTicket, virtualSportsTicket, virtualESportsTicket, virtualMusicTicket, virtualConferenceTicket, alcohol, DLC, subscription, fundACause, realEstate, computingContract, digitalArt, topUp */ productType: productType; /** * The item's list price */ listPrice?: { /** * The amount in the currency, which is specified in the `currency` property */ valueInCurrency?: number; /** * Currency specified as a three letter code according to ISO 4217 */ currency?: string; }; /** * The item's list price */ sellingPrice: { /** * The amount in the currency, which is specified in the `currency` property */ valueInCurrency?: number; /** * Currency specified as a three-letter code according to ISO 4217 */ currency?: string; }; /** * The number of units sold */ quantity: number; /** * Any additional data that the store can provide on the product, e.g. description, link to image, etc. */ rawProductData?: AnyObject; seller?: SellerInfo; transactionHistory?: TransactionHistoryItem[]; }; declare namespace nftCartItem { /** * Denotes the cart item class. The item schema is chosen based on this value */ enum itemClass { NFT = "nft" } /** * The product type. Possible values include: inGameProduct, gameOfSkill, dataStorage, computingResources, sportsTicket, eSportsTicket, musicTicket, conferenceTicket, virtualSportsTicket, virtualESportsTicket, virtualMusicTicket, virtualConferenceTicket, alcohol, DLC, subscription, fundACause, realEstate, computingContract, digitalArt, topUp */ enum productType { IN_GAME_PRODUCT = "inGameProduct", GAME_OF_SKILL = "gameOfSkill", DATA_STORAGE = "dataStorage", COMPUTING_RESOURCES = "computingResources", SPORTS_TICKET = "sportsTicket", E_SPORTS_TICKET = "eSportsTicket", MUSIC_TICKET = "musicTicket", CONFERENCE_TICKET = "conferenceTicket", VIRTUAL_SPORTS_TICKET = "virtualSportsTicket", VIRTUAL_ESPORTS_TICKET = "virtualESportsTicket", VIRTUAL_MUSIC_TICKET = "virtualMusicTicket", VIRTUAL_CONFERENCE_TICKET = "virtualConferenceTicket", ALCOHOL = "alcohol", DLC = "DLC", SUBSCRIPTION = "subscription", FUND_ACAUSE = "fundACause", REAL_ESTATE = "realEstate", COMPUTING_CONTRACT = "computingContract", DIGITAL_ART = "digitalArt", TOP_UP = "topUp", OWNERSHIP_CONTRACT = "ownershipContract", IN_GAME_CURRENCY = "inGameCurrency", MONEY_TOP_UP_CART_ITEM = "moneyTopUpCartItem" } } /** * Represents a crypto item in a shopping cart */ interface CryptoCartItem { /** * Denotes the cart item class. The item schema is chosen based on this value. * Allowed value: crypto * Example: crypto */ itemClass: 'crypto'; /** * The cart items's unique ID * Example: 5de33332-546a-4171-8988-2a43d2bfe9c6 */ id?: string; /** * Any additional product data which can be provided, e.g. description, link to image, etc * Example: {"any":"data","description":"This is the product description"} */ rawProductData?: AnyObject; /** * The amount in the crypto currency which is specified in the `cryptoCurrency` property * Example: 1.04112 * Pattern: ^[0-9]+(\.[0-9]+)?$ */ units: string; /** * The crypto-currency symbol (uppercase) * Example: BTC * Pattern: ^[A-Z0-9-]+$ */ cryptoCurrency: string; /** * The price per 1 unit */ unitPrice: { /** * The amount in the currency, which is specified in the `currency` property * Example: 90 */ valueInCurrency: number; /** * Currency specified as a three letter code according to ISO 4217 * Example: USD */ currency: string; }; /** * The expected delay in delivery, in hours * Min value: 0 */ expectedDeliveryDelay?: number; /** * The user's personal info */ recipientInfo: RecipientInfo; /** * Seller info */ seller?: SellerInfo; } /** * Represents a money top-up item in a shopping cart */ interface MoneyTopUpCartItem { /** * Denotes the cart item class. The item schema is chosen based on this value. * Allowed value: moneyTopUp * Example: moneyTopUp */ itemClass: 'moneyTopUp'; /** * The cart items's unique ID * Example: 5de33332-546a-4171-8988-2a43d2bfe9c6 */ id?: string; /** * Any additional product data which can be provided, e.g. description, link to image, etc * Example: {"any":"data","description":"This is the product description"} */ rawProductData?: Record; /** * The item's selling price */ sellingPrice: CurrencyAmount; /** * The user's personal info */ recipientInfo?: RecipientInfo; /** * The item's topUp amount */ topUpAmount: CurrencyAmount; /** * Quantity * Example: 2 */ quantity: number; /** * Represents whether the item amount is taken from a preset list, e.g. 25, 50, 100, etc. * or whether it was a different amount, e.g. 27 */ isPresetAmount: boolean; } declare enum WithdrawCategory { USER = "user", BUSINESS = "business", FIRST_PARTY = "firstParty" } declare enum WithdrawSpeed { ASAP = "asap", SAME_DAY = "same_day", STANDARD = "standard", CARD = "card", IBAN = "iban", PIX = "pix", EFT = "eft", VENMO = "venmo", PAYPAL = "paypal", WIRE = "wire", INTERAC = "interac" } declare enum SettlementType { Credits = "Credits", USDC = "USDC", Bank = "Bank" } /** * Configuration for a single custom pay-in fee line item. * Pass via the `customPayInFees` field on `/checkout/link` or `/checkout/jwt-token`. */ interface PurchaseCustomPayInFee { lineItemLabel: string; fee: { isFixed: true; percent: null; currency: Currency; cents: number; } | { isFixed: false; percent: number; currency: null; cents: null; }; } /** * Configuration for zero authorization flow - controls saved payment method visibility. */ interface ZeroAuthSavedPaymentMethods { disableSavedPaymentMethods: boolean; } /** * Configuration for zero authorization flow - verify existing card mode. * Shows the "Verify Card" flow for a specific saved card. * The card token will be validated to ensure it belongs to the current user's wallet. * If the card doesn't belong to the user, falls back to "Add New Card" view. */ interface ZeroAuthVerifyCard { cardToken: string; } /** * Configuration for zero authorization flow. * The presence of this object indicates the checkout is in zero auth mode. * * Two mutually exclusive modes: * - Saved payment methods: `{ disableSavedPaymentMethods: boolean }` - show or hide saved methods * - Verify card: `{ cardToken: "token" }` - verify a specific saved card */ type ZeroAuthorizationConfig = ZeroAuthSavedPaymentMethods | ZeroAuthVerifyCard; declare function isZeroAuthVerifyCard(config: ZeroAuthorizationConfig): config is ZeroAuthVerifyCard; declare function isZeroAuthSavedPaymentMethods(config: ZeroAuthorizationConfig): config is ZeroAuthSavedPaymentMethods; declare enum MerchantStyle { Rounded = "rounded", Sharp = "sharp", Pill = "pill" } type MerchantTheme = { primary?: string; background?: string; cardBackground?: string; backgroundAccent?: string; backgroundAccent2?: string; textColor?: string; textColorAccent?: string; textColorAction?: string; ctaColor?: string; font?: string; style?: MerchantStyle; fontSize?: string; fontWeight?: string; cardNumberPlaceholder?: string; cvvPlaceholder?: string; expirationPlaceholder?: string; placeholderColor?: string; showCardIcon?: boolean; }; interface BaseCustomerInfo { verificationId?: string; displayName?: string; address?: string; city?: string; state?: string; zip?: string; country?: string; ip?: string; lat?: string; lng?: string; /** * Date of birth in YYYY-MM-DD format */ dob?: string; email?: string; } interface NameCustomerInfo extends BaseCustomerInfo { /** * @hidden */ name?: string; } interface SplitNameCustomerInfo extends BaseCustomerInfo { /** * @minLength 1 */ firstName: string; /** * @minLength 1 */ lastName: string; } type CustomerInfo = SplitNameCustomerInfo | NameCustomerInfo; /** Coinflow Types **/ type CoinflowBlockchain = 'solana' | 'eth' | 'polygon' | 'base' | 'arbitrum' | 'stellar' | 'monad' | 'tempo' | 'user'; type CoinflowEnvs = 'prod' | 'staging' | 'staging-live' | 'sandbox' | 'local'; interface CoinflowTypes { merchantId: string; env?: CoinflowEnvs; loaderBackground?: string; blockchain?: CoinflowBlockchain | undefined; handleHeightChange?: (height: string) => void; theme?: MerchantTheme; } type PartialBy = Omit & Partial>; type MergeWithOptionalDiff = Pick> & Pick> & Partial> & Partial>; type OnSuccessMethod = (args: { paymentId: string; hash?: string | undefined; } | string) => void | Promise; type AuthDeclinedWalletCallInfo = { title: string; code: string; action: string; message: string; total: string; }; type OnAuthDeclinedMethod = (args: AuthDeclinedWalletCallInfo) => void | Promise; /** Wallets **/ interface SolanaWallet { publicKey: PublicKey | null; signTransaction?: (transaction: T) => Promise; sendTransaction: (transaction: T) => Promise; signMessage?: (message: Uint8Array) => Promise; } type AccessList = Array<{ address: string; storageKeys: Array; }>; type AccessListish = AccessList | Array<[string, Array]> | Record>; type EthWallet = { address: string | null | undefined; sendTransaction: (transaction: { to: string; from?: string; nonce?: Bytes | bigint | string | number; gasLimit?: Bytes | bigint | string | number; gasPrice?: Bytes | bigint | string | number; data?: BytesLike; value?: Bytes | bigint | string | number; chainId?: number; type?: number; accessList?: AccessListish; maxPriorityFeePerGas?: Bytes | bigint | string | number; maxFeePerGas?: Bytes | bigint | string | number; customData?: Record; ccipReadEnabled?: boolean; }) => Promise<{ hash: string; }>; signMessage: (message: string) => Promise; }; interface StellarWallet { address: string | null; sendTransaction: (base64Xdr: string) => Promise; signTransaction: (base64Xdr: string) => Promise; signMessage: (message: string) => Promise; } /** History **/ interface CoinflowSolanaHistoryProps extends CoinflowTypes { wallet: SolanaWallet; connection: Connection; blockchain: 'solana'; } interface CoinflowSessionKeyHistoryProps extends CoinflowTypes { sessionKey: string; blockchain?: undefined; } interface CoinflowEvmHistoryProps extends CoinflowTypes { wallet: EthWallet; blockchain: 'eth' | 'polygon' | 'base' | 'arbitrum' | 'monad' | 'tempo'; } interface CoinflowEthHistoryProps extends CoinflowEvmHistoryProps { blockchain: 'eth'; } interface CoinflowPolygonHistoryProps extends CoinflowEvmHistoryProps { blockchain: 'polygon'; } interface CoinflowBaseHistoryProps extends CoinflowEvmHistoryProps { blockchain: 'base'; } interface CoinflowArbitrumHistoryProps extends CoinflowEvmHistoryProps { blockchain: 'arbitrum'; } interface CoinflowStellarHistoryProps extends CoinflowTypes { wallet: StellarWallet; blockchain: 'stellar'; } interface CoinflowMonadHistoryProps extends CoinflowEvmHistoryProps { blockchain: 'monad'; } interface CoinflowTempoHistoryProps extends CoinflowEvmHistoryProps { blockchain: 'tempo'; } type CoinflowHistoryProps = CoinflowSolanaHistoryProps | CoinflowPolygonHistoryProps | CoinflowEthHistoryProps | CoinflowBaseHistoryProps | CoinflowArbitrumHistoryProps | CoinflowStellarHistoryProps | CoinflowMonadHistoryProps | CoinflowTempoHistoryProps | CoinflowSessionKeyHistoryProps; type Bytes = ArrayLike; type BytesLike = Bytes | string; /** * Cart item details required for Coinflow Chargeback Protection. Required if the merchant uses chargeback protection. */ type CartClassOmitted = CartItemClassOmitted[]; type ChargebackProtectionData = CartClassOmitted; declare enum ChargebackProtectionAccountType { GUEST = "guest", PRIVATE = "private", BUSINESS = "business" } type CartItemClassOmitted = NftCartItemClassOmitted | Omit | CryptoCartItem | MoneyTopUpCartItem; type ChargebackProtectionItem = CartItemClassOmitted; type NftCartItemClassOmitted = Omit; type Cart = CartItem[]; type CartItem = Omit | Omit | CryptoCartItem | MoneyTopUpCartItem; declare enum ThreeDsChallengePreference { NoPreference = "NoPreference", Frictionless = "Frictionless", Challenge = "Challenge" } declare enum PaymentMethods { card = "card", ach = "ach", fasterPayments = "fasterPayments", sepa = "sepa", pix = "pix", usdc = "usdc", googlePay = "googlePay", applePay = "applePay", credits = "credits", crypto = "crypto", wire = "wire", cashApp = "cashApp", rain = "rain" } declare const paymentMethodLabels: Record; interface CoinflowCommonPaymentIntentProps extends Omit { paymentIntentId: string; onSuccess?: OnSuccessMethod; onAuthDeclined?: OnAuthDeclinedMethod; /** * If true, pre-checks the partial USDC payment checkbox when USDC balance is available. * If false or undefined, maintains default behavior (unchecked). */ partialUsdcChecked?: boolean; /** * The DeviceID gotten from the Coinflow SDK: * https://docs.coinflow.cash/guides/checkout/fraud-protection/chargeback-protection/implement-chargeback-protection#how-to-add-chargeback-protection * * nSureSDK.getDeviceId() */ deviceId?: string; /** * If rendering the Coinflow component within multiple nested iframes, all ancestors in the chain must be provided as a comma-separated list. * * Example: * Primary origin that will be interacting with the Coinflow iFrame: foo.com * Subsequent origins that will render foo.com: bar.com * The origin array would then be: [https://foo.com,https://bar.com] */ origins?: string[]; /** * End-user wallet used for wallet-authenticated payment-intent checkout flows. * * Required when the target payment intent type depends on a customer wallet * (for example: EVM/Solana/Stellar transaction intents or credits/USDC signing flows). * * The wallet implementation must match the active blockchain. */ wallet?: WalletTypes; blockchain?: 'solana' | 'eth' | 'polygon' | 'base' | 'arbitrum' | 'stellar' | 'monad'; } interface CoinflowCommonPurchaseProps extends CoinflowTypes { subtotal?: Subtotal; presentment?: Currency; onSuccess?: OnSuccessMethod; sessionKey?: string; onAuthDeclined?: OnAuthDeclinedMethod; webhookInfo?: { [key: string]: any; }; email?: string; chargebackProtectionData?: ChargebackProtectionData; chargebackProtectionAccountType?: ChargebackProtectionAccountType; planCode?: string; /** * The payment methods displayed on the UI. If omitted, all available payment methods will be displayed. */ allowedPaymentMethods?: PaymentMethods[]; customerInfo?: CustomerInfo; settlementType?: SettlementType; authOnly?: boolean; /** * @deprecated Use zeroAuthorizationConfig instead for more control over zero auth behavior. * Simple boolean flag for zero authorization mode. When true, defaults to showing saved payment methods. */ isZeroAuthorization?: boolean; /** * Configuration for zero authorization flow. Takes precedence over isZeroAuthorization if both are provided. * Use this to control whether saved payment methods are shown and to pre-select a specific card for verification. */ zeroAuthorizationConfig?: ZeroAuthorizationConfig; /** * If true, pre-checks the partial USDC payment checkbox when USDC balance is available. * If false or undefined, maintains default behavior (unchecked). */ partialUsdcChecked?: boolean; /** * The DeviceID gotten from the Coinflow SDK: * https://docs.coinflow.cash/guides/checkout/fraud-protection/chargeback-protection/implement-chargeback-protection#how-to-add-chargeback-protection * * nSureSDK.getDeviceId() */ deviceId?: string; jwtToken?: string; /** * Your company email address that the customer can contact. */ supportEmail?: string; /** * If rendering the Coinflow component within multiple nested iframes, all ancestors in the chain must be provided as a comma-separated list. * * Example: * Primary origin that will be interacting with the Coinflow iFrame: foo.com * Subsequent origins that will render foo.com: bar.com * The origin array would then be: [https://foo.com,https://bar.com] */ origins?: string[]; threeDsChallengePreference?: ThreeDsChallengePreference; destinationAuthKey?: string; accountFundingTransaction?: AccountFundingTransaction; } interface WithGeo { /** * End-user GPS coordinates for `BlockingRuleMethod.GEOLOCATION` enforcement. * Required only when the merchant has a geolocation rule configured. The * web build reads the browser Geolocation API directly; React Native hosts * must request the fix from the platform (e.g. `expo-location`, * `react-native-geolocation`) and forward the result here. */ userLocation?: { lat: number; lng: number; }; } /** * Used for Account Funding Transactions */ interface AccountFundingTransaction { /** * Recipient information for Account Funding Transactions (AFT). * Required when AFT is enabled and type requires it. */ recipientAftInfo?: RecipientAftInfo; } interface CoinflowSolanaPurchaseProps extends CoinflowCommonPurchaseProps { wallet: SolanaWallet; transaction?: Transaction | VersionedTransaction; partialSigners?: Signer[]; debugTx?: boolean; connection: Connection; blockchain: 'solana'; rent?: { lamports: string | number; }; nativeSolToConvert?: { lamports: string | number; }; redemptionCheck?: boolean; } interface CoinflowSessionKeyPurchaseProps extends CoinflowCommonPurchaseProps { sessionKey: string; wallet?: undefined; blockchain?: CoinflowBlockchain | undefined; } interface CoinflowEvmPurchaseProps extends CoinflowCommonPurchaseProps { transaction?: EvmTransactionData; wallet: EthWallet; } interface CoinflowPolygonPurchaseProps extends CoinflowEvmPurchaseProps { blockchain: 'polygon'; } interface CoinflowEthPurchaseProps extends CoinflowEvmPurchaseProps { blockchain: 'eth'; } interface CoinflowBasePurchaseProps extends CoinflowEvmPurchaseProps { blockchain: 'base'; } interface CoinflowArbitrumPurchaseProps extends CoinflowEvmPurchaseProps { blockchain: 'arbitrum'; } interface CoinflowStellarPurchaseProps extends CoinflowCommonPurchaseProps { wallet: StellarWallet; transaction?: string; blockchain: 'stellar'; } interface CoinflowMonadPurchaseProps extends CoinflowEvmPurchaseProps { blockchain: 'monad'; } interface CoinflowTempoPurchaseProps extends CoinflowEvmPurchaseProps { blockchain: 'tempo'; } type CoinflowPurchaseProps = CoinflowSolanaPurchaseProps | CoinflowSessionKeyPurchaseProps | CoinflowPolygonPurchaseProps | CoinflowEthPurchaseProps | CoinflowBasePurchaseProps | CoinflowArbitrumPurchaseProps | CoinflowStellarPurchaseProps | CoinflowMonadPurchaseProps | CoinflowTempoPurchaseProps; /** Withdraw **/ interface CoinflowCommonWithdrawProps extends CoinflowTypes { onSuccess?: OnSuccessMethod; tokens?: string[]; lockDefaultToken?: boolean; amount?: number; email?: string; bankAccountLinkRedirect?: string; additionalWallets?: { wallet: string; blockchain: 'solana' | 'eth' | 'polygon' | 'base' | 'arbitrum' | 'monad' | 'tempo' | 'stellar'; }[]; lockAmount?: boolean; transactionSigner?: string; /** * If rendering the Coinflow component within multiple nested iframes, all ancestors in the chain must be provided as a comma-separated list. * * Example: * Primary origin that will be interacting with the Coinflow iFrame: foo.com * Subsequent origins that will render foo.com: bar.com * The origin array would then be: [https://foo.com,https://bar.com] */ origins?: string[]; /** * If the withdrawer is authenticated with a sessionKey pass it here. */ sessionKey?: string; /** * Array of allowed withdrawal speeds. If not provided, all speeds are allowed. */ allowedWithdrawSpeeds?: WithdrawSpeed[]; /** * End-user GPS coordinates for `BlockingRuleMethod.GEOLOCATION` enforcement. * Required only when the merchant has a geolocation rule configured. The * web build reads the browser Geolocation API directly; React Native hosts * must request the fix from the platform (e.g. `expo-location`, * `react-native-geolocation`) and forward the result here. */ userLocation?: { lat: number; lng: number; }; } type WalletTypes = SolanaWallet | EthWallet | StellarWallet; interface SolanaWalletProps { wallet: SolanaWallet; connection: Connection; blockchain: 'solana'; } type CoinflowSolanaWithdrawProps = CoinflowCommonWithdrawProps & SolanaWalletProps; interface EvmWalletProps { wallet: EthWallet; usePermit?: boolean; } type CoinflowEvmWithdrawProps = CoinflowCommonWithdrawProps & EvmWalletProps; interface EthWalletProps { blockchain: 'eth'; } type CoinflowEthWithdrawProps = CoinflowEvmWithdrawProps & EthWalletProps; interface PolygonWalletProps { blockchain: 'polygon'; } type CoinflowPolygonWithdrawProps = CoinflowEvmWithdrawProps & PolygonWalletProps; interface BaseWalletProps { blockchain: 'base'; } type CoinflowBaseWithdrawProps = CoinflowEvmWithdrawProps & BaseWalletProps; interface ArbitrumWalletProps { blockchain: 'arbitrum'; } type CoinflowArbitrumWithdrawProps = CoinflowEvmWithdrawProps & ArbitrumWalletProps; interface StellarWalletProps { wallet: StellarWallet; blockchain: 'stellar'; } type CoinflowStellarWithdrawProps = CoinflowCommonWithdrawProps & StellarWalletProps; interface MonadWalletProps { blockchain: 'monad'; } type CoinflowMonadWithdrawProps = CoinflowEvmWithdrawProps & MonadWalletProps; interface TempoWalletProps { blockchain: 'tempo'; } type CoinflowTempoWithdrawProps = CoinflowEvmWithdrawProps & TempoWalletProps; type CoinflowWithdrawProps = CoinflowSolanaWithdrawProps | CoinflowEthWithdrawProps | CoinflowPolygonWithdrawProps | CoinflowBaseWithdrawProps | CoinflowArbitrumWithdrawProps | CoinflowStellarWithdrawProps | CoinflowMonadWithdrawProps | CoinflowTempoWithdrawProps; interface CommonEvmRedeem { /** * Whether the UI should wait * for the transaction to be sent and * the hash to be returned. */ waitForHash?: boolean; } /** * (EVM only) If your contract sends the item/service being purchased via a custom "receiver" field, then utilize this object. * * The coinflow contract calls the "to" contract, which transfers the NFT/item to the "receiver" address defined in the contract function arguments. */ interface NormalRedeem extends CommonEvmRedeem { /** * Transaction to be called. */ transaction: { /** * The merchant's whitelisted contract */ to: string; /** * The data to call this contract with, HEX encoded. * * The coinflow contract calls the "to" contract, contract pulls USDC from msg.sender, and transfers the NFT/item to the "receiver" address defined in the contract function arguments. */ data: string; }; } /** * (EVM only) If your know the ID of the NFT being purchased, then utilize this object. * * The contract transfers the NFT to msg.sender (which is the Coinflow contract), the Coinflow contract fwd's the NFT to the end user's wallet. */ interface KnownTokenIdRedeem extends NormalRedeem { /** * The address of the Nft's Contract * * @minLength 42 Please provide a valid EVM Address (42 Characters Long) * @maxLength 42 Please provide a valid EVM Address (42 Characters Long) */ nftContract: string; /** * The ID of the NFT being purchased. Will be forwarded by the Coinflow contract to the customer's wallet. * * @minLength 1 Please provide a valid Nft Id */ nftId: string; } /** * (EVM only) If your contract mints an NFT via a OpenZeppelin Safe Mint Call, then utilize this object. * * The contract mints the NFT to msg.sender (which is the Coinflow contract), the Coinflow contract picks up the SafeMint event, and fwd's the NFT to the end user's wallet. */ interface SafeMintRedeem extends NormalRedeem { type: 'safeMint'; nftContract?: string; } /** * (EVM only) If your contract returns the NFT ID, then utilize this object. * * The contract mints the NFT to msg.sender (which is the Coinflow contract), the Coinflow contract picks up the returned NFT ID, and fwd's the NFT to the end user's wallet. */ interface ReturnedTokenIdRedeem extends NormalRedeem { type: 'returned'; nftContract?: string; } interface TokenRedeem extends CommonEvmRedeem { type: 'token'; destination: string; } /** * If your contract exists on a chain supported by Decent, pass this object in order to call it. */ interface DecentRedeem extends CommonEvmRedeem { type: 'decent'; /** * ID of the destination chain you will be using * Find your chain ID here: https://chainlist.org/ */ dstChainId: number; /** * Address on that chain of the token you will be receiving */ dstToken: string; /** * The contract address which will be called on the destination chain */ contractAddress: string; contractData: string; /** * Amount of the token on the destination chain you will be receiving */ cost: { /** * This is the raw amount of the token * ex: 50000000000000n */ amount: string; /** * Whether or not the token is the native token for the chain (ex: Ethereum - ETH, Polygon - POL). * If native dstToken should be the 0 address (0x00...) */ isNative: boolean; }; } /** * (EVM only) if you want to execute an EVM transaction on a successful purchase, you can pass a transaction request here. * * Gas fees for the transaction will be automatically calculated and added to the total charged to the customer. Optionally the merchant can opt to pay for these gas fees. */ type EvmTransactionData = SafeMintRedeem | ReturnedTokenIdRedeem | KnownTokenIdRedeem | NormalRedeem | TokenRedeem | DecentRedeem; interface CoinflowIFrameProps extends Omit, Pick, Pick, Pick, Pick, WithGeo { walletPubkey: string | null | undefined; sessionKey?: string; route: string; routePrefix?: string; transaction?: string; tokens?: string[] | PublicKey[]; merchantCss?: string; color?: 'white' | 'black'; disableApplePay?: boolean; disableGooglePay?: boolean; theme?: MerchantTheme; usePermit?: boolean; handleHeightChangeId: string | number; } interface CoinflowIntentsIFrameProps { theme?: MerchantTheme; merchantCss?: string; color?: 'white' | 'black'; intentId: string; route: string; routePrefix?: string; handleHeightChangeId: string | number; env?: CoinflowEnvs; loaderBackground?: string; handleHeightChange?: (height: string) => void; origins?: string[]; deviceId?: string; walletPubkey?: string | undefined | null; blockchain?: 'solana' | 'eth' | 'polygon' | 'base' | 'arbitrum' | 'stellar' | 'monad'; } declare enum CardType { VISA = "VISA", MASTERCARD = "MSTR", AMEX = "AMEX", DISCOVER = "DISC" } interface RecipientAftInfo { /** * @minLength 2 */ firstName: string; /** * @minLength 2 */ lastName: string; /** * @minLength 2 */ address1: string; /** * @minLength 2 */ city: string; /** * @minLength 2 */ postalCode: string; /** * @minLength 2 */ state?: string; /** * @minLength 2 * @maxLength 2 */ countryCode: string; /** * Recipients Date Of Birth in YYYMMDD format. * @pattern ^\d{8}$ */ dateOfBirth?: string; /** * @pattern ^\d+$ */ phoneNumber?: string; documentReference?: string; } declare const RN_REDIRECT_MESSAGE_NAME = "rnredirect"; declare class CoinflowUtils { env: CoinflowEnvs; url: string; constructor(env?: CoinflowEnvs); getNSurePartnerId(merchantId: string): Promise; static getCoinflowBaseUrl(env?: CoinflowEnvs): string; static getCoinflowAppBaseUrl(env?: CoinflowEnvs): string; static getCoinflowApiUrl(env?: CoinflowEnvs): string; static getCoinflowUrl({ walletPubkey, sessionKey, route, routePrefix, env, subtotal, presentment, transaction, blockchain, webhookInfo, email, loaderBackground, handleHeightChangeId, bankAccountLinkRedirect, additionalWallets, chargebackProtectionData, chargebackProtectionAccountType, merchantCss, color, rent, lockDefaultToken, tokens, planCode, disableApplePay, disableGooglePay, customerInfo, settlementType, lockAmount, nativeSolToConvert, theme, usePermit, transactionSigner, authOnly, deviceId, jwtToken, origins, threeDsChallengePreference, supportEmail, destinationAuthKey, allowedPaymentMethods, accountFundingTransaction, partialUsdcChecked, redemptionCheck, allowedWithdrawSpeeds, isZeroAuthorization, zeroAuthorizationConfig, userLocation, baseUrl, }: CoinflowIFrameProps & { baseUrl?: string; } & WithGeo): string; static getCoinflowIntentsUrl({ baseUrl, route, color, theme, env, origins, deviceId, merchantCss, loaderBackground, handleHeightChangeId, }: CoinflowIntentsIFrameProps & { baseUrl?: string; }): string; static getTransaction(props: CoinflowPurchaseProps): string | undefined; static byBlockchain(blockchain: CoinflowBlockchain, args: { solana: T; eth: T; polygon: T; base: T; arbitrum: T; stellar: T; monad: T; tempo: T; user: T; }): T; } interface FullName { firstName: string; lastName: string; } declare function getCustomerName(info: CustomerInfo | undefined): FullName | undefined; declare function recordFrontendError({ event, error, env, merchantId, }: { event: string; error: any; env: CoinflowEnvs; merchantId?: string; }): void; type WalletCall = { method: IFrameMessageMethods; data: string; } | SuccessWalletCall; type SuccessWalletCall = { method: IFrameMessageMethods.Success; data: string; info: { paymentId: string; hash?: string; }; }; interface IFrameMessageHandlers { handleSendTransaction: (transaction: string) => Promise; handleSignMessage?: (message: string) => Promise; handleSignTransaction?: (transaction: string) => Promise; handleHeightChange?: (height: string) => void; onSuccess: OnSuccessMethod | undefined; onAuthDeclined: OnAuthDeclinedMethod | undefined; } declare enum IFrameMessageMethods { SignMessage = "signMessage", SignTransaction = "signTransaction", SendTransaction = "sendTransaction", HeightChange = "heightChange", Success = "success", AuthDeclined = "authDeclined", Loaded = "loaded", AccountLinked = "accountLinked", Redirect = "redirect" } declare function getWalletPubkey(input: Pick): string | null | undefined; declare function handleIFrameMessage(rawMessage: string, handlers: IFrameMessageHandlers, handleHeightChangeId: string | number): Promise | void; declare function getHandlers(props: Pick): Omit; type EventBusCallback = (event: Event) => void; declare class EventBus { static on(type: string, callback: EventBusCallback): void; static dispatch(type: string, data: any): void; static remove(type: string, callback: EventBusCallback): void; } declare const TokenExCardNumberIframeId = "tokenExCardNumber"; declare const TokenExCvvContainerID = "tokenExCardCvv"; interface TokenExIframe extends ReturnType { tokenize: () => Promise; } declare const CARD_TYPE_MAPPING: Record; interface TokenExIFrameConfiguration { origin: string; timestamp: string; tokenExID: string; tokenScheme: string; authenticationKey: string; pci: true; token?: string; use3DS?: boolean; threeDSMethodNotificationUrl?: string; } interface CardFormInputStyles { base: Properties | string; placeholder?: Properties | string; focus?: Properties | string; error?: Properties | string; } type CoinflowCardTokenResponse = { token: string; }; interface CoinflowCardNumberInputProps { env: CoinflowEnvs; css: CardFormInputStyles & { cvv: CardFormInputStyles; }; debug?: boolean; origins: string[]; font?: string; } interface CoinflowCvvOnlyInputProps { token: string; cardType: CardType; env: CoinflowEnvs; css: CardFormInputStyles & { cvv: CardFormInputStyles; }; debug?: boolean; origins: string[]; font?: string; } interface VersionDetail { threeDSMethodURL: string; acsStartProtocolVersion: string; acsEndProtocolVersion: string; threeDSServerStartVersion: string; threeDSServerEndVersion?: string; acsInfoInd: [string]; directoryServerID: string; dsStartProtocolVersion: string; dsEndProtocolVersion: string; dsIdentifier: string; threeDSServerTransID: string; } interface TokenizationResponse { cardType: string; cvvIncluded: true; firstSix: string; lastFour: string; referenceNumber: string; token: string; tokenHMAC: string; recommended3dsVersion?: Record; threeDSecureResponse?: VersionDetail[]; } type MerchantIdOrCheckoutJwt = { checkoutJwt: string; } | { merchantId: string; }; interface CommonDoInitializeTokenExIframeArgs { css: string; debug?: boolean; font?: string; origins: string[]; tokenExScriptLoaded: boolean; env: CoinflowEnvs; setCachedToken: (s: string | undefined) => void; setLoaded: (b: boolean) => void; } type DoInitializeTokenExIframeArgs = CommonDoInitializeTokenExIframeArgs & MerchantIdOrCheckoutJwt; type DoInitializeCvvOnlyTokenExIframeArgs = DoInitializeTokenExIframeArgs & { token: string; cardType: CardType; }; type GetIFrameConfigArgs = { token?: string; origins: string[]; env: CoinflowEnvs; } & MerchantIdOrCheckoutJwt; declare function getIframeConfig(args: GetIFrameConfigArgs): Promise; declare function setTokenExScriptTag({ env, setTokenExScriptLoaded, }: { env: CoinflowEnvs; setTokenExScriptLoaded: (b: boolean) => void; }): void; declare function doInitializeCvvOnlyTokenExIframe(args: DoInitializeCvvOnlyTokenExIframeArgs): Promise; declare function doInitializeTokenExIframe(args: DoInitializeTokenExIframeArgs): Promise; declare function doInitializeTokenExCardOnlyIframe(args: DoInitializeTokenExIframeArgs): Promise; declare const DEVICE_ID_HEADER = "x-device-id"; declare const SESSION_ID_HEADER = "x-session-id"; declare const REFERRER_HEADER = "x-coinflow-referrer"; type CoinflowProtectionHeadersType = { [DEVICE_ID_HEADER]: string | null; [SESSION_ID_HEADER]: string | null; }; declare function getCoinflowProtectionHeaders(): CoinflowProtectionHeadersType; type CoinflowPurchaseHeadersType = CoinflowProtectionHeadersType & { [REFERRER_HEADER]: string | null; }; declare function getCoinflowPurchaseHeaders(): CoinflowPurchaseHeadersType; declare function initCoinflowProtection({ coinflowEnv, merchantId, }: { coinflowEnv: CoinflowEnvs; merchantId: string; }): Promise; declare class CoinflowIFrameComponent { private sanitizer; iframeProps: CoinflowIFrameProps; messageHandlers: IFrameMessageHandlers; onLoad?: () => void | Promise; waitForLoadedMessage?: boolean; messageEvent: EventEmitter; dynamicUrl?: SafeResourceUrl; iframe?: ElementRef; private isLoading; constructor(sanitizer: DomSanitizer); ngOnInit(): void; onPostMessage(event: any): void; sendMessage(message: string): void; handleIframeLoad(): void; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵcmp: i0.ɵɵComponentDeclaration; } declare class CoinflowPurchaseComponent { purchaseProps: CoinflowPurchaseProps & WithOnLoad; iframeProps?: CoinflowIFrameProps; messageHandlers?: IFrameMessageHandlers; ngOnInit(): void; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵcmp: i0.ɵɵComponentDeclaration; } declare class CoinflowPurchaseHistoryComponent { static ɵfac: i0.ɵɵFactoryDeclaration; static ɵcmp: i0.ɵɵComponentDeclaration; } declare class CoinflowPurchaseProtectionComponent { static ɵfac: i0.ɵɵFactoryDeclaration; static ɵcmp: i0.ɵɵComponentDeclaration; } declare class CoinflowWithdrawComponent { withdrawProps: CoinflowWithdrawProps & WithOnLoad; iframeProps?: CoinflowIFrameProps; messageHandlers?: IFrameMessageHandlers; ngOnInit(): void; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵcmp: i0.ɵɵComponentDeclaration; } declare class CoinflowWithdrawHistoryComponent { static ɵfac: i0.ɵɵFactoryDeclaration; static ɵcmp: i0.ɵɵComponentDeclaration; } declare class CoinflowCardNumberInput implements OnDestroy { private cardFormService; args: CoinflowCardNumberInputProps & MerchantIdOrCheckoutJwt; private iframe; private onScriptLoaded; private initializeTokenEx; reinitialize(): void; ngOnInit(): void; ngOnDestroy(): void; tokenize(): Promise<_coinflowlabs_angular.TokenizationResponse>; protected readonly TokenExCardNumberIframeId = "tokenExCardNumber"; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵcmp: i0.ɵɵComponentDeclaration; } declare class CoinflowCardNumberOnlyInput implements OnDestroy { private cardFormService; args: CoinflowCardNumberInputProps & MerchantIdOrCheckoutJwt; private iframe; private onScriptLoaded; private initializeTokenEx; reinitialize(): void; ngOnInit(): void; ngOnDestroy(): void; tokenize(): Promise<_coinflowlabs_angular.TokenizationResponse>; protected readonly TokenExCardNumberIframeId = "tokenExCardNumber"; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵcmp: i0.ɵɵComponentDeclaration; } declare class CoinflowCvvInputComponent { protected readonly TokenExCvvContainerID = "tokenExCardCvv"; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵcmp: i0.ɵɵComponentDeclaration; } declare class CoinflowCvvOnlyInputComponent implements OnDestroy { private cardFormService; args: CoinflowCvvOnlyInputProps & MerchantIdOrCheckoutJwt; private iframe; private onScriptLoaded; private cleanup; private initializeTokenEx; ngOnChanges(changes: SimpleChanges): void; reinitialize(): void; ngOnInit(): void; ngOnDestroy(): void; tokenize(): Promise<_coinflowlabs_angular.TokenizationResponse>; protected readonly TokenExCvvContainerID = "tokenExCardCvv"; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵcmp: i0.ɵɵComponentDeclaration; } interface CardFormArgs { merchantId: string; env?: CoinflowEnvs; theme?: MerchantTheme; variant: 'card-form' | 'card-number-form' | 'cvv-form'; token?: string; onLoad?: () => void; } interface CardFormTokenResponse { token: string; expMonth?: string; expYear?: string; } declare class CoinflowCardForm implements OnInit { private sanitizer; args: CardFormArgs; iframeRef: ElementRef; url?: SafeResourceUrl; loaded: boolean; iframeHeight: number | null; constructor(sanitizer: DomSanitizer); ngOnInit(): void; onMessage(event: MessageEvent): void; private buildUrl; private handleMessage; tokenize(): Promise; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵcmp: i0.ɵɵComponentDeclaration; } /** @deprecated Use CoinflowCardForm instead */ declare const CoinflowCardFormV2: typeof CoinflowCardForm; declare class CoinflowApplePayButtonComponent { purchaseProps: CoinflowPurchaseProps & { color: 'white' | 'black'; onError?: (message: string) => void; }; fill(): "#000" | "#FFF"; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵcmp: i0.ɵɵComponentDeclaration; } declare class CoinflowGooglePayButtonComponent { purchaseProps: CoinflowPurchaseProps & { color: 'white' | 'black'; onError?: (message: string) => void; }; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵcmp: i0.ɵɵComponentDeclaration; } type WithOnLoad = { onLoad?: () => void | Promise; }; export { BankingCurrencies, CARD_TYPE_MAPPING, CardType, ChargebackProtectionAccountType, CoinflowApplePayButtonComponent, CoinflowCardForm, CoinflowCardFormV2, CoinflowCardNumberInput, CoinflowCardNumberOnlyInput, CoinflowCvvInputComponent, CoinflowCvvOnlyInputComponent, CoinflowGooglePayButtonComponent, CoinflowIFrameComponent, CoinflowPurchaseComponent, CoinflowPurchaseHistoryComponent, CoinflowPurchaseProtectionComponent, CoinflowUtils, CoinflowWithdrawComponent, CoinflowWithdrawHistoryComponent, Currency, CurrencyToISO4217, DEVICE_ID_HEADER, EventBus, IFrameMessageMethods, MerchantStyle, PaymentMethods, REFERRER_HEADER, RN_REDIRECT_MESSAGE_NAME, SESSION_ID_HEADER, SettlementType, ThreeDsChallengePreference, TokenExCardNumberIframeId, TokenExCvvContainerID, WithdrawCategory, WithdrawCurrencies, WithdrawSpeed, doInitializeCvvOnlyTokenExIframe, doInitializeTokenExCardOnlyIframe, doInitializeTokenExIframe, getCoinflowProtectionHeaders, getCoinflowPurchaseHeaders, getCurrencyDecimals, getCustomerName, getHandlers, getIframeConfig, getWalletPubkey, handleIFrameMessage, initCoinflowProtection, invertRate, isBankingCurrency, isTypedCurrencyCents, isWithdrawCurrency, isZeroAuthSavedPaymentMethods, isZeroAuthVerifyCard, nftCartItem, paymentMethodLabels, productType, recordFrontendError, setTokenExScriptTag }; export type { AccountFundingTransaction, AnyObject, ArbitrumWalletProps, AuthDeclinedWalletCallInfo, BankingCurrency, BaseWalletProps, CardFormArgs, CardFormInputStyles, CardFormTokenResponse, Cart, CartClassOmitted, CartItem, CartItemClassOmitted, Cents, ChargebackProtectionData, ChargebackProtectionItem, CoinflowArbitrumHistoryProps, CoinflowArbitrumPurchaseProps, CoinflowArbitrumWithdrawProps, CoinflowBaseHistoryProps, CoinflowBasePurchaseProps, CoinflowBaseWithdrawProps, CoinflowBlockchain, CoinflowCardNumberInputProps, CoinflowCardTokenResponse, CoinflowCommonPaymentIntentProps, CoinflowCommonPurchaseProps, CoinflowCommonWithdrawProps, CoinflowCvvOnlyInputProps, CoinflowEnvs, CoinflowEthHistoryProps, CoinflowEthPurchaseProps, CoinflowEthWithdrawProps, CoinflowEvmHistoryProps, CoinflowEvmPurchaseProps, CoinflowHistoryProps, CoinflowIFrameProps, CoinflowIntentsIFrameProps, CoinflowMonadHistoryProps, CoinflowMonadPurchaseProps, CoinflowMonadWithdrawProps, CoinflowPolygonHistoryProps, CoinflowPolygonPurchaseProps, CoinflowPolygonWithdrawProps, CoinflowProtectionHeadersType, CoinflowPurchaseHeadersType, CoinflowPurchaseProps, CoinflowSessionKeyHistoryProps, CoinflowSessionKeyPurchaseProps, CoinflowSolanaHistoryProps, CoinflowSolanaPurchaseProps, CoinflowSolanaWithdrawProps, CoinflowStellarHistoryProps, CoinflowStellarPurchaseProps, CoinflowStellarWithdrawProps, CoinflowTempoHistoryProps, CoinflowTempoPurchaseProps, CoinflowTempoWithdrawProps, CoinflowTypes, CoinflowWithdrawProps, CommonDoInitializeTokenExIframeArgs, CommonEvmRedeem, CryptoCartItem, CurrencyCents, CustomerInfo, DecentRedeem, DoInitializeCvvOnlyTokenExIframeArgs, DoInitializeTokenExIframeArgs, EthWallet, EthWalletProps, EventBusCallback, EvmTransactionData, ExchangeRate, FullName, GetIFrameConfigArgs, GiftCardCartItem, IFrameMessageHandlers, KnownTokenIdRedeem, MerchantIdOrCheckoutJwt, MerchantTheme, MergeWithOptionalDiff, MonadWalletProps, NameCustomerInfo, NftCartItemClassOmitted, NormalRedeem, OnAuthDeclinedMethod, OnSuccessMethod, PartialBy, PolygonWalletProps, PurchaseCustomPayInFee, RecipientAftInfo, RemainingLimit, ReturnedTokenIdRedeem, SafeMintRedeem, SolanaWallet, SolanaWalletProps, SplitNameCustomerInfo, StellarWallet, StellarWalletProps, Subtotal, TempoWalletProps, TokenExIFrameConfiguration, TokenExIframe, TokenRedeem, TokenSubtotal, TokenizationResponse, TypedCurrencyCents, VersionDetail, WalletCall, WalletTypes, WithGeo, WithOnLoad, WithdrawCurrency, ZeroAuthSavedPaymentMethods, ZeroAuthVerifyCard, ZeroAuthorizationConfig };