@doujins/payments-ui 0.0.0

package/dist/index.d.ts

@@ -0,0 +1,686 @@
+import React from 'react';
+import { StoreApi } from 'zustand';
+import { PublicKey } from '@solana/web3.js';
+import * as zustand_vanilla from 'zustand/vanilla';
+import * as _tanstack_react_query from '@tanstack/react-query';
+
+type AuthTokenProvider = (() => string | null | undefined) | (() => Promise<string | null | undefined>) | null | undefined;
+interface PaymentUserDetails {
+    userId?: string;
+    email?: string;
+    firstName?: string;
+    lastName?: string;
+    address1?: string;
+    address2?: string;
+    city?: string;
+    state?: string;
+    postalCode?: string;
+    country?: string;
+}
+interface PaymentEndpoints {
+    billingBaseUrl: string;
+    accountBaseUrl?: string;
+}
+interface PaymentFeatureFlags {
+    enableCardPayments?: boolean;
+    enableStoredMethods?: boolean;
+    enableSolanaPay?: boolean;
+    enableDirectWallet?: boolean;
+}
+interface PaymentCallbacks {
+    onStatusChange?: (payload: PaymentStatusPayload) => void;
+    onSuccess?: (payload: PaymentSuccessPayload) => void;
+    onError?: (error: Error | string) => void;
+}
+interface PaymentStatusPayload {
+    status: 'idle' | 'collecting' | 'processing' | 'pending' | 'success' | 'error';
+    context?: Record<string, unknown>;
+}
+interface PaymentSuccessPayload {
+    intentId?: string;
+    transactionId?: string;
+    processor?: string;
+    metadata?: Record<string, unknown>;
+}
+type PaymentFetcher = (input: RequestInfo, init?: RequestInit) => Promise<Response>;
+interface PaymentConfig {
+    endpoints: PaymentEndpoints;
+    getAuthToken?: AuthTokenProvider;
+    fetcher?: PaymentFetcher;
+    defaultHeaders?: Record<string, string>;
+    features?: PaymentFeatureFlags;
+    defaultUser?: PaymentUserDetails;
+    callbacks?: PaymentCallbacks;
+    collectJsKey?: string;
+    solanaRpcUrl?: string;
+}
+
+interface BillingDetails {
+    firstName: string;
+    lastName: string;
+    address1: string;
+    address2?: string;
+    city: string;
+    stateRegion?: string;
+    postalCode: string;
+    country: string;
+    email: string;
+    provider?: string;
+}
+interface PaymentMethod {
+    id: string;
+    card_type?: string;
+    last_four?: string;
+    is_active?: boolean;
+    failure_reason?: string | null;
+    created_at?: string;
+}
+interface CreatePaymentMethodPayload {
+    payment_token: string;
+    first_name: string;
+    last_name: string;
+    address1: string;
+    address2?: string;
+    city: string;
+    state?: string;
+    zip: string;
+    country: string;
+    email: string;
+    provider?: string;
+}
+interface PaginatedPaymentMethods {
+    data: PaymentMethod[];
+    total?: number;
+    next_page?: number | null;
+}
+
+interface GeneratePaymentRequest {
+    price_id: string;
+    token: string;
+    user_wallet: string;
+}
+interface GeneratePaymentResponse {
+    transaction: string;
+    amount: number;
+    currency: string;
+    token_amount: number;
+    token_symbol: string;
+    expires_at: number;
+    instructions: string;
+    intent_id: string;
+}
+interface SubmitPaymentRequest {
+    signed_transaction: string;
+    price_id: string;
+    intent_id: string;
+    memo?: string;
+}
+interface SubmitPaymentResponse {
+    purchase_id: string;
+    transaction_id: string;
+    status: 'confirmed' | 'pending' | 'failed';
+    amount: number;
+    currency: string;
+    processed_at: string;
+    message: string;
+    intent_id: string;
+}
+interface PaymentStatusResponse {
+    purchase_id: string;
+    transaction_id: string;
+    status: 'confirmed' | 'pending' | 'failed';
+    amount: number;
+    currency: string;
+    created_at: string;
+    confirmed_at?: string;
+}
+interface SolanaPayQRCodeIntent {
+    url: string;
+    amount: number;
+    token_amount: string;
+    token_symbol: string;
+    label: string;
+    message: string;
+    expires_at: number;
+    reference: string;
+    intent_id: string;
+}
+interface SolanaPayStatusResponse {
+    status: 'confirmed' | 'pending' | 'failed';
+    payment_id: string;
+    transaction?: string | null;
+    error_message?: string;
+    intent_id?: string;
+}
+interface SupportedTokensResponse {
+    tokens: TokenInfo[];
+}
+interface TokenInfo {
+    name: string;
+    mint: string;
+    symbol: string;
+    decimals: number;
+    price: number;
+    is_native?: boolean;
+}
+interface PaymentState {
+    step: PaymentStep;
+    selectedToken: TokenInfo | null;
+    amount: number;
+    tokenAmount: string;
+    transaction: string | null;
+    transactionId: string | null;
+    intentId: string | null;
+    error: string | null;
+    isLoading: boolean;
+    expiresAt: number | null;
+    instructions?: string;
+}
+type PaymentStep = 'select-token' | 'review-payment' | 'sign-transaction' | 'submitting' | 'confirming' | 'success' | 'error';
+interface TokenBalance {
+    token: TokenInfo;
+    balance: number;
+    uiAmount: number;
+    hasBalance: boolean;
+}
+interface PaymentError {
+    code: string;
+    message: string;
+    details?: string;
+    retryable: boolean;
+}
+interface SolanaFlowConfig {
+    priceId: string;
+    usdAmount: number;
+    supportedTokens: TokenInfo[];
+    userWallet: PublicKey;
+    onSuccess: (result: SubmitPaymentResponse) => void;
+    onError: (error: PaymentError) => void;
+    onCancel: () => void;
+}
+interface TransactionStatus {
+    signature: string;
+    confirmationStatus: 'processed' | 'confirmed' | 'finalized' | 'failed';
+    confirmations: number;
+    slot?: number;
+    blockTime?: number;
+    error?: string;
+}
+interface SolanaPayTransaction {
+    transaction: string;
+    message: string;
+    label?: string;
+    memo?: string;
+}
+type SolanaPaymentMethod = 'traditional' | 'solana-pay';
+interface PaymentMethodOption {
+    id: SolanaPaymentMethod;
+    name: string;
+    description: string;
+    icon: string;
+    enabled: boolean;
+    requiresWallet: boolean;
+}
+
+type PaymentPlatform = 'nmi' | 'ccbill';
+interface SubscriptionResponse {
+    success: boolean;
+    message?: string;
+    subscription_id?: string;
+    status?: 'active' | 'inactive' | 'cancelled';
+    url?: string;
+}
+interface FlexFormResponse {
+    iframe_url: string;
+    width: string;
+    height: string;
+    success_url: string;
+    decline_url: string;
+}
+interface GenerateFlexFormURLBodyParams {
+    price_id: string;
+    first_name: string;
+    last_name: string;
+    address1: string;
+    city: string;
+    state: string;
+    zip_code: string;
+    country: string;
+}
+interface NmiSubscribePayload {
+    priceId: string;
+    paymentToken?: string;
+    paymentMethodId?: string;
+    firstName?: string;
+    lastName?: string;
+    address1?: string;
+    city?: string;
+    state?: string;
+    zipCode?: string;
+    country?: string;
+    email?: string;
+    provider?: string;
+    processor?: string;
+}
+interface CCBillSubscribePayload {
+    priceId: string;
+    email: string;
+    firstName: string;
+    lastName: string;
+    zipCode: string;
+    country: string;
+    processor?: string;
+}
+interface SubscriptionCheckoutPayload {
+    priceId: string;
+    provider?: string;
+    processor?: string;
+    billing: BillingDetails;
+}
+
+type RequestOptions = {
+    params?: Record<string, string | number>;
+    query?: Record<string, string | number | undefined>;
+    body?: Record<string, unknown>;
+    headers?: Record<string, string>;
+};
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+interface ApiClient {
+    request: <T>(method: HttpMethod, path: string, options?: RequestOptions) => Promise<T>;
+    get: <T>(path: string, options?: Omit<RequestOptions, 'body'>) => Promise<T>;
+    post: <T>(path: string, options?: RequestOptions) => Promise<T>;
+    put: <T>(path: string, options?: RequestOptions) => Promise<T>;
+    patch: <T>(path: string, options?: RequestOptions) => Promise<T>;
+    delete: <T>(path: string, options?: RequestOptions) => Promise<T>;
+}
+
+interface CardTokenizeResult {
+    token: string;
+    billing: BillingDetails;
+}
+declare class CardPaymentService {
+    private config;
+    private collectLoaded;
+    constructor(config: PaymentConfig);
+    ensureCollectLoaded(): Promise<void>;
+    buildCreatePayload(result: CardTokenizeResult): CreatePaymentMethodPayload;
+}
+
+interface ListParams {
+    page?: number;
+    pageSize?: number;
+}
+declare class PaymentMethodService {
+    private api;
+    constructor(api: ApiClient);
+    list(params?: ListParams): Promise<PaginatedPaymentMethods>;
+    create(payload: CreatePaymentMethodPayload): Promise<PaymentMethod>;
+    remove(id: string): Promise<void>;
+    activate(id: string): Promise<void>;
+}
+
+declare class SolanaPaymentService {
+    private api;
+    constructor(api: ApiClient);
+    generatePayment(priceId: string, token: string, userWallet: string): Promise<GeneratePaymentResponse>;
+    submitPayment(signedTransaction: string, priceId: string, intentId: string, memo?: string): Promise<SubmitPaymentResponse>;
+    fetchSupportedTokens(): Promise<TokenInfo[]>;
+    getSupportedTokens(): Promise<TokenInfo[]>;
+    generateQrCode(priceId: string, token: string, userWallet?: string): Promise<SolanaPayQRCodeIntent>;
+    generateQRCode(priceId: string, token: string, userWallet?: string): Promise<SolanaPayQRCodeIntent>;
+    checkPaymentStatus(reference: string, memo?: string): Promise<SolanaPayStatusResponse>;
+}
+
+interface TokenCatalogOptions {
+    ttlMs?: number;
+}
+declare class TokenCatalog {
+    private solanaService;
+    private options;
+    private cache;
+    private lastFetched;
+    constructor(solanaService: SolanaPaymentService, options?: TokenCatalogOptions);
+    private get ttl();
+    getTokens(force?: boolean): Promise<TokenInfo[]>;
+    getCached(): TokenInfo[];
+}
+
+interface WalletAccount {
+    publicKey: string;
+}
+interface WalletAdapterLike {
+    publicKey?: {
+        toBase58(): string;
+    };
+    signTransaction?: (tx: unknown) => Promise<unknown>;
+    signVersionedTransaction?: (tx: unknown) => Promise<unknown>;
+}
+declare class WalletGateway {
+    private adapter;
+    setAdapter(adapter: WalletAdapterLike | null): void;
+    getPublicKey(): string | null;
+    sign(transaction: unknown): Promise<unknown>;
+}
+
+declare class SubscriptionService {
+    private readonly api;
+    constructor(api: ApiClient);
+    subscribe(platform: PaymentPlatform, payload: NmiSubscribePayload | CCBillSubscribePayload): Promise<SubscriptionResponse>;
+    generateFlexFormUrl(payload: GenerateFlexFormURLBodyParams): Promise<FlexFormResponse>;
+    private serializePayload;
+}
+
+interface PaymentServices {
+    cardPayments: CardPaymentService;
+    paymentMethods: PaymentMethodService;
+    solanaPayments: SolanaPaymentService;
+    tokenCatalog: TokenCatalog;
+    walletGateway: WalletGateway;
+    subscriptions: SubscriptionService;
+    billingApi: ApiClient;
+    accountApi: ApiClient;
+}
+interface PaymentAppOptions {
+    config: PaymentConfig;
+    fetcher?: PaymentFetcher;
+}
+declare class PaymentApp {
+    private readonly config;
+    private readonly fetcher;
+    private readonly services;
+    constructor(options: PaymentAppOptions);
+    getConfig(): PaymentConfig;
+    getFetcher(): PaymentFetcher;
+    getServices(): PaymentServices;
+    private createServices;
+    resolveAuthToken: () => Promise<string | null>;
+}
+
+type AsyncStatus = 'idle' | 'processing' | 'success' | 'error';
+type SolanaFlowState = 'selecting' | 'processing' | 'confirming' | 'success' | 'error';
+interface PaymentStoreState {
+    selectedMethodId: string | null;
+    solanaModalOpen: boolean;
+    savedPaymentStatus: AsyncStatus;
+    savedPaymentError: string | null;
+    newCardStatus: AsyncStatus;
+    newCardError: string | null;
+    solanaTab: 'wallet' | 'qr';
+    solanaStatus: SolanaFlowState;
+    solanaError: string | null;
+    solanaTransactionId: string | null;
+    solanaSelectedToken: string | null;
+    solanaTokenAmount: number;
+    setSelectedMethod: (methodId: string | null) => void;
+    setSolanaModalOpen: (open: boolean) => void;
+    setSolanaTab: (tab: 'wallet' | 'qr') => void;
+    setSolanaSelectedToken: (symbol: string) => void;
+    setSolanaTokenAmount: (amount: number) => void;
+    setSolanaTransactionId: (txId: string | null) => void;
+    startSavedPayment: () => void;
+    completeSavedPayment: () => void;
+    failSavedPayment: (error: string) => void;
+    resetSavedPayment: () => void;
+    startNewCardPayment: () => void;
+    completeNewCardPayment: () => void;
+    failNewCardPayment: (error: string) => void;
+    resetNewCardPayment: () => void;
+    startSolanaPayment: () => void;
+    confirmSolanaPayment: () => void;
+    completeSolanaPayment: (payload?: PaymentSuccessPayload) => void;
+    failSolanaPayment: (error: string) => void;
+    resetSolanaPayment: () => void;
+    resetAll: () => void;
+}
+interface PaymentStoreOptions {
+    callbacks?: PaymentCallbacks;
+}
+declare const createPaymentStore: (options?: PaymentStoreOptions) => zustand_vanilla.StoreApi<PaymentStoreState>;
+
+interface PaymentContextValue {
+    config: PaymentConfig;
+    fetcher: PaymentFetcher;
+    resolveAuthToken: () => Promise<string | null>;
+    app: PaymentApp;
+    services: PaymentServices;
+    store: StoreApi<PaymentStoreState>;
+}
+interface PaymentProviderProps {
+    config: PaymentConfig;
+    children: React.ReactNode;
+}
+declare const PaymentProvider: React.FC<PaymentProviderProps>;
+declare const usePaymentContext: () => PaymentContextValue;
+
+interface CardDetailsFormProps {
+    visible: boolean;
+    onTokenize: (token: string, billing: BillingDetails) => void;
+    submitLabel: string;
+    submitting?: boolean;
+    defaultValues?: Partial<BillingDetails>;
+    externalError?: string | null;
+    collectPrefix?: string;
+    className?: string;
+    onBillingChange?: (billing: BillingDetails) => void;
+    submitDisabled?: boolean;
+}
+declare const CardDetailsForm: React.FC<CardDetailsFormProps>;
+
+interface StoredPaymentMethodsProps {
+    selectedMethodId?: string | null;
+    onMethodSelect?: (method: PaymentMethod) => void;
+    showAddButton?: boolean;
+    heading?: string;
+    description?: string;
+}
+declare const StoredPaymentMethods: React.FC<StoredPaymentMethodsProps>;
+
+interface PaymentExperienceProps {
+    priceId: string;
+    usdAmount: number;
+    onNewCardPayment?: (payload: {
+        token: string;
+        billing: BillingDetails;
+    }) => Promise<void> | void;
+    onSavedMethodPayment?: (payload: {
+        paymentMethodId: string;
+        amount: number;
+    }) => Promise<void> | void;
+    enableNewCard?: boolean;
+    enableStoredMethods?: boolean;
+    enableSolanaPay?: boolean;
+    checkoutSummary?: React.ReactNode;
+    onSolanaSuccess?: (result: SubmitPaymentResponse | string) => void;
+    onSolanaError?: (error: string) => void;
+}
+declare const PaymentExperience: React.FC<PaymentExperienceProps>;
+
+interface SolanaPaymentSelectorProps {
+    isOpen: boolean;
+    priceId: string;
+    usdAmount: number;
+    onClose: () => void;
+    onError?: (error: string) => void;
+    onSuccess: (result: SubmitPaymentResponse | string) => void;
+}
+declare const SolanaPaymentSelector: React.FC<SolanaPaymentSelectorProps>;
+
+declare const usePaymentMethods: () => {
+    listQuery: _tanstack_react_query.UseQueryResult<PaginatedPaymentMethods, Error>;
+    createMutation: _tanstack_react_query.UseMutationResult<PaymentMethod, Error, {
+        token: string;
+        billing: BillingDetails;
+    }, unknown>;
+    deleteMutation: _tanstack_react_query.UseMutationResult<void, Error, {
+        id: string;
+    }, unknown>;
+};
+
+declare const usePaymentMethodService: () => PaymentMethodService;
+
+declare const useSupportedTokens: () => {
+    tokens: TokenInfo[];
+    isLoading: boolean;
+    error: string | null;
+    lastFetched: number | null;
+    fetchSupportedTokens: () => Promise<TokenInfo[]>;
+    refreshTokens: () => Promise<TokenInfo[]>;
+    getTokenBySymbol: (symbol: string) => TokenInfo | undefined;
+    getTokenByMint: (mintAddress: string) => TokenInfo | undefined;
+    isTokenSupported: (symbol: string) => boolean;
+    getUSDCToken: () => TokenInfo | undefined;
+    getPYUSDToken: () => TokenInfo | undefined;
+    getSOLToken: () => TokenInfo | undefined;
+    getStablecoins: () => TokenInfo[];
+    getTokenDisplayInfo: (token: TokenInfo) => {
+        displayName: string;
+        shortAddress: string;
+        decimalPlaces: number;
+        name: string;
+        mint: string;
+        symbol: string;
+        decimals: number;
+        price: number;
+        is_native?: boolean;
+    };
+    getTokenPrice: (symbol: string) => number;
+    calculateTokenAmount: (usdAmount: number, tokenSymbol: string) => string;
+    formatTokenAmount: (amount: string, tokenSymbol: string) => string;
+    isCacheStale: () => boolean;
+    hasTokens: boolean;
+    tokenCount: number;
+};
+
+declare const useTokenBalance: (tokens: TokenInfo[]) => {
+    balances: TokenBalance[];
+    positiveBalances: TokenBalance[];
+    isLoading: boolean;
+    error: string | null;
+    refreshBalances: () => Promise<void>;
+    getTokenBalance: (tokenSymbol: string) => TokenBalance | undefined;
+    hasSufficientBalance: (tokenSymbol: string, requiredAmount: number) => boolean;
+    getFormattedBalance: (tokenSymbol: string) => string;
+    getTotalValue: (priceData?: Record<string, number>) => number;
+    hasAnyBalance: boolean;
+    isConnected: boolean;
+};
+
+interface DirectPaymentState {
+    loading: boolean;
+    error: string | null;
+    success: boolean;
+    transactionId: string | null;
+}
+interface UseDirectWalletPaymentReturn {
+    paymentState: DirectPaymentState;
+    payWithWallet: (token: TokenInfo, priceId: string) => Promise<void>;
+    resetPayment: () => void;
+}
+declare const useDirectWalletPayment: () => UseDirectWalletPaymentReturn;
+
+interface PaymentStatusHookOptions {
+    transactionId?: string;
+    purchaseId?: string;
+    onConfirmed?: () => void;
+    onFailed?: (error: string) => void;
+    maxRetries?: number;
+    retryInterval?: number;
+}
+declare const usePaymentStatus: (options?: PaymentStatusHookOptions) => {
+    status: TransactionStatus | null;
+    paymentStatus: PaymentStatusResponse | null;
+    isLoading: boolean;
+    error: string | null;
+    retryCount: number;
+    maxRetries: number;
+    isMonitoring: boolean;
+    confirmationStatus: string;
+    startMonitoring: () => Promise<void>;
+    stopMonitoring: () => void;
+    checkStatus: () => Promise<void>;
+    getSolscanUrl: (signature?: string) => string | null;
+    isConfirmed: boolean;
+    isFailed: boolean;
+    isPending: boolean;
+};
+
+declare const usePaymentStore: <T>(selector: (state: PaymentStoreState) => T) => T;
+
+declare const useSolanaService: () => SolanaPaymentService;
+
+interface UseSolanaDirectPaymentOptions {
+    priceId: string;
+    tokenAmount: number;
+    selectedToken: TokenInfo | null;
+    supportedTokens: TokenInfo[];
+    onStart: () => void;
+    onConfirming: () => void;
+    onSuccess: (result: SubmitPaymentResponse, txId: string) => void;
+    onError: (error: string) => void;
+}
+interface SolanaDirectPaymentState {
+    isBalanceLoading: boolean;
+    isProcessing: boolean;
+    balanceLabel: string;
+    canPay: boolean;
+    pay: () => Promise<void>;
+}
+declare const useSolanaDirectPayment: (options: UseSolanaDirectPaymentOptions) => SolanaDirectPaymentState;
+
+interface UseSolanaQrPaymentOptions {
+    priceId: string;
+    selectedToken: TokenInfo | null;
+    onSuccess: (result: SubmitPaymentResponse | string, txId: string) => void;
+    onError: (error: string) => void;
+}
+interface UseSolanaQrPaymentState {
+    intent: SolanaPayQRCodeIntent | null;
+    qrDataUri: string | null;
+    isLoading: boolean;
+    error: string | null;
+    timeRemaining: number;
+    refresh: () => void;
+}
+declare const useSolanaQrPayment: (options: UseSolanaQrPaymentOptions) => UseSolanaQrPaymentState;
+
+interface SubscribeWithCardParams {
+    priceId?: string | null;
+    processor?: string;
+    provider?: string;
+    paymentToken: string;
+    billing: BillingDetails;
+}
+interface SubscribeWithSavedMethodParams {
+    priceId?: string | null;
+    processor?: string;
+    provider?: string;
+    paymentMethodId: string;
+    email?: string;
+}
+interface SubscribeWithCCBillParams {
+    priceId?: string | null;
+    email: string;
+    firstName: string;
+    lastName: string;
+    zipCode: string;
+    country: string;
+    processor?: string;
+}
+interface GenerateFlexFormParams {
+    priceId?: string | null;
+    firstName: string;
+    lastName: string;
+    address1: string;
+    city: string;
+    state: string;
+    zipCode: string;
+    country: string;
+}
+declare const useSubscriptionActions: () => {
+    subscribeWithCard: ({ priceId, processor, provider, paymentToken, billing, }: SubscribeWithCardParams) => Promise<SubscriptionResponse>;
+    subscribeWithSavedMethod: ({ priceId, processor, provider, paymentMethodId, email, }: SubscribeWithSavedMethodParams) => Promise<SubscriptionResponse>;
+    subscribeWithCCBill: ({ priceId, email, firstName, lastName, zipCode, country, processor, }: SubscribeWithCCBillParams) => Promise<SubscriptionResponse>;
+    generateFlexFormUrl: ({ priceId, firstName, lastName, address1, city, state, zipCode, country, }: GenerateFlexFormParams) => Promise<FlexFormResponse>;
+};
+
+export { type AsyncStatus, type AuthTokenProvider, type BillingDetails, type CCBillSubscribePayload, CardDetailsForm, type CardDetailsFormProps, CardPaymentService, type CardTokenizeResult, type CreatePaymentMethodPayload, type FlexFormResponse, type GenerateFlexFormParams, type GenerateFlexFormURLBodyParams, type GeneratePaymentRequest, type GeneratePaymentResponse, type ListParams, type NmiSubscribePayload, type PaginatedPaymentMethods, PaymentApp, type PaymentAppOptions, type PaymentCallbacks, type PaymentConfig, type PaymentContextValue, type PaymentEndpoints, type PaymentError, PaymentExperience, type PaymentExperienceProps, type PaymentFeatureFlags, type PaymentFetcher, type PaymentMethod, type PaymentMethodOption, PaymentMethodService, type PaymentPlatform, PaymentProvider, type PaymentProviderProps, type PaymentServices, type PaymentState, type PaymentStatusPayload, type PaymentStatusResponse, type PaymentStep, type PaymentStoreOptions, type PaymentStoreState, type PaymentSuccessPayload, type PaymentUserDetails, type SolanaFlowConfig, type SolanaFlowState, type SolanaPayQRCodeIntent, type SolanaPayStatusResponse, type SolanaPayTransaction, type SolanaPaymentMethod, SolanaPaymentSelector, SolanaPaymentService, StoredPaymentMethods, type StoredPaymentMethodsProps, type SubmitPaymentRequest, type SubmitPaymentResponse, type SubscribeWithCCBillParams, type SubscribeWithCardParams, type SubscribeWithSavedMethodParams, type SubscriptionCheckoutPayload, type SubscriptionResponse, SubscriptionService, type SupportedTokensResponse, type TokenBalance, TokenCatalog, type TokenCatalogOptions, type TokenInfo, type TransactionStatus, type WalletAccount, type WalletAdapterLike, WalletGateway, createPaymentStore, useDirectWalletPayment, usePaymentContext, usePaymentMethodService, usePaymentMethods, usePaymentStatus, usePaymentStore, useSolanaDirectPayment, useSolanaQrPayment, useSolanaService, useSubscriptionActions, useSupportedTokens, useTokenBalance };