export { E as EngineAuthResponse, b as EngineTransactionRequest, d as EngineTransactionResponse, a as EngineWalletBalance, O as OneEngineClient, g as OnrampQuote, f as OnrampSession, e as OnrampSessionRequest, h as OnrampTransaction, j as SwapExecuteRequest, i as SwapQuote, S as SwapQuoteRequest, k as SwapResult, c as createOneEngineClient } from '../engine-DSc1Em4V.js';
import * as _supabase_realtime_js from '@supabase/realtime-js';
import * as _supabase_postgrest_js from '@supabase/postgrest-js';
import * as _supabase_auth_js from '@supabase/auth-js';
import { SupabaseClient } from '@supabase/supabase-js';
export { F as ForexPoolDataGenerator, a as PairState, P as PriceService, f as forexSimulationEngine, p as priceService } from '../ForexPoolDataGenerator-B3DCN6_i.js';
export { a as BotLogEntry, B as BotLogType, c as BotState, I as IndicatorSnapshot, $ as STRATEGY_PERSONALITIES, S as StrategyPersonality, b as botSimulationEngine } from '../console-BoAIxikK.js';
import '../types/index.js';

declare function createSupabaseClient(url?: string, anonKey?: string): SupabaseClient;
declare function getSupabaseClient(): SupabaseClient;
declare class SupabaseService {
    private client;
    constructor(client?: SupabaseClient);
    signInWithEmail(email: string): Promise<{
        data: {
            user: null;
            session: null;
            messageId?: string | null;
        } | {
            user: null;
            session: null;
            messageId?: null | undefined;
        };
        error: _supabase_auth_js.AuthError | null;
    }>;
    verifyOtp(email: string, token: string): Promise<{
        data: {
            user: _supabase_auth_js.User | null;
            session: _supabase_auth_js.Session | null;
        } | {
            user: null;
            session: null;
        };
        error: _supabase_auth_js.AuthError | null;
    }>;
    signOut(): Promise<{
        error: _supabase_auth_js.AuthError | null;
    }>;
    getSession(): Promise<{
        session: _supabase_auth_js.Session | null;
        error: _supabase_auth_js.AuthError | null;
    }>;
    getUser(): Promise<{
        user: _supabase_auth_js.User | null;
        error: _supabase_auth_js.AuthError | null;
    }>;
    getUserProfile(userId: string): Promise<{
        data: any;
        error: _supabase_postgrest_js.PostgrestError | null;
    }>;
    updateUserProfile(userId: string, updates: Record<string, any>): Promise<{
        data: any;
        error: _supabase_postgrest_js.PostgrestError | null;
    }>;
    getTransactions(userId: string, limit?: number): Promise<{
        data: any[] | null;
        error: _supabase_postgrest_js.PostgrestError | null;
    }>;
    createTransaction(transaction: Record<string, any>): Promise<{
        data: any;
        error: _supabase_postgrest_js.PostgrestError | null;
    }>;
    getStrategies(status?: string): Promise<{
        data: any[] | null;
        error: _supabase_postgrest_js.PostgrestError | null;
    }>;
    getStrategyById(strategyId: string): Promise<{
        data: any;
        error: _supabase_postgrest_js.PostgrestError | null;
    }>;
    getUserOrders(userId: string): Promise<{
        data: any[] | null;
        error: _supabase_postgrest_js.PostgrestError | null;
    }>;
    createOrder(order: Record<string, any>): Promise<{
        data: any;
        error: _supabase_postgrest_js.PostgrestError | null;
    }>;
    getUserCards(userId: string): Promise<{
        data: any[] | null;
        error: _supabase_postgrest_js.PostgrestError | null;
    }>;
    subscribeToTransactions(userId: string, callback: (payload: any) => void): _supabase_realtime_js.RealtimeChannel;
    unsubscribe(channel: ReturnType<typeof this$1.client.channel>): Promise<"error" | "ok" | "timed out">;
}

/**
 * Usage Tracking Service
 * Tracks AI usage for Personal Assistant and Trading Agent
 */
type UsageCategory = 'wallet' | 'payment' | 'exchange_onramper' | 'exchange_swap' | 'ai_thirdweb' | 'ai_trading_engine';
type DisplayCategory = 'personal_assistant' | 'trading_agent';
interface UsageRecord {
    userId: string;
    category: UsageCategory;
    action: string;
    requestTokens?: number;
    responseTokens?: number;
    creditsUsed?: number;
    metadata?: Record<string, any>;
}
interface UsageSummary {
    personal_assistant: {
        requestCount: number;
        totalTokens: number;
        totalCredits: number;
    };
    trading_agent: {
        requestCount: number;
        totalTokens: number;
        totalCredits: number;
    };
}
interface UsageActivity {
    type: DisplayCategory;
    action: string;
    tokens: number;
    credits: number;
    timestamp: string;
}
interface UsageResponse {
    summary: UsageSummary;
    dailyBreakdown: Array<{
        date: string;
        personal_assistant: number;
        trading_agent: number;
    }>;
    recentActivity: UsageActivity[];
    period: {
        days: number;
        startDate: string;
        endDate: string;
    };
}
/**
 * Usage Tracking Service
 */
declare class UsageService {
    private baseUrl;
    private userId;
    constructor(baseUrl?: string);
    /**
     * Set the current user ID for tracking
     */
    setUserId(userId: string): void;
    /**
     * Record Personal Assistant usage (Thirdweb AI)
     */
    trackPersonalAssistant(action: string, tokens?: {
        request?: number;
        response?: number;
    }, credits?: number, metadata?: Record<string, any>): Promise<boolean>;
    /**
     * Record Trading Agent usage (Engine AI)
     */
    trackTradingAgent(action: string, credits?: number, metadata?: Record<string, any>): Promise<boolean>;
    /**
     * Record wallet operation usage
     */
    trackWallet(action: string, metadata?: Record<string, any>): Promise<boolean>;
    /**
     * Record payment usage
     */
    trackPayment(action: string, metadata?: Record<string, any>): Promise<boolean>;
    /**
     * Record exchange usage (onramper)
     */
    trackOnramper(action: string, metadata?: Record<string, any>): Promise<boolean>;
    /**
     * Record exchange usage (swap)
     */
    trackSwap(action: string, metadata?: Record<string, any>): Promise<boolean>;
    /**
     * Record any usage
     */
    recordUsage(record: UsageRecord): Promise<boolean>;
    /**
     * Get AI usage summary for current user
     */
    getAIUsage(days?: number): Promise<UsageResponse | null>;
}
declare function getUsageService(): UsageService;
declare function createUsageService(baseUrl?: string): UsageService;

export { type DisplayCategory, SupabaseService, type UsageActivity, type UsageCategory, type UsageRecord, type UsageResponse, UsageService, type UsageSummary, createSupabaseClient, createUsageService, getSupabaseClient, getUsageService };
