/**
 * FieldFunded Sports API — TypeScript SDK Types
 *
 * Complete type definitions for all 25 API endpoints.
 * Zero dependencies. Works in Node.js 18+, Deno, Bun, and browsers.
 *
 * LAST SYNC: 2026-04-22 — professional 1:1 status reporting (ended)
 */
export interface SDKConfig {
    /** Your RapidAPI key or direct API key */
    apiKey: string;
    /** RapidAPI host (e.g. 'fieldfunded-sports-api.p.rapidapi.com') */
    host?: string;
    /** Direct API base URL (e.g. 'https://api.fieldfunded.com/v1'). Overrides host. */
    baseUrl?: string;
    /** Request timeout in milliseconds (default: 10000) */
    timeout?: number;
    /** Number of retries on 429/500 errors (default: 1) */
    retries?: number;
}
export type OddsFormat = 'decimal' | 'american' | 'fractional';
export type EventStatus = 'live' | 'prematch' | 'ended' | 'delayed' | 'postponed' | 'cancelled' | 'suspended' | 'retired' | 'abandoned' | 'walkover' | 'interrupted';
export type StatusFilter = 'live' | 'prematch' | 'ended' | 'all';
export interface Sport {
    key: string;
    name: string;
    active_events?: number;
    live_events?: number;
    prematch_events?: number;
    sport_id?: number | null;
    is_esport?: boolean;
    has_outrights?: boolean;
}
export interface League {
    slug: string;
    name: string;
    country: string;
}
export interface LeagueDetail extends League {
    sport: Sport;
    active_events: number;
    live_events: number;
}
export interface Score {
    home: number;
    away: number;
}
/**
 * Main market odds (1x2).
 * Values are `number` for decimal/american, `string` (e.g. "3/2") for fractional.
 */
export interface Odds {
    home: number | string | null;
    draw: number | string | null;
    away: number | string | null;
}
export interface Outcome {
    label: string;
    /** Decimal/American → number, Fractional → string (e.g. "3/2") */
    odds: number | string;
    is_locked: boolean;
    selection_id: number | string | null;
    team_side?: 'home' | 'away' | null;
}
export interface Market {
    key: string;
    name: string;
    market_id: number | string | null;
    outcomes: Outcome[];
}
export interface MarketType {
    key: string;
    name: string;
    outcomes_count: number;
}
export interface Scoreboard {
    headers: string[];
    home: (string | number)[];
    away: (string | number)[];
}
export interface SportData {
    home_serving?: boolean;
    away_serving?: boolean;
    home_game_score?: string;
    away_game_score?: string;
    is_tiebreak?: boolean;
    home_suspend?: number | null;
    away_suspend?: number | null;
}
export interface Event {
    id: string;
    sport: Sport;
    league: League;
    home_team: string;
    away_team: string;
    home_logo: string;
    away_logo: string;
    status: EventStatus;
    start_time: string | null;
    score: Score;
    clock: string | null;
    /** Current game period (e.g. "1st Half", "2nd Period", "Set 3") */
    period: string;
    odds?: Odds;
    odds_format?: OddsFormat;
    markets_count: number;
    /** True when the event is past its scheduled start_time but not yet live */
    is_delayed?: boolean;
    /** Minutes since scheduled start_time (only present when is_delayed is true) */
    delay_minutes?: number;
    updated_at: string;
}
export interface EventDetail extends Event {
    markets: Market[];
    scoreboard?: Scoreboard;
    sport_data?: SportData;
}
/** GET /v1/events/:id/odds — Lightweight odds-only response */
export interface EventOddsResponse {
    id: string;
    status: EventStatus;
    markets: Market[];
    updated_at: string;
}
export interface EventFilters {
    /** Filter by sport key (e.g. 'soccer', 'basketball', 'counter-strike') */
    sport?: string;
    /** Filter by event status */
    status?: StatusFilter;
    /** Filter by league slug or partial name (e.g. 'premier-league') */
    league?: string;
    /** Filter by country (e.g. 'england') */
    country?: string;
    /** Filter events on a specific day (UTC). Format: YYYY-MM-DD */
    date?: string;
    /** Filter events starting from this date. Format: YYYY-MM-DD */
    from?: string;
    /** Filter events up to this date. Format: YYYY-MM-DD */
    to?: string;
    /** Filter upcoming events within a time window (e.g. '60m', '2h', '1d') */
    starts_within?: string;
    /** Maximum results (1-200, default 50) */
    limit?: number;
    /** Pagination offset (default 0) */
    offset?: number;
    /** Odds format */
    odds_format?: OddsFormat;
}
export interface BaseSportFilter {
    sport?: string;
}
export interface SportFilter extends BaseSportFilter {
    odds_format?: OddsFormat;
}
export interface ScoreFilters {
    sport?: string;
    limit?: number;
}
export interface SearchOptions {
    limit?: number;
    odds_format?: OddsFormat;
}
export interface SettlementFilters {
    limit?: number;
    offset?: number;
    cursor?: string;
    event_id?: string;
    event_ids?: string[] | string;
}
export interface OutrightSettlementFilters {
    limit?: number;
    offset?: number;
    cursor?: string;
    tournament_id?: string;
    tournament_ids?: string[] | string;
}
export interface EventOptions {
    odds_format?: OddsFormat;
}
export interface FeaturedOptions extends EventOptions {
    /** Include full market depth for each featured game (default: false) */
    markets?: boolean;
    /** Max number of featured games (default: 15, max: 30) */
    limit?: number;
}
export interface BetSelection {
    /** Event ID to check */
    event_id: string;
    /** Market name (e.g. "Match Winner", "Over/Under 2.5") */
    market: string;
    /** Outcome label (e.g. "Home", "Over", "Draw") */
    outcome: string;
    /** Decimal odds at time of bet placement */
    odds?: number;
    /** Optional stake amount for payout calculation (currency-agnostic — any numeric amount) */
    stake?: number;
    /** Primary identification — market ID (from /events or /settlements) for guaranteed 100% accuracy. Consistent across fixtures within the same sport. */
    market_id?: number | string;
    /** Primary identification — selection ID (from /events or /settlements) for guaranteed 100% accuracy */
    selection_id?: number | string;
}
export interface BetCheckRequest {
    /** Batch mode (preferred) */
    selections?: BetSelection[];
    /** Single mode shortcut */
    selection?: BetSelection;
    /** Root-level single mode shortcut */
    event_id?: string;
    market?: string;
    outcome?: string;
    odds?: number;
    /** Stake amount for payout calculation (currency-agnostic) */
    stake?: number;
}
export interface ParlayLeg {
    /** Event ID to check */
    event_id: string;
    /** Market name (e.g. "Match Winner") */
    market: string;
    /** Outcome label (e.g. "Home") */
    outcome: string;
    /** Decimal odds at time of bet placement */
    odds: number;
    /** Primary identification — market ID for guaranteed accuracy. Consistent across fixtures within the same sport. */
    market_id?: number | string;
    /** Primary identification — selection ID for guaranteed accuracy */
    selection_id?: number | string;
}
export interface ParlayCheckRequest {
    /** Single parlay mode (default) */
    legs?: ParlayLeg[];
    stake?: number;
    /** Alternative single wrapper */
    parlay?: {
        parlay_id?: string;
        legs: ParlayLeg[];
        stake?: number;
    };
    /** Batch mode: resolve multiple parlays in one request */
    parlays?: Array<{
        parlay_id?: string;
        legs: ParlayLeg[];
        stake?: number;
    }>;
}
export interface BetCheckResultItem {
    event_id: string;
    market: string;
    outcome: string;
    odds?: number;
    event_status?: string;
    score?: Score;
    result: 'won' | 'lost' | 'refund' | 'pending';
    reason?: string;
    matched_market?: string;
    matched_outcome?: string;
    matched_market_id?: string | null;
    matched_selection_id?: string | null;
    available_markets?: string[];
    available_outcomes?: string[];
    payout_multiplier?: number;
    /** Stake amount (echoed from request). Only present when stake was provided. */
    stake?: number;
    /** Calculated payout: stake × payout_multiplier (rounded to 2dp). Only present when stake was provided. */
    payout?: number;
}
export interface BetCheckResponse {
    results: BetCheckResultItem[];
    summary: {
        total: number;
        settled: number;
        won: number;
        lost: number;
        refunded: number;
        pending: number;
    };
}
export interface ParlayLegResult {
    leg: number;
    event_id: string;
    market: string;
    outcome: string;
    odds: number | null;
    event_status?: string;
    teams?: string;
    result: 'won' | 'lost' | 'refund' | 'pending';
    reason?: string;
}
export interface ParlayResult {
    type: 'parlay';
    total_legs: number;
    legs: ParlayLegResult[];
    payout: {
        combined_odds: number;
        result: 'won' | 'lost' | 'pending';
        payout?: number;
        potential_payout?: number;
        note?: string;
    };
    summary: {
        won: number;
        lost: number;
        refund: number;
        pending: number;
    };
}
export interface ParlayBatchResult {
    type: 'parlay_batch';
    total_parlays: number;
    parlays: Array<(ParlayResult & {
        parlay: number;
        parlay_id?: string;
    })>;
    summary: {
        won: number;
        lost: number;
        pending: number;
    };
}
export interface SettlementOutcome {
    label: string;
    /** Settlement outcomes are finalized at market level. */
    result: 'won' | 'lost' | 'refund';
    selection_id: number | string | null;
}
export interface SettlementMarket {
    key: string;
    name: string;
    market_id: number | string | null;
    outcomes: SettlementOutcome[];
}
/** Single event result (from GET /v1/events/:id/result) */
export interface EventResult {
    id: string;
    /** Score-only result status from GET /v1/events/:id/result. */
    status: 'ended' | 'not_ended' | 'postponed' | 'delayed' | 'cancelled' | 'abandoned' | 'retired' | 'suspended' | 'interrupted' | 'walkover';
    score?: Score;
    ended_at?: string;
    message?: string;
}
/** Settlement feed item (from GET /v1/settlements) */
export interface Settlement {
    event_id: string;
    home_team: string;
    away_team: string;
    home_logo: string;
    away_logo: string;
    final_score: Score;
    sport: string | null;
    league: string | null;
    country: string | null;
    start_time: string | null;
    status: 'settled';
    settlement_status: 'settled';
    ended_at: string;
    resolved_markets: SettlementMarket[];
    resolved_markets_count: number;
    /** Total number of markets for this event. Null for legacy entries. */
    total_markets_count: number | null;
    /** Markets still pending resolution. 0 when fully settled. Null for legacy entries. */
    pending_markets_count: number | null;
}
export interface OutrightSettlement {
    entry_id: string;
    tournament_id: string | null;
    tournament?: string | null;
    market_id: number | string | null;
    market?: string | null;
    selection_id: number | string | null;
    selection?: string | null;
    result: 'won' | 'lost' | 'refund' | 'pending';
    settled_at: string;
    sport?: string | null;
}
export interface OutrightSettlementsResponse {
    outright_settlements: OutrightSettlement[];
    total: number;
    limit: number;
    offset: number;
    has_more: boolean;
    next_cursor: string | null;
    applied_filters?: {
        tournament_ids_count: number;
        using_cursor: boolean;
    };
    message?: string;
}
export interface OutrightSport {
    sport_id: number;
    name: string;
    tournament_count: number;
}
export interface OutrightTournament {
    tournament_id: number;
    name: string;
    sport_id: number;
    country: string;
    country_code: string;
    category: string;
    outright_count: number;
}
export interface OutrightEvent {
    event_id: string;
    tournament_id: string;
    tournament: string;
    description: string;
    sport: string;
    country: string;
    total_markets: number;
    markets: Array<{
        market_id: number;
        name: string;
        status: 'active' | 'suspended';
        selections: Array<{
            selection_id: number;
            name: string;
            /** Decimal number by default. String when odds_format=fractional (e.g. "3/2"). */
            odds: number | string;
            status: 'active' | 'suspended';
        }>;
    }>;
}
export interface PingResponse {
    pong: true;
    timestamp: number;
}
export interface HealthResponse {
    status: 'healthy' | 'degraded' | 'unhealthy';
    version: string;
    uptime_seconds: number;
    timestamp: string;
    services: {
        redis: {
            status: string;
            latency_ms?: number;
            error?: string;
        };
        data_pipeline: {
            status: string;
            last_update_seconds_ago?: number;
            total_events?: number;
        };
    };
}
export interface StatusResponse {
    status: string;
    version: string;
    data_freshness_ms: number;
    active_sports: number;
    live_events: number;
    prematch_events: number;
    uptime_seconds: number;
}
export interface SportsResponse {
    sports: Array<{
        key: string;
        name: string;
        sport_id: number | null;
        active_events: number;
        live_events: number;
        prematch_events: number;
        is_esport: boolean;
        has_outrights: boolean;
    }>;
    total: number;
}
export interface EventsResponse {
    events: Event[];
    total: number;
    limit: number;
    offset: number;
}
export interface LiveResponse {
    events: Event[];
    total: number;
}
/** /v1/featured returns { featured: Event[] | EventDetail[], total, markets_included, priority_leagues } */
export interface FeaturedResponse {
    featured: Event[] | EventDetail[];
    total: number;
    markets_included: boolean;
    priority_leagues: string[];
}
export interface ScoresResponse {
    scores: Array<{
        id: string;
        home_team: string;
        away_team: string;
        score: Score;
        status: EventStatus;
        clock: string | null;
        period: string;
        sport: string;
    }>;
    total: number;
}
export interface SearchResponse {
    events: Event[];
    total: number;
    query: string;
}
export interface LeaguesResponse {
    leagues: LeagueDetail[];
    total: number;
}
export interface MarketsResponse {
    markets: Record<string, MarketType[]>;
    total_unique: number;
}
/** /v1/events/batch returns { events: Record<id, EventDetail>, found, requested } */
export interface BatchResponse {
    events: Record<string, EventDetail>;
    found: number;
    requested: number;
}
export interface SettlementsResponse {
    settlements: Settlement[];
    total: number;
    fully_settled: number;
    score_only: number;
    limit: number;
    offset: number;
    has_more: boolean;
    next_cursor: string | null;
    applied_filters?: {
        event_ids_count: number;
        using_cursor: boolean;
    };
    message: string;
}
export interface UsageLimits {
    per_second: number;
    per_hour: number;
    per_month: number;
}
export interface UsageCurrent {
    today: number;
    this_month: number;
    month_remaining: number;
    month_percent: number;
    avg_response_ms: number;
    errors_today: {
        client: number;
        server: number;
    };
    warning: UsageWarning | null;
}
export interface UsageWarning {
    level: 'info' | 'warning' | 'critical';
    message: string;
    count?: number;
}
export interface UsageDailyEntry {
    date: string;
    requests: number;
    errors?: number;
}
/** GET /v1/usage — Current quota consumption and daily breakdown */
export interface UsageResponse {
    tier: string;
    limits: UsageLimits;
    current: UsageCurrent;
    daily_breakdown: UsageDailyEntry[];
}
/** GET /v1/usage/endpoints — Per-endpoint usage for the current month */
export interface UsageEndpointsResponse {
    endpoints: Array<{
        path: string;
        count: number;
    }>;
    period: string;
}
/** GET /v1/usage/warnings — Active alerts for the authenticated key */
export interface UsageWarningsResponse {
    warnings: UsageWarning[];
}
export interface OutrightsListResponse {
    outrights: OutrightTournament[];
    total: number;
    sport_id: number;
}
export interface OutrightSportsResponse {
    sports: OutrightSport[];
    total: number;
}
export interface OutrightDetailResponse {
    tournament_id: string | number;
    events: OutrightEvent[];
    total: number;
    odds_format?: OddsFormat;
}
//# sourceMappingURL=types.d.ts.map