RTACore

il y a 14 heures

Library "RTACore"
Advanced multi-timeframe technical analysis framework for Pine Script
Author WavesUnchained
BUILD 2025-10-14 22:41:47

newFloatResult(value, context)
  Create a successful Result with float value
  Parameters:
    value (float)
    context (string)

newStringResult(value, context)
  Create a successful Result with string value
  Parameters:
    value (string)
    context (string)

newBoolResult(value, context)
  Create a successful Result with boolean value
  Parameters:
    value (bool)
    context (string)

newErrorResult(errorCode, errorMessage, floatFallback, stringFallback, boolFallback, context)
  Create an error Result with fallback values
  Parameters:
    errorCode (string)
    errorMessage (string)
    floatFallback (float)
    stringFallback (string)
    boolFallback (bool)
    context (string)

addResultTag(result, tag)
  Add a tag to Result
  Parameters:
    result (Result)
    tag (string)

newSignalResult(signalStrength, signalType)
  Create a signal Result with trading-specific tags
  Parameters:
    signalStrength (float)
    signalType (string)

newIndicatorResult(value, indicatorName)
  Create an indicator calculation Result with indicator tag
  Parameters:
    value (float)
    indicatorName (string)

newTimeframeResult(value, timeframe, context)
  Create a timeframe-specific Result
  Parameters:
    value (float)
    timeframe (string)
    context (string)

newConfluenceResult(confluenceScore, confidenceLevel)
  Create a confluence Result with confidence level
  Parameters:
    confluenceScore (float)
    confidenceLevel (string)

newValidationResult(context)
  Create a new validation result (starts as valid)
  Parameters:
    context (string)

newValidationSuccess(context)
  Create a successful validation result
  Parameters:
    context (string)

newValidationFailure(errors, context)
  Create a failed validation result with errors
  Parameters:
    errors (array<string>)
    context (string)

addValidationError(result, field, error)
  Add an error to validation result
  Parameters:
    result (ValidationResult)
    field (string)
    error (string)

addValidationWarning(result, field, warning)
  Add a warning to validation result
  Parameters:
    result (ValidationResult)
    field (string)
    warning (string)

addValidationCorrection(result, correction)
  Add a correction to validation result
  Parameters:
    result (ValidationResult)
    correction (string)

setValidationMode(result, mode)
  Set validation mode
  Parameters:
    result (ValidationResult)
    mode (string)

getValidationMode(result)
  Get validation mode
  Parameters:
    result (ValidationResult)

incrementValidatedFields(result)
  Increment validated fields counter
  Parameters:
    result (ValidationResult)

setValidationTotalFields(result, total)
  Set total fields for validation
  Parameters:
    result (ValidationResult)
    total (int)

calculateValidationScore(result)
  Calculate and update validation score based on errors/warnings
  Parameters:
    result (ValidationResult)

newPerformanceProfile(functionName)
  Create a new performance profile
  Parameters:
    functionName (string)

startTiming(profile)
  Start timing a performance profile (simple)
  Parameters:
    profile (PerformanceProfile)

endTiming(profile, hadError)
  End timing and update performance profile
  Parameters:
    profile (PerformanceProfile)
    hadError (bool)

updateMemoryEstimate(profile, arrayElements)
  Set estimated memory usage (array elements)
  Parameters:
    profile (PerformanceProfile)
    arrayElements (int)

newHealthyStatus()
  Create a new healthy status

setComponentHealth(status, component, isOK, message)
  Set component health status
  Parameters:
    status (HealthStatus)
    component (string)
    isOK (bool)
    message (string)

isHealthyOverall(status)
  Quick health check - are all components OK?
  Parameters:
    status (HealthStatus)

getHealthSummary(status)
  Get simple health summary
  Parameters:
    status (HealthStatus)

hasValidFloat(result)
  Check if Result contains a valid float value
  Parameters:
    result (Result)

hasValidString(result)
  Check if Result contains a valid string value
  Parameters:
    result (Result)

getFloat(result, fallback)
  Get float value from Result with fallback
  Parameters:
    result (Result)
    fallback (float)

getString(result, fallback)
  Get string value from Result with fallback
  Parameters:
    result (Result)
    fallback (string)

getBool(result, fallback)
  Get boolean value from Result with fallback
  Parameters:
    result (Result)
    fallback (bool)

hasResultTag(result, tag)
  Check if Result has specific tag
  Parameters:
    result (Result)
    tag (string)

getResultTags(result)
  Get all tags from Result
  Parameters:
    result (Result)

setResultContext(result, context)
  Set operation context for Result
  Parameters:
    result (Result)
    context (string)

filterResultsByTag(results, tag)
  Filter Results by tag (utility for arrays of Results)
  Parameters:
    results (array<Result>)
    tag (string)

getAllResultTags(results)
  Get all unique tags from array of Results
  Parameters:
    results (array<Result>)

newDefaultAnalysisConfig()
  Create default analysis configuration

newAggressiveAnalysisConfig()
  Create aggressive trading configuration

newConservativeAnalysisConfig()
  Create conservative trading configuration

newDefaultTimeframeConfig()
  Create default timeframe configuration

newIntradayTimeframeConfig()
  Create intraday timeframe configuration

newSwingTimeframeConfig()
  Create swing trading timeframe configuration

getConfigSummary(config)
  Get configuration summary string
  Parameters:
    config (AnalysisConfig)

cloneAnalysisConfig(source)
  Clone analysis configuration
  Parameters:
    source (AnalysisConfig)

newGenericAnalysis(analysisType, timeframe)
  Create a new generic analysis result
  Parameters:
    analysisType (string)
    timeframe (string)

newConsensusData()
  Create empty consensus data

newNeutralSignal(reason)
  Create a neutral signal result
  Parameters:
    reason (string)

newBuySignal(score, confidence, reason)
  Create a buy signal result
  Parameters:
    score (float)
    confidence (float)
    reason (string)

newSellSignal(score, confidence, reason)
  Create a sell signal result
  Parameters:
    score (float)
    confidence (float)
    reason (string)

newMultiTimeframeResult(config, tfConfig)
  Create new multi-timeframe result
  Parameters:
    config (AnalysisConfig)
    tfConfig (TimeframeConfig)

getAnalysisAction(analysis)
  Get analysis action string
  Parameters:
    analysis (GenericAnalysis)

isBullish(analysis)
  Check if analysis is bullish
  Parameters:
    analysis (GenericAnalysis)

isBearish(analysis)
  Check if analysis is bearish
  Parameters:
    analysis (GenericAnalysis)

getSignalSummary(signal)
  Get signal summary string
  Parameters:
    signal (SignalResult)

hasStrongConsensus(consensus)
  Check if consensus is strong
  Parameters:
    consensus (ConsensusData)

getConsensusSummary(consensus)
  Get consensus summary
  Parameters:
    consensus (ConsensusData)

isActionableSignal(signal)
  Check if signal is actionable
  Parameters:
    signal (SignalResult)

getSignalColor(signal)
  Get signal color for UI display
  Parameters:
    signal (SignalResult)

validateAnalysisConfig(config)
  Validate analysis configuration
  Parameters:
    config (AnalysisConfig)

validateTimeframeConfig(config)
  Validate timeframe configuration
  Parameters:
    config (TimeframeConfig)

validatePriceData(prices)
  Validate price data array
  Parameters:
    prices (array<float>)

sanitizeFloat(value, minVal, maxVal, defaultVal)
  Sanitize numeric input
  Parameters:
    value (float)
    minVal (float)
    maxVal (float)
    defaultVal (float)

sanitizeInt(value, minVal, maxVal, defaultVal)
  Sanitize integer input
  Parameters:
    value (int)
    minVal (int)
    maxVal (int)
    defaultVal (int)

sanitizeFloatArray(arr)
  Sanitize array by removing invalid values
  Parameters:
    arr (array<float>)

logError(message)
  Log error message
  Parameters:
    message (string)

logWarning(message)
  Log warning message
  Parameters:
    message (string)

safeExecute(operationName, condition)
  Safe execute wrapper
  Parameters:
    operationName (string)
    condition (bool)

shouldAllowOperation(errorCount, maxErrors)
  Circuit breaker pattern
  Parameters:
    errorCount (int)
    maxErrors (int)

retryOperation(maxRetries)
  Retry mechanism
  Parameters:
    maxRetries (int)

atrDistance(value1, value2, atr)
  Calculate ATR-normalized distance between two values
  Parameters:
    value1 (float)
    value2 (float)
    atr (float)

atrDistance(value, reference, atrLength)
  Calculate ATR-normalized distance between values
  Parameters:
    value (float)
    reference (float)
    atrLength (simple int)

percentDistance(value1, value2)
  Calculate percentage-based distance between two values
  Parameters:
    value1 (float)
    value2 (float)

withinATRTolerance(value, reference, atr, multiplier)
  Check if value is within ATR-based tolerance of reference
  Parameters:
    value (float)
    reference (float)
    atr (float)
    multiplier (float)

withinATRTolerance(value, reference, multiplier)
  Check if value is within ATR-based tolerance of reference
  Parameters:
    value (float)
    reference (float)
    multiplier (float)

withinPercentTolerance(value, reference, percentTolerance)
  Check if value is within percentage tolerance of reference
  Parameters:
    value (float)
    reference (float)
    percentTolerance (float)

proximityScore(value, reference, maxDistance)
  Get proximity score (0-1, where 1 = very close)
  Parameters:
    value (float)
    reference (float)
    maxDistance (float)

sortArrayByValue(values, sortOrder)
  Efficient array sorting using Pine Script native sort
Note: Replaces inefficient bubble sort implementations found in modules
  Parameters:
    values (array<float>)
    sortOrder (string)

safeArrayAverage(values)
  Safe array average with null handling
  Parameters:
    values (array<float>)

formatTableHeader(title, width)
  Create formatted header for display tables
  Parameters:
    title (string)
    width (int)

formatTableRow(key, value, width)
  Format table row with key-value pair
  Parameters:
    key (string)
    value (string)
    width (int)

formatTableFooter(width)
  Close table formatting
  Parameters:
    width (int)

truncateText(txt, maxLength, suffix)
  Truncate text to specified length
  Parameters:
    txt (string)
    maxLength (int)
    suffix (string)

padText(txt, width, padChar, align)
  Pad text to specified width
  Parameters:
    txt (string)
    width (int)
    padChar (string)
    align (string)

titleCase(txt)
  Convert text to title case
  Parameters:
    txt (string)

joinStrings(strings, separator)
  Join array of strings with separator
  Parameters:
    strings (array<string>)
    separator (string)

formatTimestamp(timestamp, format)
  Format timestamp to readable date/time
  Parameters:
    timestamp (int)
    format (string)

evictLRU(cache)
  Evict least recently used entry
  Parameters:
    cache (CacheManager)

newRiskAssessment()
  Create a default risk assessment

calculateRiskAssessment(signal, volatility, volumeLevel)
  Calculate comprehensive risk assessment
  Parameters:
    signal (SignalResult)
    volatility (float)
    volumeLevel (float)

newPositionData()
  Create new empty position data

getConservativeStrategy()
  Create conservative strategy template

getAggressiveStrategy()
  Create aggressive strategy template

newDefaultStrategy()
  Create default balanced strategy template

getStandardATR()
  Get standard ATR(14) - cached per bar

getATR(length)
  Get custom ATR with specified length
  Parameters:
    length (simple int)

getATRTolerance(multiplier)
  Get ATR-based tolerance for distance calculations
  Parameters:
    multiplier (float)

getStandardVolumeAverage()
  Get standard volume average SMA(20) - cached per bar

getVolumeAverage(length)
  Get custom volume average
  Parameters:
    length (int)

getVolumeRatio()
  Get volume ratio (current vs average)

getVolumeConfirmation(threshold)
  Get volume confirmation (above threshold)
  Parameters:
    threshold (float)

getStandardEMAs()
  Get standard EMAs (21, 50, 200) - cached per bar

getEMA21()
  Get individual standard EMAs

getEMA50()

getEMA200()

getEMATrendAlignment()
  Get EMA trend alignment score

getStandardRSI()
  Get standard RSI(14) - cached per bar

getRSILevels(overbought, oversold)
  Get RSI with overbought/oversold levels
  Parameters:
    overbought (float)
    oversold (float)

getStandardMACD()
  Get standard MACD (12, 26, 9) - cached per bar

getMACDSignal()
  Get MACD trend signal

getMomentumScore()
  Get comprehensive momentum score

getTrendStrength()
  Get trend strength (0-100)

getIndicatorSummary()
  Get indicator calculation summary (for debugging)

newZoneDetectionConfig()
  Create default zone configuration

newZoneDetection(upperBoundary, lowerBoundary, creationBar, zoneType)
  Create new zone
  Parameters:
    upperBoundary (float)
    lowerBoundary (float)
    creationBar (int)
    zoneType (string)

calculateZoneOverlap(zone1Upper, zone1Lower, zone2Upper, zone2Lower)
  Calculate zone overlap ratio
  Parameters:
    zone1Upper (float)
    zone1Lower (float)
    zone2Upper (float)
    zone2Lower (float)

isPriceTouchingZone(zone, currentPrice, touchTolerance)
  Check if price is touching zone
  Parameters:
    zone (ZoneDetection)
    currentPrice (float)
    touchTolerance (float)

getZonesInRange(zones, minPrice, maxPrice)
  Get zones within price range
  Parameters:
    zones (array<ZoneDetection>)
    minPrice (float)
    maxPrice (float)

getNearestZones(zones, currentPrice)
  Get nearest support and resistance zones
  Parameters:
    zones (array<ZoneDetection>)
    currentPrice (float)

processZoneDetection(zones, config)
  Complete zone detection and management system
  Parameters:
    zones (array<ZoneDetection>)
    config (ZoneDetectionConfig)

processZoneDetectionEngine(zones, config)
  Parameters:
    zones (array<ZoneDetection>)
    config (ZoneDetectionConfig)

newChannelConfig()

calcKeltnerChannel(config)
  Parameters:
    config (ChannelConfig)

checkKeltnerTouch(upper, lower)
  Parameters:
    upper (float)
    lower (float)

getKeltnerDepth(basis, upper, lower)
  Parameters:
    basis (float)
    upper (float)
    lower (float)

checkKeltnerBreakout(upper, lower)
  Parameters:
    upper (float)
    lower (float)

calcDonchianChannel(config)
  Parameters:
    config (ChannelConfig)

checkDonchianTouch(upper, lower)
  Parameters:
    upper (float)
    lower (float)

checkDonchianReentry(upper, lower)
  Parameters:
    upper (float)
    lower (float)

getDonchianWidth(upper, lower)
  Parameters:
    upper (float)
    lower (float)

calcBollingerBands(config)
  Parameters:
    config (ChannelConfig)

calcSqueezeRatio(bbStdev, kcMultiplier, kcAtr)
  Parameters:
    bbStdev (float)
    kcMultiplier (float)
    kcAtr (float)

detectSqueezeState(squeezeRatio)
  Parameters:
    squeezeRatio (float)

detectSqueezeBreak(squeezeRatio, kcUpper, kcLower)
  Parameters:
    squeezeRatio (float)
    kcUpper (float)
    kcLower (float)

getSqueezeIntensity(squeezeRatio)
  Parameters:
    squeezeRatio (float)

processChannelDetection(config)
  Parameters:
    config (ChannelConfig)

detectChannelSignals(state)
  Parameters:
    state (ChannelState)

detectQualityZones(state)
  Parameters:
    state (ChannelState)

getChannelSignalText(state)
  Parameters:
    state (ChannelState)

analyzeChannelTrend(state)
  Parameters:
    state (ChannelState)

getChannelConfluence(state)
  Parameters:
    state (ChannelState)

newVwapConfig()

newVwapAnchors()

calcSessionVwap()

getPreviousSessionVwap(sessionVwap)
  Parameters:
    sessionVwap (float)

updateVwapAnchors(anchors, config)
  Parameters:
    anchors (VwapAnchors)
    config (VwapConfig)

calcAnchoredVwap(anchors, isHigh)
  Parameters:
    anchors (VwapAnchors)
    isHigh (bool)

detectPriceCrosses(sessionVwap)
  Parameters:
    sessionVwap (float)

detectStructureCrosses(sessionVwap, anchoredHigh, anchoredLow)
  Parameters:
    sessionVwap (float)
    anchoredHigh (float)
    anchoredLow (float)

detectVwapCluster(sessionVwap, anchoredHigh, anchoredLow, config)
  Parameters:
    sessionVwap (float)
    anchoredHigh (float)
    anchoredLow (float)
    config (VwapConfig)

canShowSignal(anchors, config, signalType)
  Parameters:
    anchors (VwapAnchors)
    config (VwapConfig)
    signalType (string)

updateSignalThrottle(anchors, signalType)
  Parameters:
    anchors (VwapAnchors)
    signalType (string)

calcCrossStrength(sessionVwap, isPriceCross)
  Parameters:
    sessionVwap (float)
    isPriceCross (bool)

calcClusterStrength(vwapsInCluster, priceInCluster, tolerance)
  Parameters:
    vwapsInCluster (bool)
    priceInCluster (bool)
    tolerance (float)

calcStructureStrength(sessionVwap, anchoredHigh, anchoredLow)
  Parameters:
    sessionVwap (float)
    anchoredHigh (float)
    anchoredLow (float)

analyzeVwapTrend(sessionVwap)
  Parameters:
    sessionVwap (float)

processVwapDetection(anchors, config)
  Parameters:
    anchors (VwapAnchors)
    config (VwapConfig)

generateVwapSignals(state)
  Parameters:
    state (VwapState)

getVwapBias(state)
  Parameters:
    state (VwapState)

getVwapConfluence(state)
  Parameters:
    state (VwapState)

newZoneConfig()

newZoneState()

stringToFloats(s)
  Parameters:
    s (string)

calculateBias(config)
  Parameters:
    config (ZoneConfig)

createZone(top, bottom, isBull, isHTF)
  Parameters:
    top (float)
    bottom (float)
    isBull (bool)
    isHTF (bool)

updateZoneStatus(zone)
  Parameters:
    zone (Zone)

detectFVGOverlap(zone)
  Parameters:
    zone (Zone)

scoreZone(zone, config)
  Parameters:
    zone (Zone)
    config (ZoneConfig)

sortAndTrimZones(zones, config)
  Parameters:
    zones (array<Zone>)
    config (ZoneConfig)

adjustZoneVisibility(zones, config)
  Parameters:
    zones (array<Zone>)
    config (ZoneConfig)

calculateTargetsATR(base, stepsString, atrLength)
  Parameters:
    base (float)
    stepsString (string)
    atrLength (simple int)

calculateTargetsSigma(base, stepsString, sigmaLength)
  Parameters:
    base (float)
    stepsString (string)
    sigmaLength (int)

calculateTargetsLiquidity(isLong, config)
  Parameters:
    isLong (bool)
    config (ZoneConfig)

detectZoneSignals(zones, bias, config)
  Parameters:
    zones (array<Zone>)
    bias (int)
    config (ZoneConfig)

processZoneManagement(state, config)
  Parameters:
    state (ZoneState)
    config (ZoneConfig)

findNearestZones(state)
  Parameters:
    state (ZoneState)

newVolumeConfig()

newVolumeState()

getPriceSource(config)
  Parameters:
    config (VolumeConfig)

isInSession(config)
  Parameters:
    config (VolumeConfig)

isNewSession(config)
  Parameters:
    config (VolumeConfig)

calculateWindow(config)
  Parameters:
    config (VolumeConfig)

calculateProfile(config, windowStart, windowLength)
  Parameters:
    config (VolumeConfig)
    windowStart (int)
    windowLength (int)

detectVolumeNodes(binVolumes, binPrices, totalVolume)
  Parameters:
    binVolumes (array<float>)
    binPrices (array<float>)
    totalVolume (float)

calculateVolumeChoppiness(config)
  Calculate choppiness index for volume profile
  Parameters:
    config (VolumeConfig)

detectMarketRegime(state, config)
  Detect market regime based on multiple factors
  Parameters:
    state (VolumeState)
    config (VolumeConfig)

calculateAdaptiveParameters(state, config)
  Calculate adaptive volume profile parameters
  Parameters:
    state (VolumeState)
    config (VolumeConfig)

updateMarketConditions(state, config)
  Update volume state with market conditions
  Parameters:
    state (VolumeState)
    config (VolumeConfig)

applyAdaptiveConfig(config, state)
  Apply adaptive parameters to profile calculation
  Parameters:
    config (VolumeConfig)
    state (VolumeState)

getHTFPivots(config)
  Parameters:
    config (VolumeConfig)

checkPivotConfluence(price, config, pivotHigh1, pivotLow1, pivotHigh2, pivotLow2)
  Parameters:
    price (float)
    config (VolumeConfig)
    pivotHigh1 (float)
    pivotLow1 (float)
    pivotHigh2 (float)
    pivotLow2 (float)

calculateMOST()
  Calculate MOST (Moving Stop) indicator

calculateTrendFilters(config)
  Parameters:
    config (VolumeConfig)

findNearestNodes(hvnNodes, lvnNodes)
  Parameters:
    hvnNodes (array<VolumeNode>)
    lvnNodes (array<VolumeNode>)

detectVolumeSignals(config, profile, trendBullish, htfConfluence)
  Parameters:
    config (VolumeConfig)
    profile (VolumeProfile)
    trendBullish (bool)
    htfConfluence (bool)

calculateVolumeScore(profile, trendBullish)
  Parameters:
    profile (VolumeProfile)
    trendBullish (bool)

processVolumeProfile(state, config)
  Parameters:
    state (VolumeState)
    config (VolumeConfig)

newHTFConfig()

newHTFStackState()

getOptimalTimeframes(chartTF)
  Parameters:
    chartTF (string)

calculateChoppiness(length)
  Parameters:
    length (int)

detectTrendEMA(length, threshold)
  Parameters:
    length (simple int)
    threshold (float)

detectTrendSupertrend(atrLength, multiplier)
  Parameters:
    atrLength (simple int)
    multiplier (float)

detectTrendMOST(length, multiplier)
  Parameters:
    length (simple int)
    multiplier (float)

analyzeTrendForTF(tf, config)
  Parameters:
    tf (string)
    config (HTFConfig)

calculateStackConfluence(tfData, config)
  Parameters:
    tfData (array<HTFTrendData>)
    config (HTFConfig)

calculateAutoTuningParams(choppiness, stackStrength, config)
  Parameters:
    choppiness (float)
    stackStrength (float)
    config (HTFConfig)

detectStackSignals(state, prevState, config)
  Parameters:
    state (HTFStackState)
    prevState (HTFStackState)
    config (HTFConfig)

createStackPanel(state, config)
  Parameters:
    state (HTFStackState)
    config (HTFConfig)

processHTFStack(state, config)
  Parameters:
    state (HTFStackState)
    config (HTFConfig)

processHTFStackSignals(state, prevState, config)
  Parameters:
    state (HTFStackState)
    prevState (HTFStackState)
    config (HTFConfig)

newRedefiningTechnicalAnalysisCore(analysisConfig, timeframeConfig, strategy)
  Initialize RedefiningTechnicalAnalysis Core Library
Note: This function requires valid config objects to be passed in
The configuration module must be used directly to create default configs
  Parameters:
    analysisConfig (AnalysisConfig)
    timeframeConfig (TimeframeConfig)
    strategy (StrategyTemplate)

performAnalysis(core, prices, volumes, timestamps)
  Perform complete multi-timeframe analysis
  Parameters:
    core (RedefiningTechnicalAnalysisCore)
    prices (array<float>)
    volumes (array<float>)
    timestamps (array<int>)

generateSignal(core, analysisResult)
  Generate trading signal from analysis results
  Parameters:
    core (RedefiningTechnicalAnalysisCore)
    analysisResult (MultiTimeframeResult)

assessRisk(core, signal)
  Assess risk for trading decision
  Parameters:
    core (RedefiningTechnicalAnalysisCore)
    signal (SignalResult)

executeFullWorkflow(core)
  Execute complete analysis workflow
  Parameters:
    core (RedefiningTechnicalAnalysisCore)

updateAnalysisConfig(core, newConfig)
  Update analysis configuration
  Parameters:
    core (RedefiningTechnicalAnalysisCore)
    newConfig (AnalysisConfig)

updateStrategy(core, newStrategy)
  Update strategy template
  Parameters:
    core (RedefiningTechnicalAnalysisCore)
    newStrategy (StrategyTemplate)

checkSystemHealth(core)
  Perform system health check
  Parameters:
    core (RedefiningTechnicalAnalysisCore)

generateStatusReport(core)
  Generate comprehensive status report
  Parameters:
    core (RedefiningTechnicalAnalysisCore)

enableDebugMode(core, enabled)
  Enable debug mode
  Parameters:
    core (RedefiningTechnicalAnalysisCore)
    enabled (bool)

setFeatureFlag(core, flag, enabled)
  Set feature flag
  Parameters:
    core (RedefiningTechnicalAnalysisCore)
    flag (string)
    enabled (bool)

getFeatureFlag(core, flag, defaultValue)
  Get feature flag
  Parameters:
    core (RedefiningTechnicalAnalysisCore)
    flag (string)
    defaultValue (bool)

resetLibraryState(core)
  Reset library state
  Parameters:
    core (RedefiningTechnicalAnalysisCore)

getLibraryInfo()
  Get library version information

quickAnalysis(config, tfConfig, strategy)
  Quick analysis - simplified entry point
  Parameters:
    config (AnalysisConfig)
    tfConfig (TimeframeConfig)
    strategy (StrategyTemplate)

getQuickStatus(core)
  Get quick status string
  Parameters:
    core (RedefiningTechnicalAnalysisCore)

Result
  Generic Result type for safe operations with error handling and fallbacks
  Fields:
    floatValue (series float)
    stringValue (series string)
    boolValue (series bool)
    intValue (series int)
    isSuccess (series bool)
    errorCode (series string)
    errorMessage (series string)
    floatFallback (series float)
    stringFallback (series string)
    boolFallback (series bool)
    intFallback (series int)
    operationContext (series string)
    timestamp (series int)
    tags (array<string>)

ValidationResult
  Comprehensive validation result with errors, warnings, and corrections
  Fields:
    isValid (series bool)
    errors (array<string>)
    warnings (array<string>)
    corrections (array<string>)
    suggestions (array<string>)
    validationScore (series float)
    validationMode (series string)
    validatedFields (series int)
    totalFields (series int)
    validationContext (series string)
    validationTime (series int)

PerformanceProfile
  Simplified performance profiling for Pine Script limitations
  Fields:
    executionTimeMs (series float)
    averageExecutionMs (series float)
    executionCount (series int)
    errorCount (series int)
    cacheHits (series int)
    cacheMisses (series int)
    cacheHitRatio (series float)
    estimatedArrayElements (series int)
    hasHeavyCalculation (series bool)
    lastOptimizationHint (series string)
    performanceGrade (series string)
    performanceScore (series float)
    functionName (series string)
    profileStartTime (series int)

HealthStatus
  Simplified health status for Pine Script limitations
  Fields:
    isHealthy (series bool)
    healthScore (series float)
    healthGrade (series string)
    issues (array<string>)
    warnings (array<string>)
    recommendations (array<string>)
    dataValidationOK (series bool)
    calculationsOK (series bool)
    memoryUsageOK (series bool)
    errorCountSession (series int)
    warningCountSession (series int)
    lastHealthCheck (series int)
    healthCheckVersion (series string)

AnalysisConfig
  Comprehensive analysis configuration with factor weights, thresholds, and extensible options
  Fields:
    activeFactors (array<string>)
    factorWeights (map<string, float>)
    thresholds (map<string, float>)
    features (map<string, bool>)
    tradingMode (series string)
    consensusMode (series string)
    riskProfile (series string)
    minConfidence (series float)
    signalStrength (series float)
    requireConsensus (series bool)
    minConsensusCount (series int)
    parameters (map<string, float>)
    options (map<string, string>)
    flags (map<string, bool>)
    configName (series string)
    version (series string)
    description (series string)
    createdTime (series int)
    lastModified (series int)
    validation (ValidationResult)

TimeframeConfig
  Multi-timeframe configuration with weights and adjustments
  Fields:
    timeframes (array<string>)
    weights (array<float>)
    autoDetectChartTF (series bool)
    includeHigherTFs (series bool)
    tfAdjustments (map<string, float>)
    tfSensitivity (map<string, float>)
    tfFeatures (map<string, bool>)
    minTimeframes (series int)
    consensusThreshold (series float)
    consensusMethod (series string)
    normalizeWeights (series bool)
    adaptiveBias (series bool)
    higherTFBias (series float)
    tfConfigName (series string)
    configTimestamp (series int)
    validation (ValidationResult)

GenericAnalysis
  Generic analysis result that all specific analysis types extend
  Fields:
    totalScore (series float)
    confidence (series float)
    action (series string)
    strength (series string)
    riskLevel (series string)
    factorScores (map<string, float>)
    factorWeights (map<string, float>)
    factorSignals (map<string, bool>)
    factorReasons (map<string, string>)
    analysisType (series string)
    timeframeAnalyzed (series string)
    analysisTimestamp (series int)
    marketCondition (series string)
    dataQuality (series float)
    performance (PerformanceProfile)
    validation (ValidationResult)
    numericData (map<string, float>)
    textData (map<string, string>)
    flags (map<string, bool>)

ConsensusData
  Multi-timeframe consensus analysis data
  Fields:
    agreementCount (series int)
    totalTimeframes (series int)
    agreementPercentage (series float)
    hasStrongConsensus (series bool)
    hasMajorityConsensus (series bool)
    agreeingTimeframes (array<string>)
    disagreeingTimeframes (array<string>)
    tfScores (map<string, float>)
    tfActions (map<string, string>)
    consensusMode (series string)
    consensusScore (series float)
    consensusAction (series string)
    consensusStrength (series string)
    tfWeights (map<string, float>)
    weightedConsensus (series bool)
    weightedScore (series float)
    consensusQuality (series float)
    consensusReliability (series string)
    consensusWarnings (array<string>)

SignalResult
  Comprehensive trading signal result
  Fields:
    strongBuy (series bool)
    buy (series bool)
    neutral (series bool)
    sell (series bool)
    strongSell (series bool)
    overallScore (series float)
    confidence (series float)
    primaryAction (series string)
    signalStrength (series string)
    signalReason (series string)
    contributingFactors (array<string>)
    factorContributions (map<string, float>)
    triggerCondition (series string)
    consensus (ConsensusData)
    consensusLevel (series string)
    hasConsensus (series bool)
    riskLevel (series string)
    riskRewardRatio (series float)
    successProbability (series float)
    signalTimestamp (series int)
    urgency (series string)
    validityPeriod (series int)
    marketPhase (series string)
    warningFlags (array<string>)
    metadata (map<string, string>)

MultiTimeframeResult
  Multi-timeframe analysis result container
  Fields:
    primaryAnalysis (GenericAnalysis)
    tfResults (map<string, GenericAnalysis>)
    consensus (ConsensusData)
    aggregatedScore (series float)
    confidenceScore (series float)
    dominantAction (series string)
    consensusStrength (series string)
    analyzedTimeframes (array<string>)
    failedTimeframes (array<string>)
    failureReasons (map<string, string>)
    performance (PerformanceProfile)
    validation (ValidationResult)
    dataQualityScore (series float)
    config (AnalysisConfig)
    tfConfig (TimeframeConfig)
    analysisTimestamp (series int)

DebugLogEntry
  Debug log entry
  Fields:
    timestamp (series int)
    level (series string)
    module (series string)
    function (series string)
    message (series string)
    context (series string)
    data (map<string, string>)
    barIndex (series int)
    timeframe (series string)

DebugLogger
  Debug logger with configurable levels
  Fields:
    entries (array<DebugLogEntry>)
    maxEntries (series int)
    currentLevel (series string)
    enabled (series bool)
    enabledModules (array<string>)
    showTimestamp (series bool)
    showBarIndex (series bool)
    outputFormat (series string)

PerformanceMeasurement
  Performance measurement
  Fields:
    name (series string)
    startTime (series int)
    endTime (series int)
    duration (series float)
    iterations (series int)
    avgDuration (series float)
    status (series string)
    context (series string)

TraceEntry
  Execution trace entry
  Fields:
    function (series string)
    module (series string)
    entryTime (series int)
    exitTime (series int)
    isEntry (series bool)
    parameters (series string)
    returnValue (series string)
    depth (series int)

ExecutionTracer
  Execution tracer
  Fields:
    traces (array<TraceEntry>)
    currentDepth (series int)
    maxDepth (series int)
    enabled (series bool)
    maxTraces (series int)

CacheEntry
  Cache entry
  Fields:
    key (series string)
    data (series string)
    timestamp (series int)
    ttl (series int)
    accessCount (series int)
    lastAccess (series int)

CacheManager
  Cache manager
  Fields:
    name (series string)
    entries (map<string, CacheEntry>)
    maxEntries (series int)
    defaultTTL (series int)
    enabled (series bool)
    hits (series int)
    misses (series int)
    evictions (series int)

RiskAssessment
  Core risk assessment result
  Fields:
    riskLevel (series string)
    riskScore (series float)
    riskRewardRatio (series float)
    successProbability (series float)
    maxDrawdownExpected (series float)
    positionRisk (series float)
    portfolioExposure (series float)
    correlationRisk (series float)
    concentrationRisk (series float)
    volatilityRisk (series float)
    liquidityRisk (series float)
    timeframeRisk (series float)
    newsEventRisk (series float)
    supportResistanceRisk (series float)
    trendRisk (series float)
    momentumRisk (series float)
    volumeRisk (series float)
    hasHighRisk (series bool)
    hasExtremeRisk (series bool)
    riskWarnings (array<string>)
    riskFactors (array<string>)
    recommendedPositionSize (series float)
    stopLossDistance (series float)
    takeProfitDistance (series float)
    shouldAvoidTrade (series bool)
    riskMitigationStrategy (series string)
    assessmentTimestamp (series int)
    assessmentMethod (series string)
    performance (PerformanceProfile)

PositionData
  Comprehensive position data
  Fields:
    hasPosition (series bool)
    positionSide (series string)
    positionSize (series float)
    entryPrice (series float)
    entryTimestamp (series int)
    entryReason (series string)
    unrealizedPnL (series float)
    realizedPnL (series float)
    maxUnrealizedGain (series float)
    maxUnrealizedLoss (series float)
    totalReturn (series float)
    stopLossPrice (series float)
    takeProfitPrice (series float)
    riskAmount (series float)
    riskRewardRatio (series float)
    currentRisk (RiskAssessment)
    barsInPosition (series int)
    maxBarsAllowed (series int)
    isTimedOut (series bool)
    timeframe (series string)
    hasExitSignal (series bool)
    exitReason (series string)
    exitScore (series float)
    shouldExit (series bool)
    exitUrgency (series string)
    actionHistory (array<string>)
    timestampHistory (array<int>)
    reasonHistory (array<string>)
    sharpeRatio (series float)
    maxDrawdown (series float)
    winRate (series float)
    avgHoldTime (series float)

StrategyTemplate
  Base strategy template
  Fields:
    name (series string)
    description (series string)
    category (series string)
    timeframes (array<string>)
    entryThreshold (series float)
    entryConfidenceMin (series float)
    requiredSignals (array<string>)
    excludeConditions (array<string>)
    exitThreshold (series float)
    stopLossPercent (series float)
    takeProfitPercent (series float)
    maxBarsInTrade (series int)
    maxPositionSize (series float)
    basePositionSize (series float)
    useVolatilityAdjustment (series bool)
    useConfidenceAdjustment (series bool)
    maxRiskPerTrade (series float)
    maxDailyRisk (series float)
    maxDrawdownLimit (series float)
    useAdaptiveRisk (series bool)
    requireConsensus (series bool)
    minConsensusPercent (series float)
    avoidNewsEvents (series bool)
    requireVolume (series bool)
    targetSharpeRatio (series float)
    targetWinRate (series float)
    targetRiskReward (series float)
    parameters (map<string, float>)
    flags (map<string, bool>)
    settings (map<string, string>)

MetricDataPoint
  Performance metric data point
  Fields:
    timestamp (series int)
    value (series float)
    name (series string)
    unit (series string)
    labels (map<string, string>)
    source (series string)

MetricStats
  Metric statistics
  Fields:
    min (series float)
    max (series float)
    avg (series float)
    sum (series float)
    count (series int)
    p50 (series float)
    p95 (series float)
    p99 (series float)
    stdDev (series float)
    firstTimestamp (series int)
    lastTimestamp (series int)

MetricDataPointArray
  Wrapper for array of metric data points (to avoid nested collections)
  Fields:
    dataPoints (array<MetricDataPoint>)

MetricsCollector
  Metrics collector
  Fields:
    metrics (map<string, MetricDataPointArray>)
    stats (map<string, MetricStats>)
    maxDataPoints (series int)
    retentionPeriod (series int)
    autoCleanup (series bool)
    enabled (series bool)
    enabledMetrics (array<string>)
    lastCleanupTime (series int)

ComponentHealth
  Component health status
  Fields:
    name (series string)
    status (series string)
    healthScore (series float)
    lastCheckTime (series int)
    warnings (array<string>)
    errors (array<string>)
    metrics (map<string, float>)
    lastError (series string)
    errorCount (series int)
    warningCount (series int)
    isOperational (series bool)

SystemHealth
  System health overview
  Fields:
    overallStatus (series string)
    overallScore (series float)
    healthyComponents (series int)
    degradedComponents (series int)
    unhealthyComponents (series int)
    components (array<ComponentHealth>)
    systemWarnings (array<string>)
    systemErrors (array<string>)
    lastFullCheckTime (series int)
    autoHealing (series bool)
    healingAttempts (series int)

HealthAlert
  Health alert
  Fields:
    level (series string)
    component (series string)
    message (series string)
    timestamp (series int)
    acknowledged (series bool)
    category (series string)

ZoneDetection
  Advanced zone data structure
  Fields:
    upper (series float)
    lower (series float)
    mid (series float)
    height (series float)
    score (series float)
    quality (series string)
    touchCount (series int)
    lastTouchBar (series int)
    creationBar (series int)
    role (series int)
    zoneType (series string)
    isActive (series bool)
    isBroken (series bool)
    flipBar (series int)
    flipRetestCount (series int)
    flipBestQuality (series float)
    flipScore (series float)
    hasFlipped (series bool)
    htfOverlap (series bool)
    htfTimeframe (series string)
    htfConfidence (series float)
    retestQuality (series float)
    volumeProfile (series float)
    volatilityProfile (series float)
    freshnessScore (series float)
    successfulBounces (series int)
    failedBreakouts (series int)
    successRate (series float)
    avgHoldTime (series float)
    zoneBox (series box)
    midLine (series line)
    zoneLabel (series label)
    flipLabel (series label)

ZoneDetectionConfig
  Zone analysis configuration
  Fields:
    pivotPeriod (series int)
    atrMultiplier (series float)
    atrLength (series int)
    maxZones (series int)
    mergeThreshold (series float)
    minTouchesForSignificance (series int)
    weightTouches (series float)
    weightFreshness (series float)
    weightVolume (series float)
    weightHTF (series float)
    minWickPercent (series float)
    maxBodyPercent (series float)
    freshnessHalfLife (series int)
    useHTFProjection (series bool)
    htfTimeframe (series string)
    htfPivotCount (series int)
    htfProjectionMultiplier (series float)

ChannelConfig
  Fields:
    kcEmaLength (series int)
    kcAtrLength (series int)
    kcMultiplier (series float)
    dcLength (series int)
    bbLength (series int)
    bbMultiplier (series float)
    pivotLength (series int)
    atrThreshold (series float)
    minBarsPerLeg (series int)
    minTouchCount (series int)
    mergeThreshold (series float)

ChannelState
  Fields:
    kcUpper (series float)
    kcLower (series float)
    kcBasis (series float)
    kcAtr (series float)
    dcUpper (series float)
    dcLower (series float)
    dcMid (series float)
    bbUpper (series float)
    bbLower (series float)
    bbBasis (series float)
    bbStdev (series float)
    squeezeRatio (series float)
    isSqueezeActive (series bool)
    isExpanding (series bool)
    touchKcUpper (series bool)
    touchKcLower (series bool)
    touchDcUpper (series bool)
    touchDcLower (series bool)
    kcBreakoutUp (series bool)
    kcBreakoutDown (series bool)
    dcReentryUp (series bool)
    dcReentryDown (series bool)
    squeezeBreakUp (series bool)
    squeezeBreakDown (series bool)
    kcDepth (series float)
    dcWidth (series float)
    squeezeIntensity (series float)

ChannelSignal
  Fields:
    signalType (series string)
    direction (series int)
    strength (series float)
    description (series string)
    isQualitySignal (series bool)

VwapConfig
  Fields:
    pivotLeftBars (series int)
    pivotRightBars (series int)
    clusterTolerancePercent (series float)
    minBarsBetweenSignals (series int)
    crossThreshold (series float)
    enableThrottling (series bool)
    detectClusters (series bool)

VwapState
  Fields:
    sessionVwap (series float)
    sessionVwapPrev (series float)
    anchoredVwapHigh (series float)
    anchoredVwapLow (series float)
    hasAnchoredHigh (series bool)
    hasAnchoredLow (series bool)
    priceCrossUp (series bool)
    priceCrossDown (series bool)
    canShowPriceCross (series bool)
    structureCrossUp (series bool)
    structureCrossDown (series bool)
    canShowStructureCross (series bool)
    isClusterActive (series bool)
    canShowCluster (series bool)
    clusterTolerance (series float)
    vwapsInCluster (series bool)
    priceInCluster (series bool)
    priceVwapPosition (series int)
    priceVwapDistance (series float)
    priceVwapDistancePercent (series float)
    crossStrength (series float)
    clusterStrength (series float)
    structureStrength (series float)

VwapSignal
  Fields:
    signalType (series string)
    direction (series int)
    strength (series float)
    description (series string)
    isHighConfidence (series bool)
    barIndex (series int)

VwapAnchors
  Fields:
    cumulativePV (series float)
    cumulativeV (series float)
    anchorPV_High (series float)
    anchorV_High (series float)
    hasHighAnchor (series bool)
    anchorPV_Low (series float)
    anchorV_Low (series float)
    hasLowAnchor (series bool)
    lastPriceCrossBar (series int)
    lastStructureCrossBar (series int)
    lastClusterBar (series int)

ZoneConfig
  Fields:
    htfTimeframe (series string)
    useHTF (series bool)
    maxZonesPerSide (series int)
    rankFavorHTF (series bool)
    rankFavorFVG (series bool)
    rankFavorFresh (series bool)
    showOnlyTopRank (series bool)
    alphaTop (series int)
    alphaRest (series int)
    biasLength (series int)
    biasBandMultiplier (series float)
    targetMode (series string)
    atrLength (series int)
    atrSteps (series string)
    sigmaLength (series int)
    sigmaSteps (series string)
    useSSL (series bool)
    useFVGFills (series bool)
    confirmMidline (series bool)
    confirmBreak (series bool)
    requireBias (series bool)
    lazyTargets (series bool)
    nearPercent (series float)

Zone
  Fields:
    top (series float)
    bottom (series float)
    mid (series float)
    bornTime (series int)
    isBull (series bool)
    isHTF (series bool)
    touched (series bool)
    violated (series bool)
    hasFVG (series bool)
    score (series float)
    rank (series int)
    zoneBox (series box)
    midLine (series line)
    isActive (series bool)

ZoneState
  Fields:
    zonesTF (array<Zone>)
    zonesHTF (array<Zone>)
    bias (series int)
    biasScore (series float)
    biasRegime (series string)
    vwapLevel (series float)
    bandUpper (series float)
    bandLower (series float)
    targetLevels (array<float>)
    targetLines (array<line>)
    activeBullZones (series int)
    activeBearZones (series int)
    totalZones (series int)
    avgZoneScore (series float)
    longSignal (series bool)
    shortSignal (series bool)
    nearestBullZone (Zone)
    nearestBearZone (Zone)

ZoneSignal
  Fields:
    signalType (series string)
    sourceZone (Zone)
    strength (series float)
    description (series string)
    confirmed (series bool)
    barIndex (series int)

VolumeConfig
  Fields:
    profileMode (series string)
    fixedLength (series int)
    rollingLength (series int)
    sessionString (series string)
    binCount (series int)
    valueAreaPercent (series float)
    useHLC3 (series bool)
    useHTF1 (series bool)
    htfTimeframe1 (series string)
    useHTF2 (series bool)
    htfTimeframe2 (series string)
    pivotLookback (series int)
    pivotToleranceATR (series float)
    enableAutoTuning (series bool)
    vaPct_eff (series float)
    epsATR_eff (series float)
    adaptiveAlpha (series float)
    choppinessLength (series int)
    choppyThreshold (series float)
    trendingThreshold (series float)
    useMarketRegime (series bool)
    enableLVNSignals (series bool)
    enableVASignals (series bool)
    maxRetestDistanceATR (series float)
    useEMAFilter (series bool)
    useSupertrendFilter (series bool)
    useMOSTFilter (series bool)
    showPOC (series bool)
    showValueArea (series bool)
    showNodes (series bool)
    showSilhouette (series bool)
    silhouetteOffset (series int)
    silhouetteWidth (series int)
    zoneOpacity (series int)
    enableSessionSplits (series bool)
    maxSessionCount (series int)

VolumeNode
  Fields:
    price (series float)
    volume (series float)
    nodeType (series string)
    prominence (series float)
    isSignificant (series bool)

VolumeProfile
  Fields:
    pocPrice (series float)
    pocVolume (series float)
    valueAreaHigh (series float)
    valueAreaLow (series float)
    totalVolume (series float)
    windowStart (series int)
    windowLength (series int)
    windowHigh (series float)
    windowLow (series float)
    binVolumes (array<float>)
    binPrices (array<float>)
    hvnNodes (array<VolumeNode>)
    lvnNodes (array<VolumeNode>)
    nearestLVN (series float)
    nearestHVN (series float)
    htfConfluence (series bool)
    pocLine (series line)
    valueAreaBox (series box)
    nodeBoxes (array<box>)
    silhouette (series polyline)

VolumeState
  Fields:
    currentProfile (VolumeProfile)
    sessionProfiles (array<VolumeProfile>)
    trendBullish (series bool)
    emaConfluence (series float)
    supertrendBull (series bool)
    mostBull (series bool)
    choppiness (series float)
    isChoppy (series bool)
    isTrending (series bool)
    marketRegime (series string)
    vaPct_current (series float)
    epsATR_current (series float)
    smoothingFactor (series float)
    longLVNSignal (series bool)
    shortLVNSignal (series bool)
    longVASignal (series bool)
    shortVASignal (series bool)
    volumeScore (series float)
    passFilter (series bool)
    inValueArea (series bool)
    abovePOC (series bool)
    pocRising (series bool)
    nearLVN (series bool)

VolumeSignal
  Fields:
    signalType (series string)
    direction (series int)
    strength (series float)
    description (series string)
    triggerPrice (series float)
    hasConfluence (series bool)
    barIndex (series int)

HTFConfig
  Fields:
    timeframes (array<string>)
    tfWeights (array<float>)
    autoSelectTFs (series bool)
    maxTimeframes (series int)
    trendLength (series int)
    trendThreshold (series float)
    trendMethod (series string)
    stackThreshold (series float)
    requireAllTFs (series bool)
    confluenceBonus (series float)
    enableAutoTuning (series bool)
    choppinessLength (series int)
    choppyThreshold (series float)
    trendingThreshold (series float)
    showStackPanel (series bool)
    panelPosition (series string)
    panelRows (series int)
    panelCols (series int)
    showTooltips (series bool)

HTFTrendData
  Fields:
    timeframe (series string)
    trendStrength (series float)
    trendDirection (series string)
    confidence (series float)
    isValid (series bool)
    weight (series float)
    trendColor (series color)

HTFStackState
  Fields:
    tfData (array<HTFTrendData>)
    bullConfluence (series float)
    bearConfluence (series float)
    stackStrength (series float)
    stackBias (series string)
    choppiness (series float)
    isChoppy (series bool)
    isTrending (series bool)
    marketRegime (series string)
    vaPct_eff (series float)
    epsATR_eff (series float)
    adaptiveAlpha (series float)
    bullStackSignal (series bool)
    bearStackSignal (series bool)
    stackBreakSignal (series bool)
    stackTable (series table)
    tfLabels (array<label>)
    strengthBars (array<box>)

RedefiningTechnicalAnalysisCore
  Main library state container
  Fields:
    analysisConfig (AnalysisConfig)
    timeframeConfig (TimeframeConfig)
    activeStrategy (StrategyTemplate)
    lastAnalysis (MultiTimeframeResult)
    lastSignal (SignalResult)
    lastRisk (RiskAssessment)
    currentPosition (PositionData)
    isInitialized (series bool)
    lastUpdateTime (series int)
    currentTimeframe (series string)
    globalPerformance (PerformanceProfile)
    systemHealth (SystemHealth)
    metricsCollector (MetricsCollector)
    analysisCache (CacheManager)
    calculationCache (CacheManager)
    recentErrors (array<string>)
    recentWarnings (array<string>)
    errorCount (series int)
    warningCount (series int)
    debugLogger (DebugLogger)
    debugMode (series bool)
    extensionData (map<string, float>)
    featureFlags (map<string, bool>)

il y a 2 heures

Notes de version

v2

Hinzugefügt:
calculateStopLossLevels(close, atr14, lastSupport, lastResistance, useATRStops, atrMultiplier, riskRewardRatio, strongBuySignal, strongSellSignal)
  Calculate stop-loss and take-profit levels
  Parameters:
    close (float)
    atr14 (float)
    lastSupport (float)
    lastResistance (float)
    useATRStops (bool)
    atrMultiplier (float)
    riskRewardRatio (float)
    strongBuySignal (bool)
    strongSellSignal (bool)

calculateRegimePositionSizing(regime, overallScore, accountRiskPct, maxPositionSize, minPositionSize)
  Calculate regime-aware position sizing
  Parameters:
    regime (MarketRegime)
    overallScore (float)
    accountRiskPct (float)
    maxPositionSize (float)
    minPositionSize (float)

assessRiskQuality(regime, overallScore, riskAmountBuy, close, thresholdStrong)
  Assess risk quality of current setup
  Parameters:
    regime (MarketRegime)
    overallScore (float)
    riskAmountBuy (float)
    close (float)
    thresholdStrong (float)

getRiskSummary(regime)
  Get risk summary string
  Parameters:
    regime (MarketRegime)

formatPositionSizing(sizing)
  Format position sizing for display
  Parameters:
    sizing (PositionSizing)

MarketRegime
  Market regime detection data
  Fields:
    isTrending (series bool)
    isRanging (series bool)
    isTransitioning (series bool)
    isUptrend (series bool)
    isDowntrend (series bool)
    isNoTrend (series bool)
    isHighVol (series bool)
    isLowVol (series bool)
    isNormalVol (series bool)
    volatilityRatio (series float)
    adxValue (series float)
    diPlus (series float)
    diMinus (series float)
    marketRegime (series string)
    volRegime (series string)
    timestamp (series int)

StopLossLevels
  Stop-loss and take-profit levels
  Fields:
    stopLossBuy (series float)
    stopLossSell (series float)
    profitTargetBuy (series float)
    profitTargetSell (series float)
    riskAmountBuy (series float)
    riskAmountSell (series float)
    entryZoneBuyLow (series float)
    entryZoneBuyHigh (series float)
    entryZoneSellLow (series float)
    entryZoneSellHigh (series float)
    atrValue (series float)
    atrMultiplier (series float)
    riskRewardRatio (series float)
    useATRStops (series bool)
    timestamp (series int)

PositionSizing
  Position sizing recommendation
  Fields:
    positionSizeMultiplier (series float)
    basePositionSize (series float)
    adjustedPositionSize (series float)
    volatilityAdjustment (series float)
    scoreAdjustment (series float)
    regimeAdjustment (series float)
    accountRiskPct (series float)
    maxPositionSize (series float)
    minPositionSize (series float)
    sizingReason (series string)
    timestamp (series int)

RiskQuality
  Risk quality assessment
  Fields:
    riskQualityScore (series float)
    riskQualityGrade (series string)
    riskQualityColor (series color)
    trendingFavorable (series bool)
    volatilityFavorable (series bool)
    scoreStrengthFavorable (series bool)
    riskAmountFavorable (series bool)
    positiveFactors (array<string>)
    negativeFactors (array<string>)
    timestamp (series int)