openoracle-sdk-js/dist/api/twitter-api.d.ts

OpenOracle Node.js SDK - Intelligent Oracle Routing with Multiple LLM Providers

import { OracleClient } from '../core/client';
import { OracleConfig } from '../core/config';
import { DataCategory, ConfidenceLevel } from '../types/enums';
import { OracleDataPoint, OraclePollData } from '../schemas/oracle-schemas';

export interface TwitterSearchOptions {
    query: string;
    maxResults?: number;
    tweetFields?: string[];
    userFields?: string[];
    expansions?: string[];
    startTime?: Date;
    endTime?: Date;
    lang?: string;
}
export interface TwitterUserMetrics {
    followersCount: number;
    followingCount: number;
    tweetCount: number;
    listedCount: number;
    verifiedType?: string;
    publicMetrics: {
        followers: number;
        following: number;
        tweets: number;
        listed: number;
    };
}
export interface TwitterTweet {
    id: string;
    text: string;
    authorId: string;
    createdAt: Date;
    publicMetrics: {
        retweetCount: number;
        replyCount: number;
        likeCount: number;
        quoteCount: number;
        bookmarkCount?: number;
        impressionCount?: number;
    };
    contextAnnotations?: Array<{
        domain: {
            id: string;
            name: string;
            description: string;
        };
        entity: {
            id: string;
            name: string;
            description: string;
        };
    }>;
    referencedTweets?: Array<{
        type: 'retweeted' | 'quoted' | 'replied_to';
        id: string;
    }>;
    attachments?: {
        mediaKeys?: string[];
        pollIds?: string[];
    };
    sentiment?: {
        label: 'positive' | 'negative' | 'neutral';
        score: number;
    };
    entities?: {
        hashtags?: Array<{
            start: number;
            end: number;
            tag: string;
        }>;
        mentions?: Array<{
            start: number;
            end: number;
            username: string;
            id: string;
        }>;
        urls?: Array<{
            start: number;
            end: number;
            url: string;
            expandedUrl: string;
        }>;
        cashtags?: Array<{
            start: number;
            end: number;
            tag: string;
        }>;
    };
}
export interface TwitterAnalysisResult {
    query: string;
    tweets: TwitterTweet[];
    totalCount: number;
    sentiment: {
        positive: number;
        negative: number;
        neutral: number;
        overall: 'positive' | 'negative' | 'neutral';
        confidence: ConfidenceLevel;
    };
    trends: Array<{
        topic: string;
        mentions: number;
        sentiment: number;
        velocity: number;
    }>;
    influencers: Array<{
        userId: string;
        username: string;
        influence: number;
        reach: number;
        engagement: number;
    }>;
    predictionMarkers: Array<{
        text: string;
        confidence: number;
        category: DataCategory;
        extractedValue?: string | number;
    }>;
}
export interface TwitterPredictionRequest {
    tweetId?: string;
    query?: string;
    category: DataCategory;
    timeframe?: string;
    options?: string[];
    endTime?: Date;
}
export declare class TwitterAPI {
    private readonly client;
    private readonly config;
    constructor(client: OracleClient, config: OracleConfig);
    private validateTwitterConfig;
    /**
     * Search tweets for oracle data
     */
    searchTweets(options: TwitterSearchOptions): Promise<TwitterTweet[]>;
    /**
     * Analyze sentiment from tweets
     */
    analyzeSentiment(query: string, options?: {
        maxTweets?: number;
        timeRange?: {
            from: Date;
            to: Date;
        };
        includeRetweets?: boolean;
        lang?: string;
    }): Promise<TwitterAnalysisResult>;
    /**
     * Extract prediction markets from tweets
     */
    extractPredictions(query: string, category: DataCategory, options?: {
        timeframe?: string;
        confidence?: number;
        maxTweets?: number;
    }): Promise<Array<{
        prediction: string;
        confidence: number;
        supportingTweets: TwitterTweet[];
        extractedData: OracleDataPoint[];
    }>>;
    /**
     * Create prediction market from tweet
     */
    createPredictionFromTweet(request: TwitterPredictionRequest): Promise<OraclePollData>;
    /**
     * Get trending topics relevant to oracle queries
     */
    getTrendingTopics(location?: string, category?: DataCategory): Promise<Array<{
        topic: string;
        volume: number;
        category: DataCategory;
        relevanceScore: number;
        predictiveValue: number;
    }>>;
    /**
     * Analyze user influence and credibility
     */
    analyzeUser(username: string): Promise<{
        user: {
            id: string;
            username: string;
            displayName: string;
            description: string;
            metrics: TwitterUserMetrics;
            verified: boolean;
            createdAt: Date;
        };
        influence: {
            score: number;
            rank: string;
            expertise: string[];
            credibility: number;
            networkReach: number;
        };
        predictionHistory: Array<{
            prediction: string;
            date: Date;
            outcome?: boolean;
            accuracy: number;
        }>;
    }>;
    /**
     * Monitor real-time mentions and hashtags
     */
    monitorMentions(keywords: string[], callback: (tweet: TwitterTweet) => void, options?: {
        includeRetweets?: boolean;
        lang?: string;
        sentiment?: boolean;
    }): Promise<EventSource>;
    /**
     * Get Twitter-based market confidence indicators
     */
    getMarketConfidence(query: string, timeRange: {
        from: Date;
        to: Date;
    }): Promise<{
        confidence: ConfidenceLevel;
        indicators: {
            volume: number;
            sentiment: number;
            expertMentions: number;
            virality: number;
            credibilityScore: number;
        };
        signals: Array<{
            type: 'bullish' | 'bearish' | 'neutral';
            strength: number;
            source: string;
            timestamp: Date;
        }>;
        recommendation: {
            action: 'strong_buy' | 'buy' | 'hold' | 'sell' | 'strong_sell';
            confidence: number;
            reasoning: string;
        };
    }>;
    /**
     * Extract numeric predictions from tweets
     */
    extractNumericPredictions(query: string, targetMetric: string, options?: {
        timeframe?: string;
        currency?: string;
        unit?: string;
        minConfidence?: number;
    }): Promise<Array<{
        value: number;
        unit: string;
        confidence: number;
        source: TwitterTweet;
        reasoning: string;
        timeframe?: string;
    }>>;
    /**
     * Get Twitter-based event predictions
     */
    getEventPredictions(eventQuery: string, category: DataCategory, timeHorizon: string): Promise<{
        event: string;
        probability: number;
        confidence: ConfidenceLevel;
        timeframe: string;
        supportingEvidence: Array<{
            tweet: TwitterTweet;
            relevance: number;
            sentiment: number;
            credibilityScore: number;
        }>;
        counterEvidence: Array<{
            tweet: TwitterTweet;
            relevance: number;
            sentiment: number;
            credibilityScore: number;
        }>;
        aggregatedPrediction: {
            outcome: boolean;
            probability: number;
            reasoning: string;
        };
    }>;
    /**
     * Create custom Twitter-based oracle feed
     */
    createTwitterFeed(feedConfig: {
        name: string;
        queries: string[];
        category: DataCategory;
        updateFrequency: string;
        sentimentWeight: number;
        volumeWeight: number;
        credibilityWeight: number;
        aggregationMethod: 'sentiment' | 'volume' | 'expert' | 'hybrid';
    }): Promise<{
        feedId: string;
    }>;
    /**
     * Get historical Twitter sentiment data
     */
    getHistoricalSentiment(query: string, timeRange: {
        from: Date;
        to: Date;
    }, interval?: '1h' | '6h' | '1d' | '1w'): Promise<Array<{
        timestamp: Date;
        sentiment: {
            positive: number;
            negative: number;
            neutral: number;
            overall: number;
        };
        volume: number;
        reach: number;
        engagement: number;
    }>>;
}