/// Options:
/// Date: 2026-11-07 04:02:40
/// Version: 10.42
/// Tip: To override a DTO option, remove "/" prefix before updating
/// BaseUrl: https://s4w1.api.bettor.webhop.biz
/// GlobalNamespace:
/// MakePropertiesOptional: False
/// AddServiceStackTypes: True
/// AddResponseStatus: False
/// AddImplicitVersion:
/// AddDescriptionAsComments: True
//IncludeTypes: GetDrawDignostics.*
/// ExcludeTypes:
/// DefaultImports: const std = @import("std");
///
const std = @import("std");

pub const Ref = struct {
    id: ?[]const u8 = null,
    val: ?[]const u8 = null,
};

pub const BettingApp = struct {
    name: ?[]const u8 = null,
    version: ?[]const u8 = null,
};

pub const RefEx = struct {
    id: ?[]const u8 = null,
    val: ?[]const u8 = null,
    data: ?RecordDictionary = null,
};

pub const Origin = struct {
    application: ?BettingApp = null,
    ip: ?[]const u8 = null,
    organization: ?RefEx = null,
    region: ?Ref = null,
    locationGroup: ?Ref = null,
    location: ?RefEx = null,
    device: ?RefEx = null,
    clerk: ?Ref = null,
};

pub const Bet = struct {
    id: ?[]const u8 = null,
    ordinalOfAvailableRoundToAssignTo: i32 = 0,
    content: ?[]const u8 = null,
    stake: f64 = 0,
    payload: ?std.json.Value = null,
};

pub const Pool = struct {
    id: i32 = 0,
    name: ?[]const u8 = null,
    treshold: f64 = 0,
};

pub const LocationOptimizationLevel = enum(i32) {
    None = 0,
    Low = 1,
    Medium = 2,
    High = 3,
};

pub const ThresholdInterval = struct {
    start: f64 = 0,
    end: f64 = 0,
};

pub const SortingOrder = enum(i32) {
    None = 0,
    Ascending = 1,
    Descending = 2,
};

pub const WinCountOrderProbability = struct {
    order: ?SortingOrder = null,
    probability: i32 = 0,
};

pub const PoolCaps = struct {
    plusCoef: f64 = 0,
    minusCoef: f64 = 0,
    maxAmountInPrevalentStakes: f64 = 0,
};

pub const PoolSettings = struct {
    id: i32 = 0,
    name: ?[]const u8 = null,
    isActive: bool = false,
    contributionToRoundPoolPct: f64 = 0,
    caps: ?PoolCaps = null,
};

pub const StakeCategory = enum(i32) {
    Pickerel = 0,
    Fish = 1,
    Salmon = 2,
    Tuna = 3,
    Shark = 4,
    Whale = 5,
    None = -1,
};

pub const CategoryThreshold = struct {
    category: ?StakeCategory = null,
    threshold: f64 = 0,
};

pub const HighRollerSettings = struct {
    pools: ?RecordList = null,
    categoryThresholds: ?RecordList = null,
};

pub const SyphonBlacklists = struct {
    locations: ?RecordList = null,
    players: ?RecordList = null,
};

pub const AntiSyphonConfig = struct {
    combinationCountPerRoundThresholdPct: f64 = 0,
    excludedLocations: ?RecordList = null,
    blacklists: ?SyphonBlacklists = null,
    includeRoundPctAsBettorSyphonCriteria: bool = false,
    isActive: bool = false,
};

pub const FraudDetectionConfiguration = struct {
    antiSyphon: ?AntiSyphonConfig = null,
};

pub const DebugConfiguration = struct {
    logLocationStats: bool = false,
    logBettorStats: bool = false,
};

pub const JP5WinnerCooldownPolicyConfig = struct {
    isActive: bool = false,
    cooldownIntervalInDays: i32 = 0,
};

pub const AccumulatorConfiguration = struct {
    pools: ?RecordList = null,
    prevalentStake: f64 = 0,
    purgeThresholdModifier: f64 = 0,
    locationOptimizationLevel: ?LocationOptimizationLevel = null,
    jackPot5ThresholdInterval: ?ThresholdInterval = null,
    deviationCategorySpanInPct: i32 = 0,
    deviationCategoryThresholdAmount: f64 = 0,
    roundPoolCircuitBreakerThreshold: f64 = 0,
    lowWinCountAffinityInPct: i32 = 0,
    winCountOrderAffinity: ?RecordList = null,
    highRollerSettings: ?HighRollerSettings = null,
    overflowCoefficientPoolsToRound: bool = false,
    antiSyphonProtectionOverride: bool = false,
    fraudDetectionConfig: ?FraudDetectionConfiguration = null,
    debugConfig: ?DebugConfiguration = null,
    jP5WinnerCooldownPolicy: ?JP5WinnerCooldownPolicyConfig = null,
};

pub fn RecordDictionary(comptime TKey: type, comptime TVal: type) type {
    _ = TKey;
    _ = TVal;
    return struct {};
}

pub const Pool = struct {
    id: i32 = 0,
    name: ?[]const u8 = null,
    coefficient: f64 = 0,
    rtp: f64 = 0,
    threshold: f64 = 0,
    balance: f64 = 0,
    rrtp: f64 = 0,
    rBalance: f64 = 0,
};

pub const Bet = struct {
    id: ?[]const u8 = null,
    slipId: ?[]const u8 = null,
    bettor: ?Ref = null,
    origin: ?Origin = null,
    placedAt: ?[]const u8 = null,
    roundId: ?[]const u8 = null,
    content: ?[]const u8 = null,
    stake: f64 = 0,
    outcome: ?BetOutcome = null,
    win: f64 = 0,
    processingStatus: ?BetProcessingStatus = null,
    validity: ?BetValidity = null,
    results: ?std.json.Value = null,
    payload: ?std.json.Value = null,
};

pub fn RecordList(comptime T: type) type {
    _ = T;
    return struct {
        pub const ss_collection = "items";

        items: []T = &.{},
    };

    pub const Pool = struct {
        id: i32 = 0,
        name: ?[]const u8 = null,
        rtp: f64 = 0,
        reserveRTP: f64 = 0,
        totalRTP: f64 = 0,
    };

    pub const SuperWinInfo = struct {
        isActive: bool = false,
        winner: ?SuperWinWinner = null,
        availableAmount: f64 = 0,
        allPrizesAwarded: bool = false,
    };

    pub const CurrentRoundInfo = struct {
        roundId: ?[]const u8 = null,
        amount: f64 = 0,
        inertCode: ?[]const u8 = null,
    };

    pub const WinnerByCode = struct {
        roundId: ?[]const u8 = null,
        drawnAtUtc: ?[]const u8 = null,
        slipId: ?[]const u8 = null,
        betId: ?[]const u8 = null,
        code: ?[]const u8 = null,
        amount: f64 = 0,
        origin: ?Origin = null,
        bettor: ?Ref = null,
        locationAddressOrBettorInfo: ?[]const u8 = null,
    };

    pub const LocalCodePotInfo = struct {
        isActive: bool = false,
        current: ?CurrentRoundInfo = null,
        winners: ?[]WinnerByCode = null,
    };

    pub const Initialization = struct {
        dataLoadDuration: i64 = 0,
        betsCollectionsCreationDuration: i64 = 0,
        combinationsOccuranceLookupInitializationDuration: i64 = 0,
    };

    pub const SequenceGeneration = struct {
        nrOfThreads: i32 = 0,
        nrOfResultsProbed: i32 = 0,
        duration: i64 = 0,
        avgSinglePassDuration: i64 = 0,
    };

    pub const BestFitFinder = struct {
        targetAmount: f64 = 0,
        awardedAmount: f64 = 0,
        deviation: f64 = 0,
        deviationPct: f64 = 0,
        sequenceResultType: ?[]const u8 = null,
        isJackPot5Drawn: bool = false,
        filteringPeriod: i64 = 0,
        winCountOrder: ?SortingOrder = null,
        minAmount: f64 = 0,
        maxAmount: f64 = 0,
    };

    pub const QualifiedPool = struct {
        id: i32 = 0,
        name: ?[]const u8 = null,
        coefficient: f64 = 0,
        availableAmount: f64 = 0,
        awardedAmount: f64 = 0,
        targetBet: ?Bet = null,
    };

    pub const Purger = struct {
        prevalentStake: f64 = 0,
        poolPurger: ?[]const u8 = null,
        qualifiedPools: ?[]QualifiedPool = null,
    };

    pub const ResponseStatus = enum(i32) {
        Failure = 0,
        Success = 1,
    };

    pub const StimulationResponse = struct {
        stimulationId: ?[]const u8 = null,
        status: ?ResponseStatus = null,
        failureReason: ?[]const u8 = null,
        slipId: ?[]const u8 = null,
        betId: ?[]const u8 = null,
        amountAwarded: f64 = 0,
    };

    pub const SuperWinInfo = struct {
        durationInMs: i64 = 0,
        reasoning: ?[]const u8 = null,
    };

    pub const HappyHourInfo = struct {
        isHappyHour: bool = false,
        oddsModifier: f64 = 0,
        roundPoolBonusPct: f64 = 0,
    };

    pub const SyphonType = enum(i32) {
        Location = 0,
        Bettor = 1,
    };

    pub const Syphon = struct {
        id: ?[]const u8 = null,
        name: ?[]const u8 = null,
        type: ?SyphonType = null,
        nrOfCombinations: i32 = 0,
    };

    pub const SyphonInfo = struct {
        bettors: ?std.json.Value = null,
        locations: ?std.json.Value = null,
        hasSyphons: bool = false,
        totalSyphonsInRound: i32 = 0,
    };

    pub const Bet = struct {
        isFound: bool = false,
        betId: ?[]const u8 = null,
        slipId: ?[]const u8 = null,
        combStake: ?std.json.Value = null,
    };

    pub const DrawDiagnostics = struct {
        id: ?[]const u8 = null,
        initializationInfo: ?Initialization = null,
        sequenceGenerationInfo: ?SequenceGeneration = null,
        bestFitFinderInfo: ?BestFitFinder = null,
        purgerInfo: ?Purger = null,
        duration: i64 = 0,
        stimulationResponses: ?[]StimulationResponse = null,
        localCodePot: ?LocalCodePotInfo = null,
        superWin: ?SuperWinInfo = null,
        happyHour: ?HappyHourInfo = null,
        reasoning: ?[]const u8 = null,
        configuration: ?AccumulatorConfiguration = null,
        syphonInfo: ?SyphonInfo = null,
    };

    // @Route("/qry/rounds/draw/diagnostics")
    pub const GetDrawDignostics = struct {
        pub const ss_name = "GetDrawDignostics";
        pub const ss_verb = "POST";
        pub const Response = DrawDiagnostics;

        id: ?[]const u8 = null,
    };