"""cAlgo.API for cTrader Python algos. Generated stub for IDEs and coding agents.

Algo members are reached through `api` (the cBot, indicator or plugin instance). Reference: https://help.ctrader.com/ctrader-algo/references/
"""
from __future__ import annotations
from typing import Any, Callable, Generic, Iterable, Sequence, TypeVar, overload

T = TypeVar("T")
DateTime = Any
TimeSpan = Any
Uri = Any
Task = Any
Exception = Any
Type = Any

class Event(Generic[T]):
    def __iadd__(self, handler: T) -> Event[T]: ...
    def __isub__(self, handler: T) -> Event[T]: ...

class AbsoluteStopLossProtection:
    """Represents a stop loss defined at an absolute price level."""
    @overload
    def __init__(self, Price: float) -> None: ...
    @overload
    def __init__(self, original: AbsoluteStopLossProtection) -> None: ...
    Price: float
    """The absolute price at which the stop loss is triggered."""

class AbsoluteTakeProfitLastProtection:
    """Represents the final take profit in an absolute take profit ladder, closing any remaining order volume at a specified price."""
    @overload
    def __init__(self, Price: float) -> None: ...
    @overload
    def __init__(self, original: AbsoluteTakeProfitLastProtection) -> None: ...
    Price: float
    """The absolute price at which the remaining volume is closed."""

class AbsoluteTakeProfitProtection:
    """Represents a partial take profit closing a portion of the order volume at an absolute price."""
    @overload
    def __init__(self, Volume: float, Price: float) -> None: ...
    @overload
    def __init__(self, original: AbsoluteTakeProfitProtection) -> None: ...
    Price: float
    """The absolute price at which the take profit is triggered."""
    Volume: float
    """The portion of the order volume to close when the take profit is triggered."""

class AbsoluteTakeProfitProtections:
    """Represents a ladder of up to four partial take profits at absolute prices, followed by a final take profit that closes any remaining volume."""
    @overload
    def __init__(self, lastTakeProfit: AbsoluteTakeProfitLastProtection) -> None: ...
    @overload
    def __init__(self, firstTakeProfit: AbsoluteTakeProfitProtection, lastTakeProfit: AbsoluteTakeProfitLastProtection) -> None: ...
    @overload
    def __init__(self, firstTakeProfit: AbsoluteTakeProfitProtection, secondTakeProfit: AbsoluteTakeProfitProtection, lastTakeProfit: AbsoluteTakeProfitLastProtection) -> None: ...
    @overload
    def __init__(self, firstTakeProfit: AbsoluteTakeProfitProtection, secondTakeProfit: AbsoluteTakeProfitProtection, thirdTakeProfit: AbsoluteTakeProfitProtection, lastTakeProfit: AbsoluteTakeProfitLastProtection) -> None: ...
    @overload
    def __init__(self, firstTakeProfit: AbsoluteTakeProfitProtection, secondTakeProfit: AbsoluteTakeProfitProtection, thirdTakeProfit: AbsoluteTakeProfitProtection, fourthTakeProfit: AbsoluteTakeProfitProtection, lastTakeProfit: AbsoluteTakeProfitLastProtection) -> None: ...
    @overload
    def __init__(self, original: AbsoluteTakeProfitProtections) -> None: ...
    FirstTakeProfit: AbsoluteTakeProfitProtection
    """Gets the first partial take profit, if any."""
    FourthTakeProfit: AbsoluteTakeProfitProtection
    """Gets the fourth partial take profit, if any."""
    LastTakeProfit: AbsoluteTakeProfitLastProtection
    """Gets the final take profit that closes the remaining volume."""
    SecondTakeProfit: AbsoluteTakeProfitProtection
    """Gets the second partial take profit, if any."""
    ThirdTakeProfit: AbsoluteTakeProfitProtection
    """Gets the third partial take profit, if any."""

class AcceleratorOscillator(StandardIndicator):
    """Identifies possible trend reversals"""
    Result: IndicatorDataSeries
    """AcceleratorOscillator calculation result"""

class AccessRights:
    """cBots and Indicators Access Rights."""
    None: AccessRights
    FileSystem: AccessRights
    Internet: AccessRights
    Registry: AccessRights
    FullAccess: AccessRights

class AccountSwitchedEventArgs:
    """Provides data for the account switched event."""
    CurrentAccountNumber: int
    """Returns new account number."""
    PreviousAccountNumber: int
    """Returns previous account number."""

class AccountType:
    """Returns current account type"""
    Hedged: AccountType
    Netted: AccountType

class AccumulationDistribution(StandardIndicator):
    """Accumulation Distribution indicator is an indicator that can identify if the market is driven by buyers (accumulation) or by sellers (distribution)"""
    Result: IndicatorDataSeries
    """Gets the resulting time series of the Accumulation Distribution indicator calculation."""

class AccumulativeSwingIndex(StandardIndicator):
    """A variation on Wilder's swing index which plots an accumulation of the swing index value of each candlestick or bar."""
    Result: IndicatorDataSeries
    """The time series of AccumulativeSwingIndex."""

class ActiveFrameChangedEventArgs:
    """Provides data for the active frame changed event."""
    NewFrame: Frame
    """Returns the new active frame or null."""
    OldFrame: Frame
    """Returns the old / previous active frame or null."""

class Algo:
    """The container class for the main cAlgo.API Interfaces."""
    def BeginInvokeOnMainThread(self, action: Action) -> None:
        """Invokes asynchronously the specified code on the main cBot or Indicator thread."""
        ...
    def CreateDataSeries(self) -> IndicatorDataSeries:
        """Initialization of an IndicatorDataSeries."""
        ...
    def OnException(self, exception: Exception) -> None:
        """Called on each unhandled exception."""
        ...
    def OnTimer(self) -> None:
        """Called when the timer interval has elapsed."""
        ...
    @overload
    def Print(self, value: object) -> None:
        """Prints text representation of the specified object to the log."""
        ...
    @overload
    def Print(self, parameters: list[object]) -> None:
        """Prints a message to the Log"""
        ...
    @overload
    def Print(self, message: str, parameters: list[object]) -> None:
        """Prints a message to the Log."""
        ...
    def RefreshData(self) -> None:
        """Updates Bars, Positions, PendingOrders, History, etc. And sends postponed events after Thread sleep call. If you put the main thread on sleep by calling Thread sleep method then you have to call RefreshData after Thread wakes up to send the postponed events while thread was sleeping."""
        ...
    @overload
    def Sleep(self, timespan: TimeSpan) -> None:
        """Suspends the algorithm until the specified timespan elapses."""
        ...
    @overload
    def Sleep(self, milliseconds: int) -> None:
        """Suspends the algorithm until the specified number of milliseconds elapses."""
        ...
    @overload
    def Sleep(self, dateTime: DateTime) -> None:
        """Suspends the algorithm until the specified datetime ."""
        ...
    AlgoRegistry: AlgoRegistry
    """Provides access to installed Algorithms."""
    Application: Application
    """Represents the application."""
    Ask: float
    """Gets the symbol ask price."""
    AssetConverter: IAssetConverter
    """Converts an asset to another asset."""
    Assets: Assets
    """Returns list of all available assets."""
    Bars: Bars
    """The collection of Bar objects."""
    Bid: float
    """Gets the symbol bid price."""
    Chart: Chart
    """Represents the chart where cBot or Indicator is launched."""
    ChartIndicators: ChartIndicators
    """Gets the ChartIndicators of an algorithm."""
    ChartRobots: ChartRobots
    """Gets the ChartRobots of an algorithm."""
    ChartTemplates: ChartTemplates
    """Provides access to Chart Templates."""
    Clipboard: Clipboard
    """Provides access to system Clipboard."""
    Compiler: Compiler
    """Provides access to algo compiler."""
    HistoricalOrders: HistoricalOrders
    """Provides access to historical orders."""
    History: History
    """Represents the collection of all historical trades of the account."""
    Http: Http
    """Send HTTP requests."""
    Indicators: IIndicatorsAccessor
    """Access to the built-in Indicators."""
    InstanceId: str
    """Returns unique ID of current running instance."""
    InstanceTitle: str
    """Gets or sets instance title."""
    IsBacktesting: bool
    """True if a cBot is in the Backtesting mode, otherwise False."""
    LocalStorage: LocalStorage
    """Access the local storage API."""
    MarketData: MarketData
    """Provides access to the Depth of Market Data."""
    MarketSessions: MarketSession
    """Returns current market sessions."""
    Messages: Messages
    """Access the messaging API."""
    Notifications: INotifications
    """Represents the notifications, such as sounds and email."""
    PendingOrders: PendingOrders
    """The array of all Pending Orders of the account."""
    Positions: Positions
    """The list of all open positions of the account."""
    PriceAlerts: PriceAlerts
    """Provides access to Price Alerts."""
    RunningMode: RunningMode
    """Defines if a cBot is running in real time, in the silent backtesting mode, in the visual backtesting mode, or in the optimization mode."""
    Server: IServer
    """Server related information."""
    Symbol: Symbol
    """Represents the current symbol provides access to its properties and certain methods"""
    SymbolName: str
    """Gets or sets the symbol name."""
    Symbols: Symbols
    """Gets the symbol names."""
    Time: DateTime
    """Returns the current server time. The shortcut to the Server.Time property."""
    TimeFrame: TimeFrame
    """Access to the TimeFrame values."""
    TimeFrames: TimeFrames
    """Gets collection of available TimeFrames."""
    TimeInUtc: DateTime
    """Returns the current server time in UTC. The shortcut to the Server.TimeInUtc property."""
    TimeZone: TimeZoneInfo
    """TimeZone of a cBot or an Indicator."""
    Timer: Timer
    """Access to the Timer object."""
    Transactions: Transactions
    """Access account transactions."""
    Watchlists: Watchlists
    """Gets the watchlist."""
    MarketSessionsChanged: Event[Callable[[MarketSessionChangedEventArgs], None]]
    """Occurs when market sessions change."""

class AlgoInstanceParameter:
    """The interface representing an indicator / robot instance parameter. Provides properties that allow for accessing various information about an algo instance parameter."""
    DisplayName: str
    """Gets the display name of a parameter (shown in the 'Parameters' section of an instance)."""
    Name: str
    """Gets the name of a parameter."""
    Type: AlgoParameterType
    """Gets the ALgoParameterType of a parameter."""
    Value: object
    """Gets the value of a parameter."""

class AlgoInstanceParameters:
    """Represents the collection of all the parameters of an indicator or Robot."""
    Count: int
    """Gets the number of parameters."""
    Item: AlgoInstanceParameter
    """Gets a parameter by it is index."""
    Item: AlgoInstanceParameter
    """Gets a parameter by it is name."""

class AlgoKind:
    """Represents the predefined kinds of algorithm types."""
    CustomIndicator: AlgoKind
    StandardIndicator: AlgoKind
    Robot: AlgoKind
    Plugin: AlgoKind

class AlgoParameter:
    """Represents an algorithm parameter."""
    DefaultValue: object
    """Gets default value of the parameter."""
    Name: str
    """Gets Parameter name."""
    Type: AlgoParameterType
    """Gets parameter type."""

class AlgoParameterType:
    """Represents the different types of algorithm parameters."""
    Integer: AlgoParameterType
    Double: AlgoParameterType
    Boolean: AlgoParameterType
    String: AlgoParameterType
    Enum: AlgoParameterType
    DataSeries: AlgoParameterType
    Color: AlgoParameterType
    TimeFrame: AlgoParameterType
    Symbol: AlgoParameterType
    DateTime: AlgoParameterType
    DateOnly: AlgoParameterType
    TimeSpan: AlgoParameterType
    MultiEnum: AlgoParameterType
    MultiSymbol: AlgoParameterType
    MultiTimeFrame: AlgoParameterType
    File: AlgoParameterType
    MultiFile: AlgoParameterType

class AlgoRegistry:
    """Provides all installed algorithms data"""
    @overload
    def Exists(self, name: str) -> bool:
        """Checks existence of an algorithm."""
        ...
    @overload
    def Exists(self, name: str, algoKind: AlgoKind) -> bool:
        """Checks existence of an algorithm."""
        ...
    @overload
    def Get(self, name: str) -> AlgoType:
        """Returns an algorithm type by it is name."""
        ...
    @overload
    def Get(self, name: str, algoKind: AlgoKind) -> AlgoType:
        """Returns an algorithm type by it is name and kind."""
        ...
    def GetCount(self, algoKind: AlgoKind) -> int:
        """Returns number of specific kind of installed algorithms."""
        ...
    @overload
    def Install(self, filePath: str) -> InstallationResult:
        """Installs an algo file from provided file path."""
        ...
    @overload
    def Install(self, uri: Uri) -> InstallationResult:
        """Installs an algo file from provided URI."""
        ...
    @overload
    def InstallAsync(self, filePath: str) -> InstallationOperation:
        """Installs an algo file from provided URI asynchrounsly."""
        ...
    @overload
    def InstallAsync(self, filePath: str, callback: Callable[[InstallationResult], None]) -> InstallationOperation:
        """Installs an algo file from provided URI asynchrounsly."""
        ...
    @overload
    def InstallAsync(self, uri: Uri) -> InstallationOperation:
        """Installs an algo file from provided URI asynchrounsly."""
        ...
    @overload
    def InstallAsync(self, uri: Uri, callback: Callable[[InstallationResult], None]) -> InstallationOperation:
        """Installs an algo file from provided URI asynchrounsly."""
        ...
    Count: int
    """Gets number of installed algorithms."""
    Indicators: IReadonlyList[IndicatorType]
    """Gets the list of all installed indicators."""
    Plugins: IReadonlyList[PluginType]
    """Gets the list of all installed plugins."""
    Robots: IReadonlyList[RobotType]
    """Gets the list of all installed robots."""
    AlgoTypeChanged: Event[Callable[[AlgoTypeChangedEventArgs], None]]
    """Occurs when an algorithm is changed."""
    AlgoTypeDeleted: Event[Callable[[AlgoTypeDeletedEventArgs], None]]
    """Occurs when an algorithm is deleted."""
    AlgoTypeInstalled: Event[Callable[[AlgoTypeInstalledEventArgs], None]]
    """Occurs when a new algorithm is installed."""

class AlgoType:
    """Base type for representing an algorithm."""
    AlgoKind: AlgoKind
    """Gets algorithm kind."""
    Name: str
    """Gets algorithm name."""
    ProjectFilePath: str
    """Gets algorithm project file ".csproj" path if it has source code, otherwise null."""

class AlgoTypeChangedEventArgs(AlgoTypeEventArgs):
    """Provides data for Algo type changed event."""
    ...

class AlgoTypeDeletedEventArgs(AlgoTypeEventArgs):
    """Provides data for Algo type deleted event."""
    ...

class AlgoTypeEventArgs:
    """Base structure that provides data for Algo registry events."""
    AlgoTypeName: str
    """Algo Type Name"""

class AlgoTypeInstalledEventArgs(AlgoTypeEventArgs):
    """Provides data for Algo type installed event."""
    ...

class Alligator(StandardIndicator):
    """Legendary trader Bill Williams, an early pioneer of market psychology, developed the trend-following Alligator indicator, which follows the premise that financial markets and individual securities trend just 15% to 30% of the time while grinding through sideways ranges the other 70% to 85% of the time."""
    Jaws: IndicatorDataSeries
    """The jaw is the x-period (13) smoothed moving average that is moved into the future by x (18) bars."""
    Lips: IndicatorDataSeries
    """The lips is the x-period (5) smoothed moving average that is moved by x (3) bars into the future"""
    Teeth: IndicatorDataSeries
    """The teeth is the x-period (8) smoothed moving average that is moved x (5) bars into the future."""

class Application:
    """Represents the application."""
    ColorTheme: ColorTheme
    """Gets the color theme."""
    Draggables: ApplicationDraggables
    """Gets application draggables."""
    DrawingColor: Color
    """Gets current drawing color."""
    EnvironmentType: EnvironmentType
    """Gets the environment type."""
    Language: Language
    """Gets the current language."""
    UserTimeOffset: TimeSpan
    """Gets user time offset."""
    Version: Version
    """Gets the version."""
    ColorThemeChanged: Event[Callable[[ColorThemeChangeEventArgs], None]]
    """Occurs when color theme has changed."""
    DrawingColorChanged: Event[Callable[[DrawingColorChangedEventArgs], None]]
    """Occurs when DrawingColor has changed."""
    LanguageChanged: Event[Callable[[LanguageChangedEventArgs], None]]
    """Occurs when Language has changed."""
    UserTimeOffsetChanged: Event[Callable[[UserTimeOffsetChangedEventArgs], None]]
    """Occurs when user time offset has changed."""

class ApplicationDraggable:
    """Represents a draggable box that can host a control and shown over application."""
    Child: ControlBase
    """Get / set the content control inside the draggable."""
    Id: str
    """Get unique ID of the Draggable."""
    IsVisible: bool
    """Get / set visibility of draggable."""
    ShowGrip: bool
    """Get / set move grip visibility (default: true)."""
    X: float
    """Get / set X coordinate (default: 0)."""
    Y: float
    """Get / set Y coordinate (default: 0)."""
    LocationChanged: Event[Callable[[ApplicationDraggableLocationChangedEventArgs], None]]
    """Occurs when the draggable's location is changed."""

class ApplicationDraggableLocationChangedEventArgs:
    """Provides data for LocationChanged event of ApplicationDraggable."""
    Draggable: ApplicationDraggable
    """Gets the draggable."""

class ApplicationDraggables:
    """Represents collection of application draggables."""
    def Add(self) -> ApplicationDraggable:
        """Adds a draggable to application."""
        ...
    def Remove(self, draggable: ApplicationDraggable) -> None:
        """Removes a draggable from application."""
        ...
    Count: int
    """Gets count of draggables."""

class Aroon(StandardIndicator):
    """An indicator for identifying trends in a currency pair, as well as for gauging the probability of a trend reversal."""
    Down: IndicatorDataSeries
    """Aroon Down"""
    Up: IndicatorDataSeries
    """Aroon Up"""

class Asp:
    """Represents the active symbol panel."""
    def AddTab(self, title: str) -> AspTab:
        """Adds a new tab to active symbol panel."""
        ...
    @overload
    def RemoveTab(self, id: str) -> bool:
        """Removes a tab from active symbol panel."""
        ...
    @overload
    def RemoveTab(self, tab: AspTab) -> bool:
        """Removes a tab from active symbol panel."""
        ...
    SymbolTab: AspSymbolTab
    """Symbol tab in active symbol panel."""

class AspBlock:
    """Represents an active symbol panel block."""
    Child: ControlBase
    """Get / set content of current block."""
    DetachedWindow: DetachedWindow
    """Returns detached window properties."""
    Height: float
    """Get / set height of current block (default is 200)."""
    Id: str
    """Returns unique ID of the current block."""
    Index: int
    """Get index of current block."""
    IsAttached: bool
    """Get / set block attached / detached state."""
    IsDetachable: bool
    """Get / set block detachability, if True user can attach or detach the block."""
    IsExpanded: bool
    """Get expanded state of current block."""
    Title: str
    """Returns title of the current block."""
    Attached: Event[Callable[[AspBlockAttachedEventArgs], None]]
    """Occurs when block attached."""
    Detached: Event[Callable[[AspBlockDetachedEventArgs], None]]
    """Occurs when block is detached."""
    Updated: Event[Callable[[AspBlockUpdatedEventArgs], None]]
    """Occurs when block is updated."""

class AspBlockAttachedEventArgs:
    """Provides data for plugin ASP block attached event."""
    AspBlock: AspBlock
    """Attached block."""

class AspBlockDetachedEventArgs:
    """Provides data for plugin ASP block detached event."""
    AspBlock: AspBlock
    """Detached block."""

class AspBlockUpdatedEventArgs:
    """Provides data for plugin ASP block updated event."""
    AspBlock: AspBlock
    """Updated block."""

class AspSymbolChangedEventArgs:
    """Provides data for active symbol panel symbol changed event."""
    NewSymbol: Symbol
    """New symbol of active symbol panel."""
    OldSymbol: Symbol
    """Old symbol of active symbol panel."""

class AspSymbolTab:
    """Active symbol panel tab."""
    def AddBlock(self, title: str) -> AspBlock:
        """Adds a new section block to active symbol panel."""
        ...
    @overload
    def RemoveBlock(self, id: str) -> bool:
        """Removes a section block from active symbol panel."""
        ...
    @overload
    def RemoveBlock(self, block: AspBlock) -> bool:
        """Removes a section block from active symbol panel."""
        ...
    Symbol: Symbol
    """Current symbol of Active symbol panel."""
    SymbolChanged: Event[Callable[[AspSymbolChangedEventArgs], None]]
    """Occurs when active symbol panel selected symbol changes."""

class AspTab:
    """Represents an active symbol panel tab."""
    Child: ControlBase
    """Get / set content of current tab."""
    Id: str
    """Returns unique ID of the current tab."""
    Index: int
    """Get / set index of current tab (Must be greater than zero)."""
    IsSelected: bool
    """Get / set selected state of current tab."""
    Title: str
    """Returns title of the current tab."""
    IsSelectedChanged: Event[Callable[[AspTabIsSelectedChangedEventArgs], None]]
    """Occurs after tab IsSelected value change."""

class AspTabIsSelectedChangedEventArgs:
    """Provides data for plugin ASP tab IsSelectedChanged event."""
    AspTab: AspTab
    """ASP tab."""

class Asset:
    """The asset represents a currency."""
    @overload
    def Convert(self, to: Asset, value: float) -> float:
        """Converts value to another asset."""
        ...
    @overload
    def Convert(self, to: str, value: float) -> float:
        """Converts value to another asset."""
        ...
    Digits: int
    """Number of asset digits"""
    Name: str
    """The asset Name"""

class Assets:
    """Represents the list of all the assets with the asset names as string values."""
    def Exists(self, assetName: str) -> bool:
        """Defines if the specific asset exists."""
        ...
    def GetAsset(self, assetName: str) -> Asset:
        """Gets the asset."""
        ...
    def GetAssets(self, assetNames: list[str]) -> list[Asset]:
        """Get multiple assets on a single call."""
        ...
    Count: int
    """Gets the total number of the assets."""
    Item: str
    """Gets the desired asset."""

class AverageDirectionalMovementIndexRating(StandardIndicator):
    """The Average Directional Movement Index Rating (ADXR) measures the strength of the Average Directional Movement Index (ADX). It's calculated by taking the average of the current ADX and the ADX from one time period before."""
    ADX: IndicatorDataSeries
    """The Average Directional Movement Index (ADX) indicates whether the market is trending or ranging."""
    ADXR: IndicatorDataSeries
    """The rating of Average Directional Movement Index (ADX)"""
    DIMinus: IndicatorDataSeries
    """The Positive Direction Indicator (+DI) indicates upward trend movement."""
    DIPlus: IndicatorDataSeries
    """The Negative Direction Indicator (-DI) indicates downward trend movement."""

class AverageTrueRange(StandardIndicator):
    """Average true range. An indicator providing the degree of price volatility."""
    Result: IndicatorDataSeries
    """The resulting data series of Average True Range Indicator instance"""

class AwesomeOscillator(StandardIndicator):
    """Displays the market momentum as a histogram."""
    Result: IndicatorDataSeries
    """Gets the Awesome Oscillator calculation result."""

class Backtesting:
    """Provides methods and events to manage and monitor backtesting processes."""
    def Start(self, robotType: RobotType, symbolName: str, timeFrame: TimeFrame, settings: BacktestingSettings, parameterValues: list[object]) -> BacktestingProcess:
        """Starts the backtesting process."""
        ...
    DataSources: BacktestingDataSources
    """Provides access to backtesting data sources."""
    Completed: Event[Callable[[BacktestingCompletedEventArgs], None]]
    """Occurs when the backtesting process is completed."""
    ProgressChanged: Event[Callable[[BacktestingProgressChangedEventArgs], None]]
    """Occurs when the backtesting progress changes."""

class BacktestingBar:
    """Represents an OHLCV bar."""
    def __init__(self, Time: DateTime, Open: float, High: float, Low: float, Close: float, Volume: int) -> None: ...
    Close: float
    """Close Price"""
    High: float
    """High Price"""
    Low: float
    """Low Price"""
    Open: float
    """Open Price"""
    Time: DateTime
    """Open Time"""
    Volume: int
    """Volume Amount"""

class BacktestingBarsData(BacktestingData):
    """Represents a collection of backtesting bars data."""
    def __init__(self, data: Iterable[BacktestingBar]) -> None: ...

class BacktestingCompletedEventArgs:
    """Provides data for the backtesting completed event."""
    HtmlReport: str
    """Gets the HTML report of the backtesting results."""
    JsonReport: str
    """Gets the JSON report of the backtesting results."""
    Process: BacktestingProcess
    """Gets the backtesting process that has completed."""

class BacktestingData:
    """Base type for backtesting data used for backtesting data source."""
    ...

class BacktestingDataMode:
    """Specifies the data mode used for backtesting."""
    Ticks: BacktestingDataMode
    M1: BacktestingDataMode
    M1Csv: BacktestingDataMode
    OpenPrices: BacktestingDataMode
    TickCsv: BacktestingDataMode

class BacktestingDataRequest:
    """Represents a backtesting data request for a backtesting data source."""
    def Complete(self, data: BacktestingData) -> None:
        """Completes current request."""
        ...
    def Fail(self, errorMessage: str) -> None:
        """Notifies current request failure if something went wrong."""
        ...
    DataType: BacktestingDataSourceDataType
    """Gets request data type."""
    EndTime: DateTime
    """Gets request end time."""
    PriceDataSourceId: PriceDataSourceId
    """Gets request price data source Id (Symbol and TimeFrame)."""
    StartTime: DateTime
    """Gets request start time."""
    Status: BacktestingDataRequestStatus
    """Gets current status of request."""
    StatusChanged: Event[Callable[[BacktestingDataRequestStatusChangedEventArgs], None]]
    """Occurs when request status is changed."""

class BacktestingDataRequestStatus:
    """Specifies the different status of a backtesting data request."""
    InProgress: BacktestingDataRequestStatus
    Failed: BacktestingDataRequestStatus
    Completed: BacktestingDataRequestStatus
    Cancelled: BacktestingDataRequestStatus

class BacktestingDataRequestStatusChangedEventArgs:
    """Provides data for the backtesting data request status changed event."""
    DataRequest: BacktestingDataRequest
    """Gets data request."""

class BacktestingDataSource:
    """Represents a backtesting data source."""
    def ClearCache(self) -> bool:
        """Clears cached price data of current data source if not being used."""
        ...
    Name: str
    """Gets unique name of backtesting data source."""
    SupportOnlyOwnCustomTimeFrames: bool
    """Gets / sets if current backtesting data source can be used only for owner plugin custom TimeFrames or for both owner plugin custom TimeFrames and built-in TimeFrames. If True current source will only appear if backtesting TimeFrame is owner plugin created custom TimeFrame."""

class BacktestingDataSourceDataType:
    """Specifies the different data types for backtesting data source."""
    Tick: BacktestingDataSourceDataType
    M1OpenPrices: BacktestingDataSourceDataType
    OpenPrices: BacktestingDataSourceDataType

class BacktestingDataSourceMinMaxTimeArgs:
    """Provides data for the backtesting data source min / max time handler."""
    DataType: BacktestingDataSourceDataType
    """Gets data type for the min / max time request."""
    PriceDataSourceId: PriceDataSourceId
    """Gets price data source Id for the min / max time request."""

class BacktestingDataSourceOptions:
    """Represents options of a backtesting data source, used for creating new data source."""
    @overload
    def __init__(self, SupportedDataTypes: BacktestingDataSourceDataType, MinMaxTimeHandler: Callable[[BacktestingDataSourceMinMaxTimeArgs], BacktestingMinMaxTime], DataRequestHandler: Callable[[BacktestingDataRequest], None]) -> None: ...
    @overload
    def __init__(self, original: BacktestingDataSourceOptions) -> None: ...
    DataRequestHandler: Callable[[BacktestingDataRequest], None]
    """Handler function for handling data requests."""
    MinMaxTimeHandler: Callable[[BacktestingDataSourceMinMaxTimeArgs], BacktestingMinMaxTime]
    """Handler function for getting minimum and maximum time."""
    SupportedDataTypes: BacktestingDataSourceDataType
    """Supported data types (ex: BacktestingDataSourceDateType.Tick | BacktestingDataSourceDateType.M1OpenPrices)"""

class BacktestingDataSources:
    """Provides access to backtesting data sources."""
    def Add(self, name: str, options: BacktestingDataSourceOptions) -> BacktestingDataSource:
        """Adds a new backtesting data source."""
        ...
    def Remove(self, dataSource: BacktestingDataSource) -> bool:
        """Removes a previously added backtesting data source."""
        ...
    def RemoveAllUnused(self) -> None:
        """Removes all previously added backtesting data sources that are not being used."""
        ...

class BacktestingError:
    """Specifies the error that stopped a backtesting process, None if there was no error."""
    None: BacktestingError
    Other: BacktestingError
    Net4IsNotSupported: BacktestingError
    NoConnection: BacktestingError
    NoHistoricalData: BacktestingError
    NotSupported: BacktestingError
    InvalidSettings: BacktestingError

class BacktestingMinMaxTime:
    """Represents minimum and maximum time of available data for a TimeFrame Symbol on a back testing data source."""
    def __init__(self, MinTime: DateTime, MaxTime: DateTime) -> None: ...
    MaxTime: DateTime
    """Maximum Time"""
    MinTime: DateTime
    """Minimum Time"""

class BacktestingProcess:
    """Represents a backtesting process with methods and properties to monitor its status and results."""
    def Terminate(self) -> None:
        """Terminates the backtesting process."""
        ...
    BacktestingError: BacktestingError
    """Gets the error information if the backtesting process failed."""
    HtmlReport: str
    """Gets the HTML report of the backtesting results. Returns null if the backtesting is not finished or an error occurred."""
    IsCompleted: bool
    """Gets a value indicating whether the backtesting process is completed."""
    JsonReport: str
    """Gets the JSON report of the backtesting results. Returns null if the backtesting is not finished or an error occurred."""
    MonteCarloJsonReport: str
    """Gets the Monte Carlo simulation result as JSON, which is the same snapshot that is written to the output file of the MonteCarlo settings. Returns null when no Monte Carlo simulation was configured, when the backtesting is not finished, when the backtest produced no trades, or when an error occurred."""
    Completed: Event[Callable[[BacktestingCompletedEventArgs], None]]
    """Occurs when the backtesting process is completed."""
    ProgressChanged: Event[Callable[[BacktestingProgressChangedEventArgs], None]]
    """Occurs when the backtesting progress changes."""

class BacktestingProgressChangedEventArgs:
    """Provides data for the backtesting progress changed event."""
    Operation: str
    """Gets the description of the current operation."""
    Process: BacktestingProcess
    """Gets the backtesting process that reported progress."""
    Progress: float
    """Gets the progress percentage of the backtesting process."""

class BacktestingSettings:
    """Represents settings for configuring the backtesting process."""
    def __init__(self) -> None: ...
    ApplyCommissionAutomatically: bool
    """Gets or sets a value that indicates whether the commission type and value of the backtested symbol are applied automatically. When it is set to true the Commission and CommissionType properties are ignored. The default value is false."""
    Balance: float
    """Gets or sets the initial balance for the backtesting."""
    Commission: float
    """Gets or sets the commission value, it is interpreted based on the CommissionType property value. It is ignored when ApplyCommissionAutomatically is set to true. The default value is 0."""
    CommissionType: SymbolCommissionType
    """Gets or sets the commission type that defines how the Commission property value is interpreted. It is ignored when ApplyCommissionAutomatically is set to true. The default value is SymbolCommissionType.UsdPerMillionUsdVolume."""
    DataFile: str
    """Gets or sets the path to the data file used for backtesting."""
    DataMode: BacktestingDataMode
    """Gets or sets the data mode used for backtesting."""
    EndTimeUtc: DateTime
    """Gets or sets the end time in UTC for the backtesting period."""
    MonteCarlo: MonteCarloSettings
    """Gets or sets the optional Monte Carlo simulation that runs on the completed backtest. When it is null, the default, no Monte Carlo simulation is performed and the backtest behaves exactly as before. When it is set, the simulation runs on the completed backtest and its result is written to the configured output file."""
    PreciseConversion: bool
    """Gets or sets a value indicating whether historical data for additional symbols is downloaded to convert profit and margin into the account deposit currency precisely. When true, real historical exchange rates of the additional symbols are used; when false, the default, approximated rates are used. Enabling it can increase the run time and the amount of downloaded data."""
    SpreadPips: float
    """Gets or sets the spread in pips."""
    StartTimeUtc: DateTime
    """Gets or sets the start time in UTC for the backtesting period."""

class BacktestingTick:
    """Represents a tick, used for backtesting data source tick data."""
    def __init__(self, Time: DateTime, Bid: float, Ask: float) -> None: ...
    Ask: float
    """Ask Price"""
    Bid: float
    """Bid Price"""
    Time: DateTime
    """Timestamp"""

class BacktestingTickData(BacktestingData):
    """Represents a collection of backtesting tick data."""
    def __init__(self, data: Iterable[BacktestingTick]) -> None: ...

class Bar:
    """Represents the Bar object."""
    Close: float
    """Gets the Close price."""
    High: float
    """Gets the High price."""
    Low: float
    """Gets the Low price."""
    Open: float
    """Gets the open price."""
    OpenTime: DateTime
    """Gets the bar open time."""
    TickVolume: int
    """Gets the Tick volume."""

class BarClosedEventArgs:
    """Provides data for the event when a bar closed on the chart."""
    Bars: Bars
    """Gets the bar data."""

class BarOpenedEventArgs:
    """Provides data for the event when a new bar opened on the chart."""
    Bars: Bars
    """Gets the bar data."""

class BarOutputAttribute:
    """This attribute is used for marking an indicator IndicatorBars property as a bar Output."""
    def __init__(self, name: str) -> None: ...
    AreaChartFillColor: str
    """Gets or sets the color of the area chart."""
    BearFillColor: str
    """Gets or sets the color of the bear candle fill."""
    BearOutlineColor: str
    """Gets or sets the color of the bear candle or bar outline."""
    BullFillColor: str
    """Gets or sets the color of the bull candle fill."""
    BullOutlineColor: str
    """Gets or sets the color of the bull candle or bar outline."""
    ChartType: ChartType
    """Gets or sets the type of the chart - Bar, Candlesticks, Line or Dots chart."""
    Description: str
    """Gets or sets description for output that will be shown in UI."""
    DotChartColor: str
    """Gets or sets the color of the dot chart."""
    IsColorCustomizable: bool
    """Gets or sets if Output line color is customizable or not."""
    IsLastValueVisibleInTitle: bool
    """Gets or sets if output last value should be visible or not in instance title (default: true)."""
    IsVisible: bool
    """Gets or sets default visibility of output."""
    Name: str
    """The output name"""
    TickVolumeColor: str
    """Gets or sets the color of the tick volume bars."""

class Bars:
    """Represents the Bars interface - the collection of Bar objects."""
    def GetSeries(self, standardSeriesType: StandardSeriesType) -> DataSeries:
        """Returns a data series from current Bars based on the passed StandardSeriesType."""
        ...
    def GetServerFirstBarOpenTime(self) -> DateTime:
        """Returns the first available server bar open time."""
        ...
    def Last(self, index: int) -> Bar:
        """Gets the bar from the end of the collection."""
        ...
    def LoadMoreHistory(self) -> int:
        """Loads more historical bars. Method returns the number of loaded bars that were added to the beginning of the collection."""
        ...
    @overload
    def LoadMoreHistoryAsync(self) -> None:
        """Loads more historical bars asynchronously."""
        ...
    @overload
    def LoadMoreHistoryAsync(self, callback: Callable[[BarsHistoryLoadedEventArgs], None]) -> None:
        """Loads more historical bars asynchronously."""
        ...
    AveragePrices: DataSeries
    """Gets the average prices data (Open + High + Low + Close) / 4."""
    ClosePrices: DataSeries
    """Gets the Close price bars data."""
    Count: int
    """Gets the number of bars."""
    HighPrices: DataSeries
    """Gets the High price bars data."""
    Item: Bar
    """Returns a bar based on it is index"""
    LastBar: Bar
    """Gets the last bar in the chart."""
    LowPrices: DataSeries
    """Gets the Low price bars data."""
    MedianPrices: DataSeries
    """Gets the Median prices data (High + Low) / 2."""
    OpenPrices: DataSeries
    """Gets the Open price bars data."""
    OpenTimes: TimeSeries
    """Gets the open bar time data."""
    SymbolName: str
    """Gets the symbol name."""
    TickVolumes: DataSeries
    """Gets the Tick volumes data."""
    TimeFrame: TimeFrame
    """Get the timeframe."""
    TypicalPrices: DataSeries
    """Gets the Typical prices data (High + Low + Close) / 3."""
    WeightedPrices: DataSeries
    """Gets the Weighted prices data (High + Low + 2 * Close) / 4."""
    BarClosed: Event[Callable[[BarClosedEventArgs], None]]
    """Occurs when a new bar is opened; the event is called for the previous (closed) bar."""
    BarOpened: Event[Callable[[BarOpenedEventArgs], None]]
    """Occurs when the last bar is closed and a new bar is opened."""
    HistoryLoaded: Event[Callable[[BarsHistoryLoadedEventArgs], None]]
    """Occurs when more history is loaded due to chart scroll on the left or due to API call."""
    Reloaded: Event[Callable[[BarsHistoryLoadedEventArgs], None]]
    """Occurs when bars are refreshed due to reconnect."""
    Tick: Event[Callable[[BarsTickEventArgs], None]]
    """Occurs when a new Tick arrives."""

class BarsHistoryLoadedEventArgs:
    """Provides data for the history loaded event."""
    Bars: Bars
    """Gets the bar objects data."""
    Count: int
    """Gets the number of bars."""

class BarsTickEventArgs:
    """Provides data for the tick bar event."""
    Bars: Bars
    """Gets the Bar objects data."""
    IsBarOpened: bool
    """Defines if current tick is the first tick of a new bar."""

class BearsPower(StandardIndicator):
    """The calculation of the Bears Power."""
    Result: IndicatorDataSeries
    """The histogram (bar graph). It shows the maximum bearish strength during the time period."""

class BollingerBands(StandardIndicator):
    """Bollinger Bands are used to confirm signals. The bands indicate overbought and oversold levels relative to a moving average."""
    Bottom: IndicatorDataSeries
    """Lower Bollinger Band."""
    Main: IndicatorDataSeries
    """Moving Average (Middle Bollinger Band)."""
    Top: IndicatorDataSeries
    """Upper Bollinger Band."""

class Border(ControlBase):
    """Represents the border."""
    def __init__(self) -> None: ...
    BackgroundColor: Color
    """Gets or sets the color of the border background. Check the Color class for the ARGB (alpha, red, green, blue) color values, or use the strings Color.Red, Color.FromName("Red"), Color.FromArgb(255, 0, 0), Color.FromHex("#ff0000"), "Red", "#ff0000"."""
    BorderColor: Color
    """Gets or sets the border line color. Check the Color class for the ARGB (alpha, red, green, blue) color values, or use the strings Color.Red, Color.FromName("Red"), Color.FromArgb(255, 0, 0), Color.FromHex("#ff0000"), "Red", "#ff0000"."""
    BorderThickness: Thickness
    """Gets or sets the border thickness. Property value can be set using Thickness, number, or a string new Thickness(5), new Thickness(1, 2, 3, 4), 5, "5", "1 2 3 4"."""
    Child: ControlBase
    """Gets or sets the border child object."""
    CornerRadius: CornerRadius
    """Gets or sets the border corner radius. Property value can be set using CornerRadius, number, or a string: new CornerRadius(5), new CornerRadius(1, 2, 3, 4)."""
    Padding: Thickness
    """Gets or sets the border padding thickness. Property value can be set using Thickness, number, or a string new Thickness(5), new Thickness(1, 2, 3, 4), 5, "5", "1 2 3 4"."""

class BullsPower(StandardIndicator):
    """The calculation of the Bulls Power."""
    Result: IndicatorDataSeries
    """The histogram (bar graph). It shows the maximum bullish strength during the time period."""

class Button(Control):
    """Represents the button."""
    def __init__(self) -> None: ...
    BorderColor: Color
    """Gets or sets the border line color. Check the Color class for the ARGB (alpha, red, green, blue) color values, or use the strings Color.Red, Color.FromName("Red"), Color.FromArgb(255, 0, 0), Color.FromHex("#ff0000"), "Red", "#ff0000"."""
    BorderThickness: Thickness
    """Gets or sets the border thickness."""
    Content: ControlBase
    """Gets or sets the content."""
    CornerRadius: CornerRadius
    """Gets or sets the border corner radius. Property value can be set using CornerRadius, number, or a string: new CornerRadius(5), new CornerRadius(1, 2, 3, 4)."""
    Text: str
    """Gets or sets the text."""
    Click: Event[Callable[[ButtonClickEventArgs], None]]
    """Occurs when the button is clicked."""

class ButtonClickEventArgs:
    """Represents the button click event data."""
    Button: Button
    """Gets the button data."""

class Canvas(Panel):
    """Defines an area to position child elements by coordinates relative to the Canvas area."""
    def __init__(self) -> None: ...

class CenterOfGravity(StandardIndicator):
    """The Center of Gravity (COG) indicator is a technical indicator developed by John Ehlers in 2002, used to identify potential turning points in the price as early as possible."""
    Lag: IndicatorDataSeries
    """The lag/signal/trigger line of COG"""
    Result: IndicatorDataSeries
    """The COG line, by using it you can identify the support and resistance levels and have a more or less clear idea when the price starts moving in a different direction."""

class ChaikinMoneyFlow(StandardIndicator):
    """The Chaikin Money Flow Indicator measures the amount of Money Flow Volume over a specific period. The resulting indicator fluctuates above/below the zero line."""
    Result: IndicatorDataSeries
    """The time series of the Chaikin Money Flow Indicator."""

class ChaikinOscillator(StandardIndicator):
    """The Chaikin Oscillator Indicator interface."""
    Result: IndicatorDataSeries
    """The resulting time series of Chaikin Oscillator calculation."""

class ChaikinVolatility(StandardIndicator):
    """The Chaikin Volatility Indicator interface."""
    Result: IndicatorDataSeries
    """Chaikin Volatility Result Series."""

class ChandeMomentumOscillator(StandardIndicator):
    """The calculation of the Chande Momentum Oscillator indicator."""
    Result: IndicatorDataSeries
    """Gets the resulting series of the Chande Momentum Oscillator indicator calculation."""

class CharacterCasing:
    """Specifies the case of characters typed manually into a TextBox control."""
    Normal: CharacterCasing
    Lower: CharacterCasing
    Upper: CharacterCasing

class Chart(ChartArea):
    """Represents the Chart Interface."""
    @overload
    def AddHotkey(self, hotkeyHandler: Callable[[ChartKeyboardEventArgs], None], key: Key, modifiers: ModifierKeys) -> bool:
        """Adds an hotkey to the chart that will call the handler when pressed"""
        ...
    @overload
    def AddHotkey(self, hotkeyHandler: Callable[[ChartKeyboardEventArgs], None], hotkey: str) -> bool:
        """Adds an hotkey to the chart that will call the handler when pressed"""
        ...
    @overload
    def AddHotkey(self, hotkeyHandler: Action, key: Key, modifiers: ModifierKeys) -> bool:
        """Adds an hotkey to the chart that will call the handler when pressed"""
        ...
    @overload
    def AddHotkey(self, hotkeyHandler: Action, hotkey: str) -> bool:
        """Adds an hotkey to the chart that will call the handler when pressed"""
        ...
    @overload
    def DrawRiskReward(self, name: str, barIndex1: int, barIndex2: int, entryPrice: float, orderType: OrderType, tradeType: TradeType, type: ChartRiskRewardType) -> ChartRiskReward:
        """Draws a risk reward."""
        ...
    @overload
    def DrawRiskReward(self, name: str, time1: DateTime, time2: DateTime, entryPrice: float, orderType: OrderType, tradeType: TradeType, type: ChartRiskRewardType) -> ChartRiskReward:
        """Draws a risk reward."""
        ...
    def ResetBarColor(self, barIndex: int) -> None:
        """Resets the color of the bar to the default."""
        ...
    def ResetBarColors(self) -> None:
        """Resets the colors of all the bars."""
        ...
    def ResetTickVolumeColor(self, barIndex: int) -> None:
        """Resets the color of the tick volume line to the default at the specified bar index."""
        ...
    def ResetTickVolumeColors(self) -> None:
        """Resets the color of all the tick volume bars."""
        ...
    def ScrollXBy(self, bars: int) -> None:
        """Scrolls the chart by the X-axis for the specified number of bars."""
        ...
    @overload
    def ScrollXTo(self, barIndex: int) -> None:
        """Scrolls the chart by the X-axis to the bar with the specified index."""
        ...
    @overload
    def ScrollXTo(self, time: DateTime) -> None:
        """Scrolls the chart by the X-axis to the specified date time."""
        ...
    def SetBarColor(self, barIndex: int, color: Color) -> None:
        """Sets the color of the bar at the specified bar index. It will change the bar fill color and the outline color."""
        ...
    def SetBarFillColor(self, barIndex: int, color: Color) -> None:
        """Sets the fill color of the bar at the specified bar index."""
        ...
    def SetBarOutlineColor(self, barIndex: int, color: Color) -> None:
        """Sets the outline color of the bar at the specified bar index."""
        ...
    def SetTickVolumeColor(self, barIndex: int, color: Color) -> None:
        """Sets the color of tick volume line at the specified bar index."""
        ...
    def TakeChartshot(self) -> list[int]:
        """Takes a chartshot from the chart that indicator / cBot runs on."""
        ...
    def TryChangeTimeFrame(self, timeFrame: TimeFrame) -> bool:
        """Changes the time frame on the chart."""
        ...
    def TryChangeTimeFrameAndSymbol(self, timeFrame: TimeFrame, symbolName: str) -> bool:
        """Changes the time frame and the symbol on the chart."""
        ...
    Bars: Bars
    """Gets the chart Bar objects."""
    BarsTotal: int
    """Gets the total number of the bars on the chart."""
    ChartType: ChartType
    """Gets or sets the type of the chart - Bar, Candlesticks, Line or Dots chart."""
    ColorSettings: ChartColorSettings
    """Gets the chart color settings."""
    DisplaySettings: ChartDisplaySettings
    """Gets the chart display settings."""
    FirstVisibleBarIndex: int
    """Gets the index of the first visible bar on the chart."""
    Id: Guid
    """Gets the unique Id of Chart."""
    IndicatorAreas: IReadonlyList[IndicatorArea]
    """Gets the read only list of the indicator areas."""
    Indicators: ChartIndicators
    """Gets the ChartIndicators operating on a chart."""
    IsActive: bool
    """True if Chart is active otherwise False"""
    IsPriceScaleInverted: bool
    """Gets or sets the value indicating whether the price scale of the chart main area is inverted, so the higher prices are displayed lower. BottomY is still the lowest visible price and TopY the highest. In the silent backtesting, the CLI and the cloud the value is only stored and has no visual effect."""
    IsPriceToBarRatioLocked: bool
    """Gets or sets the value indicating whether the price to bar ratio of the chart main area is locked. While locked, zooming keeps the same price distance per bar, the auto scale of the main area is disabled and the price scale mode is Regular. Locking switches Percent, IndexedTo100 and Logarithmic modes to Regular. In the silent backtesting, the CLI and the cloud the value is only stored and has no visual effect."""
    IsScalePriceChartOnly: bool
    """Gets or sets the value indicating whether the auto scale of the chart main area fits only the bars, ignoring the overlay indicator outputs and the chart objects. In the silent backtesting, the CLI and the cloud the value is only stored and has no visual effect."""
    IsScrollingEnabled: bool
    """Gets or sets the value indicating whether the scrolling is enabled or disabled for the chart. If disabled, then the chart is not affected by scrolling, dragging, scaling, or pressing any keyboard keys, but is still affected by resizing, zooming, and API calls for changing X or Y-axis positions on the chart."""
    IsVisible: bool
    """True if Chart is visible otherwise False."""
    LastVisibleBarIndex: int
    """Gets the index of the last visible bar on the chart."""
    MaxBarWidth: int
    """Gets or sets the maximum width of a single bar (the candle body) in pixels. When the chart is zoomed in, the bar body is never drawn wider than this value and the extra horizontal space is added to the gap between the bars. This is useful for footprint-style rendering where additional text must fit next to each bar."""
    MaxVisibleBars: int
    """Gets the maximum number of the visible bars on the chart."""
    PriceAxisPosition: ChartPriceAxisPosition
    """Gets or sets the side of the chart where the price axis of the main area and of all the indicator areas is displayed. In the silent backtesting, the CLI and the cloud the value is only stored and has no visual effect."""
    PriceScaleBasePrice: float
    """Gets the base price used by the Percent and IndexedTo100 price scale modes, which is the close price of the first visible bar. Returns NaN in the Regular and Logarithmic modes, and in the silent backtesting, the CLI and the cloud."""
    PriceScaleMode: ChartPriceScaleMode
    """Gets or sets the price scale mode of the chart main area. Percent and IndexedTo100 enable the auto scale of the main area. While the price to bar ratio is locked only Regular can be set, and setting any other mode is ignored. Logarithmic works for every price, zero and negative prices are drawn on a logarithmic scale mirrored below zero. The Y-axis values used by the API stay in price units in every mode. In the silent backtesting, the CLI and the cloud the value is only stored and has no visual effect."""
    PriceToBarRatio: float
    """Gets or sets the price to bar ratio of the chart main area: the price distance displayed per one bar width. Used while the price to bar ratio is locked. Values that are not greater than zero, NaN or infinite are ignored. Setting this value does not lock the ratio."""
    Robots: ChartRobots
    """Gets the ChartRobots operating on a chart."""
    Symbol: Symbol
    """Gets the chart symbol."""
    SymbolName: str
    """Gets the symbol name."""
    TimeFrame: TimeFrame
    """Gets the time frame of the chart from 1 minute to 1 month."""
    ZoomLevel: int
    """Gets or sets the zoom percent values. Valid values are from 5 to 500 with a step of 5, as can be seen on UI in the charts Zoom control."""
    Activated: Event[Callable[[ChartActivationChangedEventArgs], None]]
    """Occurs when chart is activated"""
    ChartTypeChanged: Event[Callable[[ChartTypeEventArgs], None]]
    """Occurs when the chart type changes."""
    ColorsChanged: Event[Callable[[ChartColorEventArgs], None]]
    """Occurs when the chart color settings change."""
    Deactivated: Event[Callable[[ChartActivationChangedEventArgs], None]]
    """Occurs when chart is deactivated"""
    DisplaySettingsChanged: Event[Callable[[ChartDisplaySettingsEventArgs], None]]
    """Occurs when one or several charts display settings change."""
    IndicatorAreaAdded: Event[Callable[[IndicatorAreaAddedEventArgs], None]]
    """Occurs when the indicator area is added."""
    IndicatorAreaRemoved: Event[Callable[[IndicatorAreaRemovedEventArgs], None]]
    """Occurs when the indicator area is removed."""
    KeyDown: Event[Callable[[ChartKeyboardEventArgs], None]]
    """Occurs when a keyboard key pressed while the mouse cursor is over the chart"""
    VisibilityChanged: Event[Callable[[ChartVisibilityChangedEventArgs], None]]
    """Occurs when chart visibility changes."""
    ZoomChanged: Event[Callable[[ChartZoomEventArgs], None]]
    """Occurs when the chart zoom options change."""

class ChartActivationChangedEventArgs:
    """Provides data for chart activated/deactivated events"""
    Chart: Chart
    """The chart that event belongs to"""

class ChartAndrewsPitchfork(ChartObject):
    """Represents the Andrew's Pitchfork chart object. A tool that helps to identify possible support and resistance levels with the three parallel lines."""
    @overload
    def CalculateY(self, barIndex: int) -> float:
        """Calculates Y-axis value corresponding the specified bar index."""
        ...
    @overload
    def CalculateY(self, time: DateTime) -> float:
        """Calculates Y-axis value corresponding the specified time value."""
        ...
    Color: Color
    """Gets or sets the chart object lines color."""
    LineStyle: LineStyle
    """Gets or sets the chart object lines style."""
    Thickness: int
    """Gets or sets the chart object lines thickness."""
    Time1: DateTime
    """Gets or sets the time value for the Andrew's Pitchfork point 1."""
    Time2: DateTime
    """Gets or sets the time value for the Andrew's Pitchfork point 2."""
    Time3: DateTime
    """Gets or sets the time value for the Andrew's Pitchfork point 3."""
    Y1: float
    """Gets or sets the Y-axis value for the Andrew's Pitchfork point 1."""
    Y2: float
    """Gets or sets the Y-axis value for the Andrew's Pitchfork point 2."""
    Y3: float
    """Gets or sets the Y-axis value for the Andrew's Pitchfork point 3."""

class ChartArea:
    """The Chart Area Interface."""
    @overload
    def AddControl(self, control: ControlBase) -> None:
        """Adds a chart control from the Control Base to the main chart area or to the indicator area."""
        ...
    @overload
    def AddControl(self, control: ControlBase, barIndex: int, y: float) -> None:
        """Adds a chart control to chart / indicator area on absolute bar index and price (x,y) coordinates."""
        ...
    @overload
    def AddControl(self, control: ControlBase, time: DateTime, y: float) -> None:
        """Adds a chart control to chart / indicator area on absolute time and price (x,y) coordinates."""
        ...
    @overload
    def AddControl(self, control: ControlBase, time: DateTime) -> None:
        """Adds a chart control to chart / indicator area on absolute time (x) coordinate."""
        ...
    @overload
    def AddControl(self, control: ControlBase, barIndex: int) -> None:
        """Adds a chart control to chart / indicator area on absolute bar index (x) coordinate."""
        ...
    @overload
    def AddControl(self, control: ControlBase, y: float) -> None:
        """Adds a chart control to chart / indicator area on absolute price (y) coordinate."""
        ...
    def BarIndexToX(self, barIndex: float) -> float:
        """Converts Bar Index to X coordinate."""
        ...
    @overload
    def DrawAndrewsPitchfork(self, name: str, time1: DateTime, y1: float, time2: DateTime, y2: float, time3: DateTime, y3: float, color: Color) -> ChartAndrewsPitchfork:
        """Draws an Andrew's pitchfork."""
        ...
    @overload
    def DrawAndrewsPitchfork(self, name: str, time1: DateTime, y1: float, time2: DateTime, y2: float, time3: DateTime, y3: float, color: Color, thickness: int) -> ChartAndrewsPitchfork:
        """Draws an Andrew's pitchfork."""
        ...
    @overload
    def DrawAndrewsPitchfork(self, name: str, time1: DateTime, y1: float, time2: DateTime, y2: float, time3: DateTime, y3: float, color: Color, thickness: int, lineStyle: LineStyle) -> ChartAndrewsPitchfork:
        """Draws an Andrew's pitchfork."""
        ...
    @overload
    def DrawAndrewsPitchfork(self, name: str, barIndex1: int, y1: float, barIndex2: int, y2: float, barIndex3: int, y3: float, color: Color) -> ChartAndrewsPitchfork:
        """Draws an Andrew's pitchfork."""
        ...
    @overload
    def DrawAndrewsPitchfork(self, name: str, barIndex1: int, y1: float, barIndex2: int, y2: float, barIndex3: int, y3: float, color: Color, thickness: int) -> ChartAndrewsPitchfork:
        """Draws an Andrews pitchfork."""
        ...
    @overload
    def DrawAndrewsPitchfork(self, name: str, barIndex1: int, y1: float, barIndex2: int, y2: float, barIndex3: int, y3: float, color: Color, thickness: int, lineStyle: LineStyle) -> ChartAndrewsPitchfork:
        """Draws an Andrew's pitchfork."""
        ...
    @overload
    def DrawArrow(self, name: str, time1: DateTime, y1: float, time2: DateTime, y2: float, color: Color) -> ChartArrow:
        """Draws an arrow."""
        ...
    @overload
    def DrawArrow(self, name: str, time1: DateTime, y1: float, time2: DateTime, y2: float, color: Color, thickness: int) -> ChartArrow:
        """Draws an arrow."""
        ...
    @overload
    def DrawArrow(self, name: str, time1: DateTime, y1: float, time2: DateTime, y2: float, color: Color, thickness: int, lineStyle: LineStyle) -> ChartArrow:
        """Draws an arrow."""
        ...
    @overload
    def DrawArrow(self, name: str, barIndex1: int, y1: float, barIndex2: int, y2: float, color: Color) -> ChartArrow:
        """Draws an arrow."""
        ...
    @overload
    def DrawArrow(self, name: str, barIndex1: int, y1: float, barIndex2: int, y2: float, color: Color, thickness: int) -> ChartArrow:
        """Draws an arrow."""
        ...
    @overload
    def DrawArrow(self, name: str, barIndex1: int, y1: float, barIndex2: int, y2: float, color: Color, thickness: int, lineStyle: LineStyle) -> ChartArrow:
        """Draws an arrow."""
        ...
    @overload
    def DrawElliottCorrection(self, name: str, origin: ChartPoint, waveA: ChartPoint, waveB: ChartPoint, waveC: ChartPoint, color: Color) -> ChartElliottCorrection:
        """Draws an Elliott Correction Wave (A-B-C)."""
        ...
    @overload
    def DrawElliottCorrection(self, name: str, origin: ChartPoint, waveA: ChartPoint, waveB: ChartPoint, waveC: ChartPoint, color: Color, thickness: int) -> ChartElliottCorrection:
        """Draws an Elliott Correction Wave (A-B-C)."""
        ...
    @overload
    def DrawElliottCorrection(self, name: str, origin: ChartPoint, waveA: ChartPoint, waveB: ChartPoint, waveC: ChartPoint, color: Color, thickness: int, lineStyle: LineStyle) -> ChartElliottCorrection:
        """Draws an Elliott Correction Wave (A-B-C)."""
        ...
    @overload
    def DrawElliottDoubleCombo(self, name: str, origin: ChartPoint, waveW: ChartPoint, waveX: ChartPoint, waveY: ChartPoint, color: Color) -> ChartElliottDoubleCombo:
        """Draws an Elliott Double Combo Wave (W-X-Y)."""
        ...
    @overload
    def DrawElliottDoubleCombo(self, name: str, origin: ChartPoint, waveW: ChartPoint, waveX: ChartPoint, waveY: ChartPoint, color: Color, thickness: int) -> ChartElliottDoubleCombo:
        """Draws an Elliott Double Combo Wave (W-X-Y)."""
        ...
    @overload
    def DrawElliottDoubleCombo(self, name: str, origin: ChartPoint, waveW: ChartPoint, waveX: ChartPoint, waveY: ChartPoint, color: Color, thickness: int, lineStyle: LineStyle) -> ChartElliottDoubleCombo:
        """Draws an Elliott Double Combo Wave (W-X-Y)."""
        ...
    @overload
    def DrawElliottImpulse(self, name: str, origin: ChartPoint, wave1: ChartPoint, wave2: ChartPoint, wave3: ChartPoint, wave4: ChartPoint, wave5: ChartPoint, color: Color) -> ChartElliottImpulse:
        """Draws an Elliott Impulse Wave (1-2-3-4-5)."""
        ...
    @overload
    def DrawElliottImpulse(self, name: str, origin: ChartPoint, wave1: ChartPoint, wave2: ChartPoint, wave3: ChartPoint, wave4: ChartPoint, wave5: ChartPoint, color: Color, thickness: int) -> ChartElliottImpulse:
        """Draws an Elliott Impulse Wave (1-2-3-4-5)."""
        ...
    @overload
    def DrawElliottImpulse(self, name: str, origin: ChartPoint, wave1: ChartPoint, wave2: ChartPoint, wave3: ChartPoint, wave4: ChartPoint, wave5: ChartPoint, color: Color, thickness: int, lineStyle: LineStyle) -> ChartElliottImpulse:
        """Draws an Elliott Impulse Wave (1-2-3-4-5)."""
        ...
    @overload
    def DrawElliottTriangle(self, name: str, origin: ChartPoint, waveA: ChartPoint, waveB: ChartPoint, waveC: ChartPoint, waveD: ChartPoint, waveE: ChartPoint, color: Color) -> ChartElliottTriangle:
        """Draws an Elliott Triangle Wave (A-B-C-D-E)."""
        ...
    @overload
    def DrawElliottTriangle(self, name: str, origin: ChartPoint, waveA: ChartPoint, waveB: ChartPoint, waveC: ChartPoint, waveD: ChartPoint, waveE: ChartPoint, color: Color, thickness: int) -> ChartElliottTriangle:
        """Draws an Elliott Triangle Wave (A-B-C-D-E)."""
        ...
    @overload
    def DrawElliottTriangle(self, name: str, origin: ChartPoint, waveA: ChartPoint, waveB: ChartPoint, waveC: ChartPoint, waveD: ChartPoint, waveE: ChartPoint, color: Color, thickness: int, lineStyle: LineStyle) -> ChartElliottTriangle:
        """Draws an Elliott Triangle Wave (A-B-C-D-E)."""
        ...
    @overload
    def DrawElliottTripleCombo(self, name: str, origin: ChartPoint, waveW: ChartPoint, waveX1: ChartPoint, waveY: ChartPoint, waveX2: ChartPoint, waveZ: ChartPoint, color: Color) -> ChartElliottTripleCombo:
        """Draws an Elliott Triple Combo Wave (W-X-Y-X-Z)."""
        ...
    @overload
    def DrawElliottTripleCombo(self, name: str, origin: ChartPoint, waveW: ChartPoint, waveX1: ChartPoint, waveY: ChartPoint, waveX2: ChartPoint, waveZ: ChartPoint, color: Color, thickness: int) -> ChartElliottTripleCombo:
        """Draws an Elliott Triple Combo Wave (W-X-Y-X-Z)."""
        ...
    @overload
    def DrawElliottTripleCombo(self, name: str, origin: ChartPoint, waveW: ChartPoint, waveX1: ChartPoint, waveY: ChartPoint, waveX2: ChartPoint, waveZ: ChartPoint, color: Color, thickness: int, lineStyle: LineStyle) -> ChartElliottTripleCombo:
        """Draws an Elliott Triple Combo Wave (W-X-Y-X-Z)."""
        ...
    @overload
    def DrawEllipse(self, name: str, time1: DateTime, y1: float, time2: DateTime, y2: float, color: Color) -> ChartEllipse:
        """Draws an ellipse."""
        ...
    @overload
    def DrawEllipse(self, name: str, time1: DateTime, y1: float, time2: DateTime, y2: float, color: Color, thickness: int) -> ChartEllipse:
        """Draws an ellipse."""
        ...
    @overload
    def DrawEllipse(self, name: str, time1: DateTime, y1: float, time2: DateTime, y2: float, color: Color, thickness: int, lineStyle: LineStyle) -> ChartEllipse:
        """Draws an ellipse."""
        ...
    @overload
    def DrawEllipse(self, name: str, barIndex1: int, y1: float, barIndex2: int, y2: float, color: Color) -> ChartEllipse:
        """Draws an ellipse."""
        ...
    @overload
    def DrawEllipse(self, name: str, barIndex1: int, y1: float, barIndex2: int, y2: float, color: Color, thickness: int) -> ChartEllipse:
        """Draws an ellipse."""
        ...
    @overload
    def DrawEllipse(self, name: str, barIndex1: int, y1: float, barIndex2: int, y2: float, color: Color, thickness: int, lineStyle: LineStyle) -> ChartEllipse:
        """Draws an ellipse."""
        ...
    @overload
    def DrawEquidistantChannel(self, name: str, time1: DateTime, y1: float, time2: DateTime, y2: float, channelHeight: float, color: Color) -> ChartEquidistantChannel:
        """Draws an equidistant channel."""
        ...
    @overload
    def DrawEquidistantChannel(self, name: str, time1: DateTime, y1: float, time2: DateTime, y2: float, channelHeight: float, color: Color, thickness: int) -> ChartEquidistantChannel:
        """Draws an equidistant channel."""
        ...
    @overload
    def DrawEquidistantChannel(self, name: str, time1: DateTime, y1: float, time2: DateTime, y2: float, channelHeight: float, color: Color, thickness: int, lineStyle: LineStyle) -> ChartEquidistantChannel:
        """Draws an equidistant channel."""
        ...
    @overload
    def DrawEquidistantChannel(self, name: str, barIndex1: int, y1: float, barIndex2: int, y2: float, channelHeight: float, color: Color) -> ChartEquidistantChannel:
        """Draws an equidistant channel."""
        ...
    @overload
    def DrawEquidistantChannel(self, name: str, barIndex1: int, y1: float, barIndex2: int, y2: float, channelHeight: float, color: Color, thickness: int) -> ChartEquidistantChannel:
        """Draws an equidistant channel."""
        ...
    @overload
    def DrawEquidistantChannel(self, name: str, barIndex1: int, y1: float, barIndex2: int, y2: float, channelHeight: float, color: Color, thickness: int, lineStyle: LineStyle) -> ChartEquidistantChannel:
        """Draws an equidistant channel."""
        ...
    @overload
    def DrawFibonacciArc(self, name: str, time1: DateTime, y1: float, time2: DateTime, y2: float, color: Color) -> ChartFibonacciArc:
        """Draws a Fibonacci arc."""
        ...
    @overload
    def DrawFibonacciArc(self, name: str, time1: DateTime, y1: float, time2: DateTime, y2: float, color: Color, thickness: int) -> ChartFibonacciArc:
        """Draws a Fibonacci arc."""
        ...
    @overload
    def DrawFibonacciArc(self, name: str, time1: DateTime, y1: float, time2: DateTime, y2: float, color: Color, thickness: int, lineStyle: LineStyle) -> ChartFibonacciArc:
        """Draws a Fibonacci arc."""
        ...
    @overload
    def DrawFibonacciArc(self, name: str, barIndex1: int, y1: float, barIndex2: int, y2: float, color: Color) -> ChartFibonacciArc:
        """Draws a Fibonacci arc."""
        ...
    @overload
    def DrawFibonacciArc(self, name: str, barIndex1: int, y1: float, barIndex2: int, y2: float, color: Color, thickness: int) -> ChartFibonacciArc:
        """Draws a Fibonacci arc."""
        ...
    @overload
    def DrawFibonacciArc(self, name: str, barIndex1: int, y1: float, barIndex2: int, y2: float, color: Color, thickness: int, lineStyle: LineStyle) -> ChartFibonacciArc:
        """Draws a Fibonacci arc."""
        ...
    @overload
    def DrawFibonacciExpansion(self, name: str, time1: DateTime, y1: float, time2: DateTime, y2: float, time3: DateTime, y3: float, color: Color) -> ChartFibonacciExpansion:
        """Draws a Fibonacci expansion."""
        ...
    @overload
    def DrawFibonacciExpansion(self, name: str, time1: DateTime, y1: float, time2: DateTime, y2: float, time3: DateTime, y3: float, color: Color, thickness: int) -> ChartFibonacciExpansion:
        """Draws a Fibonacci expansion."""
        ...
    @overload
    def DrawFibonacciExpansion(self, name: str, time1: DateTime, y1: float, time2: DateTime, y2: float, time3: DateTime, y3: float, color: Color, thickness: int, lineStyle: LineStyle) -> ChartFibonacciExpansion:
        """Draws a Fibonacci expansion."""
        ...
    @overload
    def DrawFibonacciExpansion(self, name: str, barIndex1: int, y1: float, barIndex2: int, y2: float, barIndex3: int, y3: float, color: Color) -> ChartFibonacciExpansion:
        """Draws a Fibonacci expansion."""
        ...
    @overload
    def DrawFibonacciExpansion(self, name: str, barIndex1: int, y1: float, barIndex2: int, y2: float, barIndex3: int, y3: float, color: Color, thickness: int) -> ChartFibonacciExpansion:
        """Draws a Fibonacci expansion."""
        ...
    @overload
    def DrawFibonacciExpansion(self, name: str, barIndex1: int, y1: float, barIndex2: int, y2: float, barIndex3: int, y3: float, color: Color, thickness: int, lineStyle: LineStyle) -> ChartFibonacciExpansion:
        """Draws a Fibonacci expansion."""
        ...
    @overload
    def DrawFibonacciFan(self, name: str, time1: DateTime, y1: float, time2: DateTime, y2: float, color: Color) -> ChartFibonacciFan:
        """Draws a Fibonacci fan."""
        ...
    @overload
    def DrawFibonacciFan(self, name: str, time1: DateTime, y1: float, time2: DateTime, y2: float, color: Color, thickness: int) -> ChartFibonacciFan:
        """Draws a Fibonacci fan."""
        ...
    @overload
    def DrawFibonacciFan(self, name: str, time1: DateTime, y1: float, time2: DateTime, y2: float, color: Color, thickness: int, lineStyle: LineStyle) -> ChartFibonacciFan:
        """Draws a Fibonacci fan."""
        ...
    @overload
    def DrawFibonacciFan(self, name: str, barIndex1: int, y1: float, barIndex2: int, y2: float, color: Color) -> ChartFibonacciFan:
        """Draws a Fibonacci fan."""
        ...
    @overload
    def DrawFibonacciFan(self, name: str, barIndex1: int, y1: float, barIndex2: int, y2: float, color: Color, thickness: int) -> ChartFibonacciFan:
        """Draws a Fibonacci fan."""
        ...
    @overload
    def DrawFibonacciFan(self, name: str, barIndex1: int, y1: float, barIndex2: int, y2: float, color: Color, thickness: int, lineStyle: LineStyle) -> ChartFibonacciFan:
        """Draws a Fibonacci fan."""
        ...
    @overload
    def DrawFibonacciRetracement(self, name: str, time1: DateTime, y1: float, time2: DateTime, y2: float, color: Color) -> ChartFibonacciRetracement:
        """Draws a Fibonacci retracement."""
        ...
    @overload
    def DrawFibonacciRetracement(self, name: str, time1: DateTime, y1: float, time2: DateTime, y2: float, color: Color, thickness: int) -> ChartFibonacciRetracement:
        """Draws a Fibonacci retracement."""
        ...
    @overload
    def DrawFibonacciRetracement(self, name: str, time1: DateTime, y1: float, time2: DateTime, y2: float, color: Color, thickness: int, lineStyle: LineStyle) -> ChartFibonacciRetracement:
        """Draws a Fibonacci retracement."""
        ...
    @overload
    def DrawFibonacciRetracement(self, name: str, barIndex1: int, y1: float, barIndex2: int, y2: float, color: Color) -> ChartFibonacciRetracement:
        """Draws a Fibonacci retracement."""
        ...
    @overload
    def DrawFibonacciRetracement(self, name: str, barIndex1: int, y1: float, barIndex2: int, y2: float, color: Color, thickness: int) -> ChartFibonacciRetracement:
        """Draws a Fibonacci retracement."""
        ...
    @overload
    def DrawFibonacciRetracement(self, name: str, barIndex1: int, y1: float, barIndex2: int, y2: float, color: Color, thickness: int, lineStyle: LineStyle) -> ChartFibonacciRetracement:
        """Draws a Fibonacci retracement."""
        ...
    @overload
    def DrawFibonacciTimezones(self, name: str, time1: DateTime, y1: float, time2: DateTime, y2: float, color: Color) -> ChartFibonacciTimezones:
        """Draws a Fibonacci timezones."""
        ...
    @overload
    def DrawFibonacciTimezones(self, name: str, time1: DateTime, y1: float, time2: DateTime, y2: float, color: Color, thickness: int) -> ChartFibonacciTimezones:
        """Draws a Fibonacci timezones."""
        ...
    @overload
    def DrawFibonacciTimezones(self, name: str, time1: DateTime, y1: float, time2: DateTime, y2: float, color: Color, thickness: int, lineStyle: LineStyle) -> ChartFibonacciTimezones:
        """Draws a Fibonacci timezones."""
        ...
    @overload
    def DrawFibonacciTimezones(self, name: str, barIndex1: int, y1: float, barIndex2: int, y2: float, color: Color) -> ChartFibonacciTimezones:
        """Draws a Fibonacci timezones."""
        ...
    @overload
    def DrawFibonacciTimezones(self, name: str, barIndex1: int, y1: float, barIndex2: int, y2: float, color: Color, thickness: int) -> ChartFibonacciTimezones:
        """Draws a Fibonacci timezones."""
        ...
    @overload
    def DrawFibonacciTimezones(self, name: str, barIndex1: int, y1: float, barIndex2: int, y2: float, color: Color, thickness: int, lineStyle: LineStyle) -> ChartFibonacciTimezones:
        """Draws a Fibonacci timezones."""
        ...
    @overload
    def DrawGannBox(self, name: str, time1: DateTime, y1: float, time2: DateTime, y2: float, color: Color) -> ChartGannBox:
        """Draws a Gann box."""
        ...
    @overload
    def DrawGannBox(self, name: str, time1: DateTime, y1: float, time2: DateTime, y2: float, color: Color, thickness: int) -> ChartGannBox:
        """Draws a Gann box."""
        ...
    @overload
    def DrawGannBox(self, name: str, time1: DateTime, y1: float, time2: DateTime, y2: float, color: Color, thickness: int, lineStyle: LineStyle) -> ChartGannBox:
        """Draws a Gann box."""
        ...
    @overload
    def DrawGannBox(self, name: str, barIndex1: int, y1: float, barIndex2: int, y2: float, color: Color) -> ChartGannBox:
        """Draws a Gann box."""
        ...
    @overload
    def DrawGannBox(self, name: str, barIndex1: int, y1: float, barIndex2: int, y2: float, color: Color, thickness: int) -> ChartGannBox:
        """Draws a Gann box."""
        ...
    @overload
    def DrawGannBox(self, name: str, barIndex1: int, y1: float, barIndex2: int, y2: float, color: Color, thickness: int, lineStyle: LineStyle) -> ChartGannBox:
        """Draws a Gann box."""
        ...
    @overload
    def DrawGannFan(self, name: str, time1: DateTime, y1: float, time2: DateTime, y2: float, color: Color) -> ChartGannFan:
        """Draws a Gann fan."""
        ...
    @overload
    def DrawGannFan(self, name: str, time1: DateTime, y1: float, time2: DateTime, y2: float, color: Color, thickness: int) -> ChartGannFan:
        """Draws a Gann fan."""
        ...
    @overload
    def DrawGannFan(self, name: str, time1: DateTime, y1: float, time2: DateTime, y2: float, color: Color, thickness: int, lineStyle: LineStyle) -> ChartGannFan:
        """Draws a Gann fan."""
        ...
    @overload
    def DrawGannFan(self, name: str, barIndex1: int, y1: float, barIndex2: int, y2: float, color: Color) -> ChartGannFan:
        """Draws a Gann fan."""
        ...
    @overload
    def DrawGannFan(self, name: str, barIndex1: int, y1: float, barIndex2: int, y2: float, color: Color, thickness: int) -> ChartGannFan:
        """Draws a Gann fan."""
        ...
    @overload
    def DrawGannFan(self, name: str, barIndex1: int, y1: float, barIndex2: int, y2: float, color: Color, thickness: int, lineStyle: LineStyle) -> ChartGannFan:
        """Draws a Gann fan."""
        ...
    @overload
    def DrawGannSquare(self, name: str, time1: DateTime, y1: float, time2: DateTime, y2: float, color: Color) -> ChartGannSquare:
        """Draws a Gann square."""
        ...
    @overload
    def DrawGannSquare(self, name: str, time1: DateTime, y1: float, time2: DateTime, y2: float, color: Color, thickness: int) -> ChartGannSquare:
        """Draws a Gann square."""
        ...
    @overload
    def DrawGannSquare(self, name: str, time1: DateTime, y1: float, time2: DateTime, y2: float, color: Color, thickness: int, lineStyle: LineStyle) -> ChartGannSquare:
        """Draws a Gann square."""
        ...
    @overload
    def DrawGannSquare(self, name: str, barIndex1: int, y1: float, barIndex2: int, y2: float, color: Color) -> ChartGannSquare:
        """Draws a Gann square."""
        ...
    @overload
    def DrawGannSquare(self, name: str, barIndex1: int, y1: float, barIndex2: int, y2: float, color: Color, thickness: int) -> ChartGannSquare:
        """Draws a Gann square."""
        ...
    @overload
    def DrawGannSquare(self, name: str, barIndex1: int, y1: float, barIndex2: int, y2: float, color: Color, thickness: int, lineStyle: LineStyle) -> ChartGannSquare:
        """Draws a Gann square."""
        ...
    @overload
    def DrawGannSquareFixed(self, name: str, time1: DateTime, y1: float, time2: DateTime, y2: float, color: Color) -> ChartGannSquareFixed:
        """Draws a Gann square fixed."""
        ...
    @overload
    def DrawGannSquareFixed(self, name: str, time1: DateTime, y1: float, time2: DateTime, y2: float, color: Color, thickness: int) -> ChartGannSquareFixed:
        """Draws a Gann square fixed."""
        ...
    @overload
    def DrawGannSquareFixed(self, name: str, time1: DateTime, y1: float, time2: DateTime, y2: float, color: Color, thickness: int, lineStyle: LineStyle) -> ChartGannSquareFixed:
        """Draws a Gann square fixed."""
        ...
    @overload
    def DrawGannSquareFixed(self, name: str, barIndex1: int, y1: float, barIndex2: int, y2: float, color: Color) -> ChartGannSquareFixed:
        """Draws a Gann square fixed."""
        ...
    @overload
    def DrawGannSquareFixed(self, name: str, barIndex1: int, y1: float, barIndex2: int, y2: float, color: Color, thickness: int) -> ChartGannSquareFixed:
        """Draws a Gann square fixed."""
        ...
    @overload
    def DrawGannSquareFixed(self, name: str, barIndex1: int, y1: float, barIndex2: int, y2: float, color: Color, thickness: int, lineStyle: LineStyle) -> ChartGannSquareFixed:
        """Draws a Gann square fixed."""
        ...
    @overload
    def DrawHorizontalLine(self, name: str, y: float, color: Color) -> ChartHorizontalLine:
        """Draws a horizontal line."""
        ...
    @overload
    def DrawHorizontalLine(self, name: str, y: float, color: Color, thickness: int) -> ChartHorizontalLine:
        """Draws a horizontal line."""
        ...
    @overload
    def DrawHorizontalLine(self, name: str, y: float, color: Color, thickness: int, lineStyle: LineStyle) -> ChartHorizontalLine:
        """Draws a horizontal line."""
        ...
    @overload
    def DrawIcon(self, name: str, iconType: ChartIconType, time: DateTime, y: float, color: Color) -> ChartIcon:
        """Draws an icon."""
        ...
    @overload
    def DrawIcon(self, name: str, iconType: ChartIconType, barIndex: int, y: float, color: Color) -> ChartIcon:
        """Draws an icon."""
        ...
    @overload
    def DrawRectangle(self, name: str, time1: DateTime, y1: float, time2: DateTime, y2: float, color: Color) -> ChartRectangle:
        """Draws a rectangle."""
        ...
    @overload
    def DrawRectangle(self, name: str, time1: DateTime, y1: float, time2: DateTime, y2: float, color: Color, thickness: int) -> ChartRectangle:
        """Draws a rectangle."""
        ...
    @overload
    def DrawRectangle(self, name: str, time1: DateTime, y1: float, time2: DateTime, y2: float, color: Color, thickness: int, lineStyle: LineStyle) -> ChartRectangle:
        """Draws a rectangle."""
        ...
    @overload
    def DrawRectangle(self, name: str, barIndex1: int, y1: float, barIndex2: int, y2: float, color: Color) -> ChartRectangle:
        """Draws a rectangle."""
        ...
    @overload
    def DrawRectangle(self, name: str, barIndex1: int, y1: float, barIndex2: int, y2: float, color: Color, thickness: int) -> ChartRectangle:
        """Draws a rectangle."""
        ...
    @overload
    def DrawRectangle(self, name: str, barIndex1: int, y1: float, barIndex2: int, y2: float, color: Color, thickness: int, lineStyle: LineStyle) -> ChartRectangle:
        """Draws a rectangle."""
        ...
    def DrawStaticText(self, name: str, text: str, verticalAlignment: VerticalAlignment, horizontalAlignment: HorizontalAlignment, color: Color) -> ChartStaticText:
        """Draws the static text."""
        ...
    @overload
    def DrawText(self, name: str, text: str, time: DateTime, y: float, color: Color) -> ChartText:
        """Draws the text."""
        ...
    @overload
    def DrawText(self, name: str, text: str, barIndex: int, y: float, color: Color) -> ChartText:
        """Draws the text."""
        ...
    @overload
    def DrawTrendLine(self, name: str, time1: DateTime, y1: float, time2: DateTime, y2: float, color: Color) -> ChartTrendLine:
        """Draws a trend line."""
        ...
    @overload
    def DrawTrendLine(self, name: str, time1: DateTime, y1: float, time2: DateTime, y2: float, color: Color, thickness: int) -> ChartTrendLine:
        """Draws a trend line."""
        ...
    @overload
    def DrawTrendLine(self, name: str, time1: DateTime, y1: float, time2: DateTime, y2: float, color: Color, thickness: int, lineStyle: LineStyle) -> ChartTrendLine:
        """Draws a trend line."""
        ...
    @overload
    def DrawTrendLine(self, name: str, barIndex1: int, y1: float, barIndex2: int, y2: float, color: Color) -> ChartTrendLine:
        """Draws a trend line."""
        ...
    @overload
    def DrawTrendLine(self, name: str, barIndex1: int, y1: float, barIndex2: int, y2: float, color: Color, thickness: int) -> ChartTrendLine:
        """Draws a trend line."""
        ...
    @overload
    def DrawTrendLine(self, name: str, barIndex1: int, y1: float, barIndex2: int, y2: float, color: Color, thickness: int, lineStyle: LineStyle) -> ChartTrendLine:
        """Draws a trend line."""
        ...
    @overload
    def DrawTriangle(self, name: str, time1: DateTime, y1: float, time2: DateTime, y2: float, time3: DateTime, y3: float, color: Color) -> ChartTriangle:
        """Draws a triangle."""
        ...
    @overload
    def DrawTriangle(self, name: str, time1: DateTime, y1: float, time2: DateTime, y2: float, time3: DateTime, y3: float, color: Color, thickness: int) -> ChartTriangle:
        """Draws a triangle."""
        ...
    @overload
    def DrawTriangle(self, name: str, time1: DateTime, y1: float, time2: DateTime, y2: float, time3: DateTime, y3: float, color: Color, thickness: int, lineStyle: LineStyle) -> ChartTriangle:
        """Draws a triangle."""
        ...
    @overload
    def DrawTriangle(self, name: str, barIndex1: int, y1: float, barIndex2: int, y2: float, barIndex3: int, y3: float, color: Color) -> ChartTriangle:
        """Draws a triangle."""
        ...
    @overload
    def DrawTriangle(self, name: str, barIndex1: int, y1: float, barIndex2: int, y2: float, barIndex3: int, y3: float, color: Color, thickness: int) -> ChartTriangle:
        """Draws a triangle."""
        ...
    @overload
    def DrawTriangle(self, name: str, barIndex1: int, y1: float, barIndex2: int, y2: float, barIndex3: int, y3: float, color: Color, thickness: int, lineStyle: LineStyle) -> ChartTriangle:
        """Draws a triangle."""
        ...
    @overload
    def DrawVerticalLine(self, name: str, time: DateTime, color: Color) -> ChartVerticalLine:
        """Draws a vertical line."""
        ...
    @overload
    def DrawVerticalLine(self, name: str, time: DateTime, color: Color, thickness: int) -> ChartVerticalLine:
        """Draws a vertical line."""
        ...
    @overload
    def DrawVerticalLine(self, name: str, time: DateTime, color: Color, thickness: int, lineStyle: LineStyle) -> ChartVerticalLine:
        """Draws a vertical line."""
        ...
    @overload
    def DrawVerticalLine(self, name: str, barIndex: int, color: Color) -> ChartVerticalLine:
        """Draws a vertical line."""
        ...
    @overload
    def DrawVerticalLine(self, name: str, barIndex: int, color: Color, thickness: int) -> ChartVerticalLine:
        """Draws a vertical line."""
        ...
    @overload
    def DrawVerticalLine(self, name: str, barIndex: int, color: Color, thickness: int, lineStyle: LineStyle) -> ChartVerticalLine:
        """Draws a vertical line."""
        ...
    @overload
    def FindAllObjects(self) -> list[T]:
        """Finds all the chart objects of the specified type."""
        ...
    @overload
    def FindAllObjects(self, objectType: ChartObjectType) -> list[ChartObject]:
        """Finds all the chart objects of the specified type."""
        ...
    def FindObject(self, objectName: str) -> ChartObject:
        """Finds the chart object of the specified name."""
        ...
    @overload
    def MoveControl(self, control: ControlBase, barIndex: int, y: float) -> None:
        """Moves a chart control to chart / indicator area on absolute bar index and price (x,y) coordinates."""
        ...
    @overload
    def MoveControl(self, control: ControlBase, time: DateTime, y: float) -> None:
        """Moves a chart control to chart / indicator area on absolute time and price (x,y) coordinates."""
        ...
    @overload
    def MoveControl(self, control: ControlBase, time: DateTime) -> None:
        """Moves a chart control to chart / indicator area on absolute time (x) coordinate."""
        ...
    @overload
    def MoveControl(self, control: ControlBase, barIndex: int) -> None:
        """Moves a chart control to chart / indicator area on absolute bar index (x) coordinate."""
        ...
    @overload
    def MoveControl(self, control: ControlBase, y: float) -> None:
        """Moves a chart control to chart / indicator area on absolute price (y) coordinate."""
        ...
    def RemoveAllObjects(self) -> None:
        """Removes all interactive and non-interactive objects available for the cBot or Indicator."""
        ...
    def RemoveControl(self, control: ControlBase) -> None:
        """Remove a chart control from the chart area."""
        ...
    def RemoveObject(self, objectName: str) -> None:
        """Removes the chart object of the specified name."""
        ...
    def ResetPriceScale(self) -> None:
        """Resets the price scale of the chart area to its default state: enables the auto scale and fits the Y-axis range to the visible bars and outputs. Does not change the price scale mode, the inversion or the price axis position. Ignored on the main chart area while the price to bar ratio is locked. Does nothing in the silent backtesting, the CLI and the cloud."""
        ...
    def SetYRange(self, bottomY: float, topY: float) -> None:
        """Sets the Y-axis lowest and highest values range. Allows scrolling the chart by the Y-axis. If only one of the values is set, then the chart will be expanded regarding the lowest or highest value respectively. A range whose lowest value is not lower than its highest value is ignored, and so is any range on the main chart area while the price scale mode is Percent or IndexedTo100."""
        ...
    def TimeToX(self, time: DateTime) -> float:
        """Converts area Time coordinate to Mouse X coordinate value."""
        ...
    def XToBarIndex(self, x: float) -> float:
        """Converts X coordinate to bar index."""
        ...
    def XToTime(self, x: float) -> DateTime:
        """Converts Mouse X coordinate to area Time coordinate value."""
        ...
    def YToYValue(self, y: float) -> float:
        """Converts Mouse Y coordinate to area Y axis coordinate value."""
        ...
    def YValueToY(self, yValue: float) -> float:
        """Converts Area Y axis coordinate value to mouse Y coordinate."""
        ...
    BottomY: float
    """Gets the lowest visible Y-axis value."""
    Draggables: ChartDraggables
    """Gets chart area draggables."""
    Height: float
    """Gets the hight of the chart area."""
    IsAlive: bool
    """Checks whether the instance is still on the chart area."""
    IsAutoScaleEnabled: bool
    """Gets or sets the value indicating whether the auto scale is enabled for the chart area. When enabled, the Y-axis range is fitted automatically to the visible bars and outputs while the chart scrolls. Setting the Y-axis range with SetYRange, or dragging the price axis, disables the auto scale. On the main chart area the auto scale is always enabled while the price scale mode is Percent or IndexedTo100, and is always disabled while the price to bar ratio is locked; setting it to a conflicting value in these states is ignored. In the silent backtesting, the CLI and the cloud the value is only stored and has no visual effect."""
    Objects: IReadonlyList[ChartObject]
    """Gets the chart objects collection."""
    SelectedObjects: IReadonlyList[ChartObject]
    """Gets the list of currently selected objects if any."""
    TopY: float
    """Gets the highest visible Y-axis value."""
    Width: float
    """Gets the width of the chart area."""
    Drag: Event[Callable[[ChartDragEventArgs], None]]
    """Occurs when dragging a chart area."""
    DragEnd: Event[Callable[[ChartDragEventArgs], None]]
    """Occurs when mouse button is released while dragging a chart area or a chart area loses mouse capture."""
    DragStart: Event[Callable[[ChartDragEventArgs], None]]
    """Occurs when MouseDown event is happening on a chart area and a mouse is captured for dragging."""
    MouseDown: Event[Callable[[ChartMouseEventArgs], None]]
    """Occurs when the left mouse button is pressed down."""
    MouseEnter: Event[Callable[[ChartMouseEventArgs], None]]
    """Occurs when the cursor hover over the chart area."""
    MouseLeave: Event[Callable[[ChartMouseEventArgs], None]]
    """Occurs when the cursor leaves the chart area"""
    MouseMove: Event[Callable[[ChartMouseEventArgs], None]]
    """Occurs when the cursor moves over the chart area."""
    MouseUp: Event[Callable[[ChartMouseEventArgs], None]]
    """Occurs when the left mouse button is released."""
    MouseWheel: Event[Callable[[ChartMouseWheelEventArgs], None]]
    """Occurs when the mouse wheel button is rotated."""
    ObjectHoverChanged: Event[Callable[[ChartObjectHoverChangedEventArgs], None]]
    """Occurs when the cursor hovers over or leaves the object."""
    ObjectsAdded: Event[Callable[[ChartObjectsAddedEventArgs], None]]
    """Occurs when one or several chart objects are added to the chart area."""
    ObjectsMoveEnded: Event[Callable[[ChartObjectsMoveEndedEventArgs], None]]
    """Occurs when one or several chart objects are moved."""
    ObjectsMoveStarted: Event[Callable[[ChartObjectsMoveStartedEventArgs], None]]
    """Occurs when one or several chart objects move started."""
    ObjectsMoving: Event[Callable[[ChartObjectsMovingEventArgs], None]]
    """Occurs when one or several chart objects are moving."""
    ObjectsRemoved: Event[Callable[[ChartObjectsRemovedEventArgs], None]]
    """Occurs when one or several chart object are removed from the chart area."""
    ObjectsSelectionChanged: Event[Callable[[ChartObjectsSelectionChangedEventArgs], None]]
    """Occurs when chart objects are selected or deselected."""
    ObjectsUpdated: Event[Callable[[ChartObjectsUpdatedEventArgs], None]]
    """Occurs when one or several chart objects are updated."""
    PriceScaleChanged: Event[Callable[[ChartPriceScaleEventArgs], None]]
    """Occurs when the price scale state of the chart area changes: the auto scale is enabled or disabled, or the price scale is reset. On the main chart area it also occurs when any chart level price scale setting changes: the price scale mode, the inversion, the price to bar ratio lock or value, the scale price chart only option or the price axis position. Not raised in the silent backtesting, the CLI and the cloud."""
    ScrollChanged: Event[Callable[[ChartScrollEventArgs], None]]
    """Occurs when the X-axis position value or the Y-axis position value changes while scrolling."""
    SizeChanged: Event[Callable[[ChartSizeEventArgs], None]]
    """Occurs when the chart area size has changed."""

class ChartArrow(ChartObject):
    """Represents the arrow chart object."""
    @overload
    def CalculateY(self, barIndex: int) -> float:
        """Calculates Y-axis value corresponding the specified bar index."""
        ...
    @overload
    def CalculateY(self, time: DateTime) -> float:
        """Calculates Y-axis value corresponding the specified time value."""
        ...
    Color: Color
    """Gets or sets the color of the Trend Line."""
    ExtendToInfinity: bool
    """Defines if the Arrow extends to infinity."""
    LineStyle: LineStyle
    """Gets or sets the Arrow style."""
    ShowAngle: bool
    """Defines the arrow angle."""
    Thickness: int
    """Gets or sets the thickness of the Arrow."""
    Time1: DateTime
    """Gets or sets the value 1 on the Time line."""
    Time2: DateTime
    """Gets or sets the value 2 on the Time line."""
    Y1: float
    """Gets or sets the value 1 on the Y-axis."""
    Y2: float
    """Gets or sets the value 2 on the Y-axis."""

class ChartColorEventArgs:
    """Provides data for the chart color event."""
    Chart: Chart
    """Gets the chart."""

class ChartColorSettings:
    """Represents the charts Color Settings."""
    AreaFillColor: Color
    """Gets or sets the color of area chart fill."""
    AskPriceLineColor: Color
    """Gets or sets the color of the ask price line."""
    BackgroundColor: Color
    """Gets or sets the color of the chart background."""
    BearFillColor: Color
    """Gets or sets the color of the bear candle fill."""
    BearOutlineColor: Color
    """Gets or sets the color of the bear candle or bar outline."""
    BidPriceLineColor: Color
    """Gets or sets the color of the bid price line."""
    BullFillColor: Color
    """Gets or sets the color of the bull candle fill."""
    BullOutlineColor: Color
    """Gets or sets the color of the bull candle or bar outline."""
    BuyColor: Color
    """Gets or sets the color of Buy positions and orders."""
    ForegroundColor: Color
    """Gets or sets the color of the chart foreground."""
    GridLinesColor: Color
    """Gets or sets the color of the grid lines."""
    LosingDealColor: Color
    """Gets or sets the color of the losing deal."""
    PeriodSeparatorColor: Color
    """Gets or sets the color of the period separator."""
    SellColor: Color
    """Gets or sets the color of Sell order positions and orders."""
    TickVolumeColor: Color
    """Gets or sets the color of the tick volume."""
    WinningDealColor: Color
    """Gets or sets the color of the winning deal."""

class ChartContainer:
    """Represents a chart frames container."""
    def Close(self) -> bool:
        """Closes current chart container window."""
        ...
    Count: int
    """Returns number of frames existing in chart container."""
    DetachedWindow: DetachedWindow
    """Returns detached window properties of chart container."""
    Id: str
    """Returns container Id."""
    Item: Frame
    """Returns a frame by it is index inside chart container."""
    Mode: ChartMode
    """Get / set chart mode of chart container."""
    SelectedFrame: Frame
    """Gets or sets the selected frame in the chart container."""

class ChartContainers:
    """Represents the list of all the chart containers."""
    def Get(self, id: str) -> ChartContainer:
        """Returns a chart container by it is ID."""
        ...
    Count: int
    """Returns number of all chart containers."""
    MainChartContainer: ChartContainer
    """Returns main chart container."""
    ContainersAdded: Event[Callable[[ChartContainersAddedEventArgs], None]]
    """Occurs when new containers are added."""
    ContainersRemoved: Event[Callable[[ChartContainersRemovedEventArgs], None]]
    """Occurs when containers are removed."""

class ChartContainersAddedEventArgs:
    """Provides data for the containers added event."""
    AddedChartContainers: list[ChartContainer]
    """Returns the added containers."""

class ChartContainersRemovedEventArgs:
    """Provides data for the containers removed event."""
    RemovedChartContainers: list[ChartContainer]
    """Returns the removed containers."""

class ChartDisplaySettings:
    """Represents the chart display settings."""
    AddRobotButton: bool
    """Defines if the Add cBot button is displayed on the chart."""
    AskPriceLine: bool
    """Defines if the Ask Price Line is displayed on the chart."""
    Bars: bool
    """Defines if the Bars is displayed on the chart."""
    BidPriceLine: bool
    """Defines if the Bid Price Line is displayed on the chart."""
    ChartScale: bool
    """Defines if the Chart Scale is displayed on the chart."""
    DealMap: bool
    """Defines if the Deal Map is displayed on the chart."""
    Grid: bool
    """Defines if the Grid is displayed on the chart background."""
    IndicatorTitles: bool
    """Defines if the Indicator Titles are displayed on the chart."""
    MarketSentiment: bool
    """Defines if the Market Sentiment is visible on the chart."""
    Orders: bool
    """Defines if the Orders are displayed on the chart."""
    PeriodSeparators: bool
    """Defines if the Period Separators are displayed on the chart."""
    Positions: bool
    """Defines if the Positions are displayed on the chart."""
    PriceAlerts: bool
    """Defines if the Price Alerts are visible on the chart."""
    PriceAxisOverlayButtons: bool
    """Defines if the price axis overlays buttons are visible on the chart."""
    QuickTradeButtons: bool
    """Defines if the QuickTrade buttons are visible on the chart."""
    Targets: bool
    """Defines if the Target is visible on the chart."""
    TickVolume: bool
    """Defines if the Tick Volume is displayed on the chart."""

class ChartDisplaySettingsEventArgs:
    """Provides data for the chart display settings event."""
    Chart: Chart
    """Gets the chart."""

class ChartDragEventArgs(ChartMouseEventArgs):
    """Provides data for the chart dragging event."""
    ...

class ChartDraggable:
    """Represents a draggable box that can host a control and shown over a chart."""
    Child: ControlBase
    """Get / set the content control inside the draggable."""
    Id: str
    """Get unique ID of the Draggable."""
    IsVisible: bool
    """Get / set visibility of draggable."""
    ShowGrip: bool
    """Get / set move grip visibility (default: true)."""
    X: float
    """Get / set X coordinate (default: 0)."""
    Y: float
    """Get / set Y coordinate (default: 0)."""
    LocationChanged: Event[Callable[[ChartDraggableLocationChangedEventArgs], None]]
    """Occurs when the draggable's location is changed."""

class ChartDraggableLocationChangedEventArgs:
    """Provides data for LocationChanged event of ChartDraggable."""
    Draggable: ChartDraggable
    """Gets the draggable."""

class ChartDraggables:
    """Represents collection of a chart area draggables."""
    def Add(self) -> ChartDraggable:
        """Adds a draggable to chart area."""
        ...
    def Remove(self, draggable: ChartDraggable) -> None:
        """Removes a draggable from chart area."""
        ...
    Count: int
    """Gets count of draggables."""

class ChartDrawing(ChartObject):
    """Represents the Drawing chart object."""
    ...

class ChartElliottCorrection(ChartElliottWaveBase, ChartObject):
    """Represents the Elliott Correction Wave (A-B-C) chart object - a three-wave corrective pattern over four pivots (origin and A, B, C)."""
    Origin: ChartPoint
    """Gets or sets the origin (wave 0) anchor point."""
    WaveA: ChartPoint
    """Gets or sets the wave A anchor point."""
    WaveB: ChartPoint
    """Gets or sets the wave B anchor point."""
    WaveC: ChartPoint
    """Gets or sets the wave C anchor point."""

class ChartElliottDoubleCombo(ChartElliottWaveBase, ChartObject):
    """Represents the Elliott Double Combo Wave (W-X-Y) chart object - a complex correction over four pivots (origin and W, X, Y)."""
    Origin: ChartPoint
    """Gets or sets the origin (wave 0) anchor point."""
    WaveW: ChartPoint
    """Gets or sets the wave W anchor point."""
    WaveX: ChartPoint
    """Gets or sets the wave X anchor point."""
    WaveY: ChartPoint
    """Gets or sets the wave Y anchor point."""

class ChartElliottImpulse(ChartElliottWaveBase, ChartObject):
    """Represents the Elliott Impulse Wave (1-2-3-4-5) chart object - a five-wave motive pattern over six pivots (origin and 1 to 5)."""
    Origin: ChartPoint
    """Gets or sets the origin (wave 0) anchor point."""
    Wave1: ChartPoint
    """Gets or sets the wave 1 anchor point."""
    Wave2: ChartPoint
    """Gets or sets the wave 2 anchor point."""
    Wave3: ChartPoint
    """Gets or sets the wave 3 anchor point."""
    Wave4: ChartPoint
    """Gets or sets the wave 4 anchor point."""
    Wave5: ChartPoint
    """Gets or sets the wave 5 anchor point."""

class ChartElliottTriangle(ChartElliottWaveBase, ChartObject):
    """Represents the Elliott Triangle Wave (A-B-C-D-E) chart object - a five-leg triangle over six pivots (origin and A to E)."""
    Origin: ChartPoint
    """Gets or sets the origin (wave 0) anchor point."""
    WaveA: ChartPoint
    """Gets or sets the wave A anchor point."""
    WaveB: ChartPoint
    """Gets or sets the wave B anchor point."""
    WaveC: ChartPoint
    """Gets or sets the wave C anchor point."""
    WaveD: ChartPoint
    """Gets or sets the wave D anchor point."""
    WaveE: ChartPoint
    """Gets or sets the wave E anchor point."""

class ChartElliottTripleCombo(ChartElliottWaveBase, ChartObject):
    """Represents the Elliott Triple Combo Wave (W-X-Y-X-Z) chart object - an extended complex correction over six pivots (origin and W, X, Y, X, Z). The two X legs are named X1 and X2."""
    Origin: ChartPoint
    """Gets or sets the origin (wave 0) anchor point."""
    WaveW: ChartPoint
    """Gets or sets the wave W anchor point."""
    WaveX1: ChartPoint
    """Gets or sets the first wave X (X1) anchor point."""
    WaveX2: ChartPoint
    """Gets or sets the second wave X (X2) anchor point."""
    WaveY: ChartPoint
    """Gets or sets the wave Y anchor point."""
    WaveZ: ChartPoint
    """Gets or sets the wave Z anchor point."""

class ChartElliottWaveBase(ChartObject):
    """Represents the shared options of the Elliott Wave chart objects. An Elliott Wave is an ordered list of labelled pivots joined by a polyline; the wave degree drives the label notation."""
    Color: Color
    """Gets or sets the chart object lines color."""
    Degree: ChartElliottWaveDegree
    """Gets or sets the wave degree that drives the label notation and default color."""
    LineStyle: LineStyle
    """Gets or sets the chart object lines style."""
    ShowLabels: bool
    """Gets or sets a value indicating whether the wave labels are displayed. Default is true."""
    Thickness: int
    """Gets or sets the chart object lines thickness."""

class ChartElliottWaveDegree:
    """The Elliott Wave degree. Determines the wave-label notation (numerals, roman or letters and the enclosure style) and the default color of an Elliott Wave chart object."""
    GrandSupercycle: ChartElliottWaveDegree
    Supercycle: ChartElliottWaveDegree
    Cycle: ChartElliottWaveDegree
    Primary: ChartElliottWaveDegree
    Intermediate: ChartElliottWaveDegree
    Minor: ChartElliottWaveDegree
    Minute: ChartElliottWaveDegree
    Minuette: ChartElliottWaveDegree
    Subminuette: ChartElliottWaveDegree

class ChartEllipse(ChartShape, ChartObject):
    """Represent the Ellipse chart object."""
    Time1: DateTime
    """Gets or sets the value 1 on the Time line."""
    Time2: DateTime
    """Gets or sets the value 2 on the Time line."""
    Y1: float
    """Gets or sets the value 1 on the Y-axis."""
    Y2: float
    """Gets or sets the value 2 on the Y-axis."""

class ChartEquidistantChannel(ChartObject):
    """Represents the Equidistant Channel chart object. The tool that allows drawing two precisely parallel lines in any direction on the chart."""
    @overload
    def CalculateY(self, barIndex: int) -> float:
        """Calculates Y-axis value corresponding the specified bar index."""
        ...
    @overload
    def CalculateY(self, time: DateTime) -> float:
        """Calculates Y-axis value corresponding the specified time value."""
        ...
    ChannelHeight: float
    """Gets or sets the height of the Equidistant Channel."""
    Color: Color
    """Gets or sets the Equidistant Channel line color."""
    ExtendToInfinity: bool
    """Defines if the Equidistant channel extends to infinity."""
    LineStyle: LineStyle
    """Gets or sets the Equidistant channel line style."""
    ShowAngle: bool
    """Gets or sets the Equidistant Channel angle."""
    Thickness: int
    """Gets or sets the Equidistant Channel line thickness."""
    Time1: DateTime
    """Gets or sets the value 1 on the Time line."""
    Time2: DateTime
    """Gets or sets the value 2 on the Time line."""
    Y1: float
    """Gets or sets the value 1 on the Y-axis."""
    Y2: float
    """Gets or sets the value 2 on the Y-axis."""

class ChartFibonacciArc(ChartFibonacciBase, ChartObject):
    """Represents the Fibonacci Arc chart object."""
    Time1: DateTime
    """Gets or sets the value 1 on the Time line."""
    Time2: DateTime
    """Gets or sets the value 2 on the Time line."""
    Y1: float
    """Gets or sets the value 1 on the Y-axis."""
    Y2: float
    """Gets or sets the value 2 on the Y-axis."""

class ChartFibonacciBase(ChartObject):
    """Represents the Fibonacci tools options."""
    Color: Color
    """Gets or sets the lines color."""
    DisplayPrices: bool
    """Defines if the Fibonacci levels display the prices"""
    FibonacciLevels: IReadonlyList[FibonacciLevel]
    """Gets the Fibonacci levels."""
    LineStyle: LineStyle
    """Gets or sets the lines style."""
    Thickness: int
    """Gets or sets the lines thickness."""

class ChartFibonacciExpansion(ChartFibonacciBase, ChartObject):
    """Represents the Fibonacci Expansion chart object."""
    Time1: DateTime
    """Gets or sets the value 1 on the Time line."""
    Time2: DateTime
    """Gets or sets the value 2 on the Time line."""
    Time3: DateTime
    """Gets or sets the value 3 on the Time line."""
    Y1: float
    """Gets or sets the value 1 on the Y-axis."""
    Y2: float
    """Gets or sets the value 2 on the Y-axis."""
    Y3: float
    """Gets or sets the value 3 on the Y-axis."""

class ChartFibonacciFan(ChartFibonacciBase, ChartObject):
    """Represents the Fibonacci Fan chart object."""
    @overload
    def CalculateY(self, barIndex: int, level: FibonacciLevel) -> float:
        """Calculates Y-axis value corresponding the specified bar index."""
        ...
    @overload
    def CalculateY(self, time: DateTime, level: FibonacciLevel) -> float:
        """Calculates Y-axis value corresponding the specified time value."""
        ...
    Time1: DateTime
    """Gets or sets the value 1 on the Time line."""
    Time2: DateTime
    """Gets or sets the value 2 on the Time line."""
    Y1: float
    """Gets or sets the value 1 on the Y-axis."""
    Y2: float
    """Gets or sets the value 2 on the Y-axis."""

class ChartFibonacciRetracement(ChartFibonacciBase, ChartObject):
    """Represents the Fibonacci Retracement chart object."""
    @overload
    def CalculateY(self, barIndex: int) -> float:
        """Calculates Y-axis value corresponding the specified bar index."""
        ...
    @overload
    def CalculateY(self, time: DateTime) -> float:
        """Calculates Y-axis value corresponding the specified time value."""
        ...
    Time1: DateTime
    """Gets or sets the value 1 on the Time line."""
    Time2: DateTime
    """Gets or sets the value 2 on the Time line."""
    Y1: float
    """Gets or sets the value 1 on the Y-axis."""
    Y2: float
    """Gets or sets the value 2 on the Y-axis."""

class ChartFibonacciTimezones(ChartFibonacciBase, ChartObject):
    """Represents the Fibonacci Timezones chart object."""
    Time1: DateTime
    """Gets or sets the value 1 on the Time line."""
    Time2: DateTime
    """Gets or sets the value 2 on the Time line."""
    Y1: float
    """Gets or sets the value 1 on the Y-axis."""
    Y2: float
    """Gets or sets the value 2 on the Y-axis."""

class ChartFrame(Frame):
    """Represents a chart frame."""
    def TryChangeTimeFrame(self, timeFrame: TimeFrame) -> bool:
        """Changes the time frame on the chart."""
        ...
    def TryChangeTimeFrameAndSymbol(self, timeFrame: TimeFrame, symbolName: str) -> bool:
        """Changes the time frame and the symbol on the chart."""
        ...
    Chart: Chart
    """Returns frame chart."""
    LinkedChartGroup: LinkedChartGroup
    """Get / set linked group of frame."""
    Symbol: Symbol
    """Get / set frame chart symbol."""
    TimeFrame: TimeFrame
    """Get / set frame chart timeframe."""
    LinkedChartGroupChanged: Event[Callable[[ChartFrameLinkedChartGroupChangedEventArgs], None]]
    """Occurs when frame LinkedChartGroup is changed."""

class ChartFrameLinkedChartGroupChangedEventArgs:
    """Provides data for the chart frame LinkedChartGroup changed event."""
    ChartFrame: ChartFrame
    """Returns the chart frame."""

class ChartGannBase(ChartObject):
    """Represents the Gann tools options."""
    Color: Color
    """Gets or sets the lines color."""
    DisplayPrices: bool
    """Defines if the Gann levels display the prices"""
    GannLevels: IReadonlyList[GannLevel]
    """Gets the Gann levels."""
    LineStyle: LineStyle
    """Gets or sets the lines style."""
    Thickness: int
    """Gets or sets the lines thickness."""
    Time1: DateTime
    """Gets or sets the first point time value on the Time line."""
    Time2: DateTime
    """Gets or sets the second point time value on the Time line."""
    Y1: float
    """Gets or sets the first point value on the Y-axis."""
    Y2: float
    """Gets or sets the second point value on the Y-axis."""

class ChartGannBox(ChartGannBase, ChartObject):
    """Represents the Gann Box chart object."""
    ...

class ChartGannFan(ChartGannBase, ChartObject):
    """Represents the Gann Fan chart object."""
    @overload
    def CalculateY(self, barIndex: int, level: GannLevel) -> float:
        """Calculates Y-axis value corresponding the specified bar index."""
        ...
    @overload
    def CalculateY(self, time: DateTime, level: GannLevel) -> float:
        """Calculates Y-axis value corresponding the specified time value."""
        ...

class ChartGannSquare(ChartGannBase, ChartObject):
    """Represents the Gann Square chart object."""
    @overload
    def CalculateY(self, barIndex: int, level: GannLevel) -> float:
        """Calculates Y-axis value corresponding the specified bar index."""
        ...
    @overload
    def CalculateY(self, time: DateTime, level: GannLevel) -> float:
        """Calculates Y-axis value corresponding the specified time value."""
        ...

class ChartGannSquareFixed(ChartGannBase, ChartObject):
    """Represents the Gann Square Fixed chart object with screen-space rendering."""
    @overload
    def CalculateY(self, barIndex: int, level: GannLevel) -> float:
        """Calculates Y-axis value corresponding the specified bar index."""
        ...
    @overload
    def CalculateY(self, time: DateTime, level: GannLevel) -> float:
        """Calculates Y-axis value corresponding the specified time value."""
        ...

class ChartHorizontalLine(ChartObject):
    """Represents the Horizontal Line chart object. Used to mark a certain value on the Y-axis throughout the whole chart."""
    Color: Color
    """Gets or sets the line color."""
    LineStyle: LineStyle
    """Gets or sets the line style."""
    Thickness: int
    """Gets or sets the line thickness."""
    Y: float
    """Gets or sets the Y-axis value of the line location."""

class ChartIcon(ChartObject):
    """Represents the Icon chart object."""
    Color: Color
    """Gets or sets the color of the icon."""
    IconType: ChartIconType
    """Gets or sets the type of the icon."""
    Time: DateTime
    """Gets or sets the Time value of the icon location."""
    Y: float
    """Gets or sets the Y-axis value of the icon location."""

class ChartIconType:
    """Represents the type of the Icon."""
    UpArrow: ChartIconType
    DownArrow: ChartIconType
    Circle: ChartIconType
    Square: ChartIconType
    Diamond: ChartIconType
    Star: ChartIconType
    UpTriangle: ChartIconType
    DownTriangle: ChartIconType

class ChartIndicator:
    """The interface representing an indicator attached to a chart. Provides properties that allow for accessing various information about an indicator."""
    BarOutputs: IReadonlyList[IndicatorBarOutput]
    """Gets the IReadonlyList of indicator bar outputs."""
    InstanceId: str
    """Gets the ID of a specific indicator instance."""
    LineOutputs: IReadonlyList[IndicatorLineOutput]
    """Gets the IReadonlyList of indicator output lines."""
    Name: str
    """Gets the name of an indicator."""
    PanelIndex: int
    """Gets or sets the index of the panel on which an indicator is displayed."""
    Parameters: AlgoInstanceParameters
    """Gets the collection of indicator parameters."""
    Type: IndicatorType
    """Gets the IndicatorType of an indicator."""

class ChartIndicatorAddedEventArgs(ChartIndicatorEventArgs):
    """The class representing AddedEventArgs for a ChildIndicator ."""
    ...

class ChartIndicatorEventArgs:
    """The base class representing event args for a ChartIndicator ."""
    Indicator: ChartIndicator
    """Gets the ChartIndicator that raised an event."""

class ChartIndicatorModifiedEventArgs(ChartIndicatorEventArgs):
    """The class representing ModifiedEventArgs for a ChartIndicator ."""
    ...

class ChartIndicatorRemovedEventArgs(ChartIndicatorEventArgs):
    """The class representing RemovedEventArgs for a ChartIndicator ."""
    ...

class ChartIndicators:
    """The interface representing a chart indicator instances collection. Provides properties and events that allow for accessing various information about indicators attached to a chart."""
    @overload
    def Add(self, name: str, parameterValues: list[object]) -> ChartIndicator:
        """Adds a new indicator to a chart."""
        ...
    @overload
    def Add(self, type: IndicatorType, parameterValues: list[object]) -> ChartIndicator:
        """Adds a new indicator to a chart."""
        ...
    def Remove(self, indicator: ChartIndicator) -> bool:
        """Removes an indicator from a chart."""
        ...
    Count: int
    """Gets the number of all indicators attached to a chart."""
    Custom: IReadonlyList[ChartIndicator]
    """Gets the list of chart custom indicators."""
    Item: ChartIndicator
    """Gets an indicator attached to a chart by its instance ID."""
    Standard: IReadonlyList[ChartIndicator]
    """Gets the list of chart standard indicators."""
    IndicatorAdded: Event[Callable[[ChartIndicatorAddedEventArgs], None]]
    """Occurs when a new indicator is added to a chart."""
    IndicatorModified: Event[Callable[[ChartIndicatorModifiedEventArgs], None]]
    """Occurs when an indicator attached to a chart is modified."""
    IndicatorRemoved: Event[Callable[[ChartIndicatorRemovedEventArgs], None]]
    """Occurs when an indicator is removed from a chart."""

class ChartKeyboardEventArgs:
    """Provides data for chart keyboard related events and callbacks"""
    AltKey: bool
    """True if Alt key was pressed otherwise False"""
    Chart: Chart
    """The chart that the event/callback occurred"""
    CtrlKey: bool
    """True if Ctrl key was pressed otherwise False"""
    Key: Key
    """Keyboard key"""
    Modifiers: ModifierKeys
    """Modifiers key that was used with the Key"""
    ShiftKey: bool
    """True if Shift key was pressed otherwise False"""

class ChartManager:
    """Represents the list of all the chart frames."""
    @overload
    def AddChartFrame(self, symbolName: str, timeFrame: TimeFrame) -> ChartFrame:
        """Adds a new chart frame to main chart container."""
        ...
    @overload
    def AddChartFrame(self, symbolName: str, timeFrame: TimeFrame, targetChartContainer: ChartContainer) -> ChartFrame:
        """Adds a new chart frame to target chart container."""
        ...
    @overload
    def AddCustomFrame(self, title: str) -> CustomFrame:
        """Adds a new custom frame to main chart container."""
        ...
    @overload
    def AddCustomFrame(self, title: str, targetChartContainer: ChartContainer) -> CustomFrame:
        """Adds a new custom frame to target chart container."""
        ...
    def GetChartFrame(self, frameId: str) -> ChartFrame:
        """Gets a chart frame by it is Id."""
        ...
    def GetCustomFrame(self, frameId: str) -> CustomFrame:
        """Gets a custom frame by it is Id."""
        ...
    def RemoveFrame(self, frameId: str) -> bool:
        """Removes a frame by it is Id."""
        ...
    ActiveChartContainer: ChartContainer
    """Returns current active chart container if any otherwise null."""
    ActiveFrame: Frame
    """Returns current active frame if any otherwise null."""
    ChartContainers: ChartContainers
    """Returns chart containers."""
    Count: int
    """Returns number of all frames."""
    ActiveFrameChanged: Event[Callable[[ActiveFrameChangedEventArgs], None]]
    """Occurs when active frame is changed."""
    FramesAdded: Event[Callable[[FramesAddedEventArgs], None]]
    """Occurs when new frames are added."""
    FramesRemoved: Event[Callable[[FramesRemovedEventArgs], None]]
    """Occurs when frames are removed."""

class ChartMode:
    """Represents the predefined chart container modes."""
    Single: ChartMode
    Multi: ChartMode
    Free: ChartMode
    Floating: ChartMode

class ChartMouseEventArgs:
    """Provides data for the mouse related routed events."""
    AltKey: bool
    """Defines whether the Alt key is pressed during the mouse event."""
    BarIndex: float
    """Gets the exact bar index of the mouse event."""
    Chart: Chart
    """Gets the chart."""
    ChartArea: ChartArea
    """Gets the chart area."""
    CtrlKey: bool
    """Defines whether the Ctrl key is pressed during the mouse event."""
    MouseX: float
    """Gets the X-axis value of the mouse event."""
    MouseY: float
    """Gets the Y-axis value of the mouse event."""
    ShiftKey: bool
    """Defines whether the Shift key is pressed during the mouse event."""
    TimeValue: DateTime
    """Gets the time value on the X-axis where the mouse event occurs."""
    YValue: float
    """Gets the Y-axis value of the mouse event."""

class ChartMouseWheelEventArgs(ChartMouseEventArgs):
    """Provides data for the mouse wheel scroll event."""
    Delta: int
    """Gets the number of detents the mouse wheel has rotated. A detent is one notch of the mouse wheel."""

class ChartObject:
    """Represents the chart object."""
    Comment: str
    """Gets or sets the comment for the chart object."""
    IsAlive: bool
    """Defines if the chart object still exists on the chart."""
    IsHidden: bool
    """Gets or sets if object is hidden and not visible to user or not."""
    IsInteractive: bool
    """Defines whether the instance is interactive. The non-interactive chart objects cannot be selected, have no hover effect and cannot be searched. Available only for the current cBot or Indicator and will be removed when the cBot/Indicator stops."""
    IsLocked: bool
    """Gets or sets if the object is locked or not, user can't move locked objects unless unlocked."""
    Name: str
    """Gets the chart object name - the unique identifier for the object in the current chart area."""
    ObjectType: ChartObjectType
    """Gets the chart object type."""
    ZIndex: int
    """Gets or sets the location of a chart object on the Z-axis in respect to the other chart objects."""

class ChartObjectEventArgs:
    """Provides data for the chart object change event."""
    Area: ChartArea
    """Gets the chart area."""
    Chart: Chart
    """Gets the chart."""
    ChartObject: ChartObject
    """Gets the chart object."""

class ChartObjectHoverChangedEventArgs(ChartObjectEventArgs):
    """Provides data for the mouse hover over a chart object event."""
    IsObjectHovered: bool
    """Defines if the mouse is hovered over the chart object."""

class ChartObjectType:
    """The chart object types."""
    HorizontalLine: ChartObjectType
    VerticalLine: ChartObjectType
    TrendLine: ChartObjectType
    Text: ChartObjectType
    StaticText: ChartObjectType
    Icon: ChartObjectType
    FibonacciRetracement: ChartObjectType
    FibonacciExpansion: ChartObjectType
    FibonacciFan: ChartObjectType
    AndrewsPitchfork: ChartObjectType
    GannFan: ChartObjectType
    GannBox: ChartObjectType
    GannSquare: ChartObjectType
    GannSquareFixed: ChartObjectType
    Rectangle: ChartObjectType
    Ellipse: ChartObjectType
    Triangle: ChartObjectType
    EquidistantChannel: ChartObjectType
    Drawing: ChartObjectType
    ArrowLine: ChartObjectType
    FibonacciTimezones: ChartObjectType
    RiskReward: ChartObjectType
    FibonacciArc: ChartObjectType
    ElliottImpulse: ChartObjectType
    ElliottCorrection: ChartObjectType
    ElliottTriangle: ChartObjectType
    ElliottDoubleCombo: ChartObjectType
    ElliottTripleCombo: ChartObjectType

class ChartObjectsAddedEventArgs(ChartObjectsEventArgs):
    """Provides data for the adding chart objects event."""
    ...

class ChartObjectsEventArgs:
    """Provides data for the chart objects change event."""
    Area: ChartArea
    """Gets the chart area."""
    Chart: Chart
    """Gets the chart."""
    ChartObjects: IReadonlyList[ChartObject]
    """Gets chart objects."""

class ChartObjectsMoveEndedEventArgs(ChartObjectsEventArgs):
    """Provides data for the chart objects move ended event."""
    ...

class ChartObjectsMoveStartedEventArgs(ChartObjectsEventArgs):
    """Provides data for the chart objects move started event."""
    ...

class ChartObjectsMovingEventArgs(ChartObjectsEventArgs):
    """Provides data for the chart objects moving event."""
    ...

class ChartObjectsRemovedEventArgs(ChartObjectsEventArgs):
    """Provides data for the removing chart objects event."""
    ...

class ChartObjectsSelectionChangedEventArgs:
    """Provides data for the chart objects selecting or deselecting event."""
    Area: ChartArea
    """A chart area where event occured"""
    Chart: Chart
    """A chart where event occured"""
    ObjectsAddedToSelection: IReadonlyList[ChartObject]
    """A list of objects that were added to selection"""
    ObjectsRemovedFromSelection: IReadonlyList[ChartObject]
    """A list of objects that were removed from selection"""

class ChartObjectsUpdatedEventArgs(ChartObjectsEventArgs):
    """Provides data for the chart objects update event."""
    ...

class ChartPoint:
    """Represents a single chart anchor point - a time value on the X-axis and a Y-axis value."""
    def __init__(self, Time: DateTime, Y: float) -> None: ...
    Time: DateTime
    """The time value on the X-axis."""
    Y: float
    """The Y-axis value."""

class ChartPriceAxisPosition:
    """Represents the side of the chart where the price axis is displayed."""
    Right: ChartPriceAxisPosition
    Left: ChartPriceAxisPosition

class ChartPriceScaleEventArgs:
    """Provides data for the chart area price scale change event."""
    Chart: Chart
    """Gets the chart."""
    ChartArea: ChartArea
    """Gets the chart area whose price scale changed. It is the chart itself for the main area."""

class ChartPriceScaleMode:
    """Represents the price scale mode of the chart main area."""
    Regular: ChartPriceScaleMode
    Percent: ChartPriceScaleMode
    IndexedTo100: ChartPriceScaleMode
    Logarithmic: ChartPriceScaleMode

class ChartRectangle(ChartShape, ChartObject):
    """Represents the Rectangle chart object. A rectangle of any preferable size and rotation that can be drawn directly in the chart, bound to X-Y axises."""
    Time1: DateTime
    """Gets or sets the value 1 on the Time line."""
    Time2: DateTime
    """Gets or sets the value 2 on the Time line."""
    Y1: float
    """Gets or sets the value 1 on the Y-axis."""
    Y2: float
    """Gets or sets the value 2 on the Y-axis."""

class ChartRiskReward(ChartObject):
    """Represents the risk reward chart object."""
    EntryPrice: float
    """Gets or sets the entry price."""
    IsFixedRatio: bool
    """Gets or sets if risk reward ratio is fixed or not."""
    IsMarketRange: bool
    """Gets or sets if order type is market range."""
    LimitRangePips: float
    """Gets or sets order limit range pips amount."""
    MarketRangePips: float
    """Gets or sets order market range pips amount."""
    OrderType: OrderType
    """Gets or sets the order type."""
    RewardColor: Color
    """Gets or sets the reward color."""
    RewardLineStyle: LineStyle
    """Gets or sets the reward style."""
    RewardThickness: int
    """Gets or sets the reward thickness."""
    RiskColor: Color
    """Gets or sets the risk color."""
    RiskLineStyle: LineStyle
    """Gets or sets the risk line style."""
    RiskRewardRatio: float
    """Gets or sets risk reward ratio."""
    RiskThickness: int
    """Gets or sets the risk line thickness."""
    StopLossPrice: float
    """Gets or sets the stop loss price."""
    TakeProfitPrice: float
    """Gets or sets the take profit price."""
    Time1: DateTime
    """Gets or sets the value 1 on the Time line."""
    Time2: DateTime
    """Gets or sets the value 2 on the Time line."""
    TradeType: TradeType
    """Gets or sets the trade type."""
    Type: ChartRiskRewardType
    """Gets or sets type."""
    VolumeInUnits: float
    """Gets or sets the volume (in units)."""

class ChartRiskRewardAmountType:
    """Represents different amount types for chart risk reward."""
    Money: ChartRiskRewardAmountType
    BalancePercentage: ChartRiskRewardAmountType
    EquityPercentage: ChartRiskRewardAmountType

class ChartRiskRewardFixedRewardType(ChartRiskRewardType):
    """Represents fixed reward type of chart risk reward."""
    @overload
    def __init__(self, amountType: ChartRiskRewardAmountType, amount: float) -> None: ...
    @overload
    def __init__(self, original: ChartRiskRewardFixedRewardType) -> None: ...
    Amount: float
    """Gets or sets amount."""
    AmountType: ChartRiskRewardAmountType
    """Gets or sets amount mode."""

class ChartRiskRewardFixedRiskType(ChartRiskRewardType):
    """Represents fixed risk type of chart risk reward."""
    @overload
    def __init__(self, amountType: ChartRiskRewardAmountType, amount: float) -> None: ...
    @overload
    def __init__(self, original: ChartRiskRewardFixedRiskType) -> None: ...
    Amount: float
    """Gets or sets amount."""
    AmountType: ChartRiskRewardAmountType
    """Gets or sets amount mode."""

class ChartRiskRewardFixedSizeType(ChartRiskRewardType):
    """Represents fixed size type of chart risk reward."""
    @overload
    def __init__(self, volumeInUnits: float) -> None: ...
    @overload
    def __init__(self, original: ChartRiskRewardFixedSizeType) -> None: ...
    VolumeInUnits: float
    """Gets or sets volume (in units)."""

class ChartRiskRewardType:
    """Represents different types of chart risk reward."""
    ...

class ChartRobot:
    """The interface representing a Robot instance attached to a chart. Provides properties that allow for accessing various information about a Robot."""
    def Start(self) -> None:
        """Starts the Robot instance."""
        ...
    def Stop(self) -> None:
        """Stops the Robot instance."""
        ...
    InstanceId: str
    """Gets the ID of a specific Robot instance."""
    Name: str
    """Gets the name of a Robot instance."""
    Parameters: AlgoInstanceParameters
    """Gets the collection of Robot parameters."""
    State: RobotState
    """Gets the current state of a Robot instance."""
    Type: RobotType
    """Gets the RobotType of a Robot instance."""

class ChartRobotAddedEventArgs(ChartRobotEventArgs):
    """The class representing AddedEventArgs for a ChartRobot ."""
    ...

class ChartRobotEventArgs:
    """The base class representing event args for a ChartRobot ."""
    Robot: ChartRobot
    """Gets the ChartRobot that raised an event."""

class ChartRobotModifiedEventArgs(ChartRobotEventArgs):
    """The class representing ModifiedEventArgs for a ChartRobot ."""
    ...

class ChartRobotRemovedEventArgs(ChartRobotEventArgs):
    """The class representing RemovedEventArgs for a ChartRobot ."""
    ...

class ChartRobotStartedEventArgs(ChartRobotEventArgs):
    """The class representing StartedEventArgs for a ChartRobot ."""
    ...

class ChartRobotStoppedEventArgs(ChartRobotEventArgs):
    """The class representing StoppedEventArgs for a ChartRobot ."""
    ...

class ChartRobots:
    """The interface representing a chart Robot instances collection. Provides properties and events that allow for accessing various information about Robots attached to a chart."""
    @overload
    def Add(self, name: str, parameterValues: list[object]) -> ChartRobot:
        """Adds a new Robot instance to a chart."""
        ...
    @overload
    def Add(self, type: RobotType, parameterValues: list[object]) -> ChartRobot:
        """Adds a new Robot instance to a chart."""
        ...
    def Remove(self, robot: ChartRobot) -> bool:
        """Removes a Robot instance from a chart."""
        ...
    Count: int
    """Gets the number of all Robots attached to a chart."""
    Item: ChartRobot
    """Gets a Robot attached instance to a chart by its instance ID."""
    RobotAdded: Event[Callable[[ChartRobotAddedEventArgs], None]]
    """Occurs when a Robot is added to a chart."""
    RobotModified: Event[Callable[[ChartRobotModifiedEventArgs], None]]
    """Occurs when a chart Robot instance is modified."""
    RobotRemoved: Event[Callable[[ChartRobotRemovedEventArgs], None]]
    """Occurs when a Robot is removed from a chart."""
    RobotStarted: Event[Callable[[ChartRobotStartedEventArgs], None]]
    """Occurs when a chart Robot instance is started."""
    RobotStopped: Event[Callable[[ChartRobotStoppedEventArgs], None]]
    """Occurs when a chart Robot instance is stopped."""

class ChartRobotsPermission(Permission):
    """Chart Robots Permission"""
    ...

class ChartScrollEventArgs:
    """Provides data for the chart scrolling event."""
    BarsDelta: int
    """Gets a value that indicates the amount of bars that the chart was scrolled for"""
    BottomYDelta: float
    """Gets the lowest value of the bars delta."""
    Chart: Chart
    """Gets the chart."""
    ChartArea: ChartArea
    """Gets the chart area."""
    TopYDelta: float
    """Gets the highest value of the bars delta."""

class ChartShape(ChartObject):
    """Represents the Shape chart object. Allows drawing a Rectangle, a Triangle, and an Ellipse on the chart."""
    Color: Color
    """Gets or sets the line color."""
    IsFilled: bool
    """Defines if the shape is filled."""
    LineStyle: LineStyle
    """Gets or sets the line style."""
    Thickness: int
    """Gets or sets the line thickness."""

class ChartSizeEventArgs:
    """Provides data for the chart size change event."""
    Area: ChartArea
    """Gets the chart area."""
    Chart: Chart
    """Gets the chart."""

class ChartStaticText(ChartObject):
    """Represents the chart static text."""
    Color: Color
    """Gets or sets the chart static text color."""
    FontFamily: str
    """Gets or sets the font style of the text."""
    FontSize: float
    """Gets or sets the font size of text"""
    HorizontalAlignment: HorizontalAlignment
    """Gets or sets the chart static text horizontal alignment."""
    IsBold: bool
    """Gets or sets if the text is Bold or not"""
    IsItalic: bool
    """Gets or sets if the text is Italic or not"""
    IsUnderlined: bool
    """Gets or sets if the text is Underlined or not"""
    Text: str
    """Gets or sets the chart static text content."""
    VerticalAlignment: VerticalAlignment
    """Gets or sets the chart static text vertical alignment."""

class ChartTemplate:
    """Represents chart template."""
    def Apply(self, chart: Chart) -> None:
        """Applies current chart template to a chart."""
        ...
    ColorSettings: ChartTemplateColorSettings
    """Gets the chart template color settings."""
    DisplaySettings: ChartTemplateDisplaySettings
    """Gets the chart template display settings."""
    Indicators: ChartTemplateIndicators
    """Gets the indicators of chart template."""
    Name: str
    """Gets the chart template name."""
    Robots: ChartTemplateRobots
    """Gets the robots of chart template."""

class ChartTemplateAddedEventArgs:
    """Occurs when a new chart template is added."""
    ChartTemplate: ChartTemplate
    """Gets the chart template."""

class ChartTemplateAlgoInstanceParameter:
    """The interface representing a chart template indicator / robot instance parameter."""
    Name: str
    """Gets the name of a parameter."""
    Value: object
    """Gets the value of a parameter."""

class ChartTemplateAlgoInstanceParameters:
    """Represents the collection of all the parameters of a chart template indicator or Robot."""
    Count: int
    """Gets the number of parameters."""
    Item: ChartTemplateAlgoInstanceParameter
    """Gets a parameter by it is name."""

class ChartTemplateColorSettings:
    """Represents the chart template Color Settings."""
    AreaFillColor: Color
    """Gets or sets the color of area chart fill."""
    AskPriceLineColor: Color
    """Gets or sets the color of the ask price line."""
    BackgroundColor: Color
    """Gets or sets the color of the chart background."""
    BearFillColor: Color
    """Gets or sets the color of the bear candle fill."""
    BearOutlineColor: Color
    """Gets or sets the color of the bear candle or bar outline."""
    BidPriceLineColor: Color
    """Gets or sets the color of the bid price line."""
    BullFillColor: Color
    """Gets or sets the color of the bull candle fill."""
    BullOutlineColor: Color
    """Gets or sets the color of the bull candle or bar outline."""
    BuyColor: Color
    """Gets or sets the color of Buy positions and orders."""
    ForegroundColor: Color
    """Gets or sets the color of the chart foreground."""
    GridLinesColor: Color
    """Gets or sets the color of the grid lines."""
    LosingDealColor: Color
    """Gets or sets the color of the losing deal."""
    PeriodSeparatorColor: Color
    """Gets or sets the color of the period separator."""
    SellColor: Color
    """Gets or sets the color of Sell order positions and orders."""
    TickVolumeColor: Color
    """Gets or sets the color of the tick volume."""
    WinningDealColor: Color
    """Gets or sets the color of the winning deal."""

class ChartTemplateDisplaySettings:
    """Represents the chart template display Settings."""
    AddRobotButton: bool
    """Defines if the Add cBot button is displayed on the chart."""
    AskPriceLine: bool
    """Defines if the Ask Price Line is displayed on the chart."""
    Bars: bool
    """Defines if the Bars is displayed on the chart."""
    BidPriceLine: bool
    """Defines if the Bid Price Line is displayed on the chart."""
    ChartScale: bool
    """Defines if the Chart Scale is displayed on the chart."""
    ChartType: ChartType
    """Gets or sets the type of the chart for chart template."""
    DealMap: bool
    """Defines if the Deal Map is displayed on the chart."""
    Grid: bool
    """Defines if the Grid is displayed on the chart background."""
    IndicatorTitles: bool
    """Defines if the Indicator Titles are displayed on the chart."""
    IsPriceScaleInverted: bool
    """Defines if the price scale is inverted for chart template."""
    IsPriceToBarRatioLocked: bool
    """Defines if the price to bar ratio is locked for chart template. Locking sets the price scale mode to Regular."""
    IsScalePriceChartOnly: bool
    """Defines if the auto scale fits only the bars for chart template."""
    MarketSentiment: bool
    """Defines if the Market Sentiment is visible on the chart."""
    Orders: bool
    """Defines if the Orders are displayed on the chart."""
    PeriodSeparators: bool
    """Defines if the Period Separators are displayed on the chart."""
    Positions: bool
    """Defines if the Positions are displayed on the chart."""
    PriceAlerts: bool
    """Defines if the Price Alerts are visible on the chart."""
    PriceAxisOverlayButtons: bool
    """Defines if the price axis overlays buttons are visible on the chart."""
    PriceAxisPosition: ChartPriceAxisPosition
    """Gets or sets the price axis position for chart template."""
    PriceScaleMode: ChartPriceScaleMode
    """Gets or sets the price scale mode for chart template. While the template price to bar ratio is locked only Regular can be set, and setting any other mode is ignored."""
    PriceToBarRatio: float
    """Gets or sets the price to bar ratio for chart template. Values that are not greater than zero, NaN or infinite are ignored."""
    QuickTradeButtons: bool
    """Defines if the QuickTrade buttons are visible on the chart."""
    Targets: bool
    """Defines if the Target is visible on the chart."""
    TickVolume: bool
    """Defines if the Tick Volume is displayed on the chart."""
    ZoomLevel: int
    """Gets or sets the chart zoom percent value for chart template. Valid values are from 5 to 500 with a step of 5, as can be seen on UI in the charts Zoom control."""

class ChartTemplateIndicator:
    """The interface representing an indicator of to a chart template."""
    Id: str
    """Gets the ID of a specific indicator."""
    Parameters: ChartTemplateAlgoInstanceParameters
    """Gets the collection of indicator parameters."""
    Type: IndicatorType
    """Gets the IndicatorType of an indicator."""

class ChartTemplateIndicators:
    """The interface representing a chart template indicator instances collection."""
    @overload
    def Add(self, name: str, parameterValues: list[object]) -> ChartTemplateIndicator:
        """Adds a new indicator to a chart template."""
        ...
    @overload
    def Add(self, type: IndicatorType, parameterValues: list[object]) -> ChartTemplateIndicator:
        """Adds a new indicator to a chart template."""
        ...
    def Get(self, id: str) -> ChartTemplateIndicator:
        """Returns a chart template indicator by type if exists otherwise null."""
        ...
    def Remove(self, chartTemplateIndicator: ChartTemplateIndicator) -> bool:
        """Removes an indicator from a chart template."""
        ...
    Count: int
    """Gets the number of all indicators attached to a chart template."""

class ChartTemplateRemovedEventArgs:
    """Occurs when a chart template is removed."""
    ChartTemplate: ChartTemplate
    """Gets the chart template."""

class ChartTemplateRobot:
    """The interface representing a Robot of a chart template."""
    Id: str
    """Gets the ID of a specific indicator."""
    Parameters: ChartTemplateAlgoInstanceParameters
    """Gets the collection of Robot parameters."""
    Type: RobotType
    """Gets the RobotType of a Robot instance."""

class ChartTemplateRobots:
    """The interface representing a chart template robots instances collection."""
    @overload
    def Add(self, name: str, parameterValues: list[object]) -> ChartTemplateRobot:
        """Adds a new Robot instance to a chart template."""
        ...
    @overload
    def Add(self, type: RobotType, parameterValues: list[object]) -> ChartTemplateRobot:
        """Adds a new Robot instance to a chart template."""
        ...
    def Get(self, id: str) -> ChartTemplateRobot:
        """Returns a chart template robot by type if exists otherwise null."""
        ...
    def Remove(self, chartTemplateRobot: ChartTemplateRobot) -> bool:
        """Removes a Robot instance from a chart template."""
        ...
    Count: int
    """Gets the number of all Robots attached to a chart."""

class ChartTemplates:
    """Represents collection of chart templates and provide access to chart template API."""
    def Contains(self, chartTemplateName: str) -> bool:
        """Checks if a chart template with passed name exists or not."""
        ...
    @overload
    def Create(self, chartTemplateName: str, chart: Chart) -> ChartTemplate:
        """Creates a new chart template based on a chart."""
        ...
    @overload
    def Create(self, chartTemplateName: str) -> ChartTemplate:
        """Creates a new chart template."""
        ...
    def Duplicate(self, chartTemplateName: str, chartTemplate: ChartTemplate) -> ChartTemplate:
        """Duplicates or creates a copy of an existing chart template."""
        ...
    def Get(self, chartTemplateName: str) -> ChartTemplate:
        """Returns a chart template by name if exists otherwise null."""
        ...
    def Remove(self, chartTemplate: ChartTemplate) -> bool:
        """Removes an existing chart template."""
        ...
    DefaultTemplate: ChartTemplate
    """Gets or sets default chart template."""
    Added: Event[Callable[[ChartTemplateAddedEventArgs], None]]
    """Occurs when a new chart template is added."""
    Removed: Event[Callable[[ChartTemplateRemovedEventArgs], None]]
    """Occurs when a chart template is removed."""

class ChartText(ChartObject):
    """Represents the Text chart object. Allows place the text anywhere on the chart, bound to the chart."""
    Angle: float
    """Gets or sets the rotation angle of the text in degrees, measured clockwise around the text anchor point. The text can be fully rotated; any value is accepted and normalized to the 0 to 360 range. The default value is 0, which renders horizontal text."""
    Color: Color
    """Gets or sets the text color."""
    FontFamily: str
    """Gets or sets the font style of the text."""
    FontSize: float
    """Gets or sets the font size of text"""
    HorizontalAlignment: HorizontalAlignment
    """Gets or sets the horizontal alignment of the text regarding the anchor point."""
    IsBold: bool
    """Gets or sets if the text is Bold or not"""
    IsItalic: bool
    """Gets or sets if the text is Italic or not"""
    IsUnderlined: bool
    """Gets or sets if the text is Underlined or not"""
    Text: str
    """Gets or sets the text content."""
    Time: DateTime
    """Gets or sets the Time line value."""
    VerticalAlignment: VerticalAlignment
    """Gets or sets the vertical alignment of the text regarding the anchor point."""
    Y: float
    """Gets or sets the Y-axis value."""

class ChartTrendLine(ChartObject):
    """Represents the Trend Line chart object. A straight line that can be drawn from point 1 to the point 2 in any direction to mark the trends on the chart."""
    @overload
    def CalculateY(self, barIndex: int) -> float:
        """Calculates Y-axis value corresponding the specified bar index."""
        ...
    @overload
    def CalculateY(self, time: DateTime) -> float:
        """Calculates Y-axis value corresponding the specified time value."""
        ...
    Color: Color
    """Gets or sets the color of the Trend Line."""
    ExtendToInfinity: bool
    """Defines if the Trend Line extends to infinity."""
    LineStyle: LineStyle
    """Gets or sets the Trend Line style."""
    ShowAngle: bool
    """Defines the trend line angle."""
    Thickness: int
    """Gets or sets the thickness of the Trend Line."""
    Time1: DateTime
    """Gets or sets the value 1 on the Time line."""
    Time2: DateTime
    """Gets or sets the value 2 on the Time line."""
    Y1: float
    """Gets or sets the value 1 on the Y-axis."""
    Y2: float
    """Gets or sets the value 2 on the Y-axis."""

class ChartTriangle(ChartShape, ChartObject):
    """Represents the Triangle chart object."""
    Time1: DateTime
    """Gets or sets the value 1 on the Time line."""
    Time2: DateTime
    """Gets or sets the value 2 on the Time line."""
    Time3: DateTime
    """Gets or sets the value 3 on the Time line."""
    Y1: float
    """Gets or sets the value 1 on the Y-axis."""
    Y2: float
    """Gets or sets the value 2 on the Y-axis."""
    Y3: float
    """Gets or sets the value 3 on the Y-axis."""

class ChartType:
    """Represents the predefined chart types."""
    Bars: ChartType
    Candlesticks: ChartType
    Line: ChartType
    Dots: ChartType
    Area: ChartType
    Hlc: ChartType

class ChartTypeEventArgs:
    """Provides data for the chart type change event."""
    Chart: Chart
    """Gets the chart."""

class ChartVerticalLine(ChartObject):
    """Represents the Vertical Line chart object. The line parallel to the Y-axis that can be set on a certain time value on the X-axis."""
    Color: Color
    """Gets or sets the line color."""
    LineStyle: LineStyle
    """Gets or sets the line style."""
    Thickness: int
    """Gets or sets the line thickness."""
    Time: DateTime
    """Gets or sets the value on the Time line."""

class ChartVisibilityChangedEventArgs:
    """Provides data for chart visibility changed event"""
    Chart: Chart
    """The chart that event belonges to."""

class ChartZoomEventArgs:
    """Provides data for the chart type change event."""
    Chart: Chart
    """Gets the chart."""

class CheckBox(Control):
    """Represents the Checkbox."""
    def __init__(self) -> None: ...
    Content: ControlBase
    """Gets or sets the content."""
    IsChecked: bool | None
    """Gets or sets a value indicating whether the checkbox is checked."""
    IsThreeState: bool
    """Checks if the checkbox may be of three states - checked, unchecked and indeterminate."""
    Text: str
    """Gets or sets the checkbox text."""
    Checked: Event[Callable[[CheckBoxEventArgs], None]]
    """Occurs when checked."""
    Click: Event[Callable[[CheckBoxEventArgs], None]]
    """Occurs when clicked."""
    Indeterminate: Event[Callable[[CheckBoxEventArgs], None]]
    """Occurs when indeterminate."""
    Unchecked: Event[Callable[[CheckBoxEventArgs], None]]
    """Occurs when unchecked."""

class CheckBoxEventArgs:
    """Provides data for the checkbox event."""
    CheckBox: CheckBox
    """Gets the checkbox data."""

class Clipboard:
    """Provides access to system Clipboard."""
    def GetText(self) -> str:
        """Returns a string containing text data on the Clipboard."""
        ...
    def SetText(self, text: str) -> None:
        """Stores text data on the Clipboard."""
        ...

class ClipboardPermission(Permission):
    """System Clipboard Permission"""
    ...

class CloudAttribute:
    """Represents the cloud between the indicator lines."""
    def __init__(self, firstLineName: str, secondLineName: str) -> None: ...
    FirstColor: str
    """Cloud color when the first line is above the second one. If not specified, the color of the first line is used."""
    FirstLineName: str
    """The name of the first indicator line."""
    Opacity: float
    """The cloud opacity. Value can be set from 0 (transparent) to 1 (opaque). Values higher than 1 will be set to 1, values below 0 will be set to 0. Opacity is multiplied by the alpha channel of the active color (first or second color). Default opacity value is 0.2."""
    SecondColor: str
    """Cloud color when the second line is above the first one. If not specified, color of the second line is used."""
    SecondLineName: str
    """The name of the second indicator line."""

class Color:
    """Represents an ARGB (alpha, red, green, blue) color."""
    @overload
    @staticmethod
    def FromArgb(alpha: int, red: int, green: int, blue: int) -> Color:
        """Creates a color from alpha, red, green and blue components."""
        ...
    @overload
    @staticmethod
    def FromArgb(alpha: int, baseColor: Color) -> Color:
        """Creates a color from existing color, but with new specified alpha value."""
        ...
    @overload
    @staticmethod
    def FromArgb(argb: int) -> Color:
        """Creates a color from a 32-bit ARGB value."""
        ...
    @overload
    @staticmethod
    def FromArgb(red: int, green: int, blue: int) -> Color:
        """Creates a color from red, green and blue values. The alpha value is implicitly 255 (fully opaque)."""
        ...
    @staticmethod
    def FromHex(hex: str) -> Color:
        """Attempts to convert a hex string to a Color."""
        ...
    @staticmethod
    def FromName(name: str) -> Color:
        """Creates a color from the specified name of a predefined color."""
        ...
    def ToArgb(self) -> int:
        """Get the 32-bit ARGB color value."""
        ...
    def ToHexString(self) -> str:
        """Get the hex string representation of the color."""
        ...
    A: int
    """Gets the alpha component value of the color."""
    AliceBlue: Color
    """Gets a system-defined color that has an ARGB value of #FFF0F8FF."""
    AntiqueWhite: Color
    """Gets a system-defined color that has an ARGB value of #FFFAEBD7."""
    Aqua: Color
    """Gets a system-defined color that has an ARGB value of #FF00FFFF."""
    Aquamarine: Color
    """Gets a system-defined color that has an ARGB value of #FF7FFFD4."""
    Azure: Color
    """Gets a system-defined color that has an ARGB value of #FFF0FFFF."""
    B: int
    """Gets the blue component value of the color."""
    Beige: Color
    """Gets a system-defined color that has an ARGB value of #FFF5F5DC."""
    Bisque: Color
    """Gets a system-defined color that has an ARGB value of #FFFFE4C4."""
    Black: Color
    """Gets a system-defined color that has an ARGB value of #FF000000."""
    BlanchedAlmond: Color
    """Gets a system-defined color that has an ARGB value of #FFFFEBCD."""
    Blue: Color
    """Gets a system-defined color that has an ARGB value of #FF0000FF."""
    BlueViolet: Color
    """Gets a system-defined color that has an ARGB value of #FF8A2BE2."""
    Brown: Color
    """Gets a system-defined color that has an ARGB value of #FFA52A2A."""
    BurlyWood: Color
    """Gets a system-defined color that has an ARGB value of #FFDEB887."""
    CadetBlue: Color
    """Gets a system-defined color that has an ARGB value of #FF5F9EA0."""
    Chartreuse: Color
    """Gets a system-defined color that has an ARGB value of #FF7FFF00."""
    Chocolate: Color
    """Gets a system-defined color that has an ARGB value of #FFD2691E."""
    Coral: Color
    """Gets a system-defined color that has an ARGB value of #FFFF7F50."""
    CornflowerBlue: Color
    """Gets a system-defined color that has an ARGB value of #FF6495ED."""
    Cornsilk: Color
    """Gets a system-defined color that has an ARGB value of #FFFFF8DC."""
    Crimson: Color
    """Gets a system-defined color that has an ARGB value of #FFDC143C."""
    Cyan: Color
    """Gets a system-defined color that has an ARGB value of #FF00FFFF."""
    DarkBlue: Color
    """Gets a system-defined color that has an ARGB value of #FF00008B."""
    DarkCyan: Color
    """Gets a system-defined color that has an ARGB value of #FF008B8B."""
    DarkGoldenrod: Color
    """Gets a system-defined color that has an ARGB value of #FFB8860B."""
    DarkGray: Color
    """Gets a system-defined color that has an ARGB value of #FFA9A9A9."""
    DarkGreen: Color
    """Gets a system-defined color that has an ARGB value of #FF006400."""
    DarkKhaki: Color
    """Gets a system-defined color that has an ARGB value of #FFBDB76B."""
    DarkMagenta: Color
    """Gets a system-defined color that has an ARGB value of #FF8B008B."""
    DarkOliveGreen: Color
    """Gets a system-defined color that has an ARGB value of #FF556B2F."""
    DarkOrange: Color
    """Gets a system-defined color that has an ARGB value of #FFFF8C00."""
    DarkOrchid: Color
    """Gets a system-defined color that has an ARGB value of #FF9932CC."""
    DarkRed: Color
    """Gets a system-defined color that has an ARGB value of #FF8B0000."""
    DarkSalmon: Color
    """Gets a system-defined color that has an ARGB value of #FFE9967A."""
    DarkSeaGreen: Color
    """Gets a system-defined color that has an ARGB value of #FF8FBC8F."""
    DarkSlateBlue: Color
    """Gets a system-defined color that has an ARGB value of #FF483D8B."""
    DarkSlateGray: Color
    """Gets a system-defined color that has an ARGB value of #FF2F4F4F."""
    DarkTurquoise: Color
    """Gets a system-defined color that has an ARGB value of #FF00CED1."""
    DarkViolet: Color
    """Gets a system-defined color that has an ARGB value of #FF9400D3."""
    DeepPink: Color
    """Gets a system-defined color that has an ARGB value of #FFFF1493."""
    DeepSkyBlue: Color
    """Gets a system-defined color that has an ARGB value of #FF00BFFF."""
    DimGray: Color
    """Gets a system-defined color that has an ARGB value of #FF696969."""
    DodgerBlue: Color
    """Gets a system-defined color that has an ARGB value of #FF1E90FF."""
    Firebrick: Color
    """Gets a system-defined color that has an ARGB value of #FFB22222."""
    FloralWhite: Color
    """Gets a system-defined color that has an ARGB value of #FFFFFAF0."""
    ForestGreen: Color
    """Gets a system-defined color that has an ARGB value of #FF228B22."""
    Fuchsia: Color
    """Gets a system-defined color that has an ARGB value of #FFFF00FF."""
    G: int
    """Gets the green component value of the color."""
    Gainsboro: Color
    """Gets a system-defined color that has an ARGB value of #FFDCDCDC."""
    GhostWhite: Color
    """Gets a system-defined color that has an ARGB value of #FFF8F8FF."""
    Gold: Color
    """Gets a system-defined color that has an ARGB value of #FFFFD700."""
    Goldenrod: Color
    """Gets a system-defined color that has an ARGB value of #FFDAA520."""
    Gray: Color
    """Gets a system-defined color that has an ARGB value of #FF808080."""
    Green: Color
    """Gets a system-defined color that has an ARGB value of #FF008000."""
    GreenYellow: Color
    """Gets a system-defined color that has an ARGB value of #FFADFF2F."""
    Honeydew: Color
    """Gets a system-defined color that has an ARGB value of #FFF0FFF0."""
    HotPink: Color
    """Gets a system-defined color that has an ARGB value of #FFFF69B4."""
    IndianRed: Color
    """Gets a system-defined color that has an ARGB value of #FFCD5C5C."""
    Indigo: Color
    """Gets a system-defined color that has an ARGB value of #FF4B0082."""
    Ivory: Color
    """Gets a system-defined color that has an ARGB value of #FFFFFFF0."""
    Khaki: Color
    """Gets a system-defined color that has an ARGB value of #FFF0E68C."""
    Lavender: Color
    """Gets a system-defined color that has an ARGB value of #FFE6E6FA."""
    LavenderBlush: Color
    """Gets a system-defined color that has an ARGB value of #FFFFF0F5."""
    LawnGreen: Color
    """Gets a system-defined color that has an ARGB value of #FF7CFC00."""
    LemonChiffon: Color
    """Gets a system-defined color that has an ARGB value of #FFFFFACD."""
    LightBlue: Color
    """Gets a system-defined color that has an ARGB value of #FFADD8E6."""
    LightCoral: Color
    """Gets a system-defined color that has an ARGB value of #FFF08080."""
    LightCyan: Color
    """Gets a system-defined color that has an ARGB value of #FFE0FFFF."""
    LightGoldenrodYellow: Color
    """Gets a system-defined color that has an ARGB value of #FFFAFAD2."""
    LightGray: Color
    """Gets a system-defined color that has an ARGB value of #FFD3D3D3."""
    LightGreen: Color
    """Gets a system-defined color that has an ARGB value of #FF90EE90."""
    LightPink: Color
    """Gets a system-defined color that has an ARGB value of #FFFFB6C1."""
    LightSalmon: Color
    """Gets a system-defined color that has an ARGB value of #FFFFA07A."""
    LightSeaGreen: Color
    """Gets a system-defined color that has an ARGB value of #FF20B2AA."""
    LightSkyBlue: Color
    """Gets a system-defined color that has an ARGB value of #FF87CEFA."""
    LightSlateGray: Color
    """Gets a system-defined color that has an ARGB value of #FF778899."""
    LightSteelBlue: Color
    """Gets a system-defined color that has an ARGB value of #FFB0C4DE."""
    LightYellow: Color
    """Gets a system-defined color that has an ARGB value of #FFFFFFE0."""
    Lime: Color
    """Gets a system-defined color that has an ARGB value of #FF00FF00."""
    LimeGreen: Color
    """Gets a system-defined color that has an ARGB value of #FF32CD32."""
    Linen: Color
    """Gets a system-defined color that has an ARGB value of #FFFAF0E6."""
    Magenta: Color
    """Gets a system-defined color that has an ARGB value of #FFFF00FF."""
    Maroon: Color
    """Gets a system-defined color that has an ARGB value of #FF800000."""
    MediumAquamarine: Color
    """Gets a system-defined color that has an ARGB value of #FF66CDAA."""
    MediumBlue: Color
    """Gets a system-defined color that has an ARGB value of #FF0000CD."""
    MediumOrchid: Color
    """Gets a system-defined color that has an ARGB value of #FFBA55D3."""
    MediumPurple: Color
    """Gets a system-defined color that has an ARGB value of #FF9370DB."""
    MediumSeaGreen: Color
    """Gets a system-defined color that has an ARGB value of #FF3CB371."""
    MediumSlateBlue: Color
    """Gets a system-defined color that has an ARGB value of #FF7B68EE."""
    MediumSpringGreen: Color
    """Gets a system-defined color that has an ARGB value of #FF00FA9A."""
    MediumTurquoise: Color
    """Gets a system-defined color that has an ARGB value of #FF48D1CC."""
    MediumVioletRed: Color
    """Gets a system-defined color that has an ARGB value of #FFC71585"""
    MidnightBlue: Color
    """Gets a system-defined color that has an ARGB value of #FF191970."""
    MintCream: Color
    """Gets a system-defined color that has an ARGB value of #FFF5FFFA."""
    MistyRose: Color
    """Gets a system-defined color that has an ARGB value of #FFFFE4E1."""
    Moccasin: Color
    """Gets a system-defined color that has an ARGB value of #FFFFE4B5."""
    NavajoWhite: Color
    """Gets a system-defined color that has an ARGB value of #FFFFDEAD."""
    Navy: Color
    """Gets a system-defined color that has an ARGB value of #FF000080."""
    OldLace: Color
    """Gets a system-defined color that has an ARGB value of #FFFDF5E6."""
    Olive: Color
    """Gets a system-defined color that has an ARGB value of #FF808000."""
    OliveDrab: Color
    """Gets a system-defined color that has an ARGB value of #FF6B8E23."""
    Orange: Color
    """Gets a system-defined color that has an ARGB value of #FFFFA500."""
    OrangeRed: Color
    """Gets a system-defined color that has an ARGB value of #FFFF4500."""
    Orchid: Color
    """Gets a system-defined color that has an ARGB value of #FFDA70D6."""
    PaleGoldenrod: Color
    """Gets a system-defined color that has an ARGB value of #FFEEE8AA."""
    PaleGreen: Color
    """Gets a system-defined color that has an ARGB value of #FF98FB98."""
    PaleTurquoise: Color
    """Gets a system-defined color that has an ARGB value of #FFAFEEEE."""
    PaleVioletRed: Color
    """Gets a system-defined color that has an ARGB value of #FFDB7093."""
    PapayaWhip: Color
    """Gets a system-defined color that has an ARGB value of #FFFFEFD5."""
    PeachPuff: Color
    """Gets a system-defined color that has an ARGB value of #FFFFDAB9."""
    Peru: Color
    """Gets a system-defined color that has an ARGB value of #FFCD853F."""
    Pink: Color
    """Gets a system-defined color that has an ARGB value of #FFFFC0CB."""
    Plum: Color
    """Gets a system-defined color that has an ARGB value of #FFDDA0DD."""
    PowderBlue: Color
    """Gets a system-defined color that has an ARGB value of #FFB0E0E6."""
    Purple: Color
    """Gets a system-defined color that has an ARGB value of #FF800080."""
    R: int
    """Gets the red component value of the color."""
    Red: Color
    """Gets a system-defined color that has an ARGB value of #FFFF0000."""
    RosyBrown: Color
    """Gets a system-defined color that has an ARGB value of #FFBC8F8F."""
    RoyalBlue: Color
    """Gets a system-defined color that has an ARGB value of #FF4169E1."""
    SaddleBrown: Color
    """Gets a system-defined color that has an ARGB value of #FF8B4513."""
    Salmon: Color
    """Gets a system-defined color that has an ARGB value of #FFFA8072."""
    SandyBrown: Color
    """Gets a system-defined color that has an ARGB value of #FFF4A460."""
    SeaGreen: Color
    """Gets a system-defined color that has an ARGB value of #FF2E8B57."""
    SeaShell: Color
    """Gets a system-defined color that has an ARGB value of #FFFFF5EE."""
    Sienna: Color
    """Gets a system-defined color that has an ARGB value of #FFA0522D."""
    Silver: Color
    """Gets a system-defined color that has an ARGB value of #FFC0C0C0."""
    SkyBlue: Color
    """Gets a system-defined color that has an ARGB value of #FF87CEEB."""
    SlateBlue: Color
    """Gets a system-defined color that has an ARGB value of #FF6A5ACD."""
    SlateGray: Color
    """Gets a system-defined color that has an ARGB value of #FF708090."""
    Snow: Color
    """Gets a system-defined color that has an ARGB value of #FFFFFAFA."""
    SpringGreen: Color
    """Gets a system-defined color that has an ARGB value of #FF00FF7F."""
    SteelBlue: Color
    """Gets a system-defined color that has an ARGB value of #FF4682B4."""
    Tan: Color
    """Gets a system-defined color that has an ARGB value of #FFD2B48C."""
    Teal: Color
    """Gets a system-defined color that has an ARGB value of #FF008080."""
    Thistle: Color
    """Gets a system-defined color that has an ARGB value of #FFD8BFD8."""
    Tomato: Color
    """Gets a system-defined color that has an ARGB value of #FFFF6347."""
    Transparent: Color
    """Gets a system-defined color that has an ARGB value of #00FFFFFF."""
    Turquoise: Color
    """Gets a system-defined color that has an ARGB value of #FF40E0D0."""
    Violet: Color
    """Gets a system-defined color that has an ARGB value of #FFEE82EE."""
    Wheat: Color
    """Gets a system-defined color that has an ARGB value of #FFF5DEB3."""
    White: Color
    """Gets a system-defined color that has an ARGB value of #FFFFFFFF."""
    WhiteSmoke: Color
    """Gets a system-defined color that has an ARGB value of #FFF5F5F5."""
    Yellow: Color
    """Gets a system-defined color that has an ARGB value of #FFFFFF00."""
    YellowGreen: Color
    """Gets a system-defined color that has an ARGB value of #FF9ACD32."""
    Empty: Color
    """Represents empty color."""

class ColorPicker(ControlBase):
    """Represents the ColorPicker control."""
    def __init__(self) -> None: ...
    IsStretched: bool
    """Gets or sets if color picker is stretched or not."""
    SelectedColor: Color
    """Gets or sets selected color."""
    SelectedColorChanged: Event[Callable[[ColorPickerSelectedColorChangedEventArgs], None]]
    """Occurs when selected color is changed."""

class ColorPickerSelectedColorChangedEventArgs:
    """Provides data for the ColorPicker SelectedColorChanged event."""
    ColorPicker: ColorPicker
    """Gets the color picker control."""
    NewSelectedColor: Color
    """Gets the new selected color."""
    PreviousSelectedColor: Color
    """Gets the previous selected color."""

class ColorTheme:
    """Represents the color theme."""
    Dark: ColorTheme
    Light: ColorTheme

class ColorThemeChangeEventArgs:
    """Provides data for the color theme change event."""
    ColorTheme: ColorTheme
    """Gets the color theme."""

class ComboBox(Control):
    """A control that shows drop down list of items and allows user to select a single item from the list"""
    def __init__(self) -> None: ...
    def AddItem(self, item: str) -> None:
        """Adds a new item to the ComboBox"""
        ...
    def RemoveItem(self, item: str) -> None:
        """Removes an existing item from the ComboBox"""
        ...
    SelectedIndex: int
    """Set / Get the ComboBox selected item index"""
    SelectedItem: str
    """Set / Get the ComboBox selected item"""
    SelectedItemChanged: Event[Callable[[ComboBoxSelectedItemChangedEventArgs], None]]
    """This event will trigger if the ComboBox selected item changed"""

class ComboBoxSelectedItemChangedEventArgs:
    """Provides data for ComboBox SelectedItemChanged event handlers"""
    ComboBox: ComboBox
    """The ComboBox that it is selected item changed"""
    SelectedItem: str
    """The new selected item of ComboBox"""

class Command:
    """Represents a plugin command."""
    Id: Guid
    """Gets command unique Id."""
    IsEnabled: bool
    """Gets / sets if command is enabled or not."""
    ToolTip: str
    """Gets / sets command tooltips."""
    Type: CommandType
    """Gets command type."""

class CommandArgs:
    """Represents a plugin command callback arguments."""
    Command: Command
    """Gets the command associated with these arguments."""
    Context: object
    """Gets the context in which the command is executed."""

class CommandResult:
    """Represents the result of a command execution."""
    def __init__(self, child: ControlBase) -> None: ...
    Child: ControlBase
    """Gets the child control associated with the command result."""

class CommandType:
    """Represents the predefined types of plugin commands."""
    ChartContainerToolbar: CommandType

class Commands:
    """Represents the collection of plugin commands."""
    @overload
    def Add(self, type: CommandType, callback: Callable[[CommandArgs], None]) -> Command:
        """Adds a new command with a callback."""
        ...
    @overload
    def Add(self, type: CommandType, callback: Callable[[CommandArgs], None], icon: SvgIcon) -> Command:
        """Adds a new command with a callback."""
        ...
    @overload
    def Add(self, type: CommandType, callback: Callable[[CommandArgs], CommandResult]) -> Command:
        """Adds a new command with a callback."""
        ...
    @overload
    def Add(self, type: CommandType, callback: Callable[[CommandArgs], CommandResult], icon: SvgIcon) -> Command:
        """Adds a new command with a callback and icon."""
        ...
    def GetById(self, id: Guid) -> Command:
        """Returns a command by Id."""
        ...
    def GetByType(self, type: CommandType) -> list[Command]:
        """Returns all commands based on type."""
        ...
    def Remove(self, id: Guid) -> bool:
        """Removes a command by Id."""
        ...
    Count: int
    """Returns number of all commands."""

class CommodityChannelIndex(StandardIndicator):
    """The Commodity Channel Index interface."""
    Result: IndicatorDataSeries
    """Commodity Channel Index Result Series."""

class CompilationOperation:
    """Provides access to the properties describing an asynchronous algo compilation operation."""
    IsExecuting: bool
    """True if compilation operation is being executed, false if it completed."""
    Result: CompilationResult
    """The result of compilation operation."""

class CompilationOptions:
    """Compilation options container."""
    def __init__(self) -> None: ...
    IncludeSourceCode: bool
    """Gets / Inits inclusion of source code in output algo file (Default is False)."""
    OutputAlgoFilePath: str
    """Gets / Inits output algo file path, if not provided default platform algo path will be used."""

class CompilationResult:
    """The result of an algo compilation."""
    Errors: IReadonlyList[str]
    """Gets compilation errors if Succeeded was False, otherwise null."""
    Succeeded: bool
    """Gets the result of compilation, True if succeeded otherwise False."""

class Compiler:
    """Provides access to compiler for algos."""
    @overload
    def Compile(self, csprojFilePath: str) -> CompilationResult:
        """Compiles an algo."""
        ...
    @overload
    def Compile(self, csprojFilePath: str, options: CompilationOptions) -> CompilationResult:
        """Compiles an algo."""
        ...
    @overload
    def CompileAsync(self, csprojFilePath: str, callback: Callable[[CompilationResult], None]) -> CompilationOperation:
        """Compiles an algo asynchronously and calls the passed callback when compilation finishes."""
        ...
    @overload
    def CompileAsync(self, csprojFilePath: str, callback: Callable[[CompilationResult], None], options: CompilationOptions) -> CompilationOperation:
        """Compiles an algo asynchronously and calls the passed callback when compilation finishes."""
        ...

class Control(ControlBase):
    """Represents the Chart Control class."""
    BackgroundColor: Color
    """Gets or sets the color of the chart control background."""
    FontFamily: str
    """Gets or sets the font family."""
    FontSize: float
    """Gets or sets the font size."""
    FontStyle: FontStyle
    """Gets or sets the font style."""
    FontWeight: FontWeight
    """Gets or sets the font weight."""
    ForegroundColor: Color
    """Gets or sets the color of the chart control foreground. Check the Color class for the ARGB (alpha, red, green, blue) color values, or use the strings Color.Red, Color.FromName("Red"), Color.FromArgb(255, 0, 0), Color.FromHex("#ff0000"), "Red", "#ff0000"."""
    HorizontalContentAlignment: HorizontalAlignment
    """Gets or sets the horizontal content alignment."""
    Padding: Thickness
    """Gets or sets the chart control padding. Property value can be set using Thickness, number, or a string new Thickness(5), new Thickness(1, 2, 3, 4), 5, "5", "1 2 3 4"."""
    VerticalContentAlignment: VerticalAlignment
    """Gets or sets the vertical content alignment."""

class ControlBase:
    """Represents the base of chart controls."""
    def ResetProperty(self, property: ControlProperty) -> None:
        """Sets the property to the default value and removes its privelege over the style."""
        ...
    Bottom: float
    """Gets or sets the position of the chart control to the bottom of the chart area. Works only when the control is inside the Canvas panel."""
    Dock: Dock
    """Specifies the dock position of the chart control instance. Works only inside the DockPanel."""
    Height: float
    """Gets or sets the hight of the chart control."""
    HorizontalAlignment: HorizontalAlignment
    """Gets or sets the horizontal alignment of the chart control instance."""
    IsEnabled: bool
    """Gets or sets the value indicating whether this instance of the chart control is enabled."""
    IsHitTestVisible: bool
    """Gets or sets a value that declares if the chart control instance is visible for the mouse hit testing. If set to false, then the control will not handle any mouse events."""
    IsVisible: bool
    """Gets or sets the value indicating whether this instance of the chart control instance is visible."""
    Left: float
    """Gets or sets the position of the chart control to the left side of the chart area. Works only when the control is inside the Canvas panel."""
    Margin: Thickness
    """Gets or sets the level of thickness of the margin of the chart control instance. Property value can be set using Thickness, number, or a string new Thickness(5), new Thickness(1, 2, 3, 4), 5, "5", "1 2 3 4"."""
    MaxHeight: float
    """Gets or sets the maximum height of the chart control."""
    MaxWidth: float
    """Gets or sets the maximum width of the chart control."""
    MinHeight: float
    """Gets or sets the minimum height of the chart control."""
    MinWidth: float
    """Gets or sets the minimum width of the chart control."""
    Opacity: float
    """Gets or sets the level of opacity of the chart control instance. Can be set from 0 (transparent) to 1 (opaque). Values higher than 1 will be set to 1, values below 0 will be set to 0."""
    Right: float
    """Gets or sets the position of the chart control to the rignt side of the chart area. Works only when the control is inside the Canvas panel."""
    Style: Style
    """Gets or sets the style of a chart control."""
    Top: float
    """Gets or sets the position of the chart control to the top of the chart area. Works only when the control is inside the Canvas panel."""
    UniqueId: Guid
    """Gets the unique identifier of a chart control."""
    VerticalAlignment: VerticalAlignment
    """Gets or sets the vertical alignment of the chart control instance."""
    Width: float
    """Gets or sets the width of the chart control."""

class ControlProperty:
    """Represents the Control property enumeration used in Style to get or set a style for a specific property."""
    BackgroundColor: ControlProperty
    ForegroundColor: ControlProperty
    Opacity: ControlProperty
    MinWidth: ControlProperty
    MaxWidth: ControlProperty
    MinHeight: ControlProperty
    MaxHeight: ControlProperty
    Width: ControlProperty
    Height: ControlProperty
    Padding: ControlProperty
    BorderThickness: ControlProperty
    CornerRadius: ControlProperty
    HorizontalContentAlignment: ControlProperty
    VerticalContentAlignment: ControlProperty
    TextAlignment: ControlProperty
    Margin: ControlProperty
    FontWeight: ControlProperty
    FontStyle: ControlProperty
    FontFamily: ControlProperty
    FontSize: ControlProperty
    BorderColor: ControlProperty
    CaretColor: ControlProperty

class ControlState:
    """Represents the chart control state."""
    Hover: ControlState
    Pressed: ControlState
    Disabled: ControlState
    Checked: ControlState
    DarkTheme: ControlState
    LightTheme: ControlState

class CornerRadius:
    """Represents the radii of a rectangle's corners."""
    @overload
    def __init__(self, topLeft: float, topRight: float, bottomRight: float, bottomLeft: float) -> None: ...
    @overload
    def __init__(self, uniformRadius: float) -> None: ...
    BottomLeft: float
    """Gets or sets the radius of the bottom-left corner."""
    BottomRight: float
    """Gets or sets the radius of the bottom-right corner."""
    TopLeft: float
    """Gets or sets the radius of the top-left corner."""
    TopRight: float
    """Gets or sets the radius of the top-right corner."""

class CustomBar:
    """Represents a custom OHLC bar."""
    def __init__(self, time: DateTime, open: float, high: float, low: float, close: float, volume: int) -> None: ...
    Close: float
    """Gets close price of bar."""
    High: float
    """Gets high price of bar."""
    Low: float
    """Gets low price of bar."""
    Open: float
    """Gets open price of bar."""
    Time: DateTime
    """Gets open time of bar."""
    Volume: int
    """Gets volume of bar."""

class CustomBars:
    """Represents a mutable collection of OHLC bars that will be used for a custom time frame / symbol."""
    def AppendBar(self, bar: CustomBar) -> None:
        """Appends a new bar to the end of bars collection."""
        ...
    def AppendBars(self, bars: Iterable[CustomBar]) -> None:
        """Appends a collection of bars to the end of bars collection."""
        ...
    def PrependBar(self, bar: CustomBar) -> None:
        """Prepends a new bar to the start of bars collection."""
        ...
    def PrependBars(self, bars: Iterable[CustomBar]) -> None:
        """Prepends a collection of bars to the start of bars collection."""
        ...
    def UpdateLastBar(self, open: float, high: float, low: float, close: float, volume: int) -> None:
        """Updates the last bar."""
        ...
    Bars: Bars
    """Gets readonly bars."""
    IsLoaded: bool
    """Gets IsLoaded status, If true it means custom bars is being used and can't be removed."""
    Symbol: Symbol
    """Gets symbol of custom bars."""
    TimeFrame: TimeFrame
    """Gets timeframe of custom bars."""
    NeedsMore: Event[Callable[[CustomBarsNeedsMoreEventArgs], None]]
    """Occurs when user scrolls back on a custom bars chart."""

class CustomBarsNeedsMoreEventArgs:
    """Provides data for CustomBars NeedsMore event."""
    CustomBars: CustomBars
    """Gets custom bars that needs more bars."""

class CustomControl(ControlBase):
    """Represents the custom control to create reusable controls with customized look and behavior."""
    def AddChild(self, childControl: ControlBase) -> None:
        """Adds a child control."""
        ...

class CustomFrame(Frame):
    """Represents a custom frame."""
    Child: ControlBase
    """Get / set child control of frame."""

class CustomSymbol:
    """Represents a custom symbol."""
    def AddBars(self, timeFrame: TimeFrame) -> CustomBars:
        """Adds bars for a time frame that will be used for this custom symbol."""
        ...
    def GetBars(self, timeFrame: TimeFrame) -> CustomBars:
        """Returns bars of a time frame if exists otherwise null."""
        ...
    def RemoveAllUnloadedBars(self) -> None:
        """Removes all existing unloaded custom bars that aren't being used."""
        ...
    def RemoveBars(self, timeFrame: TimeFrame) -> bool:
        """Removes bars of a time frame which has no user."""
        ...
    def UpdateQuote(self, bid: float | None, ask: float | None) -> None:
        """Updates current symbol quotes."""
        ...
    AdministrativeCharge: float
    """Gets symbol administrative charge. Administrative fee will be charged instead of SWAP if account is marked as SWAP free. Only applicable for SWAP free trading accounts."""
    AdministrativeCharge3DaysRollover: DayOfWeek | None
    """Gets / sets the Day of the week (in UTC) when Administrative Fee charge amount will be tripled. Only applicable for SWAP free trading accounts."""
    Ask: float
    """Gets the current ask price for this symbol."""
    BarsNeeded: Callable[[CustomSymbolBarsNeededArgs], None]
    """Gets / sets BarsNeeded handler, it's triggered when bars are needed for a time frame of current custom symbol."""
    BaseAsset: Asset
    """Gets / sets the symbol base asset."""
    Bid: float
    """Gets the current bid price for this symbol."""
    Commission: float
    """Gets / sets the amount of base commission for the symbol."""
    CommissionType: SymbolCommissionType
    """Gets / sets the symbol base commission calculation type."""
    Description: str
    """Gets / sets symbol description."""
    DynamicLeverage: Sequence[CustomSymbolLeverageTier]
    """Gets / sets the symbol dynamic leverage."""
    FuturesSettings: CustomSymbolFuturesSettings
    """Gets / sets custom future contract settings."""
    GracePeriod: int
    """Gets / sets symbol grace period. This is the number of days free of Administrative fee from the time of opening a position. Only applicable for SWAP free trading accounts."""
    Id: int
    """Gets the custom symbol ID."""
    LotSize: int
    """Gets / sets the lot size."""
    MarketHours: CustomSymbolMarketHours
    """Gets / sets the symbol market hours."""
    MinCommission: float
    """Gets / sets the minimum amount of commission for the symbol. This is the amount of commission that will be paid by trader for any trade. Check MinCommissionType for interpretation of MinCommission value."""
    MinCommissionAsset: Asset
    """Gets / sets the symbol minimum commission asset. If MinCommissionType is set to Asset then you can use this property to get that asset. The MinCommission value will be converted from MinCommissionAsset to account deposit asset at the moment of trade."""
    MinCommissionType: SymbolMinCommissionType
    """Gets / sets the symbol minimum commission type. Use this property to interpret MinCommission value."""
    MinDistanceType: SymbolMinDistanceType
    """Gets / sets the symbol minimum distances type."""
    MinStopLossDistance: float
    """Gets / sets symbol minimum stop loss distance. Use MinDistanceType for interpretation."""
    MinTakeProfitDistance: float
    """Gets / sets symbol minimum take profit distance. Use MinDistanceType for interpretation."""
    Name: str
    """Gets custom symbol unique name."""
    PipDigits: int
    """Gets / sets the symbol pip digits."""
    PnLConversionFeeRate: float
    """Gets / sets the symbol profit and loss conversion fee rate."""
    QuoteAsset: Asset
    """Gets / sets the symbol quote asset."""
    Sentiment: CustomSymbolSentiment
    """Gets custom symbol sentiment."""
    Swap3DaysRollover: DayOfWeek | None
    """Gets / sets the Day of the week when Symbol SWAP charge amount will be tripled."""
    SwapCalculationType: SymbolSwapCalculationType
    """Gets / sets the symbol SWAP calculation type."""
    SwapLong: float
    """Gets / sets the SWAP charge for long positions of the symbol."""
    SwapPeriod: int
    """Gets / sets symbol swap period. This is the number of days free of Administrative fee from the time of opening a position."""
    SwapShort: float
    """Gets / sets the SWAP charge for short positions of the symbol."""
    SwapTimeInMinutes: int
    """Gets / sets the SWAP time in minutes."""
    Symbol: Symbol
    """Gets regular Symbol."""
    TickDigits: int
    """Gets / sets the symbol tick digits."""
    VolumeInUnitsMax: float
    """Gets / sets the maximum units value."""
    VolumeInUnitsMin: float
    """Gets / sets the minimum units value."""
    VolumeInUnitsStep: float
    """Gets / sets the step volume in units."""
    WeekendSwaps: bool
    """Gets / sets whether swap is charged on weekends or not."""
    BarsUnloaded: Event[Callable[[CustomSymbolBarsUnloadedEventArgs], None]]
    """Occurs when a custom bars is unloaded and not being used anymore."""
    NewChart: Event[Callable[[CustomSymbolNewChartEventArgs], None]]
    """Occurs when user opens a new chart of current custom symbol."""

class CustomSymbolBarsNeededArgs:
    """Provides data for custom symbol BarsNeeded handler."""
    CustomBars: CustomBars
    """Gets custom bars."""
    CustomSymbol: CustomSymbol
    """Gets custom symbol."""

class CustomSymbolBarsUnloadedEventArgs:
    """Provides data for custom symbol BarsUnloaded event."""
    CustomBars: CustomBars
    """Gets custom bars that was unloaded."""
    CustomSymbol: CustomSymbol
    """Gets custom symbol."""

class CustomSymbolFuturesSettings:
    """Represents a custom symbol futures settings."""
    def __init__(self, lastTradeTime: DateTime, expirationTime: DateTime, maintenanceMargin: float | None) -> None: ...
    ExpirationTime: DateTime
    """Gets the expiration time of future contract."""
    LastTradeTime: DateTime
    """Gets the last trade time of future contract."""
    MaintenanceMargin: float | None
    """The amount of quote asset that will be taken as a margin per one traded lot."""

class CustomSymbolLeverageTier(LeverageTier):
    """Custom symbol tier of dynamic leverage."""
    def __init__(self, volume: float, leverage: float) -> None: ...
    Leverage: float
    """Leverage of dynamic leverage tier."""
    Volume: float
    """Volume of dynamic leverage tier."""

class CustomSymbolMarketHours:
    """Access to custom symbol's trading sessions schedule."""
    Holidays: Sequence[CustomSymbolTradingHoliday]
    """Collection of all symbol's trading holidays"""
    Sessions: Sequence[CustomSymbolTradingSession]
    """Collection of all symbol's trading sessions"""

class CustomSymbolNewChartEventArgs:
    """Provides data for custom symbol NewChart event."""
    Chart: Chart
    """Chart that is newly opened or switched to custom symbol."""
    CustomBars: CustomBars
    """Gets custom bars for the newly opened custom symbol chart."""
    CustomSymbol: CustomSymbol
    """Gets custom symbol."""

class CustomSymbolSentiment:
    """Represents a custom symbol sentiment."""
    BuyPercentage: float
    """Gets / sets buy percentage."""
    SellPercentage: float
    """Gets / sets sell percentage."""

class CustomSymbolTradingHoliday(TradingHoliday):
    """Represents a custom symbol trading holiday."""
    def __init__(self, name: str, startTime: DateTime, endTime: DateTime, isRecurring: bool) -> None: ...
    EndTime: DateTime
    """Gets the end date and time of the trading holiday."""
    IsRecurring: bool
    """Gets a value indicating whether the trading holiday is recurring."""
    Name: str
    """Gets the name of the trading holiday."""
    StartTime: DateTime
    """Gets the start date and time of the trading holiday."""

class CustomSymbolTradingSession(TradingSession):
    """Custom symbol trading session schedule."""
    def __init__(self, startDay: DayOfWeek, endDay: DayOfWeek, startTime: TimeSpan, endTime: TimeSpan) -> None: ...
    EndDay: DayOfWeek
    """Day of week when trading session ends"""
    EndTime: TimeSpan
    """Time when trading session ends"""
    StartDay: DayOfWeek
    """Day of week when trading session starts"""
    StartTime: TimeSpan
    """Time when trading session starts"""

class CustomSymbols:
    """Represents collection of custom symbols."""
    @overload
    def Add(self, name: str, baseAsset: Asset, quoteAsset: Asset) -> CustomSymbol:
        """Adds a new custom symbol."""
        ...
    @overload
    def Add(self, name: str, baseSymbol: Symbol) -> CustomSymbol:
        """Adds a new custom symbol based on existing symbol."""
        ...
    def Get(self, name: str) -> CustomSymbol:
        """Returns a custom symbol by it's name."""
        ...
    def Remove(self, customSymbol: CustomSymbol) -> bool:
        """Removes a custom symbol."""
        ...

class CustomTimeFrame:
    """Represents a custom time frame."""
    def AddBars(self, symbol: Symbol) -> CustomBars:
        """Adds bars for a symbol that will be used for this custom time frame when needed."""
        ...
    def GetBars(self, symbol: Symbol) -> CustomBars:
        """Returns bars of a symbol if exists otherwise null."""
        ...
    def RemoveAllUnloadedBars(self) -> None:
        """Removes all existing unloaded custom bars that aren't being used."""
        ...
    def RemoveBars(self, symbol: Symbol) -> bool:
        """Removes bars of a symbol which is not being used."""
        ...
    BarsNeeded: Callable[[CustomTimeFrameBarsNeededArgs], None]
    """Gets / sets BarsNeeded handler, it's triggered when bars are needed for a symbol of current time frame."""
    Description: str
    """Gets / sets custom time frame description."""
    Name: str
    """Gets Custom time frame unique name."""
    TimeFrame: TimeFrame
    """Gets regular time frame."""
    BarsUnloaded: Event[Callable[[CustomTimeFrameBarsUnloadedEventArgs], None]]
    """Occurs when a custom bars is unloaded and not being used anymore."""
    NewChart: Event[Callable[[CustomTimeFrameNewChartEventArgs], None]]
    """Occurs when user opens a new chart of current custom time frame."""

class CustomTimeFrameBarsNeededArgs:
    """Provides data for custom time frame BarsNeeded handler."""
    CustomBars: CustomBars
    """Gets custom bars."""
    CustomTimeFrame: CustomTimeFrame
    """Gets custom time frame."""

class CustomTimeFrameBarsUnloadedEventArgs:
    """Provides data for custom time frame BarsUnloaded event."""
    CustomBars: CustomBars
    """Gets custom bars that was unloaded."""
    CustomTimeFrame: CustomTimeFrame
    """Gets custom time frame."""

class CustomTimeFrameNewChartEventArgs:
    """Provides data for custom time frame NewChart event."""
    Chart: Chart
    """Chart that is newly opened or switched to custom time frame."""
    CustomBars: CustomBars
    """Gets custom bars for the newly opened custom time frame chart."""
    CustomTimeFrame: CustomTimeFrame
    """Gets custom time frame."""

class CustomTimeFrames:
    """Represents collection of custom time frames."""
    def Add(self, name: str) -> CustomTimeFrame:
        """Adds a new custom time frame."""
        ...
    def Get(self, name: str) -> CustomTimeFrame:
        """Returns a custom time frame by it's name."""
        ...
    def Remove(self, customTimeFrame: CustomTimeFrame) -> bool:
        """Removes a custom time frame."""
        ...

class CyberCycle(StandardIndicator):
    """The Cyber Cycles Oscillator is an indicator designed by John Ehlers, it is used for isolating the cycle component of the market from its trend counterpart."""
    Cycle: IndicatorDataSeries
    """The Cyber Cycles Oscillator plot."""
    Trigger: IndicatorDataSeries
    """The CCO plot shifted one bar back; crossovers of the two plots suggest Buy/Sell signals."""

class DataSeries:
    """Represents a read only list of values, typically used to represent market price series. The values are accessed with an array-like [] operator."""
    def Last(self, index: int) -> float:
        """Access a value in the data series certain bars ago"""
        ...
    Count: int
    """Gets the total number of elements contained in the DataSeries."""
    Item: float
    """Gets the value in the data series at the specified position."""
    LastValue: float
    """Gets the last value of this DataSeries."""

class DateTimePicker(ControlBase):
    """Represents the date time picker control."""
    def __init__(self) -> None: ...
    MaxValue: DateTime
    """Gets or sets maximum value."""
    MinValue: DateTime
    """Gets or sets minimum value."""
    ShowTimeInput: bool
    """Gets or sets whether show time picker input or not."""
    Value: DateTime
    """Gets or sets value."""
    ValueChanged: Event[Callable[[DateTimePickerValueChangedEventArgs], None]]
    """Occurs when value is changed."""

class DateTimePickerValueChangedEventArgs:
    """Provides data for the DateTimePicker ValueChanged event."""
    DateTimePicker: DateTimePicker
    """Gets the date time picker control."""
    NewValue: DateTime
    """Gets the new selected value."""
    OldValue: DateTime
    """Gets the old selected value."""

class DeMarker(StandardIndicator):
    """The DeMarker is an oscillator that compares the most recent maximum and minimum prices to the previous period's equivalent price."""
    Result: IndicatorDataSeries
    """Gets the resulting time series of the DeMarker calculation."""

class Deal:
    """Represents a deal."""
    Channel: str
    """Gets the channel."""
    ClosedBy: IReadonlyList[Deal]
    """If deal was an opening deal then this property will return the deals that closed current deal."""
    Closing: IReadonlyList[Deal]
    """If deal was a closing deal then this property will return the deals that were closed by current deal."""
    Comment: str
    """Gets the comment."""
    ExecutionPrice: float | None
    """Returns deal execution price if deal is filled otherwise null."""
    ExecutionTime: DateTime
    """Returns deal execution time."""
    Id: int
    """Unique deal Id."""
    Label: str
    """Gets the label."""
    OrderId: int
    """Order Id."""
    PositionId: int
    """Position Id."""
    PositionImpact: DealPositionImpact | None
    """Returns deal position impact if deal is filled otherwise null."""
    Status: DealStatus
    """Returns status of deal."""
    SymbolName: str
    """Gets the symbol name."""
    TradeType: TradeType
    """Gets the TradeType."""
    VolumeInUnits: float
    """Deal filled volume amount in units."""

class DealPositionImpact:
    """Represents the impact of a deal on position."""
    Opening: DealPositionImpact
    Closing: DealPositionImpact

class DealStatus:
    """Represents the different status of a deal."""
    Filled: DealStatus
    PartiallyFilled: DealStatus
    Rejected: DealStatus
    Error: DealStatus
    Missed: DealStatus
    InternallyRejected: DealStatus

class DefaultStyles:
    """Represent the list of default styles for the built-in controls."""
    ButtonStyle: Style
    """Gets the Button default style."""
    CheckBoxStyle: Style
    """Gets the Checkbox default style."""
    ComboBoxStyle: Style
    """Gets the ComboBox default style."""
    MultiSelectStyle: Style
    """Gets the MultiSelect default style."""
    RadioButtonStyle: Style
    """Gets the Radio Button default stile."""
    ScrollViewerStyle: Style
    """Gets the Scroll Viewer default style."""
    TabControlStyle: Style
    """Gets the Tab Control default style."""
    TabItemStyle: Style
    """Gets the Tab Item default style."""
    TextBlockStyle: Style
    """Gets the Text Block default style."""
    TextBoxStyle: Style
    """Gets the Text Box default style."""
    ToggleButtonStyle: Style
    """Gets the Toggle Button default style."""

class DetachedWindow:
    """Used to represent the properties of a detached window."""
    Height: float
    """Get / Set height of the Window"""
    Left: float
    """Get / Set window left margin (X)"""
    MaxHeight: float
    """Get / Set the window maximum height"""
    MaxWidth: float
    """Get / Set the window maximum width"""
    MinHeight: float
    """Get / Set the window minimum height"""
    MinWidth: float
    """Get / Set the window minimum width"""
    ResizeMode: ResizeMode
    """Get / Set the window resize mode"""
    Top: float
    """Get / Set window top margin (Y)"""
    Width: float
    """Get / Set width of the window"""
    WindowStartupLocation: WindowStartupLocation
    """Get / Set the window startup location"""

class DetrendedPriceOscillator(StandardIndicator):
    """The Detrended Price Oscillator Indicator interface."""
    Result: IndicatorDataSeries
    """The resulting time series of Detrended Price Oscillator calculation."""

class DirectionalMovementSystem(StandardIndicator):
    """The Welles Wilder's Directional Movement Indicator calculation."""
    ADX: IndicatorDataSeries
    """The Average Directional Movement Index (ADX) indicates whether the market is trending or ranging."""
    DIMinus: IndicatorDataSeries
    """The Negative Direction Indicator (-DI) indicates downward trend movement."""
    DIPlus: IndicatorDataSeries
    """The Positive Direction Indicator (+DI) indicates upward trend movement."""

class Dock:
    """Specifies where a chart control will be docked inside the DockPanel."""
    Left: Dock
    Top: Dock
    Right: Dock
    Bottom: Dock

class DockPanel(Panel):
    """Defines the area where you can arrange child elemens either horizontally or vertically, relative to each other."""
    def __init__(self) -> None: ...
    LastChildFill: bool
    """Indicates whether the last child element within a DockPanel stretches to fill the remaining available space."""

class DonchianChannel(StandardIndicator):
    """The Donchian channel is a volatility indicator forming a channel between the highest high and the lowest low of the chosen period."""
    Bottom: IndicatorDataSeries
    """Gets or sets the lowest low of the period."""
    Middle: IndicatorDataSeries
    """Gets or sets the middle of the highest high and the lowest low of the period."""
    Top: IndicatorDataSeries
    """Gets or sets the highest high of the period."""

class DoubleExponentialMovingAverage(MovingAverage, StandardIndicator):
    """The Double Exponential Moving Average (DEMA) is a combination of smoothed exponential moving averages (EMA) and a basic EMA"""
    ...

class DrawingColorChangedEventArgs:
    """Provides data for the drawing color changed event."""
    DrawingColor: Color
    """Gets the drawing color."""

class DropZone(ControlBase):
    """Represents the DropZone control that can be used as a file(s) input."""
    def __init__(self) -> None: ...
    Child: ControlBase
    """Gets or sets the drop zone child object."""
    FilterExtensions: list[str]
    """Gets or sets the file extensions filter."""
    IsDirectoryDropAllowed: bool
    """Gets or sets whether user can drop directories or not."""
    Dropped: Event[Callable[[DroppedEventArgs], None]]
    """Occurs when files are dropped."""

class DroppedEventArgs:
    """Provides data for the Dropzone Dropped event."""
    DropZone: DropZone
    """Gets the Dropzone control."""
    FilePaths: IReadonlyList[str]
    """Gets the dropped file paths."""

class EaseOfMovement(StandardIndicator):
    """Ease of Movement is a volume based oscillator that measures the "ease" of price movement."""
    Result: IndicatorDataSeries
    """The time series of the Ease Of Movement Indicator."""

class ElderForceIndex(StandardIndicator):
    """The calculation of the Elder's Force Index."""
    Result: IndicatorDataSeries
    """Alexander Elder's force index is a technical indicator that measures the amount of power used to move the price of an asset."""

class ElderRayIndex(StandardIndicator):
    """The calculation of the Elder Ray Index."""
    BearsPower: IndicatorDataSeries
    """The histogram (bar graph). It shows the maximum bearish strength during the time period."""
    BullsPower: IndicatorDataSeries
    """The histogram (bar graph). It shows the maximum bullish strength during the time period."""

class Ellipse(Shape):
    """Represents the ellipse shape."""
    def __init__(self) -> None: ...

class EncodingType:
    """Represents different character encoding types."""
    Ascii: EncodingType
    BigEndianUnicode: EncodingType
    Latin1: EncodingType
    Unicode: EncodingType
    Utf8: EncodingType
    Utf32: EncodingType

class Envelopes(StandardIndicator):
    """The Envelopes indicator is used to visualize potential trading ranges and overbought/oversold conditions."""
    Lower: IndicatorDataSeries
    """The lower line of the Envelopes."""
    Main: IndicatorDataSeries
    """The main line of the Envelopes."""
    Upper: IndicatorDataSeries
    """The upper line of the Envelopes."""

class EnvironmentType:
    """Represents the different environments where an algo can run."""
    Desktop: EnvironmentType
    Cloud: EnvironmentType
    CLI: EnvironmentType

class Error:
    """Encapsulates an error code."""
    Code: ErrorCode
    """The encapsulated error code."""
    TradeResult: TradeResult
    """The result of the trade that produced the error"""

class ErrorCode:
    """Enumeration of standard error codes."""
    TechnicalError: ErrorCode
    BadVolume: ErrorCode
    NoMoney: ErrorCode
    MarketClosed: ErrorCode
    Disconnected: ErrorCode
    EntityNotFound: ErrorCode
    Timeout: ErrorCode
    UnknownSymbol: ErrorCode
    InvalidStopLossTakeProfit: ErrorCode
    InvalidRequest: ErrorCode
    NoTradingPermission: ErrorCode

class ExecuteScriptResult:
    """The result of JavaScript execution on a WebView control."""
    def __init__(self, isSuccessful: bool, json: str) -> None: ...
    IsSuccessful: bool
    """True if JavaScript execution was successful otherwise false"""
    Json: str
    """Returned JSON result of execution."""

class ExponentialMovingAverage(MovingAverage, StandardIndicator):
    """The exponential moving average of the price data source over a period of time."""
    ...

class FavoriteTimeFrames:
    """Provides access to favorite TimeFrames API for plugins."""
    def Add(self, timeFrame: TimeFrame) -> None:
        """Adds a time frame to favorite TimeFrames."""
        ...
    def Contains(self, timeFrame: TimeFrame) -> bool:
        """Returns True if passed TimeFrame is in favorite TimeFrames otherwise False."""
        ...
    def Remove(self, timeFrame: TimeFrame) -> bool:
        """Removes a time frame from favorite TimeFrames."""
        ...
    Added: Event[Callable[[FavoriteTimeFramesAddedEventArgs], None]]
    """Occurs when new TimeFrames are added to favorite TimeFrames."""
    Removed: Event[Callable[[FavoriteTimeFramesRemovedEventArgs], None]]
    """Occurs when TimeFrames are removed from favorite TimeFrames."""

class FavoriteTimeFramesAddedEventArgs:
    """Provides data for the Favorite TimeFrames Added event."""
    TimeFrames: list[TimeFrame]
    """Gets the added time frames."""

class FavoriteTimeFramesRemovedEventArgs:
    """Provides data for the Favorite TimeFrames Removed event."""
    TimeFrames: list[TimeFrame]
    """Gets the removed time frames."""

class FibonacciLevel:
    """Represents the Fibonacci Level."""
    IsVisible: bool
    """Defines if the level is visible."""
    Percent: float
    """Gets or sets the level percent."""
    Price: float | None
    """Gets or sets the level price."""
    Time: DateTime | None
    """Gets or sets the level time."""

class File:
    """Represents a file."""
    @overload
    def AppendAllLines(self, contents: list[str]) -> None:
        """Appends lines to file."""
        ...
    @overload
    def AppendAllLines(self, contents: list[str], encodingType: EncodingType) -> None:
        """Appends lines to file that has a specified encoding."""
        ...
    @overload
    def AppendAllText(self, contents: str) -> None:
        """Append text to file."""
        ...
    @overload
    def AppendAllText(self, contents: str, encodingType: EncodingType) -> None:
        """Appends text to file that has a specified encoding."""
        ...
    def Exists(self) -> bool:
        """Returns True if File exists otherwise False."""
        ...
    def ReadAllBytes(self) -> list[int]:
        """Reads the contents of the file into a byte array."""
        ...
    @overload
    def ReadAllText(self) -> str:
        """Reads all the text in the file."""
        ...
    @overload
    def ReadAllText(self, encodingType: EncodingType) -> str:
        """Reads all the text in the file that has a specified encoding."""
        ...
    def ReadBytes(self, offset: int, count: int) -> list[int]:
        """Reads a sequence of bytes from the file."""
        ...
    @overload
    def ReadLines(self) -> list[str]:
        """Reads the lines of file."""
        ...
    @overload
    def ReadLines(self, encodingType: EncodingType) -> list[str]:
        """Reads the lines of file that has a specified encoding."""
        ...
    def WriteAllBytes(self, bytes: list[int]) -> None:
        """Overwrites file content with passed bytes."""
        ...
    @overload
    def WriteAllText(self, contents: str) -> None:
        """Overwrites file content with passed text content."""
        ...
    @overload
    def WriteAllText(self, contents: str, encodingType: EncodingType) -> None:
        """Overwrites file content with passed text content that has a specified encoding."""
        ...
    def WriteBytes(self, bytes: list[int], offset: int, count: int) -> None:
        """Writes a chunk of data to file specific position."""
        ...
    CreationTime: DateTime
    """Gets the creation time of the file."""
    Extension: str
    """Gets the extension part of the file name, including the leading dot '.' even if it is the entire file name, or an empty string if no extension is present."""
    LastAccessTime: DateTime
    """Gets the time the current file was last accessed."""
    LastWriteTime: DateTime
    """Gets the time when the current file was last written to."""
    Name: str
    """Gets file name without path."""
    Size: int
    """Gets file size in bytes."""

class FileAssociations:
    """Represents the collection of plugin file associations."""
    @overload
    def Add(self, fileExtension: str, iconFilePath: str) -> None:
        """Adds a file extension to the list of associations along with a specified icon file path."""
        ...
    @overload
    def Add(self, fileExtension: str, svgIcon: SvgIcon) -> None:
        """Adds a file extension to the list of associations along with a specified icon file path."""
        ...
    @overload
    def Add(self, fileExtension: str) -> None:
        """Adds a file extension to the list of associations without specifying an icon."""
        ...
    def Contains(self, fileExtension: str) -> bool:
        """Checks if the specified file extension is already associated."""
        ...
    def Remove(self, fileExtension: str) -> None:
        """Removes a file extension from the list of associations."""
        ...
    FileOpened: Event[Callable[[FileAssociationsFileOpenedEventArgs], None]]
    """Event triggered when a file associated with a registered extension is opened."""

class FileAssociationsFileOpenedEventArgs:
    """Provides data for plugin file associations file opened event."""
    FilePath: str
    """Gets opened file path."""

class FileDialogResult:
    """An enumeration of the different file dialog results."""
    None: FileDialogResult
    Cancel: FileDialogResult
    OK: FileDialogResult
    Error: FileDialogResult

class FillRule:
    """Specifies how the intersecting areas of PathFigure objects contained in a Geometry are combined to form the area of the Geometry."""
    EvenOdd: FillRule
    Nonzero: FillRule

class FontStyle:
    """Specifies style information applied to text."""
    Normal: FontStyle
    Oblique: FontStyle
    Italic: FontStyle

class FontWeight:
    """Specifies the weight or thickness of the font."""
    Thin: FontWeight
    ExtraLight: FontWeight
    UltraLight: FontWeight
    Light: FontWeight
    Normal: FontWeight
    Regular: FontWeight
    Medium: FontWeight
    DemiBold: FontWeight
    SemiBold: FontWeight
    Bold: FontWeight
    ExtraBold: FontWeight
    UltraBold: FontWeight
    Black: FontWeight
    Heavy: FontWeight
    ExtraBlack: FontWeight
    UltraBlack: FontWeight

class FractalAdaptiveMovingAverage(MovingAverage, StandardIndicator):
    """The FRAMA (Fractal Adaptive Moving Average) indicator is a type of moving average that adjusts its sensitivity to price movements based on market volatility"""
    ...

class FractalChaosBands(StandardIndicator):
    """The Fractal Chaos Bands indicator attempts to determine whether or not the market is trending."""
    High: IndicatorDataSeries
    """The high limit of the chaos band."""
    Low: IndicatorDataSeries
    """The low limit of the chaos band."""

class Fractals(StandardIndicator):
    """The fractal indicator is a trading indicator used in technical analysis that is used to identify potential trend reversal points in a market."""
    DownFractal: IndicatorDataSeries
    """The down fractals plot/output"""
    UpFractal: IndicatorDataSeries
    """The up fractals plot/output"""

class Frame:
    """Base interface for chart frames."""
    def Activate(self) -> None:
        """Brings the chart frame to the front."""
        ...
    @overload
    def Attach(self) -> bool:
        """Attaches frame to main chart container."""
        ...
    @overload
    def Attach(self, targetContainer: ChartContainer) -> bool:
        """Attaches frame to passed chart container."""
        ...
    def Detach(self) -> bool:
        """Detaches frame from it is chart container."""
        ...
    ChartContainer: ChartContainer
    """Returns frame container."""
    Height: float
    """Returns current height of frame."""
    Id: str
    """Returns frame Id."""
    Index: int
    """Get / set frame index in container."""
    IsAttached: bool
    """Returns true if frame is attached otherwise false."""
    Width: float
    """Returns current width of frame."""
    Attached: Event[Callable[[FrameAttachedEventArgs], None]]
    """Occurs when frame is attached."""
    ContainerChanged: Event[Callable[[FrameContainerChangedEventArgs], None]]
    """Occurs when frame container is changed."""
    Detached: Event[Callable[[FrameDetachedEventArgs], None]]
    """Occurs when frame is detached."""
    SizeChanged: Event[Callable[[FrameSizeChangedEventArgs], None]]
    """Occurs when frame size changes."""

class FrameAttachedEventArgs:
    """Provides data for the frame attached event."""
    Frame: Frame
    """Returns the frame."""

class FrameContainerChangedEventArgs:
    """Provides data for the frame container changed event."""
    Frame: Frame
    """Returns the frame."""

class FrameDetachedEventArgs:
    """Provides data for the frame detached event."""
    Frame: Frame
    """Returns the frame."""

class FrameSizeChangedEventArgs:
    """Provides data for the frame size changed event."""
    Frame: Frame
    """Returns the frame."""

class FramesAddedEventArgs:
    """Provides data for the frames added event."""
    AddedFrames: list[Frame]
    """Returns the added frames."""

class FramesRemovedEventArgs:
    """Provides data for the frames removed event."""
    RemovedFrames: list[Frame]
    """Returns the removed frames."""

class Functions:
    """This class contains valuable functions that apply to DataSeries."""
    @overload
    @staticmethod
    def HasCrossedAbove(crossingSeries: DataSeries, crossedSeries: DataSeries, period: int) -> bool:
        """Returns true, if crossingSeries has crossed above crossedSeries, over the specified Period."""
        ...
    @overload
    @staticmethod
    def HasCrossedAbove(crossingSeries: DataSeries, value: float, period: int) -> bool:
        """Checks if crossingSeries has crossed above value, sometime within the specified period."""
        ...
    @overload
    @staticmethod
    def HasCrossedBelow(crossingSeries: DataSeries, crossedSeries: DataSeries, period: int) -> bool:
        """Returns true, if crossingSeries has crossed below crossedSeries, over the specified Period."""
        ...
    @overload
    @staticmethod
    def HasCrossedBelow(crossingSeries: DataSeries, value: float, period: int) -> bool:
        """Checks if crossingSeries has crossed below the value, sometime within the specified period."""
        ...
    @staticmethod
    def IsFalling(series: DataSeries) -> bool:
        """Checks if the last value in a data series is less than the previous"""
        ...
    @staticmethod
    def IsRising(series: DataSeries) -> bool:
        """Checks if the last value in a data series is greater than the previous."""
        ...
    @staticmethod
    def Maximum(series: DataSeries, period: int) -> float:
        """Finds the maximum value in a data series for a given period."""
        ...
    @staticmethod
    def Minimum(series: DataSeries, period: int) -> float:
        """Finds the minimum of a data series for a given period."""
        ...
    @staticmethod
    def Sum(series: DataSeries, period: int) -> float:
        """Calculates the sum of a data series, over the specified period."""
        ...

class FuturesSettings:
    """Represents a future contract symbol settings."""
    ExpirationTime: DateTime
    """Gets the expiration time of future contract."""
    LastTradeTime: DateTime
    """Gets the last trade time of future contract."""
    MaintenanceMargin: float | None
    """The amount of quote asset that will be taken as a margin per one traded lot."""

class GannLevel:
    """Represents a Gann Level."""
    IsVisible: bool
    """Defines if the level is visible."""
    Ratio: float
    """Gets or sets the level ratio (e.g., 1.0 for 1x1, 2.0 for 2x1, 0.5 for 1x2)."""

class GatorOscillator(StandardIndicator):
    """The calculation of the Gator Oscillator."""
    Lower: IndicatorDataSeries
    """The histogram (bar graph). The difference between the Alligator's teeth and lips."""
    Upper: IndicatorDataSeries
    """The histogram (bar graph). The difference between the Alligator's jaws and teeth."""

class GetFitnessArgs:
    """Represents the custom fitness calculation interface."""
    AverageTrade: float
    """Gets the average profit for all trades in account deposit currency."""
    Commissions: float
    """Gets the commissions of all trades in account deposit currency."""
    Equity: float
    """Gets the equity of the account (balance plus unrealized profit and loss)."""
    History: History
    """Gets all the historical trades."""
    LosingTrades: float
    """Gets total number of losing trades."""
    MaxBalanceDrawdown: float
    """Gets the maximum amount of balance drawdown in account deposit currency."""
    MaxBalanceDrawdownPercentages: float
    """Gets the maximum amount of balance drawdown in percentage (ex: 40%). It can return a positive value between 0-100."""
    MaxEquityDrawdown: float
    """Gets the maximum amount of equity drawdown in account deposit currency."""
    MaxEquityDrawdownPercentages: float
    """Gets the maximum amount of equity drawdown in percentage (ex: 40%). It can return a positive value between 0-100."""
    NetProfit: float
    """Gets the net profit of all trades in account deposit currency."""
    PendingOrders: PendingOrders
    """Gets all pending orders."""
    Positions: Positions
    """Gets all open positions."""
    ProfitFactor: float
    """Gets the Profit Factor - the ratio of Total Net Profit divided by the Total Net Loss."""
    Swaps: float
    """Gets the swaps of all trades in account deposit currency."""
    TotalTrades: float
    """Gets the total number of trades taken."""
    WinningTrades: float
    """Gets the total number of winning trades."""

class Grid(Panel):
    """Represents the Grid class."""
    @overload
    def __init__(self) -> None: ...
    @overload
    def __init__(self, rowsCount: int, columnsCount: int) -> None: ...
    @overload
    def AddChild(self, child: ControlBase, row: int, column: int) -> None:
        """Adds a child element."""
        ...
    @overload
    def AddChild(self, child: ControlBase, row: int, column: int, rowSpan: int, columnSpan: int) -> None:
        """Adds the child."""
        ...
    def AddColumn(self) -> GridColumn:
        """Adds a column."""
        ...
    def AddColumns(self, count: int) -> None:
        """Adds columns."""
        ...
    def AddRow(self) -> GridRow:
        """Adds a row."""
        ...
    def AddRows(self, count: int) -> None:
        """Adds a rows."""
        ...
    def GetChildPosition(self, child: ControlBase) -> GridChildPositionInfo | None:
        """Returns a child position info if exists otherwise null."""
        ...
    def RemoveColumnAt(self, index: int) -> None:
        """Removes a column."""
        ...
    def RemoveRowAt(self, index: int) -> None:
        """Removes the row."""
        ...
    Columns: IReadonlyList[GridColumn]
    """Gets the read only list of the grid columns."""
    Rows: IReadonlyList[GridRow]
    """Gets the read only list of the grid rows."""
    ShowGridLines: bool
    """Defines if the grid lines are visible."""

class GridChildPositionInfo:
    """Represents a Grid panel child position info."""
    Column: int
    """Gets column number of child."""
    ColumnSpan: int
    """Gets column span of child."""
    Row: int
    """Gets row number of child."""
    RowSpan: int
    """Gets row span of child."""

class GridColumn:
    """Represents the column of the grid."""
    def SetWidthInPixels(self, value: float) -> None:
        """Sets the grid column width in pixels."""
        ...
    def SetWidthInStars(self, stars: float) -> None:
        """Sets the grid column width in stars."""
        ...
    def SetWidthToAuto(self) -> None:
        """Sets the grid column width to automatic."""
        ...
    Index: int
    """Gets the grid column index."""
    MaxWidth: float
    """Defines the grid column maximum width."""
    MinWidth: float
    """Defines the grid column minimum width."""
    Width: GridLength
    """Gets the grid column width."""

class GridLength:
    """Represents the length of the grid."""
    UnitType: GridUnitType
    """Gets or sets the type of the unit."""
    Value: float
    """Gets or sets the value."""

class GridRow:
    """Represents the row of the grid."""
    def SetHeightInPixels(self, value: float) -> None:
        """Sets the height of the grid row in pixels."""
        ...
    def SetHeightInStars(self, stars: float) -> None:
        """Sets the height of the grid row in stars."""
        ...
    def SetHeightToAuto(self) -> None:
        """Sets the height of the grid row to automatic."""
        ...
    Height: GridLength
    """Gets the height of the grid row."""
    Index: int
    """Gets the grid row index."""
    MaxHeight: float
    """Gets or sets the maximum height of the grid row."""
    MinHeight: float
    """Gets or sets the minimum height of the grid row."""

class GridUnitType:
    """Represents the type of the grid unit."""
    Auto: GridUnitType
    Pixel: GridUnitType
    Star: GridUnitType

class HighMinusLow(StandardIndicator):
    """Difference between Bars.HighPrices and Bars.LowPrices calculation for each index"""
    Result: IndicatorDataSeries
    """The resulting time series of the calculation."""

class HistoricalOrder:
    """Represents a historical order."""
    Channel: str
    """Order channel."""
    Comment: str
    """Order comment."""
    ExpirationTime: DateTime | None
    """Order expiration time."""
    FilledQuantity: float | None
    """Order filled quantity (lots)."""
    FilledTime: DateTime | None
    """Order filled time."""
    FilledVolumeInUnits: float | None
    """Order filled volume in units."""
    HasTrailingStop: bool
    """Returns true if order has trailing stop loss."""
    Id: int
    """Unique order Id."""
    Label: str
    """Order label."""
    OrderType: HistoricalOrderType
    """Order type."""
    PositionId: int | None
    """Unique position Id."""
    Quantity: float
    """Order quantity (lots)."""
    Status: HistoricalOrderStatus
    """Order status."""
    StopLoss: float | None
    """Order stop loss in Price."""
    StopLossPips: float | None
    """Order stop loss in Pips."""
    StopLossTriggerMethod: StopTriggerMethod | None
    """Trigger method for order's StopLoss"""
    StopOrderTriggerMethod: StopTriggerMethod | None
    """StopOrder trigger method."""
    SubmittedTime: DateTime
    """Order submitted time."""
    Symbol: Symbol
    """Order symbol."""
    SymbolName: str
    """Order symbol name."""
    TakeProfit: float | None
    """Order take profit in Price."""
    TakeProfitPips: float | None
    """Order take profit in Pips."""
    TargetPrice: float
    """Order target price"""
    TradeType: TradeType
    """Order Trade type (buy or sell)"""
    VolumeInUnits: float
    """Order volume in units."""

class HistoricalOrderStatus:
    """Represents the status of HistoricalOrder."""
    Filled: HistoricalOrderStatus
    Expired: HistoricalOrderStatus
    Created: HistoricalOrderStatus
    Accepted: HistoricalOrderStatus
    Error: HistoricalOrderStatus
    Cancelled: HistoricalOrderStatus

class HistoricalOrderType:
    """Represents the type of HistoricalOrder."""
    Limit: HistoricalOrderType
    Market: HistoricalOrderType
    MarketRange: HistoricalOrderType
    MarketOnOpen: HistoricalOrderType
    Stop: HistoricalOrderType
    StopOut: HistoricalOrderType
    StopLimit: HistoricalOrderType
    StopLossTakeProfit: HistoricalOrderType

class HistoricalOrders:
    """Provides access to methods of the Historical Orders collection"""
    @overload
    def FindAll(self, label: str) -> list[HistoricalOrder]:
        """Finds historical orders by label."""
        ...
    @overload
    def FindAll(self, label: str, symbolName: str) -> list[HistoricalOrder]:
        """Finds historical orders by label and symbol name."""
        ...
    @overload
    def FindAll(self, label: str, symbolName: str, tradeType: TradeType) -> list[HistoricalOrder]:
        """Finds historical orders by label, symbol name, and trade type."""
        ...
    def FindById(self, id: int) -> HistoricalOrder:
        """Finds a historical order by Id."""
        ...
    @overload
    def FindLast(self, label: str) -> HistoricalOrder:
        """Finds last historical order by label."""
        ...
    @overload
    def FindLast(self, label: str, symbolName: str) -> HistoricalOrder:
        """Finds last historical order by label and symbol name."""
        ...
    @overload
    def FindLast(self, label: str, symbolName: str, tradeType: TradeType) -> HistoricalOrder:
        """Finds last historical order by label, symbol name, and trade type."""
        ...
    Count: int
    """Returns count of historical orders."""
    Item: HistoricalOrder
    """Access historical orders by their index."""

class HistoricalTrade:
    """Represents the historical trade interface."""
    Balance: float
    """Account balance after the Deal was filled"""
    Channel: str
    """Gets the channel via which the trade was executed in a string format."""
    ClosingDeal: Deal
    """Gets the closing deal."""
    ClosingDealId: int
    """Gets the unique closing deal identifier."""
    ClosingPrice: float
    """The execution price of the Closing Deal."""
    ClosingTime: DateTime
    """Time of the Closing Deal."""
    Comment: str
    """The comment."""
    Commissions: float
    """Commission owed."""
    EntryPrice: float
    """The VWAP (Volume Weighted Average Price) of the Opening Deals that are closed."""
    EntryTime: DateTime
    """Time of the Opening Deal, or the time of the first Opening deal that was closed."""
    GrossProfit: float
    """Profit and loss before swaps and commission"""
    Label: str
    """The label."""
    NetProfit: float
    """Profit and loss including swaps and commissions"""
    Pips: float
    """Represents the winning or loosing pips"""
    PositionId: int
    """Gets the position unique identifier."""
    Quantity: float
    """The Quantity (in lots) that was closed by the Closing Deal"""
    Swap: float
    """Swap is the overnight interest rate if any, accrued on the position."""
    Symbol: Symbol
    """Gets the trade symbol."""
    SymbolName: str
    """Gets the symbol name."""
    TradeType: TradeType
    """The TradeType of the Opening Deal."""
    VolumeInUnits: float
    """The Volume that was closed by the Closing Deal."""

class HistoricalVolatility(StandardIndicator):
    """The measured price fluctuation over a specified time period."""
    Result: IndicatorDataSeries
    """The result of the HistoricalVolatility Indicator"""

class History:
    """Provides access to methods of the historical trades collection"""
    @overload
    def FindAll(self, label: str) -> list[HistoricalTrade]:
        """Find all historical trades by the label"""
        ...
    @overload
    def FindAll(self, label: str, symbolName: str) -> list[HistoricalTrade]:
        """Find all historical trades by label, symbol name"""
        ...
    @overload
    def FindAll(self, label: str, symbolName: str, tradeType: TradeType) -> list[HistoricalTrade]:
        """Find all historical trades by label, symbol name and trade type"""
        ...
    def FindByClosingDealId(self, closingDealId: int) -> HistoricalTrade:
        """Find HistoricalTrade by closing deal Id."""
        ...
    def FindByPositionId(self, positionId: int) -> list[HistoricalTrade]:
        """Find all historical trades related to a position."""
        ...
    @overload
    def FindLast(self, label: str) -> HistoricalTrade:
        """Find last historical trade by its label"""
        ...
    @overload
    def FindLast(self, label: str, symbolName: str) -> HistoricalTrade:
        """Find last historical trade by its label, symbol name"""
        ...
    @overload
    def FindLast(self, label: str, symbolName: str, tradeType: TradeType) -> HistoricalTrade:
        """Find last historical trade by its label, symbol name and trade type"""
        ...
    Count: int
    """Total number of historical trades"""
    Item: HistoricalTrade
    """Find a historical trade by index"""

class HorizontalAlignment:
    """Describes horizontal position related to an anchor point or a parent element"""
    Center: HorizontalAlignment
    Left: HorizontalAlignment
    Right: HorizontalAlignment
    Stretch: HorizontalAlignment

class HotkeyArgs:
    """Provides data for Plugin Hotkeys handler."""
    Key: Key
    """Keyboard key"""
    Modifiers: ModifierKeys
    """Modifiers key that was used with the Key"""

class Hotkeys:
    """Provides access to Hotkeys API for plugins."""
    def Clear(self) -> None:
        """Clears all added hotkeys."""
        ...
    @overload
    def Remove(self, key: Key) -> bool:
        """Removes an hotkey."""
        ...
    @overload
    def Remove(self, key: Key, modifiers: ModifierKeys) -> bool:
        """Removes an hotkey."""
        ...
    @overload
    def TryAdd(self, key: Key, handler: Callable[[HotkeyArgs], None]) -> bool:
        """Adds a new hotkey."""
        ...
    @overload
    def TryAdd(self, key: Key, modifiers: ModifierKeys, handler: Callable[[HotkeyArgs], None]) -> bool:
        """Adds a new hotkey."""
        ...

class Http:
    """The Https interface contains the methods necessary for sending HTTP requests."""
    @overload
    def Get(self, uri: Uri) -> HttpResponse:
        """Performs a GET request to the specified URI."""
        ...
    @overload
    def Get(self, uri: str) -> HttpResponse:
        """Performs a GET request to the specified URI."""
        ...
    @overload
    def GetAsync(self, uri: Uri, callback: Callable[[HttpResponse], None]) -> None:
        """Performs a GET request to the specified URI asynchronously."""
        ...
    @overload
    def GetAsync(self, uri: str, callback: Callable[[HttpResponse], None]) -> None:
        """Performs a GET request to the specified URI asynchronously."""
        ...
    def Send(self, request: HttpRequest) -> HttpResponse:
        """Performs a request to the specified URI. The request method depends on the value of the request.Method property."""
        ...
    def SendAsync(self, request: HttpRequest, callback: Callable[[HttpResponse], None]) -> None:
        """Performs a request to the specified URI. The request method depends on the value of the request.Method property."""
        ...

class HttpException:
    """Represents errors that may occur during HTTP request"""
    ...

class HttpMethod:
    """An enumeration of different HTTP Methods."""
    Get: HttpMethod
    Post: HttpMethod
    Delete: HttpMethod
    Put: HttpMethod
    Patch: HttpMethod
    Head: HttpMethod
    Options: HttpMethod
    Trace: HttpMethod

class HttpRequest:
    """The class representing an HTTP request."""
    def __init__(self, uri: Uri) -> None: ...
    Body: str
    """Gets or sets the request body. If a GET, TRACE, HEAD, CONNECT, and OPTIONS request is performed, the value of this property is ignored."""
    Headers: HttpRequestHeaders
    """Gets the request headers."""
    Method: HttpMethod
    """Gets or sets the request method. The default value is Get."""
    Timeout: TimeSpan
    """Gets or sets the request timeout. The default value is 100,000 milliseconds (100 seconds)."""
    Uri: Uri
    """Gets or sets the request URI."""
    Version: Version
    """Gets or sets the request version. The default value is 2.0."""
    VersionPolicy: HttpVersionPolicy
    """Gets or sets the request version policy. The default value is RequestVersionOrLower ."""

class HttpRequestHeaders:
    """The class that represents an HTTP request headers collection."""
    def Add(self, name: str, value: str) -> None:
        """Adds a new header."""
        ...
    def GetEnumerator(self) -> IEnumerator[KeyValuePair[str, str]]:
        """Returns an enumerator that iterates through HttpRequestHeaders ."""
        ...
    def GetValue(self, name: str) -> str:
        """Returns an existing header value."""
        ...
    def Remove(self, name: str) -> bool:
        """Removes an existing header."""
        ...
    def Update(self, name: str, value: str) -> None:
        """Updates an existing header."""
        ...

class HttpResponse:
    """The class representing an HTTP response."""
    Body: str
    """Gets the body of the response."""
    Exception: HttpException
    """Gets the exception thrown when sending HTTP request."""
    Headers: HttpResponseHeaders
    """Gets the headers contained in the response."""
    IsSuccessful: bool
    """Gets true if the response is successful, false otherwise."""
    StatusCode: int
    """Gets the response status code."""

class HttpResponseHeaders:
    """The class that represents an HTTP response headers collection."""
    def GetEnumerator(self) -> IEnumerator[KeyValuePair[str, str]]:
        """Returns an enumerator that iterates through HttpResponseHeaders ."""
        ...
    def GetValue(self, name: str) -> str:
        """Returns an existing header value."""
        ...

class HttpVersionPolicy:
    """An enumeration of different HTTP version policies."""
    RequestVersionOrLower: HttpVersionPolicy
    RequestVersionOrHigher: HttpVersionPolicy
    RequestVersionExact: HttpVersionPolicy

class HullMovingAverage(MovingAverage, StandardIndicator):
    """The Hull Moving Average (HMA) is a directional trend indicator. It captures the current state of the market and uses recent price action to determine if conditions are bullish or bearish relative to historical data."""
    ...

class IAccount:
    """Contains the current account information."""
    AccountType: AccountType
    """Returns the current account type."""
    Asset: Asset
    """Gets the account deposit asset/currency"""
    Balance: float
    """Returns the balance of the current account."""
    BrokerName: str
    """Returns the broker name of the current account."""
    CreationTime: DateTime
    """Gets the account creation time."""
    Credit: float
    """Gets the credit of the current account."""
    Equity: float
    """Represents the equity of the current account (balance minus Unrealized Net Loss plus Unrealized Net Profit plus Bonus)."""
    FreeMargin: float
    """Represents the free margin of the current account."""
    IsLive: bool
    """Defines if the account is Live or Demo. True if the Account is Live, False if it is a Demo."""
    Margin: float
    """Represents the margin of the current account."""
    MarginLevel: float | None
    """Represents the margin level of the current account. Margin Level (in %) is calculated using this formula: Equity / Margin * 100"""
    Number: int
    """Returns the number of the current account, e.g. 123456."""
    PreciseLeverage: float
    """Gets the precise account leverage value."""
    StopOutLevel: float
    """Stop Out level is a lowest allowed Margin Level for account. If Margin Level is less than Stop Out, position will be closed sequentially until Margin Level is greater than Stop Out."""
    TotalMarginCalculationType: TotalMarginCalculationType
    """Type of total margin requirements per Symbol."""
    UnrealizedGrossProfit: float
    """Gets the Unrealized Gross profit value."""
    UnrealizedNetProfit: float
    """Gets the Unrealized Net profit value."""
    UserId: int
    """Gets the user ID."""
    UserNickName: str
    """Gets the user nick name."""
    Switched: Event[Callable[[AccountSwitchedEventArgs], None]]
    """Occurs when user switch his account."""

class IAssetConverter:
    """Its an interface for converting an asset / currency value to another asset / currency value."""
    @overload
    def Convert(self, value: float, from_: Asset, to: Asset) -> float:
        """Converts an asset to another asset."""
        ...
    @overload
    def Convert(self, value: float, from_: str, to: str) -> float:
        """Converts an asset to another asset."""
        ...
    @overload
    def Convert(self, value: float, from_: Asset, to: str) -> float:
        """Converts an asset to another asset."""
        ...
    @overload
    def Convert(self, value: float, from_: str, to: Asset) -> float:
        """Converts an asset to another asset."""
        ...

class IIndicatorsAccessor:
    """Accessor to Indicators"""
    @overload
    def AcceleratorOscillator(self) -> AcceleratorOscillator:
        """Initializes the AcceleratorOscillator indicator instance"""
        ...
    @overload
    def AcceleratorOscillator(self, bars: Bars) -> AcceleratorOscillator:
        """Initializes the AcceleratorOscillator indicator instance"""
        ...
    @overload
    def AccumulationDistribution(self) -> AccumulationDistribution:
        """The Accumulation Distribution indicator shows bullish or bearish trends."""
        ...
    @overload
    def AccumulationDistribution(self, bars: Bars) -> AccumulationDistribution:
        """The Accumulation Distribution indicator shows bullish or bearish trends."""
        ...
    @overload
    def AccumulativeSwingIndex(self, limitMoveValue: int) -> AccumulativeSwingIndex:
        """Initializes the Accumulative Swing Index indicator"""
        ...
    @overload
    def AccumulativeSwingIndex(self, bars: Bars, limitMoveValue: int) -> AccumulativeSwingIndex:
        """Initializes the Accumulative Swing Index indicator"""
        ...
    @overload
    def Alligator(self, jawsPeriods: int, jawsShift: int, teethPeriods: int, teethShift: int, lipsPeriods: int, lipsShift: int, maType: MovingAverageType) -> Alligator:
        """Legendary trader Bill Williams, an early pioneer of market psychology, developed the trend-following Alligator indicator, which follows the premise that financial markets and individual securities trend just 15% to 30% of the time while grinding through sideways ranges the other 70% to 85% of the time."""
        ...
    @overload
    def Alligator(self, source: DataSeries, jawsPeriods: int, jawsShift: int, teethPeriods: int, teethShift: int, lipsPeriods: int, lipsShift: int, maType: MovingAverageType) -> Alligator:
        """Legendary trader Bill Williams, an early pioneer of market psychology, developed the trend-following Alligator indicator, which follows the premise that financial markets and individual securities trend just 15% to 30% of the time while grinding through sideways ranges the other 70% to 85% of the time."""
        ...
    @overload
    def Aroon(self, periods: int) -> Aroon:
        """The Aroon indicator is used to identify trends and their reversals."""
        ...
    @overload
    def Aroon(self, bars: Bars, periods: int) -> Aroon:
        """The Aroon indicator is used to identify trends and their reversals."""
        ...
    @overload
    def AverageDirectionalMovementIndexRating(self, periods: int) -> AverageDirectionalMovementIndexRating:
        """The Average Directional Movement Index Rating (ADXR) measures the strength of the Average Directional Movement Index (ADX). It's calculated by taking the average of the current ADX and the ADX from one time period before."""
        ...
    @overload
    def AverageDirectionalMovementIndexRating(self, periods: int, maType: MovingAverageType) -> AverageDirectionalMovementIndexRating:
        """The Average Directional Movement Index Rating (ADXR) measures the strength of the Average Directional Movement Index (ADX). It's calculated by taking the average of the current ADX and the ADX from one time period before."""
        ...
    @overload
    def AverageTrueRange(self, periods: int, maType: MovingAverageType) -> AverageTrueRange:
        """Average true range. An indicator providing the degree of price volatility."""
        ...
    @overload
    def AverageTrueRange(self, bars: Bars, periods: int, maType: MovingAverageType) -> AverageTrueRange:
        """Average true range. An indicator providing the degree of price volatility."""
        ...
    @overload
    def AwesomeOscillator(self) -> AwesomeOscillator:
        """Initializes the AwesomeOscillator indicator instance"""
        ...
    @overload
    def AwesomeOscillator(self, bars: Bars) -> AwesomeOscillator:
        """Initializes the AwesomeOscillator indicator instance by passing the bars"""
        ...
    @overload
    def BearsPower(self, periods: int, maType: MovingAverageType) -> BearsPower:
        """Bears Power shows the maximum bearish strength during the time period."""
        ...
    @overload
    def BearsPower(self, bars: Bars, periods: int, maType: MovingAverageType) -> BearsPower:
        """Bears Power shows the maximum bearish strength during the time period."""
        ...
    def BollingerBands(self, source: DataSeries, periods: int, standardDeviations: float, maType: MovingAverageType) -> BollingerBands:
        """The Bollinger Bands indicator shows volatility."""
        ...
    @overload
    def BullsPower(self, periods: int, maType: MovingAverageType) -> BullsPower:
        """Bulls Power shows the maximum bullish strength during the time period."""
        ...
    @overload
    def BullsPower(self, bars: Bars, periods: int, maType: MovingAverageType) -> BullsPower:
        """Bulls Power shows the maximum bullish strength during the time period."""
        ...
    def CenterOfGravity(self, length: int) -> CenterOfGravity:
        """The Center of Gravity (COG) indicator is a technical indicator developed by John Ehlers in 2002, used to identify potential turning points in the price as early as possible."""
        ...
    @overload
    def ChaikinMoneyFlow(self, periods: int) -> ChaikinMoneyFlow:
        """The Chaikin Money Flow indicator measures the money flow volume over a specific period."""
        ...
    @overload
    def ChaikinMoneyFlow(self, bars: Bars, periods: int) -> ChaikinMoneyFlow:
        """The Chaikin Money Flow indicator measures the money flow volume over a specific period."""
        ...
    @overload
    def ChaikinOscillator(self, shortTerm: int, longTerm: int, maType: MovingAverageType) -> ChaikinOscillator:
        """The Chaikin Oscillator indicator is the difference between two moving averages over the Chaikin Money Flow."""
        ...
    @overload
    def ChaikinOscillator(self, bars: Bars, shortTerm: int, longTerm: int, maType: MovingAverageType) -> ChaikinOscillator:
        """The Chaikin Oscillator indicator is the difference between two moving averages over the Chaikin Money Flow."""
        ...
    @overload
    def ChaikinVolatility(self, periods: int, rateOfChange: int, maType: MovingAverageType) -> ChaikinVolatility:
        """The Chaikin Volatiliy indicator measures the trading range between the high and the low prices."""
        ...
    @overload
    def ChaikinVolatility(self, bars: Bars, periods: int, rateOfChange: int, maType: MovingAverageType) -> ChaikinVolatility:
        """The Chaikin Volatility indicator measures the trading range between the high and the low prices."""
        ...
    @overload
    def ChandeMomentumOscillator(self, source: DataSeries, periods: int) -> ChandeMomentumOscillator:
        """The Chande Momentum Oscillator (CMO) is a technical indicator designed to measure the momentum of a financial instrument."""
        ...
    @overload
    def ChandeMomentumOscillator(self, periods: int) -> ChandeMomentumOscillator:
        """The Chande Momentum Oscillator (CMO) is a technical indicator designed to measure the momentum of a financial instrument."""
        ...
    @overload
    def CommodityChannelIndex(self, periods: int) -> CommodityChannelIndex:
        """The Commodity Channel Index identifies overbought and oversold conditions, price reversals and trend strength."""
        ...
    @overload
    def CommodityChannelIndex(self, source: DataSeries, periods: int) -> CommodityChannelIndex:
        """The Commodity Channel Index identifies overbought and oversold conditions, price reversals and trend strength."""
        ...
    def CyberCycle(self, alpha: float) -> CyberCycle:
        """The Cyber Cycles Oscillator is an indicator designed by John Ehlers, it is used for isolating the cycle component of the market from its trend counterpart."""
        ...
    @overload
    def DeMarker(self, periods: int) -> DeMarker:
        """The DeMarker (DeM) is an oscillator that compares the most recent maximum and minimum prices to the previous period's equivalent price."""
        ...
    @overload
    def DeMarker(self, bars: Bars, periods: int) -> DeMarker:
        """The DeMarker (DeM) is an oscillator that compares the most recent maximum and minimum prices to the previous period's equivalent price."""
        ...
    def DetrendedPriceOscillator(self, source: DataSeries, periods: int, maType: MovingAverageType) -> DetrendedPriceOscillator:
        """The Detrended Price Oscillator shows intermediate overbought and oversold levels."""
        ...
    @overload
    def DirectionalMovementSystem(self, periods: int) -> DirectionalMovementSystem:
        """The Directional Movement System is composed of three indicators that show if the market is trending and provide signals."""
        ...
    @overload
    def DirectionalMovementSystem(self, bars: Bars, periods: int) -> DirectionalMovementSystem:
        """The Directional Movement System is composed of three indicators that show if the market is trending and provide signals."""
        ...
    @overload
    def DirectionalMovementSystem(self, bars: Bars, periods: int, maType: MovingAverageType) -> DirectionalMovementSystem:
        """The Directional Movement System is composed of three indicators that show if the market is trending and provide signals."""
        ...
    @overload
    def DonchianChannel(self, periods: int) -> DonchianChannel:
        """The Donchian channel is a volatility indicator forming a channel between the highest high and the lowest low of the chosen period."""
        ...
    @overload
    def DonchianChannel(self, bars: Bars, periods: int) -> DonchianChannel:
        """The Donchian channel is a volatility indicator forming a channel between the highest high and the lowest low of the chosen period."""
        ...
    def DoubleExponentialMovingAverage(self, source: DataSeries, periods: int) -> DoubleExponentialMovingAverage:
        """The Double Exponential Moving Average (DEMA) is a combination of smoothed exponential moving averages (EMA) and a basic EMA"""
        ...
    @overload
    def EaseOfMovement(self, periods: int, maType: MovingAverageType) -> EaseOfMovement:
        """The Ease Of Movement indicator relates the price change to the volume."""
        ...
    @overload
    def EaseOfMovement(self, bars: Bars, periods: int, maType: MovingAverageType) -> EaseOfMovement:
        """The Ease Of Movement indicator relates the price change to the volume."""
        ...
    @overload
    def ElderForceIndex(self, periods: int, maType: MovingAverageType) -> ElderForceIndex:
        """Elder's Force Index measures the amount of power used to move the price of an asset."""
        ...
    @overload
    def ElderForceIndex(self, bars: Bars, periods: int, maType: MovingAverageType) -> ElderForceIndex:
        """Elder's Force Index measures the amount of power used to move the price of an asset."""
        ...
    @overload
    def ElderRayIndex(self, periods: int, maType: MovingAverageType) -> ElderRayIndex:
        """Elder Ray Index shows the maximum bullish and bearish strengths during the time period."""
        ...
    @overload
    def ElderRayIndex(self, bars: Bars, periods: int, maType: MovingAverageType) -> ElderRayIndex:
        """Elder Ray Index shows the maximum bullish and bearish strengths during the time period."""
        ...
    @overload
    def Envelopes(self, periods: int, maType: MovingAverageType, deviation: float) -> Envelopes:
        """The Envelopes indicator is used to visualize potential trading ranges and overbought/oversold conditions."""
        ...
    @overload
    def Envelopes(self, source: DataSeries, periods: int, maType: MovingAverageType, deviation: float) -> Envelopes:
        """The Envelopes indicator is used to visualize potential trading ranges and overbought/oversold conditions."""
        ...
    def ExponentialMovingAverage(self, source: DataSeries, periods: int) -> ExponentialMovingAverage:
        """The Exponential Moving Average smoothes the price data producing a trend indicator."""
        ...
    @overload
    def FractalAdaptiveMovingAverage(self, periods: int) -> FractalAdaptiveMovingAverage:
        """The Fractal Adaptive Moving Average (FRAMA) indicator is a type of moving average that adjusts its sensitivity to price movements based on market volatility"""
        ...
    @overload
    def FractalAdaptiveMovingAverage(self, bars: Bars, periods: int) -> FractalAdaptiveMovingAverage:
        """The Fractal Adaptive Moving Average (FRAMA) indicator is a type of moving average that adjusts its sensitivity to price movements based on market volatility"""
        ...
    @overload
    def FractalChaosBands(self) -> FractalChaosBands:
        """The Fractal Chaos Bands indicator breaks down large trends into predictable patterns."""
        ...
    @overload
    def FractalChaosBands(self, bars: Bars) -> FractalChaosBands:
        """The Fractal Chaos Bands indicator breaks down large trends into predictable patterns."""
        ...
    @overload
    def Fractals(self, periods: int) -> Fractals:
        """The fractal indicator is a trading indicator used in technical analysis that is used to identify potential trend reversal points in a market."""
        ...
    @overload
    def Fractals(self, bars: Bars, periods: int) -> Fractals:
        """The fractal indicator is a trading indicator used in technical analysis that is used to identify potential trend reversal points in a market."""
        ...
    @overload
    def GatorOscillator(self, jawsPeriods: int, jawsShift: int, teethPeriods: int, teethShift: int, lipsPeriods: int, lipsShift: int, maType: MovingAverageType) -> GatorOscillator:
        """Gator Oscillator (GO) supplements the Alligator indicator and is used together with it."""
        ...
    @overload
    def GatorOscillator(self, source: DataSeries, jawsPeriods: int, jawsShift: int, teethPeriods: int, teethShift: int, lipsPeriods: int, lipsShift: int, maType: MovingAverageType) -> GatorOscillator:
        """Gator Oscillator (GO) supplements the Alligator indicator and is used together with it."""
        ...
    @overload
    def GetIndicator(self, parameterValues: list[object]) -> TIndicator:
        """Initializes the custom indicator"""
        ...
    @overload
    def GetIndicator(self, bars: Bars, parameterValues: list[object]) -> TIndicator:
        """Initializes the custom indicator"""
        ...
    @overload
    def HighMinusLow(self) -> HighMinusLow:
        """The High Minus Low indicator is used to compute the range of daily bars"""
        ...
    @overload
    def HighMinusLow(self, bars: Bars) -> HighMinusLow:
        """The High Minus Low indicator is used to compute the range of daily bars"""
        ...
    def HistoricalVolatility(self, source: DataSeries, periods: int, barHistory: int) -> HistoricalVolatility:
        """The Historical Volatility indicator is derived from time series of past market prices."""
        ...
    def HullMovingAverage(self, source: DataSeries, periods: int) -> HullMovingAverage:
        """The Hull Moving Average is a more responsive moving average that nearly removes lag and improves smoothing at the same time."""
        ...
    @overload
    def IchimokuKinkoHyo(self, tenkanSenPeriods: int, kijunSenPeriods: int, senkouSpanBPeriods: int) -> IchimokuKinkoHyo:
        """Ichimoku Kinko Hyo Indicator is a moving average based trend identification system."""
        ...
    @overload
    def IchimokuKinkoHyo(self, bars: Bars, tenkanSenPeriods: int, kijunSenPeriods: int, senkouSpanBPeriods: int) -> IchimokuKinkoHyo:
        """Ichimoku Kinko Hyo Indicator is a moving average based trend identification system."""
        ...
    @overload
    def KaufmanAdaptiveMovingAverage(self, periods: int, fastPeriods: int, slowPeriods: int) -> KaufmanAdaptiveMovingAverage:
        """The Kaufman's Adaptive Moving Average (KAMA) indicator is a type of adaptive moving average designed to adjust its smoothing factor based on market volatility"""
        ...
    @overload
    def KaufmanAdaptiveMovingAverage(self, source: DataSeries, periods: int, fastPeriods: int, slowPeriods: int) -> KaufmanAdaptiveMovingAverage:
        """The Kaufman's Adaptive Moving Average (KAMA) indicator is a type of adaptive moving average designed to adjust its smoothing factor based on market volatility"""
        ...
    @overload
    def KeltnerChannels(self, maPeriod: int, maType: MovingAverageType, atrPeriod: int, atrMaType: MovingAverageType, bandDistance: float) -> KeltnerChannels:
        """Initializes the Keltner Channels indicator instance"""
        ...
    @overload
    def KeltnerChannels(self, bars: Bars, maPeriod: int, maType: MovingAverageType, atrPeriod: int, atrMaType: MovingAverageType, bandDistance: float) -> KeltnerChannels:
        """Initializes the Keltner Channels indicator instance"""
        ...
    def LinearRegressionForecast(self, source: DataSeries, periods: int) -> LinearRegressionForecast:
        """Linear Regression Forecast is a trend indicator used to forecast values using the Least Squares Fit method."""
        ...
    def LinearRegressionIntercept(self, source: DataSeries, periods: int) -> LinearRegressionIntercept:
        """The Linear Regression Intercept can be used together with the Linear Regression Slope indicator to plot the Linear Regression Line."""
        ...
    def LinearRegressionRSquared(self, source: DataSeries, periods: int) -> LinearRegressionRSquared:
        """The R Squared or coefficient of determination indicator's main purpose is the confirm the strength of the market."""
        ...
    def LinearRegressionSlope(self, source: DataSeries, periods: int) -> LinearRegressionSlope:
        """The Linear Regression Slope indicator is intended to measure the direction and strength of a trend."""
        ...
    @overload
    def MacdCrossOver(self, longCycle: int, shortCycle: int, signalPeriods: int) -> MacdCrossOver:
        """The MACD Line with the Signal line and their difference as a histogram."""
        ...
    @overload
    def MacdCrossOver(self, source: DataSeries, longCycle: int, shortCycle: int, signalPeriods: int) -> MacdCrossOver:
        """Initializes the MacdCrossOver indicator instance for a specific source series"""
        ...
    @overload
    def MacdHistogram(self, longCycle: int, shortCycle: int, signalPeriods: int) -> MacdHistogram:
        """The MACD Histogram is a momentum indicator measured by typically subtracting a 26 period moving average from a 12 period moving average."""
        ...
    @overload
    def MacdHistogram(self, source: DataSeries, longCycle: int, shortCycle: int, signalPeriods: int) -> MacdHistogram:
        """Initializes the MacdHistogram indicator instance for a specific source series"""
        ...
    @overload
    def MacdOscillatorMovingAverage(self, longCycle: int, shortCycle: int, signalPeriods: int, maType: MovingAverageType) -> MacdOscillatorMovingAverage:
        """The Oscillator of a Moving Average (OsMA) over the MACD."""
        ...
    @overload
    def MacdOscillatorMovingAverage(self, source: DataSeries, longCycle: int, shortCycle: int, signalPeriods: int, maType: MovingAverageType) -> MacdOscillatorMovingAverage:
        """The Oscillator of a Moving Average (OsMA) over the MACD."""
        ...
    @overload
    def MarketFacilitationIndex(self) -> MarketFacilitationIndex:
        """The indicator shows the effectiveness of price movement by computing the price movement per volume unit"""
        ...
    @overload
    def MarketFacilitationIndex(self, bars: Bars) -> MarketFacilitationIndex:
        """The indicator shows the effectiveness of price movement by computing the price movement per volume unit"""
        ...
    @overload
    def MassIndex(self, periods: int) -> MassIndex:
        """The Mass Index indicator is used to predict trend reversals."""
        ...
    @overload
    def MassIndex(self, bars: Bars, periods: int) -> MassIndex:
        """The Mass Index indicator is used to predict trend reversals."""
        ...
    @overload
    def MedianPrice(self) -> MedianPrice:
        """The Median indicator is the average of the high and the low."""
        ...
    @overload
    def MedianPrice(self, bars: Bars) -> MedianPrice:
        """The Median indicator is the average of the high and the low."""
        ...
    def MomentumOscillator(self, source: DataSeries, periods: int) -> MomentumOscillator:
        """The Momentum Oscillator measures the momentum of the price."""
        ...
    @overload
    def MoneyFlowIndex(self, periods: int) -> MoneyFlowIndex:
        """The Money Flow Index measures the strength of the money flow."""
        ...
    @overload
    def MoneyFlowIndex(self, bars: Bars, periods: int) -> MoneyFlowIndex:
        """The Money Flow Index measures the strength of the money flow."""
        ...
    def MovingAverage(self, source: DataSeries, periods: int, maType: MovingAverageType) -> MovingAverage:
        """Moving Average indicators are used to smooth data producing trend indicators."""
        ...
    def NegativeVolumeIndex(self, source: DataSeries) -> NegativeVolumeIndex:
        """The Negative Volume Index is a calculation of the percentage change in price on days when trading volume declines."""
        ...
    def OnBalanceVolume(self, source: DataSeries) -> OnBalanceVolume:
        """The On Balance Volume indicator relates price and volume."""
        ...
    def OscillatorMovingAverage(self, source: DataSeries, periods: int, maType: MovingAverageType) -> OscillatorMovingAverage:
        """The Oscillator of a Moving Average (OsMA) is a technical indicator that shows the difference between an oscillator and its moving average over a given period of time."""
        ...
    @overload
    def ParabolicSAR(self, minAf: float, maxAf: float) -> ParabolicSAR:
        """The Parabolic SAR indicator identifies potential reversals in the market direction"""
        ...
    @overload
    def ParabolicSAR(self, bars: Bars, minAf: float, maxAf: float) -> ParabolicSAR:
        """The Parabolic SAR indicator identifies potential reversals in the market direction"""
        ...
    def PolynomialRegressionChannels(self, degree: int, periods: int, standardDeviation: float, standardDeviation2: float) -> PolynomialRegressionChannels:
        """Polynomial Regression Channel (PRC) is an RTX Extension indicator that draws a best fit n-degree polynomial regression line through a recent period of data."""
        ...
    def PositiveVolumeIndex(self, source: DataSeries) -> PositiveVolumeIndex:
        """The Positive Volume Index is a calculation of the percentage change in price on days when trading volume increased."""
        ...
    def PriceOscillator(self, source: DataSeries, longCycle: int, shortCycle: int, maType: MovingAverageType) -> PriceOscillator:
        """The Price Oscillator calculates the difference between two moving averages."""
        ...
    def PriceROC(self, source: DataSeries, periods: int) -> PriceROC:
        """The Price Rate of Change indicator is the percentage change of the current price and the price N periods ago."""
        ...
    def PriceVolumeTrend(self, source: DataSeries) -> PriceVolumeTrend:
        """The Price Volume Trend indicator shows the relationship between price and volume."""
        ...
    def RainbowOscillator(self, source: DataSeries, levels: int, maType: MovingAverageType) -> RainbowOscillator:
        """The Rainbow Oscillator is a process of repetitive smoothing of simple moving averages resulting in a full spectrum of trends."""
        ...
    def RelativeStrengthIndex(self, source: DataSeries, periods: int) -> RelativeStrengthIndex:
        """The Relative Strength Index indicator measures turns in price by measuring turns in momentum."""
        ...
    @overload
    def RelativeVigorIndex(self, periods: int) -> RelativeVigorIndex:
        """The Relative Vigor Index is a momentum oscillator, measuring the strength of a trend."""
        ...
    @overload
    def RelativeVigorIndex(self, bars: Bars, periods: int) -> RelativeVigorIndex:
        """The Relative Vigor Index is a momentum oscillator, measuring the strength of a trend."""
        ...
    def SimpleMovingAverage(self, source: DataSeries, periods: int) -> SimpleMovingAverage:
        """The simple moving average smoothes the price data producing a trend indicator"""
        ...
    def StandardDeviation(self, source: DataSeries, periods: int, maType: MovingAverageType) -> StandardDeviation:
        """The Standard Deviation indicator shows volatility."""
        ...
    @overload
    def StochasticOscillator(self, kPeriods: int, kSlowing: int, dPeriods: int, maType: MovingAverageType) -> StochasticOscillator:
        """The Stochastic Oscillator is a momentum indicator that aims to show price reversals by comparing the closing price to the price range."""
        ...
    @overload
    def StochasticOscillator(self, kPeriods: int, kSlowing: int, dPeriods: int, maType: MovingAverageType, calculationType: StochasticCalculationType) -> StochasticOscillator:
        """The Stochastic Oscillator is a momentum indicator that aims to show price reversals by comparing the closing price to the price range."""
        ...
    @overload
    def StochasticOscillator(self, bars: Bars, kPeriods: int, kSlowing: int, dPeriods: int, maType: MovingAverageType) -> StochasticOscillator:
        """The Stochastic Oscillator is a momentum indicator that aims to show price reversals by comparing the closing price to the price range."""
        ...
    @overload
    def StochasticOscillator(self, bars: Bars, kPeriods: int, kSlowing: int, dPeriods: int, maType: MovingAverageType, calculationType: StochasticCalculationType) -> StochasticOscillator:
        """The Stochastic Oscillator is a momentum indicator that aims to show price reversals by comparing the closing price to the price range."""
        ...
    def Supertrend(self, periods: int, multiplier: float) -> Supertrend:
        """Supertrend is one of the most popular trend trading indicators"""
        ...
    @overload
    def SwingIndex(self, limitMoveValue: int) -> SwingIndex:
        """Returns the Swing Index indicator instance."""
        ...
    @overload
    def SwingIndex(self, bars: Bars, limitMoveValue: int) -> SwingIndex:
        """Returns the Swing Index indicator instance."""
        ...
    def TickVolume(self) -> TickVolume:
        """Tick Volume gives you the number of ticks for each bar."""
        ...
    def TimeSeriesMovingAverage(self, source: DataSeries, periods: int) -> TimeSeriesMovingAverage:
        """The Time Series Moving Average is a moving average based on linear regression"""
        ...
    def TradeVolumeIndex(self, source: DataSeries) -> TradeVolumeIndex:
        """Trade Volume Index indicator measures the amount of money flowing in and out of an asset."""
        ...
    def TriangularMovingAverage(self, source: DataSeries, periods: int) -> TriangularMovingAverage:
        """The Triangular Moving Average is averaged twice to produce a double smoothed trend indicator"""
        ...
    def TripleExponentialMovingAverage(self, source: DataSeries, periods: int) -> TripleExponentialMovingAverage:
        """The Triple Exponential Moving Average (TEMA) is a technical indicator that provides a smoothed representation of price data by applying three levels of exponential smoothing"""
        ...
    def Trix(self, source: DataSeries, periods: int) -> Trix:
        """The Trix indicator shows the slope of a triple-smoothed exponential moving average."""
        ...
    @overload
    def TrueRange(self) -> TrueRange:
        """Initializes the True Range indicator."""
        ...
    @overload
    def TrueRange(self, bars: Bars) -> TrueRange:
        """Initializes the True Range indicator."""
        ...
    @overload
    def TypicalPrice(self) -> TypicalPrice:
        """The Typical Price indicator is the average of the high, low, and closing prices."""
        ...
    @overload
    def TypicalPrice(self, bars: Bars) -> TypicalPrice:
        """The Typical Price indicator is the average of the high, low, and closing prices."""
        ...
    @overload
    def UltimateOscillator(self, cycle1: int, cycle2: int, cycle3: int) -> UltimateOscillator:
        """Returns the Ultimate Oscillator indicator instance."""
        ...
    @overload
    def UltimateOscillator(self, bars: Bars, cycle1: int, cycle2: int, cycle3: int) -> UltimateOscillator:
        """Returns the Ultimate Oscillator indicator instance."""
        ...
    @overload
    def VariableIndexDynamicAverage(self, source: DataSeries, cmoPeriods: int, smoothPeriods: int) -> VariableIndexDynamicAverage:
        """The Variable Index Dynamic Average (VIDYA) indicator is a type of moving average that dynamically adjusts its smoothing period based on market volatility."""
        ...
    @overload
    def VariableIndexDynamicAverage(self, cmoPeriods: int, smoothPeriods: int) -> VariableIndexDynamicAverage:
        """The Variable Index Dynamic Average (VIDYA) indicator is a type of moving average that dynamically adjusts its smoothing period based on market volatility."""
        ...
    def VerticalHorizontalFilter(self, source: DataSeries, periods: int) -> VerticalHorizontalFilter:
        """The Vertical Horizontal Filter indicator measures the level of trend activity."""
        ...
    @overload
    def VolumeOscillator(self, shortTerm: int, longTerm: int) -> VolumeOscillator:
        """The Volume Oscillator indicator is the difference between two moving averages."""
        ...
    @overload
    def VolumeOscillator(self, bars: Bars, shortTerm: int, longTerm: int) -> VolumeOscillator:
        """The Volume Oscillator indicator is the difference between two moving averages."""
        ...
    @overload
    def VolumeROC(self, periods: int) -> VolumeROC:
        """Volume Rate of Change Indicator measures the rate of change of the tick volume."""
        ...
    @overload
    def VolumeROC(self, bars: Bars, periods: int) -> VolumeROC:
        """Volume Rate of Change Indicator measures the rate of change of the tick volume."""
        ...
    @overload
    def WeightedClose(self) -> WeightedClose:
        """The WeightedClose indicator is an average of each day's price with extra weight given to the closing price."""
        ...
    @overload
    def WeightedClose(self, bars: Bars) -> WeightedClose:
        """The WeightedClose indicator is an average of each day's price with extra weight given to the closing price."""
        ...
    def WeightedMovingAverage(self, source: DataSeries, periods: int) -> WeightedMovingAverage:
        """The Weighted Moving Average smoothes the price data producing a trend indicator."""
        ...
    def WellesWilderSmoothing(self, source: DataSeries, periods: int) -> WellesWilderSmoothing:
        """Welles Wilder Smoothing eliminates noise to identify the trend."""
        ...
    @overload
    def WilliamsAccumulationDistribution(self) -> WilliamsAccumulationDistribution:
        """The Williams Accumulation Distribution indicator shows bullish or bearish trends."""
        ...
    @overload
    def WilliamsAccumulationDistribution(self, bars: Bars) -> WilliamsAccumulationDistribution:
        """The Williams Accumulation Distribution indicator shows bullish or bearish trends."""
        ...
    @overload
    def WilliamsPctR(self, periods: int) -> WilliamsPctR:
        """The Williams Percent R indicator is a momentum indicator measuring overbought and oversold levels."""
        ...
    @overload
    def WilliamsPctR(self, bars: Bars, periods: int) -> WilliamsPctR:
        """The Williams Percent R indicator is a momentum indicator measuring overbought and oversold levels."""
        ...

class INotifications:
    """It is an interface that represents all Notifications."""
    @overload
    def PlaySound(self, fileName: str) -> None:
        """Plays a notification sound."""
        ...
    @overload
    def PlaySound(self, soundType: SoundType) -> None:
        """Plays the specified SoundType."""
        ...
    def SendEmail(self, from_: str, to: str, subject: str, text: str) -> None:
        """Sends a notification email message."""
        ...
    def ShowPopup(self, caption: str, message: str, initialState: PopupNotificationState) -> PopupNotification:
        """Shows a popup notification."""
        ...

class IReadonlyList:
    """Represents a read only collection of a specified type"""
    Count: int
    """The total number of elements contained in the collection"""
    Item: T
    """Represents the item contained in the collection at a specific index"""

class IServer:
    """Server related information."""
    IsConnected: bool
    """Indicates current connection status with the server"""
    Time: DateTime
    """Returns the server time."""
    TimeInUtc: DateTime
    """Returns the server time in UTC."""
    Connected: Event[Action]
    """Event raised when successfully connected with the server"""
    Disconnected: Event[Action]
    """Disconnected - Event raised when connection with the server is lost"""

class IchimokuKinkoHyo(StandardIndicator):
    """Ichimoku Kinko Hyo Indicator."""
    ChikouSpan: IndicatorDataSeries
    """It is used as a support-resistance aid."""
    KijunSen: IndicatorDataSeries
    """This is a confirmation line, a support-resistance line, and can be used as a trailing stop line."""
    SenkouSpanA: IndicatorDataSeries
    """Leading span 1, this line forms one edge of the kumo, or cloud. If the price is above the Senkou span, the top line serves as the first support level while the bottom line serves as the second support level."""
    SenkouSpanB: IndicatorDataSeries
    """Leading span 2, this line forms the other edge of the kumo."""
    TenkanSen: IndicatorDataSeries
    """It is primarily used as a signal line and a minor support-resistance line."""

class Image(ControlBase):
    """Represents the image chart control."""
    def __init__(self) -> None: ...
    Source: object
    """Gets or sets the source of the image."""
    Stretch: Stretch
    """Gets or sets a value that describes how an Image should be stretched to fill the destination rectangle."""
    StretchDirection: StretchDirection
    """Gets or sets a value that indicates how the image is scaled."""

class Indicator(Algo):
    """Base class for Indicators."""
    def AddToChart(self) -> ChartIndicator:
        """Adds current indicator to chart if not added yet."""
        ...
    def Calculate(self, index: int) -> None:
        """Calculate the value(s) of indicator for the given index."""
        ...
    def CancelPendingOrder(self, pendingOrder: PendingOrder) -> TradeResult:
        """Cancel a Pending Order"""
        ...
    def CancelPendingOrderAsync(self, pendingOrder: PendingOrder, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Cancel a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ClosePosition(self, position: Position) -> TradeResult:
        """Close a position"""
        ...
    @overload
    def ClosePosition(self, position: Position, volume: int) -> TradeResult:
        """Close a position"""
        ...
    @overload
    def ClosePosition(self, position: Position, volume: float) -> TradeResult:
        """Close a position"""
        ...
    @overload
    def ClosePositionAsync(self, position: Position, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Close a position in asynchronous execution mode"""
        ...
    @overload
    def ClosePositionAsync(self, position: Position, volume: int, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Close a position in asynchronous execution mode"""
        ...
    @overload
    def ClosePositionAsync(self, position: Position, volume: float, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Close a position in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketOrder(self, tradeType: TradeType, symbolName: str, volume: float) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketOrder(self, tradeType: TradeType, symbolName: str, volume: float, label: str) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketOrder(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLossPips: float | None, takeProfitPips: float | None) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketOrder(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketOrder(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketOrder(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLossPips: float | None, takeProfitPips: float | None, comment: str) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketOrder(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketOrder(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketOrder(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLossPips: float | None, takeProfitPips: float | None, comment: str, hasTrailingStop: bool) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketOrder(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, hasTrailingStop: bool) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketOrder(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketOrder(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLossPips: float | None, takeProfitPips: float | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketOrder(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketOrder(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, label: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLossPips: float | None, takeProfitPips: float | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLossPips: float | None, takeProfitPips: float | None, comment: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLossPips: float | None, takeProfitPips: float | None, comment: str, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLossPips: float | None, takeProfitPips: float | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketRangeOrder(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketRangeOrder(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketRangeOrder(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLossPips: float | None, takeProfitPips: float | None) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketRangeOrder(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketRangeOrder(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketRangeOrder(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLossPips: float | None, takeProfitPips: float | None, comment: str) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketRangeOrder(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketRangeOrder(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketRangeOrder(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLossPips: float | None, takeProfitPips: float | None, comment: str, hasTrailingStop: bool) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketRangeOrder(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, hasTrailingStop: bool) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketRangeOrder(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketRangeOrder(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLossPips: float | None, takeProfitPips: float | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketRangeOrder(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketRangeOrder(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketRangeOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketRangeOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketRangeOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLossPips: float | None, takeProfitPips: float | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketRangeOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketRangeOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketRangeOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLossPips: float | None, takeProfitPips: float | None, comment: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketRangeOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketRangeOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketRangeOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLossPips: float | None, takeProfitPips: float | None, comment: str, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketRangeOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketRangeOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketRangeOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLossPips: float | None, takeProfitPips: float | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketRangeOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketRangeOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    def Initialize(self) -> None:
        """Custom initialization for the Indicator. This method is invoked when an indicator is launched."""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expirationTime: DateTime | None) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expirationTime: DateTime | None, volume: int) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: int) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: int, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: int) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: int, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expirationTime: DateTime | None, volume: float) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None, stopLimitRangePips: float | None) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None, stopLimitRangePips: float | None) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None, stopLimitRangePips: float | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None, stopLimitRangePips: float | None) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None, stopLimitRangePips: float | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expirationTime: DateTime | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expirationTime: DateTime | None, volume: int, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: int, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: int, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: int, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: int, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expirationTime: DateTime | None, volume: float, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None, stopLimitRangePips: float | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None, stopLimitRangePips: float | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None, stopLimitRangePips: float | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None, stopLimitRangePips: float | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None, stopLimitRangePips: float | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPosition(self, position: Position, volume: float) -> TradeResult:
        """Modify the volume of a position"""
        ...
    @overload
    def ModifyPosition(self, position: Position, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None) -> TradeResult:
        """Modify the protection of a position"""
        ...
    @overload
    def ModifyPosition(self, position: Position, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections) -> TradeResult:
        """Modify the protection of a position"""
        ...
    @overload
    def ModifyPosition(self, position: Position, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections) -> TradeResult:
        """Modify the protection of a position"""
        ...
    @overload
    def ModifyPosition(self, position: Position, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify the protection of a position"""
        ...
    @overload
    def ModifyPosition(self, position: Position, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify the protection of a position"""
        ...
    @overload
    def ModifyPosition(self, position: Position, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, hasTrailingStop: bool) -> TradeResult:
        """Modify the protection of a position"""
        ...
    @overload
    def ModifyPosition(self, position: Position, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, hasTrailingStop: bool) -> TradeResult:
        """Modify the protection of a position"""
        ...
    @overload
    def ModifyPosition(self, position: Position, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, hasTrailingStop: bool) -> TradeResult:
        """Modify the protection of a position"""
        ...
    @overload
    def ModifyPosition(self, position: Position, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify the protection of a position"""
        ...
    @overload
    def ModifyPosition(self, position: Position, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify the protection of a position"""
        ...
    @overload
    def ModifyPosition(self, position: Position, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Modify the protection of a position"""
        ...
    @overload
    def ModifyPosition(self, position: Position, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Modify the protection of a position"""
        ...
    @overload
    def ModifyPosition(self, position: Position, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Modify the protection of a position"""
        ...
    @overload
    def ModifyPosition(self, position: Position, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify the protection of a position"""
        ...
    @overload
    def ModifyPosition(self, position: Position, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify the protection of a position"""
        ...
    @overload
    def ModifyPositionAsync(self, position: Position, volume: float, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify Position in asynchronous execution mode"""
        ...
    @overload
    def ModifyPositionAsync(self, position: Position, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify Position in asynchronous execution mode"""
        ...
    @overload
    def ModifyPositionAsync(self, position: Position, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify Position in asynchronous execution mode"""
        ...
    @overload
    def ModifyPositionAsync(self, position: Position, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify Position in asynchronous execution mode"""
        ...
    @overload
    def ModifyPositionAsync(self, position: Position, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify Position in asynchronous execution mode"""
        ...
    @overload
    def ModifyPositionAsync(self, position: Position, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify Position in asynchronous execution mode"""
        ...
    @overload
    def ModifyPositionAsync(self, position: Position, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify Position in asynchronous execution mode"""
        ...
    @overload
    def ModifyPositionAsync(self, position: Position, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify Position in asynchronous execution mode"""
        ...
    @overload
    def ModifyPositionAsync(self, position: Position, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify Position in asynchronous execution mode"""
        ...
    @overload
    def ModifyPositionAsync(self, position: Position, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify Position in asynchronous execution mode"""
        ...
    @overload
    def ModifyPositionAsync(self, position: Position, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify Position in asynchronous execution mode"""
        ...
    @overload
    def ModifyPositionAsync(self, position: Position, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify Position in asynchronous execution mode"""
        ...
    @overload
    def ModifyPositionAsync(self, position: Position, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify Position in asynchronous execution mode"""
        ...
    @overload
    def ModifyPositionAsync(self, position: Position, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify Position in asynchronous execution mode"""
        ...
    @overload
    def ModifyPositionAsync(self, position: Position, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify Position in asynchronous execution mode"""
        ...
    @overload
    def ModifyPositionAsync(self, position: Position, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify Position in asynchronous execution mode"""
        ...
    def OnDestroy(self) -> None:
        """Called when Indicator is destroyed."""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, hasTrailingStop: bool) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, hasTrailingStop: bool) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, hasTrailingStop: bool) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def ReversePosition(self, position: Position) -> TradeResult:
        """Modify the direction of trade at position"""
        ...
    @overload
    def ReversePosition(self, position: Position, volume: float) -> TradeResult:
        """Modify the direction of trade and volume of a position"""
        ...
    @overload
    def ReversePositionAsync(self, position: Position, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Reverses Position in asynchronous execution mode"""
        ...
    @overload
    def ReversePositionAsync(self, position: Position, volume: float, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Reverses Position in asynchronous execution mode"""
        ...
    @overload
    def SetBarColor(self, barOutput: IndicatorBarOutput, barIndex: int, outlineColor: Color) -> None:
        """Sets appearance of an indicator bar output from startIndex to last index."""
        ...
    @overload
    def SetBarColor(self, barOutput: IndicatorBarOutput, barIndex: int, outlineColor: Color, fillColor: Color) -> None:
        """Sets appearance of an indicator bar output from startIndex to startIndex + count."""
        ...
    @overload
    def SetBarColor(self, barOutput: IndicatorBarOutput, barIndex: int, outlineColor: Color, fillColor: Color, volumeColor: Color) -> None:
        """Sets appearance of an indicator bar output from startIndex to last index."""
        ...
    @overload
    def SetLineAppearance(self, lineOutput: IndicatorLineOutput, startIndex: int, color: Color) -> None:
        """Sets appearance of an indicator line output from startIndex to last index."""
        ...
    @overload
    def SetLineAppearance(self, lineOutput: IndicatorLineOutput, startIndex: int, color: Color, thickness: int) -> None:
        """Sets appearance of an indicator line output from startIndex to last index."""
        ...
    @overload
    def SetLineAppearance(self, lineOutput: IndicatorLineOutput, startIndex: int, color: Color, thickness: int, lineStyle: LineStyle) -> None:
        """Sets appearance of an indicator line output from startIndex to last index."""
        ...
    @overload
    def SetLineAppearance(self, lineOutput: IndicatorLineOutput, startIndex: int, count: int, color: Color) -> None:
        """Sets appearance of an indicator line output from startIndex to startIndex + count."""
        ...
    @overload
    def SetLineAppearance(self, lineOutput: IndicatorLineOutput, startIndex: int, count: int, color: Color, thickness: int) -> None:
        """Sets appearance of an indicator line output from startIndex to startIndex + count."""
        ...
    @overload
    def SetLineAppearance(self, lineOutput: IndicatorLineOutput, startIndex: int, count: int, color: Color, thickness: int, lineStyle: LineStyle) -> None:
        """Sets appearance of an indicator line output from startIndex to startIndex + count."""
        ...
    Account: IAccount
    """Contains information of the current account."""
    IndicatorArea: IndicatorArea
    """Defines the area where the indicator is placed."""
    IsLastBar: bool
    """Returns true, if Calculate is invoked for the last bar"""
    LastResult: TradeResult
    """The latest trade result"""
    Permissions: Permissions
    """Contains all Permissions information"""

class IndicatorArea(ChartArea):
    """Represents the area where the Indicator is placed."""
    ...

class IndicatorAreaAddedEventArgs(IndicatorAreaEventArgs):
    """Provides data for the indicator area adding event."""
    ...

class IndicatorAreaEventArgs:
    """The arguments for the indicator area event."""
    Area: IndicatorArea
    """Gets the area."""
    Chart: Chart
    """Gets the chart."""

class IndicatorAreaRemovedEventArgs(IndicatorAreaEventArgs):
    """Provides data for the indicator area removing event."""
    ...

class IndicatorAttribute:
    """Indicator Attribute. Applies metadata to enable the indicator plot."""
    def __init__(self) -> None: ...
    AccessRights: AccessRights
    """Gets or sets the access rights required for Indicator."""
    AdditionalInfoUrl: str
    """Gets or sets additional info url."""
    AutoRescale: bool
    """Indicates whether this instance automatically rescales the chart or not. Default value is true."""
    IsOverlay: bool
    """Indicates whether this instance is overlayed on the chart or plotted on a separate indicator panel"""
    IsPercentage: bool
    """Gets or sets whether the indicator is a percentage indicator. If one or more percentage indicators are added to the same panel, they will share the same scale. The default value is false ."""
    Name: str
    """The name of the Indicator."""
    ScalePrecision: int
    """The price scale precision."""
    TimeZone: str
    """Gets or sets the chart timezone of the displayed indicator."""

class IndicatorBarOutput:
    """The interface representing an indicator bars output. Provides properties that allow for accessing various information about a bars output."""
    AreaChartFillColor: Color
    """Gets or sets the color of the area chart."""
    BearFillColor: Color
    """Gets or sets the color of the bear candle fill."""
    BearOutlineColor: Color
    """Gets or sets the color of the bear candle or bar outline."""
    BullFillColor: Color
    """Gets or sets the color of the bull candle fill."""
    BullOutlineColor: Color
    """Gets or sets the color of the bull candle or bar outline."""
    ChartType: ChartType
    """Gets or sets the type of the chart - Bar, Candlesticks, Line or Dots chart."""
    DotChartColor: Color
    """Gets or sets the color of the dot chart."""
    IsVisible: bool
    """Gets or sets the visibility of a line."""
    Name: str
    """Gets the name of a line."""
    TickVolumeColor: Color
    """Gets or sets the color of the tick volume bars."""

class IndicatorBars:
    """The interface representing an indicator bars that are displayed as an output."""
    ClosePrices: DataSeries
    """Gets the Close price bars data."""
    Count: int
    """Gets the number of bars."""
    HighPrices: DataSeries
    """Gets the High price bars data."""
    Item: OhlcvBar
    """Gets or sets a bar based on it is index."""
    LowPrices: DataSeries
    """Gets the Low price bars data."""
    OpenPrices: DataSeries
    """Gets the Open price bars data."""
    Output: IndicatorBarOutput
    """Gets the indicator output."""
    TickVolumes: DataSeries
    """Gets the Tick volumes data."""

class IndicatorDataSeries(DataSeries):
    """Represents a mutable array of values. An extension of DataSeries used to represent indicator values."""
    Item: float
    """Gets or sets the value at the specified index."""
    LineOutput: IndicatorLineOutput
    """Gets the indicator line output."""

class IndicatorLineOutput:
    """The interface representing an indicator line. Provides properties that allow for accessing various information about a line."""
    Color: Color
    """Gets or sets the Color of a line."""
    IsVisible: bool
    """Gets or sets the visibility of a line."""
    LineStyle: LineStyle
    """Gets or sets the LineStyle of a line."""
    Name: str
    """Gets the name of a line."""
    PlotType: PlotType
    """Gets the PlotType of a line."""
    StickToBottom: bool
    """Gets or sets whether line should stick to bottom of it's panel or not similar to Tick Volume (Default: false)."""
    Thickness: float
    """Gets or sets the thickness of a line."""

class IndicatorType(AlgoType):
    """Represents an indicator algorithm type."""
    Bars: IReadonlyList[IndicatorTypeBarOutput]
    """Gets collection of indicator bar outputs."""
    Lines: IReadonlyList[IndicatorTypeLineOutput]
    """Gets collection of indicator line outputs."""
    Parameters: IReadonlyList[AlgoParameter]
    """Gets collection of indicator parameters."""

class IndicatorTypeBarOutput:
    """Represents an indicator type bar output."""
    DefaultAreaChartFillColor: Color
    """Gets default color of the area chart."""
    DefaultBearFillColor: Color
    """Gets default bear fill color."""
    DefaultBearOutlineColor: Color
    """Gets default bear outline color."""
    DefaultBullFillColor: Color
    """Gets default bull fill color."""
    DefaultBullOutlineColor: Color
    """Gets default bull outline color."""
    DefaultChartType: ChartType
    """Gets default chart type."""
    DefaultDotChartColor: Color
    """Gets default color of the dot chart."""
    DefaultTickVolumeColor: Color
    """Gets default tick volume color."""
    Name: str
    """Gets output name."""

class IndicatorTypeLineOutput:
    """Represents an indicator type line output."""
    DefaultColor: Color
    """Gets default color."""
    DefaultLineStyle: LineStyle
    """Gets default line style."""
    DefaultPlotType: PlotType
    """Gets the PlotType ."""
    DefaultThickness: float
    """Gets default thickness."""
    Name: str
    """Gets output name."""

class InstallationError:
    """Represents the predefined algo installation errors."""
    Forbidden: InstallationError
    InvalidFile: InstallationError
    FileNotFound: InstallationError
    DownloadError: InstallationError
    Canceled: InstallationError
    Unknown: InstallationError

class InstallationOperation:
    """Provides access to the properties describing an asynchronous algo installation operation."""
    IsExecuting: bool
    """True if installation operation is being executed, false if it completed."""
    Result: InstallationResult
    """The result of installation operation."""

class InstallationPermission(Permission):
    """Algo Installation Permission"""
    ...

class InstallationResult:
    """The result of an algo installation."""
    Error: InstallationError | None
    """Returns algo installation error if algo installation failed otherwise null."""
    Succeeded: bool
    """Returns True if algo installation succeeded otherwise false."""

class KaufmanAdaptiveMovingAverage(MovingAverage, StandardIndicator):
    """The Kaufman's Adaptive Moving Average (KAMA) indicator is a type of adaptive moving average designed to adjust its smoothing factor based on market volatility"""
    ...

class KeltnerChannels(StandardIndicator):
    """The Keltner Channels are volatility-based envelopes set above and below an exponential moving average."""
    Bottom: IndicatorDataSeries
    """Moving Average - ATR * BandDistance"""
    Main: IndicatorDataSeries
    """Moving Average Line"""
    Top: IndicatorDataSeries
    """Moving Average + ATR * BandDistance"""

class Key:
    """Specifies the possible key values on a keyboard."""
    None: Key
    Cancel: Key
    Back: Key
    Tab: Key
    LineFeed: Key
    Clear: Key
    Enter: Key
    Pause: Key
    CapsLock: Key
    KanaMode: Key
    JunjaMode: Key
    FinalMode: Key
    HanjaMode: Key
    Escape: Key
    ImeConvert: Key
    ImeNonConvert: Key
    ImeAccept: Key
    ImeModeChange: Key
    Space: Key
    PageUp: Key
    PageDown: Key
    End: Key
    Home: Key
    Left: Key
    Up: Key
    Right: Key
    Down: Key
    Select: Key
    Print: Key
    Execute: Key
    PrintScreen: Key
    Insert: Key
    Delete: Key
    Help: Key
    D0: Key
    D1: Key
    D2: Key
    D3: Key
    D4: Key
    D5: Key
    D6: Key
    D7: Key
    D8: Key
    D9: Key
    A: Key
    B: Key
    C: Key
    D: Key
    E: Key
    F: Key
    G: Key
    H: Key
    I: Key
    J: Key
    K: Key
    L: Key
    M: Key
    N: Key
    O: Key
    P: Key
    Q: Key
    R: Key
    S: Key
    T: Key
    U: Key
    V: Key
    W: Key
    X: Key
    Y: Key
    Z: Key
    LWin: Key
    RWin: Key
    Apps: Key
    Sleep: Key
    NumPad0: Key
    NumPad1: Key
    NumPad2: Key
    NumPad3: Key
    NumPad4: Key
    NumPad5: Key
    NumPad6: Key
    NumPad7: Key
    NumPad8: Key
    NumPad9: Key
    Multiply: Key
    Add: Key
    Separator: Key
    Subtract: Key
    Decimal: Key
    Divide: Key
    F1: Key
    F2: Key
    F3: Key
    F4: Key
    F5: Key
    F6: Key
    F7: Key
    F8: Key
    F9: Key
    F10: Key
    F11: Key
    F12: Key
    F13: Key
    F14: Key
    F15: Key
    F16: Key
    F17: Key
    F18: Key
    F19: Key
    F20: Key
    F21: Key
    F22: Key
    F23: Key
    F24: Key
    NumLock: Key
    Scroll: Key
    LeftShift: Key
    RightShift: Key
    LeftCtrl: Key
    RightCtrl: Key
    LeftAlt: Key
    RightAlt: Key
    BrowserBack: Key
    BrowserForward: Key
    BrowserRefresh: Key
    BrowserStop: Key
    BrowserSearch: Key
    BrowserFavorites: Key
    BrowserHome: Key
    VolumeMute: Key
    VolumeDown: Key
    VolumeUp: Key
    MediaNextTrack: Key
    MediaPreviousTrack: Key
    MediaStop: Key
    MediaPlayPause: Key
    LaunchMail: Key
    SelectMedia: Key
    LaunchApplication1: Key
    LaunchApplication2: Key
    Oem1: Key
    OemPlus: Key
    OemComma: Key
    OemMinus: Key
    OemPeriod: Key
    Oem2: Key
    Oem3: Key
    AbntC1: Key
    AbntC2: Key
    Oem4: Key
    Oem5: Key
    Oem6: Key
    Oem7: Key
    Oem8: Key
    Oem102: Key
    ImeProcessed: Key
    System: Key
    OemAttn: Key
    OemFinish: Key
    OemCopy: Key
    OemAuto: Key
    OemEnlw: Key
    OemBackTab: Key
    Attn: Key
    CrSel: Key
    ExSel: Key
    EraseEof: Key
    Play: Key
    Zoom: Key
    NoName: Key
    Pa1: Key
    OemClear: Key
    DeadCharProcessed: Key

class Language:
    """Represents the application language."""
    CultureName: str
    """Gets the culture name of the language."""
    TwoLetterCode: str
    """Gets the two-letter code of the language."""

class LanguageChangedEventArgs:
    """Provides data for the language changed event."""
    Language: Language
    """Gets the language."""

class LevelsAttribute:
    """Levels Attribute. Applies metadata to enable the plot of level lines."""
    def __init__(self, levels: list[float]) -> None: ...
    Levels: list[float]
    """The array of price values that are ploted as level lines"""

class LeverageTier:
    """Tier of dynamic leverage."""
    Leverage: float
    """Leverage of dynamic leverage tier."""
    Volume: float
    """Volume of dynamic leverage tier."""

class Line(Shape):
    """Represents the line shape."""
    def __init__(self) -> None: ...
    X1: float
    """Gets or sets x-axis point 1 data."""
    X2: float
    """Gets or sets the x-axis point 2 data."""
    Y1: float
    """Gets or sets the y-axis point 2 data."""
    Y2: float
    """Gets or sets the y-axis point 2 data."""

class LineStackingStrategy:
    """Describes a mechanism by which a line box is determined for each line."""
    BlockLineHeight: LineStackingStrategy
    MaxHeight: LineStackingStrategy

class LineStyle:
    """An enumeration of different stroke styles used to render lines."""
    Solid: LineStyle
    Dots: LineStyle
    DotsRare: LineStyle
    DotsVeryRare: LineStyle
    LinesDots: LineStyle
    Lines: LineStyle

class LinearRegressionForecast(StandardIndicator):
    """Linear Regression Forecast is one of the indicators calculated by the Linear Regression approach."""
    Result: IndicatorDataSeries
    """The Result Series of the Linear Regression Forecast Indicator"""

class LinearRegressionIntercept(StandardIndicator):
    """Linear Regression Intercept is one of the indicators calculated by the Linear Regression approach."""
    Result: IndicatorDataSeries
    """The Result Series of the Linear Regression Intercept Indicator"""

class LinearRegressionRSquared(StandardIndicator):
    """The Linear Regression R Squared is used to confirm the strength of the market trend."""
    Result: IndicatorDataSeries
    """The Result Series of the Linear Regression R Squared indicator."""

class LinearRegressionSlope(StandardIndicator):
    """The calculation of the Linear Regression Slope Indicator."""
    Result: IndicatorDataSeries
    """The resulting time series of the calculation of the Linear Regression Slope indicator."""

class LinkedChartGroup:
    """Represents the predefined chart linked groups."""
    None: LinkedChartGroup
    A: LinkedChartGroup
    B: LinkedChartGroup
    C: LinkedChartGroup
    D: LinkedChartGroup
    E: LinkedChartGroup
    F: LinkedChartGroup
    G: LinkedChartGroup
    H: LinkedChartGroup

class LocalStorage:
    """Represents the local storage API."""
    def Flush(self, localStorageScope: LocalStorageScope) -> None:
        """Saves all data to the disk. When using local storage, data is automatically saved every minute. Use this method if you want to save data without delays."""
        ...
    @overload
    def GetObject(self, key: str) -> T:
        """Gets an object from local storage. This method will search all available scopes (Instance -> Type -> Device) and stops on first found value."""
        ...
    @overload
    def GetObject(self, key: str, localStorageScope: LocalStorageScope) -> T:
        """Gets an object from local storage."""
        ...
    @overload
    def GetString(self, key: str) -> str:
        """Gets a string value from local storage. This method will search all available scopes (Instance -> Type -> Device) and stops on first found value."""
        ...
    @overload
    def GetString(self, key: str, localStorageScope: LocalStorageScope) -> str:
        """Gets a string value from local storage."""
        ...
    def Reload(self, localStorageScope: LocalStorageScope) -> None:
        """Reloads all values from the disk. When calling this method, unsaved pending changes may be lost. To avoid losing information, call the Flush() method first."""
        ...
    @overload
    def Remove(self, key: str) -> None:
        """Removes an element from local storage. This method will search all available scopes (Instance -> Type -> Device) and stops on first found value."""
        ...
    @overload
    def Remove(self, key: str, localStorageScope: LocalStorageScope) -> None:
        """Removes an element from local storage."""
        ...
    @overload
    def SetObject(self, key: str, obj: object) -> None:
        """Saves an object to local storage. The storage scope is LocalStorageScope.Instance."""
        ...
    @overload
    def SetObject(self, key: str, obj: object, localStorageScope: LocalStorageScope) -> None:
        """Saves an object to local storage."""
        ...
    @overload
    def SetString(self, key: str, value: str) -> None:
        """Saves a string value to local storage. The storage scope is LocalStorageScope.Instance."""
        ...
    @overload
    def SetString(self, key: str, value: str, localStorageScope: LocalStorageScope) -> None:
        """Saves a string value to local storage."""
        ...

class LocalStorageException:
    """Represents errors that occur during local storage operations. This exception will be passed to cBot / indicator OnException method."""
    ...

class LocalStorageScope:
    """Defines the local storage scope."""
    Instance: LocalStorageScope
    Type: LocalStorageScope
    Device: LocalStorageScope

class MacdCrossOver(StandardIndicator):
    """Calculates the MACD (Moving Average Convergence/Divergence) indicator."""
    Histogram: IndicatorDataSeries
    """Gets the Histogram (bar graph)."""
    MACD: IndicatorDataSeries
    """Gets the main MACD line (blue line)."""
    Signal: IndicatorDataSeries
    """Gets the Signal line of MACD (red line)."""

class MacdHistogram(StandardIndicator):
    """The calculation of the MACD Histogram."""
    Histogram: IndicatorDataSeries
    """The histogram (bar graph). The difference between the short and long cycles."""
    Signal: IndicatorDataSeries
    """The signal (red line). The exponential moving average of the MACD histogram."""

class MacdOscillatorMovingAverage(OscillatorMovingAverage, StandardIndicator):
    """The calculation of the Oscillator of a Moving Average over MACD."""
    ...

class MainMenu:
    """Provides plugins access to main menu API."""
    def AddBottomItem(self, name: str, icon: SvgIcon) -> MainMenuBottomCustomItem:
        """Adds a new bottom custom item to main menu."""
        ...
    def AddItem(self, name: str, icon: SvgIcon) -> MainMenuOwnCustomItem:
        """Adds a new custom item to main menu."""
        ...
    def ContainsBottomItem(self, name: str) -> bool:
        """Allows checking if a bottom custom item exist with passed name or not."""
        ...
    def ContainsItem(self, name: str) -> bool:
        """Allows checking if a custom item exist with passed name or not."""
        ...
    def GetBuiltInItem(self, type: MainMenuBuiltInItemType) -> MainMenuBuiltInItem:
        """Returns a built-in item by type."""
        ...
    def RemoveBottomItem(self, item: MainMenuBottomCustomItem) -> bool:
        """Removes a previously added bottom item from main menu."""
        ...
    def RemoveItem(self, item: MainMenuOwnCustomItem) -> bool:
        """Removes a previously added custom item from main menu."""
        ...
    @overload
    def TryChangeSelectedItem(self, builtInItem: MainMenuBuiltInItem) -> bool:
        """Tries to change selected item to passed built-in item."""
        ...
    @overload
    def TryChangeSelectedItem(self, customItem: MainMenuOwnCustomItem) -> bool:
        """Tries to change selected item to passed custom item."""
        ...
    BuiltInItems: IReadonlyList[MainMenuBuiltInItem]
    """Gets a collection of built-in items."""
    IsExpanded: bool
    """Gets or sets main menu expanded state."""
    SelectedItem: MainMenuItem
    """Gets or sets main menu selected item."""
    SelectedItemChanged: Event[Callable[[MainMenuSelectedItemChangedEventArgs], None]]
    """Occurs when main menu selected item changes."""

class MainMenuBottomCustomItem(MainMenuBottomItem):
    """Represents a bottom custom item in main menu."""
    Handler: Action
    """Get / set handler of bottom item."""
    Name: str
    """Gets name of item."""

class MainMenuBottomItem:
    """Represents a bottom item in main menu."""
    ...

class MainMenuBuiltInItem(MainMenuItem):
    """Represents a built-in item in main menu."""
    Type: MainMenuBuiltInItemType
    """Gets type of built-in item."""

class MainMenuBuiltInItemType:
    """Represents main menu section built-in item types."""
    Trade: MainMenuBuiltInItemType
    Copy: MainMenuBuiltInItemType
    Algo: MainMenuBuiltInItemType
    Analyze: MainMenuBuiltInItemType
    Invite: MainMenuBuiltInItemType

class MainMenuCustomItem(MainMenuItem):
    """Represents a custom item in main menu."""
    Name: str
    """Gets name of item."""

class MainMenuItem:
    """Represents a item in main menu."""
    ...

class MainMenuOwnCustomItem(MainMenuCustomItem, MainMenuItem):
    """Represents a custom item in main menu which is owned / added by plugin."""
    Child: ControlBase
    """Get / set content of item."""

class MainMenuSelectedItemChangedEventArgs:
    """Provides data for the main menu selected item changed event."""
    NewItem: MainMenuItem
    """Gets new selected item."""
    OldItem: MainMenuItem
    """Gets old selected item."""

class MarketData:
    """Provide access to charts data (bars and ticks) and to the Depth of Market data."""
    @overload
    def GetBars(self, timeFrame: TimeFrame) -> Bars:
        """Gets the bars for the specific timeframe."""
        ...
    @overload
    def GetBars(self, timeFrame: TimeFrame, symbolName: str) -> Bars:
        """Gets the chart bars for the specific timeframe for the specific symbol."""
        ...
    @overload
    def GetBarsAsync(self, timeFrame: TimeFrame, callback: Callable[[Bars], None]) -> None:
        """The asynchronous method to get the bars for the specific timeframe for the specific symbol."""
        ...
    @overload
    def GetBarsAsync(self, timeFrame: TimeFrame, symbolName: str, callback: Callable[[Bars], None]) -> None:
        """The asynchronous method to get the specific bars for the specific timeframe for the specific symbol."""
        ...
    def GetMarketDepth(self, symbolName: str) -> MarketDepth:
        """Gets the Depth of Market for the specific symbol."""
        ...
    @overload
    def GetTicks(self) -> Ticks:
        """Gets the Tick data."""
        ...
    @overload
    def GetTicks(self, symbolName: str) -> Ticks:
        """Gets the Tick data for the specific symbol."""
        ...
    @overload
    def GetTicksAsync(self, callback: Callable[[Ticks], None]) -> None:
        """The asynchronous method to get tick data."""
        ...
    @overload
    def GetTicksAsync(self, symbolName: str, callback: Callable[[Ticks], None]) -> None:
        """The asynchronous method to get tick data for the specific symbol."""
        ...

class MarketDataLoadException:
    """Represents errors that occur during loading market data (Bars/Ticks)"""
    ...

class MarketDepth:
    """Access to MarketDepth Ask Entries, Bid Entries and the event at which the market depth gets updated"""
    AskEntries: IReadonlyList[MarketDepthEntry]
    """The total number of Ask entries"""
    BidEntries: IReadonlyList[MarketDepthEntry]
    """The total number of Bid entries"""
    Updated: Event[Action]
    """The event at which the market depth gets updated"""

class MarketDepthEntry:
    """Provides access to market depth prices and volumes"""
    Price: float
    """The price of this market depth entry"""
    VolumeInUnits: float
    """The volume of this market depth entry"""

class MarketFacilitationIndex(StandardIndicator):
    """The calculation of the Market Facilitation Index."""
    Result: IndicatorDataSeries
    """Gets the resulting series of the Market Facilitation Index calculation."""

class MarketHours:
    """Access to symbol's trading sessions schedule"""
    @overload
    def IsOpened(self) -> bool:
        """Indicates if trading session is active"""
        ...
    @overload
    def IsOpened(self, datetime: DateTime) -> bool:
        """Indicates if trading session is active"""
        ...
    def TimeTillClose(self) -> TimeSpan:
        """Time left till end of current trading session. Returns 0 if session is not active"""
        ...
    def TimeTillOpen(self) -> TimeSpan:
        """Time left till start of new trading session. Returns 0 if session is already active"""
        ...
    Holidays: IReadonlyList[TradingHoliday]
    """List of all symbol's trading holidays"""
    Sessions: IReadonlyList[TradingSession]
    """List of all symbol's trading sessions"""

class MarketSession:
    """Represents the predefined market sessions."""
    None: MarketSession
    Wellington: MarketSession
    Tokyo: MarketSession
    Sydney: MarketSession
    Singapore: MarketSession
    Frankfurt: MarketSession
    London: MarketSession
    NewYork: MarketSession

class MarketSessionChangedEventArgs:
    """The arguments for MarketSessionsChanged event."""
    NewSessions: MarketSession
    """All current sessions including any new sessions that have just begun. The value of NewSessions is always equal to the value of the MarketSessions property of a cBot / indicator. Returns MarketSession.None if no new sessions started when the MarketSessionsChanged event was triggered."""
    PreviousSessions: MarketSession
    """Returns the previous value of the MarketSessions property before the MarketSessionsChanged event was triggered. Returns MarketSession.None if no previous sessions ended when the event was triggered."""

class MassIndex(StandardIndicator):
    """The Mass Index Indicator interface."""
    Result: IndicatorDataSeries
    """Gets the resulting series of the calculation of the Mass Index indicator."""

class MedianPrice(StandardIndicator):
    """A Median Price is an average of one period’s high and low values."""
    Result: IndicatorDataSeries
    """The resulting series of the calculation of Median Price"""

class MessageArgs:
    """Provides data for the message handler."""
    ChartId: str
    """Gets message sender ChartId. ChartId is null for plugin sent messages."""
    Message: TMessage
    """Gets the message."""
    SenderInstanceId: str
    """Gets message sender instance Id."""
    Subscription: MessageSubscription
    """Gets message subscription."""

class MessageBox:
    """A message dialog window that you can use to show a message with buttons"""
    @overload
    @staticmethod
    def Show(messageBoxText: str) -> MessageBoxResult:
        """Shows a MessageBox with just a text"""
        ...
    @overload
    @staticmethod
    def Show(messageBoxText: str, caption: str) -> MessageBoxResult:
        """Shows a MessageBox with text and caption / title"""
        ...
    @overload
    @staticmethod
    def Show(messageBoxText: str, caption: str, button: MessageBoxButton) -> MessageBoxResult:
        """Shows a MessageBox with text, caption / title, and button"""
        ...
    @overload
    @staticmethod
    def Show(messageBoxText: str, caption: str, button: MessageBoxButton, icon: MessageBoxImage) -> MessageBoxResult:
        """Shows a MessageBox with text, caption / title, button, and an image icon"""
        ...
    @overload
    @staticmethod
    def Show(messageBoxText: str, caption: str, button: MessageBoxButton, icon: MessageBoxImage, defaultResult: MessageBoxResult) -> MessageBoxResult:
        """Shows a MessageBox with text, caption / title, button, icon, and a default result"""
        ...
    @overload
    @staticmethod
    def Show(owner: Window, messageBoxText: str) -> MessageBoxResult:
        """Shows a MessageBox with text that is a child of another window"""
        ...
    @overload
    @staticmethod
    def Show(owner: Window, messageBoxText: str, caption: str) -> MessageBoxResult:
        """Shows a MessageBox with text, and caption / title that is a child of another window"""
        ...
    @overload
    @staticmethod
    def Show(owner: Window, messageBoxText: str, caption: str, button: MessageBoxButton) -> MessageBoxResult:
        """Shows a MessageBox with text, caption / title, and button that is a child of another window"""
        ...
    @overload
    @staticmethod
    def Show(owner: Window, messageBoxText: str, caption: str, button: MessageBoxButton, icon: MessageBoxImage) -> MessageBoxResult:
        """Shows a MessageBox with text, caption / title, button, and image icon that is a child of another window"""
        ...
    @overload
    @staticmethod
    def Show(owner: Window, messageBoxText: str, caption: str, button: MessageBoxButton, icon: MessageBoxImage, defaultResult: MessageBoxResult) -> MessageBoxResult:
        """Shows a MessageBox with text, caption / title, button, icon, and a default result that is a child of another window"""
        ...

class MessageBoxButton:
    """This Enum contains MessageBox buttons"""
    OK: MessageBoxButton
    OKCancel: MessageBoxButton
    YesNoCancel: MessageBoxButton
    YesNo: MessageBoxButton

class MessageBoxImage:
    """This Enum contains MessageBox image icons"""
    None: MessageBoxImage
    Error: MessageBoxImage
    Question: MessageBoxImage
    Warning: MessageBoxImage
    Information: MessageBoxImage

class MessageBoxResult:
    """This Enum contains MessageBox results"""
    None: MessageBoxResult
    OK: MessageBoxResult
    Cancel: MessageBoxResult
    Yes: MessageBoxResult
    No: MessageBoxResult

class MessageSubscription:
    """Represents a message subscription."""
    def Unsubscribe(self) -> None:
        """Unsubscribes current subscription."""
        ...
    Id: str
    """Gets subscription Id."""
    Subject: str
    """GGets message subject."""

class Messages:
    """Provides access to messaging API."""
    def Send(self, subject: str, message: TMessage) -> None:
        """Sends a message for a specific subject."""
        ...
    def Subscribe(self, subject: str, handler: Callable[[MessageArgs[TMessage]], None]) -> MessageSubscription:
        """Subscribes to a message subject."""
        ...

class ModifierKeys:
    """Specifies the set of modifier keys."""
    None: ModifierKeys
    Alt: ModifierKeys
    Control: ModifierKeys
    Shift: ModifierKeys

class MomentumOscillator(StandardIndicator):
    """The calculation of the Momentum Oscillator indicator."""
    Result: IndicatorDataSeries
    """Gets the resulting series of the Momentum Oscillator indicator calculation."""

class MoneyFlowIndex(StandardIndicator):
    """The Money Flow Index is an oscillator that calculates buying and selling pressure using typical price and volume. It oscillates between zero and one hundred. It is typically used to identify trend reversals and price extremes."""
    Result: IndicatorDataSeries
    """The time series of the Money Flow Index indicator."""

class MonteCarloMethod:
    """Specifies the Monte Carlo simulation method that is applied to a completed backtest."""
    Reshuffle: MonteCarloMethod
    Bootstrap: MonteCarloMethod
    BlockBootstrap: MonteCarloMethod
    StationaryBootstrap: MonteCarloMethod
    SyntheticPricePath: MonteCarloMethod

class MonteCarloSettings:
    """Represents the optional Monte Carlo simulation that is attached to a backtest. A backtest produces a single equity curve, the one historical ordering of its trades. A Monte Carlo simulation re-runs that result many times, each time resampling or perturbing it, and reports the distribution of the outcomes instead of the single historical path."""
    @overload
    def __init__(self, method: MonteCarloMethod, outputFilePath: str) -> None: ...
    @overload
    def __init__(self, original: MonteCarloSettings) -> None: ...
    BlockSize: int
    """Gets the number of consecutive trades that are kept together when resampling. It is used only by the BlockBootstrap and StationaryBootstrap methods and is ignored by the others. It must be greater than or equal to 1 and the default value is 5."""
    Iterations: int
    """Gets the number of simulated iterations. When it is 0, the default, the method default is used, which is 1000 for the resampling methods and 100 for SyntheticPricePath. Any other value outside the range of the method, which is 100 to 100000 for the resampling methods and 100 to 1000 for SyntheticPricePath, is reported as an invalid settings error instead of being clamped."""
    Method: MonteCarloMethod
    """Gets the Monte Carlo simulation method."""
    OutputFilePath: str
    """Gets the destination file path for the Monte Carlo result JSON. The file uses the same snapshot format the desktop Monte Carlo tab saves, so it can be loaded back by the desktop application."""
    RuinFloor: float
    """Gets the equity level that is treated as account ruin. The risk of ruin is the share of the simulations whose equity drops to or below this level. It must be greater than or equal to 0 and the default value is 0."""
    Seed: int
    """Gets the random seed that makes the simulation reproducible. The same seed with the same inputs produces the same result, even across application restarts. The default value is 0."""
    StartingEquity: float
    """Gets the starting equity used as the additive base for the simulated equity curves. When it is 0, the default, the initial balance of the backtest is used."""

class MovingAverage(StandardIndicator):
    """The Moving Average Indicator calculation."""
    Result: IndicatorDataSeries
    """The resulting time series of the calculation."""

class MovingAverageType:
    """An enumeration of the different MovingAverage weighting (smoothing) methods."""
    Simple: MovingAverageType
    Exponential: MovingAverageType
    TimeSeries: MovingAverageType
    Triangular: MovingAverageType
    VIDYA: MovingAverageType
    Weighted: MovingAverageType
    WilderSmoothing: MovingAverageType
    Hull: MovingAverageType
    DoubleExponential: MovingAverageType
    TripleExponential: MovingAverageType
    KaufmanAdaptive: MovingAverageType

class MultiSelect(Control):
    """A control that shows list of unique items and allows user to select multiple items from the list"""
    def __init__(self) -> None: ...
    def AddItem(self, item: str) -> bool:
        """Adds a new item to the MultiSelect"""
        ...
    def RemoveItem(self, item: str) -> bool:
        """Removes an existing item from the MultiSelect"""
        ...
    def SelectAllItems(self) -> None:
        """Selects all items on the MultiSelect"""
        ...
    def SelectItem(self, item: str) -> bool:
        """Selects item on the MultiSelect"""
        ...
    def SelectItems(self, items: Iterable[str]) -> None:
        """Selects items on the MultiSelect"""
        ...
    def UnselectAllItems(self) -> None:
        """Unselects all items on the MultiSelect"""
        ...
    def UnselectItem(self, item: str) -> bool:
        """Unselects item on the MultiSelect"""
        ...
    def UnselectItems(self, items: Iterable[str]) -> None:
        """Unselects items on the MultiSelect"""
        ...
    Items: IReadonlyList[str]
    """Get the read-only copy of MultiSelect items"""
    SelectedItems: IReadonlyList[str]
    """Get the read-only copy of MultiSelect selected items"""
    SelectedItemsChanged: Event[Callable[[MultiSelectSelectedItemsChangedEventArgs], None]]
    """This event will trigger if the MultiSelect selected items changed"""

class MultiSelectSelectedItemsChangedEventArgs:
    """Provides data for MultiSelect SelectedItemsChanged event handlers"""
    MultiSelect: MultiSelect
    """The ComboBox that it is selected item changed"""

class NegativeVolumeIndex(StandardIndicator):
    """Dysart's Negative Volume Index assumes that the smart money is active on days when volume decreases and the not-so-smart money is active on days when volume increases (measured by the Positive Volume Index)."""
    Result: IndicatorDataSeries
    """The time series of the Negative Volume Index indicator."""

class NewOrderDialog:
    """Represents a common dialog box that allows a user to create a new order."""
    def __init__(self) -> None: ...
    def ShowDialog(self) -> None:
        """Shows the dialog."""
        ...
    Comment: str
    """Gets or sets the Comment."""
    Expiration: DateTime | None
    """Gets or sets the Expiration."""
    HasTrailingStop: bool
    """Gets or sets the HasTrailingStop."""
    MarketRangePips: float | None
    """Gets or sets the MarketRangePips."""
    OrderType: OrderType
    """Gets or sets the OrderType."""
    StopLimitRangePips: float | None
    """Gets or sets the StopLimitRangePips."""
    StopLossPips: float | None
    """Gets or sets the StopLossPips."""
    StopLossTriggerMethod: StopTriggerMethod | None
    """Gets or sets Trigger method for order StopLoss"""
    StopOrderTriggerMethod: StopTriggerMethod | None
    """Gets or sets the HasTrailingStop."""
    SymbolName: str
    """Gets or sets the SymbolName."""
    TakeProfitPips: float | None
    """Gets or sets the TakeProfitPips."""
    TargetPrice: float | None
    """Gets or sets the TargetPrice."""
    TradeType: TradeType
    """Gets or sets the TradeType."""
    Volume: float | None
    """Gets or sets the Volume."""

class OhlcvBar:
    """Represents a OHLCV Bar object."""
    def __init__(self, open: float, high: float, low: float, close: float, tickVolume: int) -> None: ...
    Close: float
    """Gets the Close price."""
    High: float
    """Gets the High price."""
    Low: float
    """Gets the Low price."""
    Open: float
    """Gets the open price."""
    TickVolume: int
    """Gets the Tick volume."""

class OnBalanceVolume(StandardIndicator):
    """On Balance Volume measures buying and selling pressure as a cumulative indicator that adds volume on up days and subtracts volume on down days."""
    Result: IndicatorDataSeries
    """Gets or sets the time series of the On Balance Volume indicator."""

class OpenFileDialog:
    """Represents a common dialog box that allows a user to specify a filename for one or more files to open."""
    def __init__(self) -> None: ...
    def Reset(self) -> None:
        """Resets all dialog properties to their default values."""
        ...
    @overload
    def ShowDialog(self) -> FileDialogResult:
        """Shows a file dialog, with the owner as the main Window"""
        ...
    @overload
    def ShowDialog(self, owner: Window) -> FileDialogResult:
        """Shows a file dialog, with the passed owner window."""
        ...
    AddExtension: bool
    """Gets or sets a value indicating whether a file dialog automatically adds an extension to a file name if the user omits an extension."""
    DefaultExt: str
    """Gets or sets a value that specifies the default extension string to use to filter the list of files that are displayed."""
    FileName: str
    """Gets a string containing the full path of the file selected in a file dialog."""
    FileNames: list[str]
    """Gets an array that contains one file name for each selected file."""
    Filter: str
    """Gets or sets the filter string that determines what types of files are displayed in file dialog."""
    InitialDirectory: str
    """Gets or sets the initial directory that is displayed by a file dialog."""
    Multiselect: bool
    """Gets or sets an option indicating whether OpenFileDialog allows users to select multiple files."""
    Title: str
    """Gets or sets a string shown in the title bar of the dialog. If this property is null, a localized default from the operating system itself will be used."""
    ValidateNames: bool
    """Gets or sets a value indicating whether the dialog accepts only valid file names."""

class OpenFolderDialog:
    """Represents a common dialog box that allows the user to open one or more folders."""
    def __init__(self) -> None: ...
    def Reset(self) -> None:
        """Resets all dialog properties to their default values."""
        ...
    @overload
    def ShowDialog(self) -> FileDialogResult:
        """Shows a file dialog, with the owner as the main Window"""
        ...
    @overload
    def ShowDialog(self, owner: Window) -> FileDialogResult:
        """Shows a file dialog, with the passed owner window."""
        ...
    FolderName: str
    """Gets a string containing the full path of the folder selected in an open folder dialog."""
    InitialDirectory: str
    """Gets or sets the initial directory that is displayed by a file dialog."""
    Title: str
    """Gets or sets a string shown in the title bar of the dialog. If this property is null, a localized default from the operating system itself will be used."""

class Optimization:
    """Provides methods and events to manage and monitor cBot parameter optimization processes."""
    @overload
    def Start(self, robotType: RobotType, symbolName: str, timeFrame: TimeFrame, settings: OptimizationSettings, parameters: list[OptimizationParameter]) -> OptimizationProcess:
        """Starts an optimization process."""
        ...
    @overload
    def Start(self, robotType: RobotType, symbolName: str, timeFrames: Iterable[TimeFrame], settings: OptimizationSettings, parameters: list[OptimizationParameter]) -> OptimizationProcess:
        """Starts an optimization process across multiple time frames. Use this overload to optimize the time frame alongside the cBot parameters, mirroring the desktop UI where the time frame can itself be part of the optimization. Each time frame is combined with the supplied parameter set during the optimization."""
        ...
    Completed: Event[Callable[[OptimizationCompletedEventArgs], None]]
    """Occurs when the optimization process is completed."""
    PassCompleted: Event[Callable[[OptimizationPassCompletedEventArgs], None]]
    """Occurs when an individual optimization pass completes."""
    ProgressChanged: Event[Callable[[OptimizationProgressChangedEventArgs], None]]
    """Occurs when the optimization progress changes."""

class OptimizationBooleanParameter:
    """A bool cBot parameter, optimized over a set of values or held fixed."""
    @overload
    def __init__(self, name: str, values: Iterable[bool]) -> None: ...
    @overload
    def __init__(self, name: str, value: bool) -> None: ...
    @overload
    def __init__(self, original: OptimizationBooleanParameter) -> None: ...
    Values: Sequence[bool]
    """Gets the discrete set of values to optimize over."""

class OptimizationColorParameter:
    """A Color cBot parameter. Not optimizable; always held fixed."""
    @overload
    def __init__(self, name: str, value: Color) -> None: ...
    @overload
    def __init__(self, original: OptimizationColorParameter) -> None: ...

class OptimizationCompletedEventArgs:
    """Provides data for the optimization completed event."""
    def __init__(self, original: OptimizationCompletedEventArgs) -> None: ...
    BestPass: OptimizationPass
    """Gets the best pass by the configured criteria or custom fitness, or null if no pass completed."""
    JsonReport: str
    """Gets the full optimization result as JSON (the .optres content)."""
    Process: OptimizationProcess
    """Gets the optimization process that has completed."""

class OptimizationCriterion:
    """A single optimization criterion: a performance index and the direction to optimize it."""
    def __init__(self, Type: OptimizationCriterionType, Direction: OptimizationCriterionDirection) -> None: ...
    Direction: OptimizationCriterionDirection
    """Whether to maximize or minimize the index."""
    Type: OptimizationCriterionType
    """The performance index to optimize."""

class OptimizationCriterionDirection:
    """The direction in which an optimization criterion is optimized."""
    Maximize: OptimizationCriterionDirection
    Minimize: OptimizationCriterionDirection

class OptimizationCriterionType:
    """The performance index used as an optimization criterion."""
    NetProfit: OptimizationCriterionType
    ProfitFactor: OptimizationCriterionType
    MaxEquityDrawdownPercentages: OptimizationCriterionType
    MaxBalanceDrawdownPercentages: OptimizationCriterionType
    MaxEquityDrawdown: OptimizationCriterionType
    MaxBalanceDrawdown: OptimizationCriterionType
    WinningTrades: OptimizationCriterionType
    LosingTrades: OptimizationCriterionType
    TotalTrades: OptimizationCriterionType
    AverageTrade: OptimizationCriterionType

class OptimizationDataSeriesParameter:
    """A DataSeries cBot parameter, held fixed at a standard series type. The selector is StandardSeriesType — a live DataSeries cannot itself be an optimization input, and data series parameters cannot be optimized over multiple values."""
    @overload
    def __init__(self, name: str, value: StandardSeriesType) -> None: ...
    @overload
    def __init__(self, original: OptimizationDataSeriesParameter) -> None: ...

class OptimizationDateOnlyParameter:
    """A DateOnly cBot parameter, optimized over a date range or held fixed."""
    @overload
    def __init__(self, name: str, min: DateOnly, max: DateOnly, step: TimeSpan) -> None: ...
    @overload
    def __init__(self, name: str, value: DateOnly) -> None: ...
    @overload
    def __init__(self, original: OptimizationDateOnlyParameter) -> None: ...
    Max: DateOnly
    """Gets the inclusive maximum of the range."""
    Min: DateOnly
    """Gets the inclusive minimum of the range."""
    Step: TimeSpan
    """Gets the step of the range, as a time span."""

class OptimizationDateTimeParameter:
    """A DateTime cBot parameter, optimized over a date-time range or held fixed."""
    @overload
    def __init__(self, name: str, min: DateTime, max: DateTime, step: TimeSpan) -> None: ...
    @overload
    def __init__(self, name: str, value: DateTime) -> None: ...
    @overload
    def __init__(self, original: OptimizationDateTimeParameter) -> None: ...
    Max: DateTime
    """Gets the inclusive maximum of the range."""
    Min: DateTime
    """Gets the inclusive minimum of the range."""
    Step: TimeSpan
    """Gets the step of the range, as a time span."""

class OptimizationDoubleParameter:
    """A double cBot parameter, optimized over a numeric range or held fixed."""
    @overload
    def __init__(self, name: str, min: float, max: float, step: float) -> None: ...
    @overload
    def __init__(self, name: str, value: float) -> None: ...
    @overload
    def __init__(self, original: OptimizationDoubleParameter) -> None: ...
    Max: float
    """Gets the inclusive maximum of the range."""
    Min: float
    """Gets the inclusive minimum of the range."""
    Step: float
    """Gets the step of the range."""

class OptimizationEnumParameter:
    """An enum cBot parameter, optimized over a set of members or held fixed. The CLR enum type is resolved from the cBot metadata, so members are supplied by their string names."""
    @overload
    def __init__(self, name: str, values: Iterable[str]) -> None: ...
    @overload
    def __init__(self, name: str, value: str) -> None: ...
    @overload
    def __init__(self, original: OptimizationEnumParameter) -> None: ...
    Values: Sequence[str]
    """Gets the discrete set of enum member names to optimize over."""

class OptimizationError:
    """Describes why an optimization process failed."""
    None: OptimizationError
    Other: OptimizationError
    Net4IsNotSupported: OptimizationError
    NoConnection: OptimizationError
    NoHistoricalData: OptimizationError
    NotSupported: OptimizationError
    InvalidSettings: OptimizationError
    InvalidParameters: OptimizationError

class OptimizationFileParameter:
    """A File cBot parameter (a file path). Not optimizable; always held fixed."""
    @overload
    def __init__(self, name: str, value: str) -> None: ...
    @overload
    def __init__(self, original: OptimizationFileParameter) -> None: ...

class OptimizationIntegerParameter:
    """An int cBot parameter, optimized over an integer range or held fixed."""
    @overload
    def __init__(self, name: str, min: int, max: int, step: int) -> None: ...
    @overload
    def __init__(self, name: str, value: int) -> None: ...
    @overload
    def __init__(self, original: OptimizationIntegerParameter) -> None: ...
    Max: int
    """Gets the inclusive maximum of the range."""
    Min: int
    """Gets the inclusive minimum of the range."""
    Step: int
    """Gets the step of the range."""

class OptimizationMethod:
    """Specifies the method used to explore the parameter space during optimization."""
    Genetic: OptimizationMethod
    Grid: OptimizationMethod

class OptimizationMultiEnumParameter:
    """An Enum[] (multi-enum) cBot parameter. Not optimizable; always held fixed. Members are supplied by their string names."""
    @overload
    def __init__(self, name: str, value: Sequence[str]) -> None: ...
    @overload
    def __init__(self, original: OptimizationMultiEnumParameter) -> None: ...

class OptimizationMultiFileParameter:
    """A MultiFile (a set of file paths) cBot parameter. Not optimizable; always held fixed."""
    @overload
    def __init__(self, name: str, value: Sequence[str]) -> None: ...
    @overload
    def __init__(self, original: OptimizationMultiFileParameter) -> None: ...

class OptimizationMultiSymbolParameter:
    """A Symbol[] (multi-symbol) cBot parameter. Not optimizable; always held fixed."""
    @overload
    def __init__(self, name: str, value: Sequence[Symbol]) -> None: ...
    @overload
    def __init__(self, original: OptimizationMultiSymbolParameter) -> None: ...

class OptimizationMultiTimeFrameParameter:
    """A TimeFrame[] (multi-time-frame) cBot parameter. Not optimizable; always held fixed."""
    @overload
    def __init__(self, name: str, value: Sequence[TimeFrame]) -> None: ...
    @overload
    def __init__(self, original: OptimizationMultiTimeFrameParameter) -> None: ...

class OptimizationParameter:
    """Base type for a cBot parameter's optimization configuration. One derived record exists for each AlgoParameterType."""
    IsOptimized: bool
    """Gets a value indicating whether the parameter is included in the sweep. When false, the parameter is held fixed at its value."""
    Name: str
    """Gets the cBot parameter name (must match its property name)."""

class OptimizationParameter-API(OptimizationParameter):
    """Base type for a typed optimization parameter that carries a scalar value (used when the parameter is held fixed)."""
    Value: T
    """Gets the scalar value used when the parameter is held fixed."""

class OptimizationPass:
    """Represents a single completed optimization pass and its key statistics."""
    Fitness: float
    """Gets the fitness value of the pass."""
    Id: int
    """Gets the pass id."""
    JsonReport: str
    """Gets the full per-pass backtest result as JSON."""
    MaxEquityDrawdownPercentages: float
    """Gets the maximum equity drawdown of the pass, as a percentage."""
    NetProfit: float
    """Gets the net profit of the pass."""
    ParameterValues: dict[str, str]
    """Gets the exact parameter values this pass used, keyed by parameter name."""
    ProfitFactor: float
    """Gets the profit factor of the pass."""
    TimeFrame: TimeFrame
    """Gets the time frame of the pass."""
    TotalTrades: int
    """Gets the total number of trades in the pass."""

class OptimizationPassCompletedEventArgs:
    """Provides data for the optimization pass completed event."""
    def __init__(self, original: OptimizationPassCompletedEventArgs) -> None: ...
    Pass: OptimizationPass
    """Gets the pass that completed."""
    Process: OptimizationProcess
    """Gets the optimization process that produced the pass."""

class OptimizationProcess:
    """Represents an optimization process with methods and properties to monitor its status and results."""
    def Terminate(self) -> None:
        """Terminates the optimization process."""
        ...
    BestPass: OptimizationPass
    """Gets the best pass by the configured criteria or custom fitness, or null if no pass has completed."""
    IsCompleted: bool
    """Gets a value indicating whether the optimization process is completed."""
    JsonReport: str
    """Gets the optimization result as JSON (the .optres content): configuration plus every pass with its statistics. Returns null if the optimization is not finished or an error occurred. The format matches the desktop optimization "Save results", so the JSON can be opened or imported by the desktop optimization UI."""
    OptimizationError: OptimizationError
    """Gets the error information if the optimization process failed."""
    Passes: Sequence[OptimizationPass]
    """Gets the passes completed so far, ordered by pass id. While running this grows as passes finish; on completion it holds every pass."""
    Completed: Event[Callable[[OptimizationCompletedEventArgs], None]]
    """Occurs when the optimization process is completed."""
    PassCompleted: Event[Callable[[OptimizationPassCompletedEventArgs], None]]
    """Occurs when an individual optimization pass completes."""
    ProgressChanged: Event[Callable[[OptimizationProgressChangedEventArgs], None]]
    """Occurs when the optimization progress changes."""

class OptimizationProgressChangedEventArgs:
    """Provides data for the optimization progress changed event."""
    def __init__(self, original: OptimizationProgressChangedEventArgs) -> None: ...
    Operation: str
    """Gets the description of the current operation."""
    Process: OptimizationProcess
    """Gets the optimization process that reported progress."""
    Progress: float
    """Gets the progress percentage of the current operation."""

class OptimizationSettings:
    """Represents settings for configuring an optimization process."""
    @overload
    def __init__(self, startTimeUtc: DateTime, endTimeUtc: DateTime, balance: float, criteria: Iterable[OptimizationCriterion]) -> None: ...
    @overload
    def __init__(self, original: OptimizationSettings) -> None: ...
    ApplyCommissionAutomatically: bool
    """Gets a value that indicates whether the commission type and value of the optimized symbol are applied automatically. When it is set to true the Commission and CommissionType properties are ignored. The default value is false."""
    AutoSelectBest: bool
    """Gets a value indicating whether the best pass is auto-selected on completion."""
    Balance: float
    """Gets the initial balance for each pass."""
    Commission: float
    """Gets the commission value, it is interpreted based on the CommissionType property value. It is ignored when ApplyCommissionAutomatically is set to true. The default value is 0."""
    CommissionType: SymbolCommissionType
    """Gets the commission type that defines how the Commission property value is interpreted. It is ignored when ApplyCommissionAutomatically is set to true. The default value is SymbolCommissionType.UsdPerMillionUsdVolume."""
    Cores: int
    """Gets the number of CPU cores used to run passes in parallel. Must be greater than or equal to 1. Zero will use the platform default which is ProcessorCount / 2 + 1."""
    Criteria: Sequence[OptimizationCriterion]
    """Gets the standard optimization criteria. Ignored when OptimizationSettings.UseCustomFitness is true."""
    DataFile: str
    """Gets the path to the data file used for the optimization."""
    DataMode: BacktestingDataMode
    """Gets the data mode used for the optimization."""
    EndTimeUtc: DateTime
    """Gets the end time in UTC for the optimization period."""
    Method: OptimizationMethod
    """Gets the optimization method. Defaults to OptimizationMethod.Genetic."""
    PreciseConversion: bool
    """Gets a value indicating whether historical data for additional symbols is downloaded to convert profit and margin into the account deposit currency precisely. When true, real historical exchange rates of the additional symbols are used; when false, the default, approximated rates are used. Enabling it can increase the run time and the amount of downloaded data."""
    SpreadPips: float
    """Gets the spread in pips."""
    StartTimeUtc: DateTime
    """Gets the start time in UTC for the optimization period."""
    UseCustomFitness: bool
    """Gets a value indicating whether to use the cBot's custom GetFitness instead of OptimizationSettings.Criteria."""

class OptimizationStringParameter:
    """A string cBot parameter. Not optimizable; always held fixed."""
    @overload
    def __init__(self, name: str, value: str) -> None: ...
    @overload
    def __init__(self, original: OptimizationStringParameter) -> None: ...

class OptimizationSymbolParameter:
    """A Symbol cBot parameter, optimized over a set of symbols or held fixed."""
    @overload
    def __init__(self, name: str, values: Iterable[Symbol]) -> None: ...
    @overload
    def __init__(self, name: str, value: Symbol) -> None: ...
    @overload
    def __init__(self, original: OptimizationSymbolParameter) -> None: ...
    Values: Sequence[Symbol]
    """Gets the discrete set of symbols to optimize over."""

class OptimizationTimeFrameParameter:
    """A TimeFrame cBot parameter, optimized over a set of time frames or held fixed."""
    @overload
    def __init__(self, name: str, values: Iterable[TimeFrame]) -> None: ...
    @overload
    def __init__(self, name: str, value: TimeFrame) -> None: ...
    @overload
    def __init__(self, original: OptimizationTimeFrameParameter) -> None: ...
    Values: Sequence[TimeFrame]
    """Gets the discrete set of time frames to optimize over."""

class OptimizationTimeSpanParameter:
    """A TimeSpan cBot parameter, optimized over a range or held fixed."""
    @overload
    def __init__(self, name: str, min: TimeSpan, max: TimeSpan, step: TimeSpan) -> None: ...
    @overload
    def __init__(self, name: str, value: TimeSpan) -> None: ...
    @overload
    def __init__(self, original: OptimizationTimeSpanParameter) -> None: ...
    Max: TimeSpan
    """Gets the inclusive maximum of the range."""
    Min: TimeSpan
    """Gets the inclusive minimum of the range."""
    Step: TimeSpan
    """Gets the step of the range."""

class OrderType:
    """Represents the different types of orders."""
    Market: OrderType
    Limit: OrderType
    Stop: OrderType
    StopLimit: OrderType

class Orientation:
    """Defines the different orientations that panel layout can have."""
    Horizontal: Orientation
    Vertical: Orientation

class OscillatorMovingAverage(StandardIndicator):
    """The calculation of the Oscillator of a Moving Average."""
    Histogram: IndicatorDataSeries
    """The Oscillator of a Moving Average is a technical indicator that shows the difference between an oscillator and its moving average over a given period of time."""

class OutputAttribute:
    """This attribute is used for marking an indicator IndicatorDataSeries property as a line Output."""
    def __init__(self, lineName: str) -> None: ...
    Description: str
    """Gets or sets description for output that will be shown in UI."""
    IsColorCustomizable: bool
    """Gets or sets if Output line color is customizable or not."""
    IsLastValueVisibleInTitle: bool
    """Gets or sets if output last value should be visible or not in instance title (default: true)."""
    IsVisible: bool
    """Gets or sets default visibility of output."""
    LineColor: str
    """Gets or sets the Color of the Output property. This Color will be used when the line for this Output is plotted."""
    LineStyle: LineStyle
    """Gets or sets the Line Style for given Output property. By default it is set to Solid"""
    Name: str
    """The plot name"""
    PlotType: PlotType
    """Plot type."""
    Thickness: float
    """Sets the Width of the Output property."""

class OwnerType:
    """The types of owners for windows"""
    None: OwnerType
    Chart: OwnerType
    Application: OwnerType

class Panel(ControlBase):
    """Provides a base class for all Panel elements. Use Panel elements to position and arrange child objects."""
    def AddChild(self, child: ControlBase) -> None:
        """Adds the child element."""
        ...
    def HasChild(self, child: ControlBase) -> bool:
        """Returns True if panel has passed child otherwise false."""
        ...
    def RemoveChild(self, child: ControlBase) -> None:
        """Removes the child element."""
        ...
    BackgroundColor: Color
    """Gets or sets the color of the panel background."""
    ChildCount: int
    """Gets count of panel children."""
    Children: Iterable[ControlBase]
    """Gets panel children."""

class ParabolicSAR(StandardIndicator):
    """The calculation of the Parabolic SAR Indicator."""
    Result: IndicatorDataSeries
    """Gets the resulting series of the Parabolic SAR indicator."""

class ParameterAttribute:
    """The Parameter Attribute class."""
    @overload
    def __init__(self, name: str) -> None: ...
    @overload
    def __init__(self) -> None: ...
    DefaultValue: object
    """Gets or sets the default value of this Parameter property."""
    Description: str
    """Gets or sets description for input parameter that will be shown in UI."""
    Group: str
    """Groups parameters in UI."""
    IsValueVisibleInTitle: bool
    """Gets or sets whether parameter value should be visible or not in instance title (default: true)."""
    MaxValue: object
    """Gets or sets the maximum value of this Parameter property. It is used for validating user input."""
    MinValue: object
    """Gets or sets the minimum value of this Parameter property. It is used for validating user input."""
    Name: str
    """The input parameter name."""
    Step: float
    """Gets or sets the step of this Parameter. Step is used in NumericUpDown controls in parameter editors."""

class PenLineCap:
    """Describes the shape at the end of a line or segment."""
    Flat: PenLineCap
    Square: PenLineCap
    Round: PenLineCap
    Triangle: PenLineCap

class PenLineJoin:
    """Describes the shape that joins two lines or segments."""
    Miter: PenLineJoin
    Bevel: PenLineJoin
    Round: PenLineJoin

class PendingOrder:
    """Provides access to properties of pending orders"""
    def Cancel(self) -> TradeResult:
        """Shortcut for Robot.CancelPendingOrder method"""
        ...
    def ModifyExpirationTime(self, expirationTime: DateTime | None) -> TradeResult:
        """Shortcut for Robot.ModifyPendingOrder method to change Expiration Time"""
        ...
    def ModifyStopLimitRange(self, stopLimitRangePips: float) -> TradeResult:
        """Shortcut for Robot.ModifyPendingOrder method to change Stop Limit Range"""
        ...
    def ModifyStopLossBreakEven(self, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Shortcut for the Robot.ModifyPosition method to change the StopLoss Break-Even."""
        ...
    def ModifyStopLossPips(self, stopLossPips: float | None) -> TradeResult:
        """Shortcut for Robot.ModifyPendingOrder method to change Stop Loss"""
        ...
    def ModifyStopLossPrice(self, stopLoss: float | None) -> TradeResult:
        """Shortcut for Robot.ModifyPendingOrder method to change Stop Loss"""
        ...
    @overload
    def ModifyTakeProfit(self, takeProfitProtections: RelativeTakeProfitProtections) -> TradeResult:
        """Shortcut for the Robot.ModifyTakeProfit method to change the Take Profit protection"""
        ...
    @overload
    def ModifyTakeProfit(self, takeProfitProtections: AbsoluteTakeProfitProtections) -> TradeResult:
        """Shortcut for the Robot.ModifyTakeProfit method to change the Take Profit protection"""
        ...
    def ModifyTakeProfitPips(self, takeProfitPips: float | None) -> TradeResult:
        """Shortcut for Robot.ModifyPendingOrder method to change Take Profit"""
        ...
    def ModifyTakeProfitPrice(self, takeProfit: float | None) -> TradeResult:
        """Shortcut for Robot.ModifyPendingOrder method to change Take Profit"""
        ...
    def ModifyTargetPrice(self, targetPrice: float) -> TradeResult:
        """Shortcut for Robot.ModifyPendingOrder method to change Target Price"""
        ...
    def ModifyVolume(self, volume: float) -> TradeResult:
        """Shortcut for Robot.ModifyPendingOrder method to change VolumeInUnits"""
        ...
    AbsoluteTakeProfitProtections: AbsoluteTakeProfitProtections
    """The absolute take profit protections of the order. Null if order has no take profit."""
    Channel: str
    """Gets the channel via which the order was placed in a string format."""
    Comment: str
    """User assigned Order Comment"""
    CurrentPrice: float
    """Gets the current price of the symbol for which the pending order is placed."""
    DistancePips: float
    """Gets the distance in pips between the current price of the symbol and the target price of the pending order (via TargetPrice )."""
    ExpirationTime: DateTime | None
    """The order Expiration time The Timezone used is set in the Robot attribute"""
    HasTrailingStop: bool
    """When HasTrailingStop set to true, server updates Stop Loss every time position moves in your favor."""
    Id: int
    """Unique order Id."""
    Label: str
    """User assigned identifier for the order."""
    LastUpdateTime: DateTime | None
    """Gets the time when an order was last updated. The timezone used is set in the algorithm class attribute."""
    OrderType: PendingOrderType
    """Specifies whether this order is Stop or Limit."""
    ProtectionType: ProtectionType
    """Gets the order protection type."""
    Quantity: float
    """Quantity (lots) of this order"""
    RelativeTakeProfitProtections: RelativeTakeProfitProtections
    """The relative take profit protections of the order. Null if order has no take profit."""
    StopLimitRangePips: float | None
    """Maximum limit from order target price, where order can be executed."""
    StopLoss: float | None
    """The order stop loss in price"""
    StopLossBreakEven: StopLossBreakEven
    """The stop loss break even of the order."""
    StopLossPips: float | None
    """The order stop loss in pips"""
    StopLossTriggerMethod: StopTriggerMethod | None
    """Trigger method for order's StopLoss"""
    StopOrderTriggerMethod: StopTriggerMethod | None
    """Determines how pending order will be triggered in case it is a StopOrder"""
    SubmittedTime: DateTime
    """Gets the order submission time."""
    Symbol: Symbol
    """Gets the order symbol."""
    SymbolName: str
    """Gets the symbol name."""
    TakeProfit: float | None
    """The order take profit in price"""
    TakeProfitPips: float | None
    """The order take profit in pips"""
    TargetPrice: float
    """The order target price."""
    TradeType: TradeType
    """Specifies whether this order is to buy or sell."""
    VolumeInUnits: float
    """Volume of this order."""

class PendingOrderCancellationReason:
    """The reason for the order cancellation."""
    Cancelled: PendingOrderCancellationReason
    Expired: PendingOrderCancellationReason
    Rejected: PendingOrderCancellationReason

class PendingOrderCancelledEventArgs:
    """Provides data for the pending order cancellation event."""
    PendingOrder: PendingOrder
    """Gets the pending order that was cancelled."""
    Reason: PendingOrderCancellationReason
    """Gets the reason for the pending order cancellation."""

class PendingOrderCreatedEventArgs:
    """Provides data for the pending order creation events."""
    PendingOrder: PendingOrder
    """Gets the pending order that was created."""

class PendingOrderFilledEventArgs:
    """Provides data for the pending order fill event."""
    PendingOrder: PendingOrder
    """Gets the pending order that was filled."""
    Position: Position
    """Gets the position that was filled from the pending order."""

class PendingOrderModifiedEventArgs:
    """Provides data for the pending order modification event."""
    PendingOrder: PendingOrder
    """Gets the pending order that was modified."""

class PendingOrderType:
    """Represents the type of pending order."""
    Limit: PendingOrderType
    Stop: PendingOrderType
    StopLimit: PendingOrderType

class PendingOrders:
    """Provides access to methods of the Pending Orders collection"""
    def FindById(self, id: int) -> PendingOrder:
        """Find PendingOrder by Id."""
        ...
    Count: int
    """Total number of pending orders"""
    Item: PendingOrder
    """Find a pending order by index"""
    Cancelled: Event[Callable[[PendingOrderCancelledEventArgs], None]]
    """Occurs when pending order is cancelled"""
    Created: Event[Callable[[PendingOrderCreatedEventArgs], None]]
    """Occurs when pending order is created"""
    Filled: Event[Callable[[PendingOrderFilledEventArgs], None]]
    """Occurs when pending order is filled"""
    Modified: Event[Callable[[PendingOrderModifiedEventArgs], None]]
    """Occurs when pending order is modified"""

class Permission:
    """Base interface for Permissions"""
    def Request(self) -> bool:
        """Requests the permission from user."""
        ...
    IsAllowed: bool
    """True if Permission is given by user otherwise false."""

class Permissions:
    """Provides all permissions state."""
    ChartRobotsPermission: ChartRobotsPermission
    """Chart robots permission."""
    ClipboardPermission: ClipboardPermission
    """System Clipboard permission."""
    InstallationPermission: InstallationPermission
    """Algo installation permission."""
    TradingPermission: TradingPermission
    """Trading permission."""

class PlotType:
    """The Plot type."""
    Line: PlotType
    Histogram: PlotType
    Points: PlotType
    DiscontinuousLine: PlotType

class Plugin:
    """Base class for Plugins."""
    def BeginInvokeOnMainThread(self, action: Action) -> None:
        """Invokes asynchronously the specified code on the main Plugin thread."""
        ...
    def CancelPendingOrder(self, pendingOrder: PendingOrder) -> TradeResult:
        """Cancel a Pending Order"""
        ...
    def CancelPendingOrderAsync(self, pendingOrder: PendingOrder, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Cancel a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ClosePosition(self, position: Position) -> TradeResult:
        """Close a position"""
        ...
    @overload
    def ClosePosition(self, position: Position, volume: int) -> TradeResult:
        """Close a position"""
        ...
    @overload
    def ClosePosition(self, position: Position, volume: float) -> TradeResult:
        """Close a position"""
        ...
    @overload
    def ClosePositionAsync(self, position: Position, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Close a position in asynchronous execution mode"""
        ...
    @overload
    def ClosePositionAsync(self, position: Position, volume: int, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Close a position in asynchronous execution mode"""
        ...
    @overload
    def ClosePositionAsync(self, position: Position, volume: float, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Close a position in asynchronous execution mode"""
        ...
    def CreateDataSeries(self, symbolName: str, timeFrame: TimeFrame) -> IndicatorDataSeries:
        """Returns a new IndicatorDataSeries."""
        ...
    @overload
    def ExecuteMarketOrder(self, tradeType: TradeType, symbolName: str, volume: float) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketOrder(self, tradeType: TradeType, symbolName: str, volume: float, label: str) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketOrder(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLossPips: float | None, takeProfitPips: float | None) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketOrder(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLossPips: float | None, takeProfitPips: float | None, comment: str) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketOrder(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLossPips: float | None, takeProfitPips: float | None, comment: str, hasTrailingStop: bool) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketOrder(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLossPips: float | None, takeProfitPips: float | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketOrder(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketOrder(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketOrder(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketOrder(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketOrder(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketOrder(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketOrder(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, hasTrailingStop: bool) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketOrder(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, label: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLossPips: float | None, takeProfitPips: float | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLossPips: float | None, takeProfitPips: float | None, comment: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLossPips: float | None, takeProfitPips: float | None, comment: str, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLossPips: float | None, takeProfitPips: float | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketRangeOrder(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketRangeOrder(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketRangeOrder(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLossPips: float | None, takeProfitPips: float | None) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketRangeOrder(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLossPips: float | None, takeProfitPips: float | None, comment: str) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketRangeOrder(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLossPips: float | None, takeProfitPips: float | None, comment: str, hasTrailingStop: bool) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketRangeOrder(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLossPips: float | None, takeProfitPips: float | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketRangeOrder(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Execute a Market Range Order"""
        ...
    @overload
    def ExecuteMarketRangeOrder(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Execute a Market Range Order"""
        ...
    @overload
    def ExecuteMarketRangeOrder(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketRangeOrder(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketRangeOrder(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketRangeOrder(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketRangeOrder(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, hasTrailingStop: bool) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketRangeOrder(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketRangeOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketRangeOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketRangeOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLossPips: float | None, takeProfitPips: float | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketRangeOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLossPips: float | None, takeProfitPips: float | None, comment: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketRangeOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLossPips: float | None, takeProfitPips: float | None, comment: str, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketRangeOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLossPips: float | None, takeProfitPips: float | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketRangeOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market range order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketRangeOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market range order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketRangeOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketRangeOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketRangeOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketRangeOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketRangeOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketRangeOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expirationTime: DateTime | None) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expirationTime: DateTime | None, volume: int) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: int) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: int, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: int) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: int, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expirationTime: DateTime | None, volume: float) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None, stopLimitRangePips: float | None) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None, stopLimitRangePips: float | None) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None, stopLimitRangePips: float | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None, stopLimitRangePips: float | None) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None, stopLimitRangePips: float | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expirationTime: DateTime | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expirationTime: DateTime | None, volume: int, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: int, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: int, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: int, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: int, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expirationTime: DateTime | None, volume: float, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None, stopLimitRangePips: float | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None, stopLimitRangePips: float | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None, stopLimitRangePips: float | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None, stopLimitRangePips: float | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None, stopLimitRangePips: float | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPosition(self, position: Position, volume: float) -> TradeResult:
        """Modify the volume of a position"""
        ...
    @overload
    def ModifyPosition(self, position: Position, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None) -> TradeResult:
        """Modify the protection of a position"""
        ...
    @overload
    def ModifyPosition(self, position: Position, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections) -> TradeResult:
        """Modify the protection of a position"""
        ...
    @overload
    def ModifyPosition(self, position: Position, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections) -> TradeResult:
        """Modify the protection of a position"""
        ...
    @overload
    def ModifyPosition(self, position: Position, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify the protection of a position"""
        ...
    @overload
    def ModifyPosition(self, position: Position, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify the protection of a position"""
        ...
    @overload
    def ModifyPosition(self, position: Position, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, hasTrailingStop: bool) -> TradeResult:
        """Modify the protection of a position"""
        ...
    @overload
    def ModifyPosition(self, position: Position, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, hasTrailingStop: bool) -> TradeResult:
        """Modify the protection of a position"""
        ...
    @overload
    def ModifyPosition(self, position: Position, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, hasTrailingStop: bool) -> TradeResult:
        """Modify the protection of a position"""
        ...
    @overload
    def ModifyPosition(self, position: Position, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify the protection of a position"""
        ...
    @overload
    def ModifyPosition(self, position: Position, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify the protection of a position"""
        ...
    @overload
    def ModifyPosition(self, position: Position, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Modify the protection of a position"""
        ...
    @overload
    def ModifyPosition(self, position: Position, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Modify the protection of a position"""
        ...
    @overload
    def ModifyPosition(self, position: Position, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Modify the protection of a position"""
        ...
    @overload
    def ModifyPosition(self, position: Position, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify the protection of a position"""
        ...
    @overload
    def ModifyPosition(self, position: Position, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify the protection of a position"""
        ...
    @overload
    def ModifyPositionAsync(self, position: Position, volume: float, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify Position in asynchronous execution mode"""
        ...
    @overload
    def ModifyPositionAsync(self, position: Position, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify Position in asynchronous execution mode"""
        ...
    @overload
    def ModifyPositionAsync(self, position: Position, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify Position in asynchronous execution mode"""
        ...
    @overload
    def ModifyPositionAsync(self, position: Position, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify Position in asynchronous execution mode"""
        ...
    @overload
    def ModifyPositionAsync(self, position: Position, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify Position in asynchronous execution mode"""
        ...
    @overload
    def ModifyPositionAsync(self, position: Position, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify Position in asynchronous execution mode"""
        ...
    @overload
    def ModifyPositionAsync(self, position: Position, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify Position in asynchronous execution mode"""
        ...
    @overload
    def ModifyPositionAsync(self, position: Position, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify Position in asynchronous execution mode"""
        ...
    @overload
    def ModifyPositionAsync(self, position: Position, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify Position in asynchronous execution mode"""
        ...
    @overload
    def ModifyPositionAsync(self, position: Position, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify Position in asynchronous execution mode"""
        ...
    @overload
    def ModifyPositionAsync(self, position: Position, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify Position in asynchronous execution mode"""
        ...
    @overload
    def ModifyPositionAsync(self, position: Position, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify Position in asynchronous execution mode"""
        ...
    @overload
    def ModifyPositionAsync(self, position: Position, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify Position in asynchronous execution mode"""
        ...
    @overload
    def ModifyPositionAsync(self, position: Position, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify Position in asynchronous execution mode"""
        ...
    @overload
    def ModifyPositionAsync(self, position: Position, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify Position in asynchronous execution mode"""
        ...
    @overload
    def ModifyPositionAsync(self, position: Position, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify Position in asynchronous execution mode"""
        ...
    def OnError(self, error: Error) -> None:
        """Called if there is an error executing a trade operation."""
        ...
    def OnException(self, exception: Exception) -> None:
        """Called on each unhandled exception."""
        ...
    def OnStart(self) -> None:
        """Called when Plugin is being started. Override this method to initialize your Plugin."""
        ...
    def OnStop(self) -> None:
        """Called when Plugin is stopped."""
        ...
    def OnTimer(self) -> None:
        """Called when the timer interval has elapsed."""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, hasTrailingStop: bool) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, hasTrailingStop: bool) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, hasTrailingStop: bool) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def Print(self, value: object) -> None:
        """Prints text representation of the specified object to the log."""
        ...
    @overload
    def Print(self, parameters: list[object]) -> None:
        """Prints a message to the Log"""
        ...
    @overload
    def Print(self, message: str, parameters: list[object]) -> None:
        """Prints a message to the Log."""
        ...
    def RefreshData(self) -> None:
        """Updates Bars, Positions, PendingOrders, History, etc. And sends postponed events after Thread sleep call. If you put the main thread on sleep by calling Thread sleep method then you have to call RefreshData after Thread wakes up to send the postponed events while thread was sleeping."""
        ...
    @overload
    def ReversePosition(self, position: Position) -> TradeResult:
        """Modify the direction of trade at position"""
        ...
    @overload
    def ReversePosition(self, position: Position, volume: float) -> TradeResult:
        """Modify the direction of trade and volume of a position"""
        ...
    @overload
    def ReversePositionAsync(self, position: Position, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Reverses Position in asynchronous execution mode"""
        ...
    @overload
    def ReversePositionAsync(self, position: Position, volume: float, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Reverses Position in asynchronous execution mode"""
        ...
    @overload
    def Sleep(self, timespan: TimeSpan) -> None:
        """Suspends the plugin until the specified timespan elapses."""
        ...
    @overload
    def Sleep(self, milliseconds: int) -> None:
        """Suspends the plugin until the specified number of milliseconds elapses."""
        ...
    @overload
    def Sleep(self, dateTime: DateTime) -> None:
        """Suspends the plugin until the specified datetime ."""
        ...
    Account: IAccount
    """Contains all Account information"""
    AlgoRegistry: AlgoRegistry
    """Provides access to installed Algorithms."""
    Application: Application
    """Represents the application."""
    Asp: Asp
    """Gets the active symbol panel."""
    AssetConverter: IAssetConverter
    """Converts an asset to another asset."""
    Assets: Assets
    """Returns list of all available assets."""
    Backtesting: Backtesting
    """Provides access to cBot backtesting from plugins, including custom backtesting data sources."""
    ChartManager: ChartManager
    """Returns chart manager."""
    ChartTemplates: ChartTemplates
    """Provides access to Chart Templates."""
    Clipboard: Clipboard
    """Provides access to system Clipboard."""
    Commands: Commands
    """Provides access to commands."""
    Compiler: Compiler
    """Provides access to algo compiler."""
    CustomSymbols: CustomSymbols
    """Provides access to custom symbols API."""
    FileAssociations: FileAssociations
    """Provides access to file associations."""
    HistoricalOrders: HistoricalOrders
    """Provides access to historical orders."""
    History: History
    """Represents the collection of all historical trades of the account."""
    Hotkeys: Hotkeys
    """Provides access to hotkeys API."""
    Http: Http
    """Send HTTP requests."""
    Indicators: IIndicatorsAccessor
    """Access to the built-in Indicators."""
    LastResult: TradeResult
    """The latest trade result"""
    LocalStorage: LocalStorage
    """Access the local storage API."""
    MainMenu: MainMenu
    """Provides access to main menu API."""
    MarketData: MarketData
    """Provides access to Market Data."""
    MarketSessions: MarketSession
    """Returns current market sessions."""
    Messages: Messages
    """Access the messaging API."""
    Notifications: INotifications
    """Represents the notifications, such as sounds and email."""
    Optimization: Optimization
    """Provides access to cBot parameter optimization."""
    PendingOrders: PendingOrders
    """The array of all Pending Orders of the account."""
    Permissions: Permissions
    """Contains all Permissions information"""
    Positions: Positions
    """The list of all open positions of the account."""
    PriceAlerts: PriceAlerts
    """Provides access to Price Alerts."""
    Server: IServer
    """Server related information."""
    Symbols: Symbols
    """Gets the symbol names."""
    Time: DateTime
    """Returns the current server time. The shortcut to the Server.Time property."""
    TimeFrameManager: TimeFrameManager
    """Provides access to TimeFrames API."""
    TimeFrames: TimeFrames
    """Gets collection of available TimeFrames."""
    TimeInUtc: DateTime
    """Returns the current server time in UTC. The shortcut to the Server.TimeInUtc property."""
    TimeZone: TimeZoneInfo
    """TimeZone of a Plugin."""
    Timer: Timer
    """Access to the Timer object."""
    TradeWatch: TradeWatch
    """Gets the Trade Watch panel."""
    Transactions: Transactions
    """Access account transactions."""
    Watchlists: Watchlists
    """Gets the watchlist."""
    MarketSessionsChanged: Event[Callable[[MarketSessionChangedEventArgs], None]]
    """Occurs when market sessions change."""

class PluginAttribute:
    """Sealed class PluginAttribute."""
    def __init__(self) -> None: ...
    AccessRights: AccessRights
    """Gets or sets the access rights required for the Plugin."""
    AdditionalInfoUrl: str
    """Gets or sets additional info url."""
    TimeZone: str
    """Sets the timezone for all the Plugin datetime references"""

class PluginType(AlgoType):
    """Represents a plugin algorithm type."""
    IsEnabled: bool
    """Returns true if plugin is enabled otherwise false."""
    Parameters: IReadonlyList[AlgoParameter]
    """Gets collection of Plugin parameters."""

class Point:
    """Represents an x- and y-coordinate pair in two-dimensional space."""
    def __init__(self, x: float, y: float) -> None: ...
    X: float
    """Gets or sets the x-coordinate of this Point."""
    Y: float
    """Gets or sets the y-coordinate of this Point."""

class Polygon(Shape):
    """Draws a polygon, which is a connected series of lines that form a closed shape."""
    def __init__(self) -> None: ...
    FillRule: FillRule
    """Gets or sets a FillRule enumeration that specifies how the interior fill of the shape is determined."""
    Points: list[Point]
    """Gets or sets a collection that contains the vertex points of the polygon."""

class Polyline(Shape):
    """Draws a series of connected straight lines."""
    def __init__(self) -> None: ...
    FillRule: FillRule
    """Gets or sets a FillRule enumeration that specifies how the interior fill of the shape is determined."""
    Points: list[Point]
    """Gets or sets a collection that contains the vertex points of the Polyline."""

class PolynomialRegressionChannels(StandardIndicator):
    """Polynomial Regression Channel (PRC) is an RTX Extension indicator that draws a best fit n-degree polynomial regression line through a recent period of data."""
    Prc: IndicatorDataSeries
    """Get the Polynomial Regression Channels Prc data series"""
    Sqh: IndicatorDataSeries
    """Get the Polynomial Regression Channels Sqh data series"""
    Sqh2: IndicatorDataSeries
    """Get the Polynomial Regression Channels Sqh2 data series"""
    Sql: IndicatorDataSeries
    """Get the Polynomial Regression Channels Sql data series"""
    Sql2: IndicatorDataSeries
    """Get the Polynomial Regression Channels Sql2 data series"""

class PopupNotification:
    """Represents a popup notification."""
    def Complete(self, finalState: PopupNotificationState) -> None:
        """Completes an InProgress popup notification."""
        ...
    State: PopupNotificationState
    """Gets state of popup notification."""

class PopupNotificationState:
    """Represents different states for popup notifications."""
    InProgress: PopupNotificationState
    Success: PopupNotificationState
    Error: PopupNotificationState
    Partial: PopupNotificationState
    Information: PopupNotificationState

class Position:
    """Taking or opening a position means buying or selling a trading pair."""
    def Close(self) -> TradeResult:
        """Shortcut for the Robot.ClosePosition method."""
        ...
    def ModifyStopLossBreakEven(self, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Shortcut for the Robot.ModifyPosition method to change the StopLoss Break-Even."""
        ...
    def ModifyStopLossPips(self, stopLossPips: float | None) -> TradeResult:
        """Shortcut for the Robot.ModifyPosition method to change the Stop Loss pips"""
        ...
    def ModifyStopLossPrice(self, stopLoss: float | None) -> TradeResult:
        """Shortcut for Robot.ModifyPosition method to change the Stop Loss."""
        ...
    @overload
    def ModifyTakeProfit(self, takeProfitProtections: RelativeTakeProfitProtections) -> TradeResult:
        """Shortcut for the Robot.ModifyPosition method to change the Take Profit protection"""
        ...
    @overload
    def ModifyTakeProfit(self, takeProfitProtections: AbsoluteTakeProfitProtections) -> TradeResult:
        """Shortcut for the Robot.ModifyPosition method to change the Take Profit protection"""
        ...
    def ModifyTakeProfitPips(self, takeProfitPips: float | None) -> TradeResult:
        """Shortcut for the Robot.ModifyPosition method to change the Take Profit pips"""
        ...
    def ModifyTakeProfitPrice(self, takeProfit: float | None) -> TradeResult:
        """Shortcut for Robot.ModifyPosition method to change the Take Profit."""
        ...
    def ModifyTrailingStop(self, hasTrailingStop: bool) -> TradeResult:
        """Shortcut for the Robot.ModifyPosition method to change the Trailing Stop."""
        ...
    def ModifyVolume(self, volume: float) -> TradeResult:
        """Shortcut for the Robot.ModifyPosition method to change the VolumeInUnits."""
        ...
    @overload
    def Reverse(self) -> TradeResult:
        """Shortcut for the Robot.ReversePosition method to change the direction of the trade."""
        ...
    @overload
    def Reverse(self, volume: float) -> TradeResult:
        """Shortcut for the Robot.ReversePosition method to change the direction of trade and the volume."""
        ...
    AbsoluteTakeProfitProtections: AbsoluteTakeProfitProtections
    """The take profit protections of the position. Null if position has no take profit."""
    Channel: str
    """Gets the channel via which the position was placed in a string format."""
    Comment: str
    """Comment can be used as a note for the order."""
    Commissions: float
    """Commission Amount of the request to trade one way (Buy/Sell) associated with this position."""
    CurrentPrice: float
    """Gets the position current market price. If Position's TradeType is Buy it returns Symbol current Bid price. If position's TradeType is Sell it returns Symbol current Ask price."""
    Deals: IReadonlyList[Deal]
    """Gets the position deals."""
    EntryPrice: float
    """Entry price of the position."""
    EntryTime: DateTime
    """Entry time of trade associated with the position. The Timezone used is set in the cBot attribute."""
    GrossProfit: float
    """Gross profit accrued by the order associated with the position."""
    HasTrailingStop: bool
    """When HasTrailingStop set to true, the server updates the Stop Loss every time the position moves in your favor."""
    Id: int
    """The position's unique identifier."""
    Label: str
    """Label can be used to represent the order."""
    LastUpdateTime: DateTime | None
    """Gets the time when a position was last updated. The timezone used is set in the algorithm class attribute."""
    Margin: float
    """The amount of used margin by the position."""
    NetProfit: float
    """The Net profit of the position."""
    Pips: float
    """Represents the winning or loosing pips of the position."""
    Quantity: float
    """Quantity of lots traded by the position."""
    StopLoss: float | None
    """The Stop Loss level of the position."""
    StopLossBreakEven: StopLossBreakEven
    """The stop loss break even of the position."""
    StopLossTriggerMethod: StopTriggerMethod | None
    """Trigger method for the position's Stop Loss."""
    Swap: float
    """Swap is the overnight interest rate if any, accrued on the position."""
    Symbol: Symbol
    """Gets the position symbol."""
    SymbolName: str
    """Gets the symbol name."""
    TakeProfit: float | None
    """The take profit level of the position."""
    TradeType: TradeType
    """Trade type (Buy/Sell) of the position."""
    VolumeInUnits: float
    """The amount traded by the position."""

class PositionCloseReason:
    """The reason for closing the position."""
    Closed: PositionCloseReason
    StopLoss: PositionCloseReason
    TakeProfit: PositionCloseReason
    StopOut: PositionCloseReason

class PositionClosedEventArgs:
    """Provides data for the position closing event."""
    def __init__(self, position: Position, reason: PositionCloseReason) -> None: ...
    Position: Position
    """Gets the position being closed."""
    Reason: PositionCloseReason
    """Gets the reason of the position being closed."""

class PositionModifiedEventArgs:
    """Provides data for the position modification event."""
    Position: Position
    """Gets or sets the modified position."""

class PositionOpenedEventArgs:
    """Provides data for the position opening event."""
    Position: Position
    """Gets or sets the position being opened."""

class Positions:
    """Provides access to methods of the positions collection."""
    @overload
    def Find(self, label: str) -> Position:
        """Find a position by its label."""
        ...
    @overload
    def Find(self, label: str, symbolName: str) -> Position:
        """Find a position by its label and symbol name."""
        ...
    @overload
    def Find(self, label: str, symbolName: str, tradeType: TradeType) -> Position:
        """Find a position by its label, symbol name and trade type"""
        ...
    @overload
    def FindAll(self, label: str) -> list[Position]:
        """Find all positions with this label."""
        ...
    @overload
    def FindAll(self, label: str, symbolName: str) -> list[Position]:
        """Find all positions with this label and symbol name."""
        ...
    @overload
    def FindAll(self, label: str, symbolName: str, tradeType: TradeType) -> list[Position]:
        """Finds all the positions of this label, symbol name and trade type."""
        ...
    def FindById(self, id: int) -> Position:
        """Find Position by Id."""
        ...
    Count: int
    """The total number of open positions."""
    Item: Position
    """Finds a position by index."""
    Closed: Event[Callable[[PositionClosedEventArgs], None]]
    """Occurs each time a position is closed."""
    Modified: Event[Callable[[PositionModifiedEventArgs], None]]
    """Occurs each time a position is modified."""
    Opened: Event[Callable[[PositionOpenedEventArgs], None]]
    """Occurs each time a position is opened."""

class PositiveVolumeIndex(StandardIndicator):
    """The positive volume index measures the trend of the stock prices for days when volume increases from previous day's volume."""
    Result: IndicatorDataSeries
    """Gets or sets the time series result of the Positive Volume Index indicator instance."""

class PriceAlert:
    """Represents a price alert."""
    @overload
    def Update(self, symbol: Symbol, price: float, quoteType: PriceAlertQuoteType, condition: PriceAlertCondition) -> None:
        """Updates price alert."""
        ...
    @overload
    def Update(self, symbol: Symbol, price: float, quoteType: PriceAlertQuoteType, condition: PriceAlertCondition, showPopup: bool, message: str) -> None:
        """Updates price alert."""
        ...
    Condition: PriceAlertCondition
    """Get condition."""
    Id: int
    """Get unique Id."""
    LastUpdateTime: DateTime
    """Get/set last update time."""
    Message: str
    """Get optional message."""
    Price: float
    """Get price level."""
    QuoteType: PriceAlertQuoteType
    """Get quote type."""
    ShowPopup: bool
    """Get if the price alert will show a pop-up."""
    Symbol: Symbol
    """Get symbol."""

class PriceAlertAddedEventArgs:
    """Provides data for the price alert added event."""
    PriceAlert: PriceAlert
    """Gets added price alert."""

class PriceAlertCondition:
    """Represents the price alert conditions."""
    HigherOrEqual: PriceAlertCondition
    LowerOrEqual: PriceAlertCondition

class PriceAlertQuoteType:
    """Represents the price alert quote types."""
    Bid: PriceAlertQuoteType
    Ask: PriceAlertQuoteType

class PriceAlertRemovedEventArgs:
    """Provides data for the price alert removed event."""
    PriceAlert: PriceAlert
    """Gets removed price alert."""

class PriceAlertTriggeredEventArgs:
    """Provides data for the price alert triggered event."""
    PriceAlert: PriceAlert
    """Gets triggered price alert."""

class PriceAlertUpdatedEventArgs:
    """Provides data for the price alert updated event."""
    PriceAlert: PriceAlert
    """Gets updated price alert."""

class PriceAlerts:
    """Represents a collection of price alerts."""
    def Add(self, symbol: Symbol, price: float, quoteType: PriceAlertQuoteType, condition: PriceAlertCondition) -> PriceAlert:
        """Adds a new price alert."""
        ...
    def Find(self, id: int) -> PriceAlert:
        """Finds a price alert by its Id."""
        ...
    def FindAll(self, symbolName: str) -> list[PriceAlert]:
        """Finds all price alerts by their symbol."""
        ...
    def Remove(self, priceAlert: PriceAlert) -> bool:
        """Removes a price alert."""
        ...
    Count: int
    """Gets the total number of active price alerts."""
    Added: Event[Callable[[PriceAlertAddedEventArgs], None]]
    """Occurs when a new price alert is added."""
    Removed: Event[Callable[[PriceAlertRemovedEventArgs], None]]
    """Occurs when a price alert is removed."""
    Triggered: Event[Callable[[PriceAlertTriggeredEventArgs], None]]
    """Occurs when a price alert is triggered."""
    Updated: Event[Callable[[PriceAlertUpdatedEventArgs], None]]
    """Occurs when a price alert is updated."""

class PriceDataSourceId:
    """Represents the Id for price data, it's used for backtesting data sources."""
    def __init__(self, Symbol: Symbol, TimeFrame: TimeFrame) -> None: ...
    Symbol: Symbol
    """Symbol"""
    TimeFrame: TimeFrame
    """TimeFrame"""

class PriceOscillator(StandardIndicator):
    """The Price Oscillator calculates the spread between a short-period moving average and a long-period moving average."""
    Result: IndicatorDataSeries
    """Gets the resulting time series of the Price Oscillator indicator calculation."""

class PriceROC(StandardIndicator):
    """The Price ROC calculates the percentage change between the most recent price and the n-periods of the past price."""
    Result: IndicatorDataSeries
    """Gets the resulting time series of the Price ROC indicator calculation."""

class PriceType:
    """An enumeration of the different price types."""
    Open: PriceType
    High: PriceType
    Low: PriceType
    Close: PriceType
    TickVolume: PriceType
    Median: PriceType
    Typical: PriceType
    Weighted: PriceType
    Average: PriceType

class PriceVolumeTrend(StandardIndicator):
    """Price and Volume Trend is a variation of On Balance Volume, used to determine the strength of trends and warn of reversals."""
    Result: IndicatorDataSeries
    """Gets or sets the time series of the Price Volume Trend indicator."""

class ProgressBar(ControlBase):
    """Progress bar control."""
    def __init__(self) -> None: ...
    IsIndeterminate: bool
    """Gets / sets whether the ProgressBar shows actual values or generic, continuous progress feedback."""
    Maximum: float
    """Get / set progress bar maximum value amount if type is Determinate (default is 100)."""
    Minimum: float
    """Get / set progress bar minimum value amount if type is Determinate (default is 0)."""
    Value: float
    """Get / set progress bar value amount if type is Determinate."""

class ProportionalAmountType:
    """Defines types of amounts you can use for using symbol volume methods."""
    Balance: ProportionalAmountType
    Equity: ProportionalAmountType

class ProtectionType:
    """The protection type for orders and positions."""
    None: ProtectionType
    Relative: ProtectionType
    Absolute: ProtectionType

class RadioButton(Control):
    """Reporesents the Radiobutton chart control type."""
    def __init__(self) -> None: ...
    Content: ControlBase
    """Gets or sets the content."""
    GroupName: str
    """Gets or sets the name of the group."""
    IsChecked: bool
    """Defines if the radiobutton is checked."""
    Text: str
    """Gets or sets the text."""
    Checked: Event[Callable[[RadioButtonEventArgs], None]]
    """Occurs when checked."""
    Click: Event[Callable[[RadioButtonEventArgs], None]]
    """Occurs when clicked."""
    Unchecked: Event[Callable[[RadioButtonEventArgs], None]]
    """Occurs when unchecked."""

class RadioButtonEventArgs:
    """Represents the radio button actions."""
    RadioButton: RadioButton
    """Gets the radiobutton data."""

class RainbowOscillator(StandardIndicator):
    """Developed by Mel Widner, Rainbow Oscillator is based on multiple moving averages and helps to identify trends and provides overbought/oversold levels."""
    Result: IndicatorDataSeries
    """Gets the resulting time series of the Rainbow Oscillator indicator calculation."""

class RateLimitException:
    """Represents errors that occur when API rate limits are exceeded."""
    ...

class Rectangle(Shape):
    """Represents the rectangle."""
    def __init__(self) -> None: ...
    RadiusX: float
    """Gets or sets the x-axis radius of the ellipse that is used to round the corners of the rectangle."""
    RadiusY: float
    """Gets or sets the y-axis radius of the ellipse that is used to round the corners of the rectangle."""

class RelativeStopLossProtection:
    """Represents a stop loss defined as a distance (in pips) from the order's entry price."""
    @overload
    def __init__(self, Distance: float) -> None: ...
    @overload
    def __init__(self, original: RelativeStopLossProtection) -> None: ...
    Distance: float
    """The stop loss distance, in pips, from the order's entry price."""

class RelativeStrengthIndex(StandardIndicator):
    """The RSI (Wilder) is momentum oscillator, measuring the velocity and magnitude of directional price movements."""
    Result: IndicatorDataSeries
    """Gets the resulting time series of the Relative Strength Index indicator calculation."""

class RelativeTakeProfitLastProtection:
    """Represents the final take profit in a relative take profit ladder, closing the remaining order volume at a distance (in pips) from the entry price."""
    @overload
    def __init__(self, Distance: float) -> None: ...
    @overload
    def __init__(self, original: RelativeTakeProfitLastProtection) -> None: ...
    Distance: float
    """The take profit distance, in pips, from the order's entry price."""

class RelativeTakeProfitProtection:
    """Represents a partial take profit closing a portion of the order volume at a distance (in pips) from the entry price."""
    @overload
    def __init__(self, Volume: float, Distance: float) -> None: ...
    @overload
    def __init__(self, original: RelativeTakeProfitProtection) -> None: ...
    Distance: float
    """The take profit distance, in pips, from the order's entry price."""
    Volume: float
    """The portion of the order volume to close when the take profit is triggered."""

class RelativeTakeProfitProtections:
    """Represents a ladder of up to four partial take profits at distances (in pips) from the entry price, followed by a final take profit that closes any remaining volume."""
    @overload
    def __init__(self, lastTakeProfit: RelativeTakeProfitLastProtection) -> None: ...
    @overload
    def __init__(self, firstTakeProfit: RelativeTakeProfitProtection, lastTakeProfit: RelativeTakeProfitLastProtection) -> None: ...
    @overload
    def __init__(self, firstTakeProfit: RelativeTakeProfitProtection, secondTakeProfit: RelativeTakeProfitProtection, lastTakeProfit: RelativeTakeProfitLastProtection) -> None: ...
    @overload
    def __init__(self, firstTakeProfit: RelativeTakeProfitProtection, secondTakeProfit: RelativeTakeProfitProtection, thirdTakeProfit: RelativeTakeProfitProtection, lastTakeProfit: RelativeTakeProfitLastProtection) -> None: ...
    @overload
    def __init__(self, firstTakeProfit: RelativeTakeProfitProtection, secondTakeProfit: RelativeTakeProfitProtection, thirdTakeProfit: RelativeTakeProfitProtection, fourthTakeProfit: RelativeTakeProfitProtection, lastTakeProfit: RelativeTakeProfitLastProtection) -> None: ...
    @overload
    def __init__(self, original: RelativeTakeProfitProtections) -> None: ...
    FirstTakeProfit: RelativeTakeProfitProtection
    """Gets the first partial take profit, if any."""
    FourthTakeProfit: RelativeTakeProfitProtection
    """Gets the fourth partial take profit, if any."""
    LastTakeProfit: RelativeTakeProfitLastProtection
    """Gets the final take profit that closes the remaining volume."""
    SecondTakeProfit: RelativeTakeProfitProtection
    """Gets the second partial take profit, if any."""
    ThirdTakeProfit: RelativeTakeProfitProtection
    """Gets the third partial take profit, if any."""

class RelativeVigorIndex(StandardIndicator):
    """The RVI is a momentum oscillator, measuring the strength of a trend."""
    Result: IndicatorDataSeries
    """Gets the resulting time series of the Relative Vigor Index calculation (blue line)."""
    Signal: IndicatorDataSeries
    """Gets the Signal line of RVI (red line)."""

class ResizeMode:
    """Types of resize modes for windows"""
    NoResize: ResizeMode
    CanMinimize: ResizeMode
    CanResize: ResizeMode
    CanResizeWithGrip: ResizeMode

class Robot(Algo):
    """Base class for all cBots."""
    def __init__(self) -> None: ...
    def CancelPendingOrder(self, pendingOrder: PendingOrder) -> TradeResult:
        """Cancel a Pending Order"""
        ...
    def CancelPendingOrderAsync(self, pendingOrder: PendingOrder, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Cancel a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ClosePosition(self, position: Position) -> TradeResult:
        """Close a position"""
        ...
    @overload
    def ClosePosition(self, position: Position, volume: int) -> TradeResult:
        """Close a position"""
        ...
    @overload
    def ClosePosition(self, position: Position, volume: float) -> TradeResult:
        """Close a position"""
        ...
    @overload
    def ClosePositionAsync(self, position: Position, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Close a position in asynchronous execution mode"""
        ...
    @overload
    def ClosePositionAsync(self, position: Position, volume: int, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Close a position in asynchronous execution mode"""
        ...
    @overload
    def ClosePositionAsync(self, position: Position, volume: float, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Close a position in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketOrder(self, tradeType: TradeType, symbolName: str, volume: float) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketOrder(self, tradeType: TradeType, symbolName: str, volume: float, label: str) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketOrder(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLossPips: float | None, takeProfitPips: float | None) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketOrder(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLossPips: float | None, takeProfitPips: float | None, comment: str) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketOrder(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLossPips: float | None, takeProfitPips: float | None, comment: str, hasTrailingStop: bool) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketOrder(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLossPips: float | None, takeProfitPips: float | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketOrder(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketOrder(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketOrder(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketOrder(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketOrder(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketOrder(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketOrder(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, hasTrailingStop: bool) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketOrder(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, label: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLossPips: float | None, takeProfitPips: float | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLossPips: float | None, takeProfitPips: float | None, comment: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLossPips: float | None, takeProfitPips: float | None, comment: str, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLossPips: float | None, takeProfitPips: float | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketRangeOrder(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketRangeOrder(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketRangeOrder(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLossPips: float | None, takeProfitPips: float | None) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketRangeOrder(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLossPips: float | None, takeProfitPips: float | None, comment: str) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketRangeOrder(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLossPips: float | None, takeProfitPips: float | None, comment: str, hasTrailingStop: bool) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketRangeOrder(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLossPips: float | None, takeProfitPips: float | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketRangeOrder(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Execute a Market Range Order"""
        ...
    @overload
    def ExecuteMarketRangeOrder(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Execute a Market Range Order"""
        ...
    @overload
    def ExecuteMarketRangeOrder(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketRangeOrder(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketRangeOrder(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketRangeOrder(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketRangeOrder(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, hasTrailingStop: bool) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketRangeOrder(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Execute a Market Order"""
        ...
    @overload
    def ExecuteMarketRangeOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketRangeOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketRangeOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLossPips: float | None, takeProfitPips: float | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketRangeOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLossPips: float | None, takeProfitPips: float | None, comment: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketRangeOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLossPips: float | None, takeProfitPips: float | None, comment: str, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketRangeOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLossPips: float | None, takeProfitPips: float | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketRangeOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market range order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketRangeOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market range order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketRangeOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketRangeOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketRangeOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketRangeOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketRangeOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    @overload
    def ExecuteMarketRangeOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, marketRangePips: float, basePrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, comment: str, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Execute a market order in asynchronous execution mode"""
        ...
    def GetFitness(self, args: GetFitnessArgs) -> float:
        """Override this method to provide custom fitness value for Optimization"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expirationTime: DateTime | None) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expirationTime: DateTime | None, volume: int) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: int) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: int, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: int) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: int, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expirationTime: DateTime | None, volume: float) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None, stopLimitRangePips: float | None) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None, stopLimitRangePips: float | None) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None, stopLimitRangePips: float | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None, stopLimitRangePips: float | None) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrder(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None, stopLimitRangePips: float | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify a Pending Order"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expirationTime: DateTime | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expirationTime: DateTime | None, volume: int, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: int, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: int, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: int, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: int, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expirationTime: DateTime | None, volume: float, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None, stopLimitRangePips: float | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None, stopLimitRangePips: float | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None, stopLimitRangePips: float | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None, stopLimitRangePips: float | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPendingOrderAsync(self, pendingOrder: PendingOrder, targetPrice: float, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expirationTime: DateTime | None, volume: float, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod | None, stopLimitRangePips: float | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify a Pending Order in asynchronous execution mode"""
        ...
    @overload
    def ModifyPosition(self, position: Position, volume: float) -> TradeResult:
        """Modify the volume of a position"""
        ...
    @overload
    def ModifyPosition(self, position: Position, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None) -> TradeResult:
        """Modify the protection of a position"""
        ...
    @overload
    def ModifyPosition(self, position: Position, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections) -> TradeResult:
        """Modify the protection of a position"""
        ...
    @overload
    def ModifyPosition(self, position: Position, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections) -> TradeResult:
        """Modify the protection of a position"""
        ...
    @overload
    def ModifyPosition(self, position: Position, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify the protection of a position"""
        ...
    @overload
    def ModifyPosition(self, position: Position, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify the protection of a position"""
        ...
    @overload
    def ModifyPosition(self, position: Position, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, hasTrailingStop: bool) -> TradeResult:
        """Modify the protection of a position"""
        ...
    @overload
    def ModifyPosition(self, position: Position, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, hasTrailingStop: bool) -> TradeResult:
        """Modify the protection of a position"""
        ...
    @overload
    def ModifyPosition(self, position: Position, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, hasTrailingStop: bool) -> TradeResult:
        """Modify the protection of a position"""
        ...
    @overload
    def ModifyPosition(self, position: Position, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify the protection of a position"""
        ...
    @overload
    def ModifyPosition(self, position: Position, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify the protection of a position"""
        ...
    @overload
    def ModifyPosition(self, position: Position, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Modify the protection of a position"""
        ...
    @overload
    def ModifyPosition(self, position: Position, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Modify the protection of a position"""
        ...
    @overload
    def ModifyPosition(self, position: Position, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Modify the protection of a position"""
        ...
    @overload
    def ModifyPosition(self, position: Position, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify the protection of a position"""
        ...
    @overload
    def ModifyPosition(self, position: Position, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Modify the protection of a position"""
        ...
    @overload
    def ModifyPositionAsync(self, position: Position, volume: float, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify Position in asynchronous execution mode"""
        ...
    @overload
    def ModifyPositionAsync(self, position: Position, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify Position in asynchronous execution mode"""
        ...
    @overload
    def ModifyPositionAsync(self, position: Position, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify Position in asynchronous execution mode"""
        ...
    @overload
    def ModifyPositionAsync(self, position: Position, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify Position in asynchronous execution mode"""
        ...
    @overload
    def ModifyPositionAsync(self, position: Position, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify Position in asynchronous execution mode"""
        ...
    @overload
    def ModifyPositionAsync(self, position: Position, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify Position in asynchronous execution mode"""
        ...
    @overload
    def ModifyPositionAsync(self, position: Position, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify Position in asynchronous execution mode"""
        ...
    @overload
    def ModifyPositionAsync(self, position: Position, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify Position in asynchronous execution mode"""
        ...
    @overload
    def ModifyPositionAsync(self, position: Position, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify Position in asynchronous execution mode"""
        ...
    @overload
    def ModifyPositionAsync(self, position: Position, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify Position in asynchronous execution mode"""
        ...
    @overload
    def ModifyPositionAsync(self, position: Position, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify Position in asynchronous execution mode"""
        ...
    @overload
    def ModifyPositionAsync(self, position: Position, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify Position in asynchronous execution mode"""
        ...
    @overload
    def ModifyPositionAsync(self, position: Position, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify Position in asynchronous execution mode"""
        ...
    @overload
    def ModifyPositionAsync(self, position: Position, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify Position in asynchronous execution mode"""
        ...
    @overload
    def ModifyPositionAsync(self, position: Position, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify Position in asynchronous execution mode"""
        ...
    @overload
    def ModifyPositionAsync(self, position: Position, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Modify Position in asynchronous execution mode"""
        ...
    def OnBar(self) -> None:
        """Called on each incoming Bar."""
        ...
    def OnBarClosed(self) -> None:
        """Called when a new bar is opened; the method is called for the previous (closed) bar."""
        ...
    def OnError(self, error: Error) -> None:
        """Called if there is an error executing a trade operation."""
        ...
    def OnStart(self) -> None:
        """Called when cBot is being started. Override this method to initialize cBot, create nested indicators, etc."""
        ...
    def OnStop(self) -> None:
        """Called when cBot is stopped."""
        ...
    def OnTick(self) -> None:
        """Called on each incoming market tick."""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, hasTrailingStop: bool) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Limit Order"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, hasTrailingStop: bool) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a Stop Limit Order"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopLimitOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place Stop Limit order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, hasTrailingStop: bool) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrder(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod, stopLossBreakEven: StopLossBreakEven) -> TradeResult:
        """Place a stop order"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def PlaceStopOrderAsync(self, tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Place stop order in asynchronous execution mode"""
        ...
    @overload
    def ReversePosition(self, position: Position) -> TradeResult:
        """Modify the direction of trade at position"""
        ...
    @overload
    def ReversePosition(self, position: Position, volume: float) -> TradeResult:
        """Modify the direction of trade and volume of a position"""
        ...
    @overload
    def ReversePositionAsync(self, position: Position, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Reverses Position in asynchronous execution mode"""
        ...
    @overload
    def ReversePositionAsync(self, position: Position, volume: float, callback: Callable[[TradeResult], None]) -> TradeOperation:
        """Reverses Position in asynchronous execution mode"""
        ...
    def Stop(self) -> None:
        """Stops the cBot. cBot will be completely stopped and will not send/receive any signals."""
        ...
    Account: IAccount
    """Contains all Account information"""
    LastResult: TradeResult
    """The latest trade result"""

class RobotAttribute:
    """Sealed class RobotAttribute."""
    def __init__(self) -> None: ...
    AccessRights: AccessRights
    """Gets or sets the access rights required for the cBot."""
    AddIndicators: bool
    """Gets or sets whether indicators created by robot will be added to chart or not."""
    AdditionalInfoUrl: str
    """Gets or sets additional info url."""
    DefaultSymbolName: str
    """Not used. cTrader applies no default symbol to a cBot: a new instance runs on the symbol it is added with, which the cBot reads from SymbolName."""
    DefaultTimeFrame: str
    """Not used. cTrader applies no default time frame to a cBot: a new instance runs on the time frame of the chart it is added to, which the cBot reads from TimeFrame."""
    Name: str
    """The name of a robot. Sets from constructor."""
    TimeZone: str
    """Sets the timezone for all the robot or indicator datetime references"""

class RobotStartDialog:
    """Represents a common dialog box that allows a user to start a cBot."""
    def __init__(self, robotType: RobotType) -> None: ...
    def ShowDialog(self) -> None:
        """Shows the dialog."""
        ...
    RobotType: RobotType
    """Gets or sets the Robot Type."""

class RobotState:
    """Represents the predefined states of a Robot instance."""
    Stopped: RobotState
    Running: RobotState
    Stopping: RobotState
    Restarting: RobotState

class RobotType(AlgoType):
    """Represents a robot / cBot algorithm type."""
    Parameters: IReadonlyList[AlgoParameter]
    """Gets collection of Robot parameters."""

class RoundingMode:
    """The rounding mode for normalizing trade volume."""
    ToNearest: RoundingMode
    Down: RoundingMode
    Up: RoundingMode

class RunningMode:
    """Defines if a cBot is running in real time, in the silent backtesting mode, in the visual backtesting mode, or in the optimization mode."""
    RealTime: RunningMode
    SilentBacktesting: RunningMode
    VisualBacktesting: RunningMode
    Optimization: RunningMode

class SaveFileDialog:
    """Represents a common dialog box that allows a user to specify a filename to save."""
    def __init__(self) -> None: ...
    def Reset(self) -> None:
        """Resets all dialog properties to their default values."""
        ...
    @overload
    def ShowDialog(self) -> FileDialogResult:
        """Shows a file dialog, with the owner as the main Window"""
        ...
    @overload
    def ShowDialog(self, owner: Window) -> FileDialogResult:
        """Shows a file dialog, with the passed owner window."""
        ...
    @overload
    def WriteToFile(self, data: str) -> None:
        """Writes data to selected file."""
        ...
    @overload
    def WriteToFile(self, data: list[int]) -> None:
        """Writes data to selected file."""
        ...
    AddExtension: bool
    """Gets or sets a value indicating whether a file dialog automatically adds an extension to a file name if the user omits an extension."""
    DefaultExt: str
    """Gets or sets a value that specifies the default extension string to use to filter the list of files that are displayed."""
    Filter: str
    """Gets or sets the filter string that determines what types of files are displayed in file dialog."""
    InitialDirectory: str
    """Gets or sets the initial directory that is displayed by a file dialog."""
    Title: str
    """Gets or sets a string shown in the title bar of the dialog. If this property is null, a localized default from the operating system itself will be used."""
    ValidateNames: bool
    """Gets or sets a value indicating whether the dialog accepts only valid file names."""

class ScrollBarVisibility:
    """Specifies the visibility of a ScrollBar for scrollable content."""
    Disabled: ScrollBarVisibility
    Auto: ScrollBarVisibility
    Hidden: ScrollBarVisibility
    Visible: ScrollBarVisibility

class ScrollViewer(Control):
    """Represents a scrollable area that can contain other visible elements."""
    def __init__(self) -> None: ...
    Content: ControlBase
    """Gets or sets the content."""
    HorizontalScrollBarVisibility: ScrollBarVisibility
    """Defines the horizontal scroll bar visibility."""
    VerticalScrollBarVisibility: ScrollBarVisibility
    """Defines the vertical scroll bar visibility."""

class Shape(ControlBase):
    """Provides the base class for shape elements, such as Ellipse, Polygon, and Rectangle."""
    FillColor: Color
    """Gets or sets the fill color."""
    Stretch: Stretch
    """Gets or sets the stretch value."""
    StrokeColor: Color
    """Gets or sets the stroke color."""
    StrokeDashArray: list[float]
    """Gets or sets a collection of Double values that indicate the pattern of dashes and gaps that is used to outline shapes."""
    StrokeDashCap: PenLineCap
    """Gets or sets a PenLineCap enumeration value that specifies how the ends of a dash are drawn."""
    StrokeDashOffset: float
    """Gets or sets a Double that specifies the distance within the dash pattern where a dash begins."""
    StrokeEndLineCap: PenLineCap
    """Gets or sets the shape at the end of a line."""
    StrokeLineJoin: PenLineJoin
    """Gets or sets the shape that joins two lines."""
    StrokeMiterLimit: float
    """Gets or sets a limit on the ratio of the miter length to half the StrokeThickness of a Shape element."""
    StrokeStartLineCap: PenLineCap
    """Gets or sets the shape at the beginning of a line."""
    StrokeThickness: float
    """Gets or sets the stroke thickness."""

class SimpleMovingAverage(MovingAverage, StandardIndicator):
    """The simple moving average is an average of price within n previous periods."""
    ...

class SoundType:
    """An enum containing various constants representing different built-in sounds for notifications."""
    PositiveNotification: SoundType
    NegativeNotification: SoundType
    Announcement: SoundType
    Doorbell: SoundType
    Confirmation: SoundType

class StackPanel(Panel):
    """Arranges the child element into a single line that can be oriented horizontally or vertically."""
    def __init__(self) -> None: ...
    Orientation: Orientation
    """Gets or sets the StackPanel orientation."""

class StandardDeviation(StandardIndicator):
    """Standard Deviation measures the market volatility with a commonly used statisctical function."""
    Result: IndicatorDataSeries
    """Gets the resulting time series of the Standard Deviation indicator calculation."""

class StandardIndicator:
    """Base type for standard indicators."""
    def AddToChart(self) -> ChartIndicator:
        """Adds current indicator to chart if not added yet."""
        ...
    Bars: Bars
    """Gets indicator Bars."""
    Symbol: Symbol
    """Gets indicator Symbol."""
    TimeFrame: TimeFrame
    """Gets indicator TimeFrame."""

class StandardSeriesType:
    """An enumeration of the standard data series types of a bar."""
    Open: StandardSeriesType
    High: StandardSeriesType
    Low: StandardSeriesType
    Close: StandardSeriesType
    TickVolume: StandardSeriesType
    Median: StandardSeriesType
    Typical: StandardSeriesType
    Weighted: StandardSeriesType
    Average: StandardSeriesType

class StochasticCalculationType:
    """An enumeration of the different Stochastic Oscillator indicator calculation types."""
    LowHigh: StochasticCalculationType
    CloseClose: StochasticCalculationType

class StochasticOscillator(StandardIndicator):
    """The Stochastic Oscillator is a momentum indicator that aims to show price reversals by comparing the closing price to the price range."""
    PercentD: IndicatorDataSeries
    """%D is 3 Period Exponential Moving Average of %K."""
    PercentK: IndicatorDataSeries
    """Calculation of %K is 100 multiplied by the ratio of the closing price minus the lowest price over the last N periods over the highest price over the last N minus the lowest price over the last N periods."""

class StopLossBreakEven:
    """Represents a break-even rule that moves the stop loss to the entry price (optionally offset by a number of pips) once the trade has moved a configured trigger distance in favor of the position."""
    @overload
    def __init__(self, triggerDistance: float, offset: float) -> None: ...
    @overload
    def __init__(self, original: StopLossBreakEven) -> None: ...
    Offset: float
    """The offset in pips applied to the entry price when the stop loss is moved."""
    TriggerDistance: float
    """The distance in pips that activates the break-even rule."""

class StopTriggerMethod:
    """The trigger side for the Stop Orders."""
    Trade: StopTriggerMethod
    Opposite: StopTriggerMethod
    DoubleTrade: StopTriggerMethod
    DoubleOpposite: StopTriggerMethod

class Stretch:
    """Describes how content is resized to fill its allocated space."""
    None: Stretch
    Fill: Stretch
    Uniform: Stretch
    UniformToFill: Stretch

class StretchDirection:
    """Describes how scaling applies to content and restricts scaling to named axis types."""
    UpOnly: StretchDirection
    DownOnly: StretchDirection
    Both: StretchDirection

class Style:
    """Represents the style of a chart control."""
    @overload
    def __init__(self) -> None: ...
    @overload
    def __init__(self, parentStyle: Style) -> None: ...
    @overload
    def Get(self, property: ControlProperty) -> object:
        """Gets the chart object style for the specified ControlProperty."""
        ...
    @overload
    def Get(self, property: ControlProperty, state: ControlState) -> object:
        """Gets the chart control style for the specified ControlProperty and ControlState."""
        ...
    @overload
    def Set(self, property: ControlProperty, value: object, state: ControlState) -> None:
        """Provides data for the chart control Style for the specified ControlProperty and the ControlState."""
        ...
    @overload
    def Set(self, property: ControlProperty, value: object) -> None:
        """Sets the chart control Style for the specified ControlProperty."""
        ...

class Supertrend(StandardIndicator):
    """Supertrend is one of the most popular trend trading indicators"""
    DownTrend: IndicatorDataSeries
    """Gets the Supertrend Down trend data series"""
    UpTrend: IndicatorDataSeries
    """Gets the Supertrend Up trend data series"""

class SvgIcon:
    """Represents a SVG format vector icon."""
    def __init__(self, svgXml: str) -> None: ...

class SwingIndex(StandardIndicator):
    """Developed by Welles Wilder, the Swing Index compares current Open, high, Low and Close prices to find of current and previous periods to find "real" price."""
    Result: IndicatorDataSeries
    """Gets the Result Series of the Swing Index indicator."""

class Symbol:
    """Represents a currency pair."""
    def AmountRisked(self, volume: float, stopLossInPips: float) -> float:
        """Calculates the amount to be risked based on the specified stop loss and trading volume. Note that the result of this calculation may be imprecise as the exact degree of risk always depends on market movement and is impossible to predict."""
        ...
    def GetEstimatedMargin(self, tradeType: TradeType, volume: float) -> float:
        """Returns the amount of margin you need for x amount of volume."""
        ...
    def NormalizeVolumeInUnits(self, volume: float, roundingMode: RoundingMode) -> float:
        """Round the volume to the amount suitable for a trade."""
        ...
    def PipsForFixedRisk(self, amount: float, volume: float) -> float:
        """Calculates the number of pips to be risked based on the specified stop loss and trading volume. Note that the result of this calculation may be imprecise as the exact degree of risk always depends on market movement and is impossible to predict."""
        ...
    def PipsForProportionalRisk(self, type: ProportionalAmountType, percentage: float, volume: float) -> float:
        """Calculates the stop loss (in pips) for the proportional amount to be risked based on the specified volume. Note that the result of this calculation may be imprecise as the exact degree of risk always depends on market movement and is impossible to predict."""
        ...
    def QuantityToVolumeInUnits(self, quantity: float) -> float:
        """Convert Quantity (in lots) to Volume in units of base currency."""
        ...
    @overload
    def VolumeForFixedRisk(self, amount: float, stopLossInPips: float) -> float:
        """Calculates the volume to be risked (in X units of the account deposit currency) based on the specified stop loss. Note that the result of this calculation may be imprecise as the exact degree of risk always depends on market movement and is impossible to predict."""
        ...
    @overload
    def VolumeForFixedRisk(self, amount: float, stopLossInPips: float, roundingMode: RoundingMode) -> float:
        """Calculates the volume to be risked (in X units of the account deposit currency) based on the specified stop loss. Note that the result of this calculation may be imprecise as the exact degree of risk always depends on market movement and is impossible to predict."""
        ...
    @overload
    def VolumeForProportionalRisk(self, type: ProportionalAmountType, percentage: float, stopLossInPips: float) -> float:
        """Calculates the volume to be risked (in X% of either the account equity or balance) based on the specified stop loss. Note that the result of this calculation may be imprecise as the exact degree of risk always depends on market movement and is impossible to predict."""
        ...
    @overload
    def VolumeForProportionalRisk(self, type: ProportionalAmountType, percentage: float, stopLossInPips: float, roundingMode: RoundingMode) -> float:
        """Calculates the volume to be risked (in X% of either the account equity or balance) based on the specified stop loss. Note that the result of this calculation may be imprecise as the exact degree of risk always depends on market movement and is impossible to predict."""
        ...
    def VolumeInUnitsToQuantity(self, volume: float) -> float:
        """Convert Volume in units of base currency to Quantity (in lots)."""
        ...
    AdministrativeCharge: float
    """Gets symbol administrative charge. Administrative fee will be charged instead of SWAP if account is marked as SWAP free. Only applicable for SWAP free trading accounts."""
    AdministrativeCharge3DaysRollover: DayOfWeek | None
    """Gets the Day of the week (in UTC) when Administrative Fee charge amount will be tripled. Only applicable for SWAP free trading accounts."""
    Ask: float
    """Gets the current ask price for this symbol."""
    BaseAsset: Asset
    """Gets the symbol base asset."""
    Bid: float
    """Gets the current bid price for this symbol."""
    Commission: float
    """Gets the amount of base commission for the symbol."""
    CommissionType: SymbolCommissionType
    """Gets the symbol base commission calculation type."""
    Digits: int
    """Gets the number of digits for the symbol."""
    DynamicLeverage: IReadonlyList[LeverageTier]
    """Gets the dynamic leverage tiers for the symbol."""
    FuturesSettings: FuturesSettings
    """Gets the future contract settings if symbol represents a future contract otherwise null."""
    GracePeriod: int
    """Gets symbol grace period. This is the number of days free of Administrative fee from the time of opening a position. Only applicable for SWAP free trading accounts."""
    IsCustom: bool
    """Gets whether current symbol is a custom symbol or not."""
    IsTradingEnabled: bool
    """Gets If trading is enabled or not for the symbol."""
    LotSize: int
    """Gets the size of 1 lot in units of the base currency."""
    MarketHours: MarketHours
    """Gets access to the symbol's trading sessions schedule."""
    MinCommission: float
    """Gets the minimum amount of commission for the symbol. This is the amount of commission that will be paid by trader for any trade. Check MinCommissionType for interpretation of MinCommission value."""
    MinCommissionAsset: Asset
    """Gets the symbol minimum commission asset. If MinCommissionType is set to Asset then you can use this property to get that asset. The MinCommission value will be converted from MinCommissionAsset to account deposit asset at the moment of trade."""
    MinCommissionType: SymbolMinCommissionType
    """Gets the symbol minimum commission type. Use this property to interpret MinCommission value."""
    MinDistanceType: SymbolMinDistanceType
    """Gets the symbol minimum distances type."""
    MinStopLossDistance: float
    """Gets symbol minimum stop loss distance. Use MinDistanceType for interpretation."""
    MinTakeProfitDistance: float
    """Gets symbol minimum take profit distance. Use MinDistanceType for interpretation."""
    PipSize: float
    """Gets the pip size for current symbol."""
    PipValue: float
    """Gets the monetary value of one pip. This is the monetary value of one pip of the symbol when you started your cBot or initialized your indicator. Its not updated in real time and it remains constant."""
    PnLConversionFeeRate: float
    """Gets the symbol profit and loss conversion fee rate."""
    QuoteAsset: Asset
    """Gets the symbol quote asset."""
    Sentiment: SymbolSentiment
    """Gets symbol sentiment."""
    Spread: float
    """Gets the current spread of this symbol."""
    Swap3DaysRollover: DayOfWeek | None
    """Gets the Day of the week when Symbol SWAP charge amount will be tripled."""
    SwapCalculationType: SymbolSwapCalculationType
    """Gets the symbol SWAP calculation type."""
    SwapLong: float
    """Gets the SWAP charge for long positions of the symbol."""
    SwapShort: float
    """Gets the SWAP charge for short positions of the symbol."""
    TickSize: float
    """Gets the tick size for the current symbol."""
    TickValue: float
    """Gets the monetary value of one tick. This is the monetary value of one tick of the symbol when you started your cBot or initialized your indicator. Its not updated in real time and it remains constant."""
    TradingMode: SymbolTradingMode
    """Gets symbol trading mode."""
    UnrealizedGrossProfit: float
    """Gets the sum of the unrealized Gross profits of the positions of this Symbol"""
    UnrealizedNetProfit: float
    """Gets the sum of the unrealized Net profits of the positions of this Symbol."""
    VolumeInUnitsMax: float
    """Gets the maximum tradable amount."""
    VolumeInUnitsMin: float
    """Gets the minimum tradable amount."""
    VolumeInUnitsStep: float
    """Gets the minimum trade amount increment."""
    Tick: Event[Callable[[SymbolTickEventArgs], None]]
    """Occurs on each incoming symbol ticks"""

class SymbolAddedEventArgs:
    """Provides data for the symbols added event."""
    SymbolName: str
    """Gets added symbol name."""

class SymbolCommissionType:
    """Defines symbol commission types."""
    UsdPerMillionUsdVolume: SymbolCommissionType
    UsdPerOneLot: SymbolCommissionType
    PercentageOfTradingVolume: SymbolCommissionType
    QuoteCurrencyPerOneLot: SymbolCommissionType

class SymbolMinCommissionType:
    """Defines symbol minimum commission types."""
    Asset: SymbolMinCommissionType
    QuoteAsset: SymbolMinCommissionType

class SymbolMinDistanceType:
    """Defines symbol minimum distance types."""
    Pips: SymbolMinDistanceType
    Percentage: SymbolMinDistanceType

class SymbolRemovedEventArgs:
    """Provides data for the symbols removed event."""
    SymbolName: str
    """Gets removed symbol name."""

class SymbolSentiment:
    """Represents a symbol sentiment."""
    BuyPercentage: float
    """Gets buy percentage if available otherwise 0."""
    SellPercentage: float
    """Gets sell percentage if available otherwise 0."""
    Updated: Event[Callable[[SymbolSentimentUpdatedEventArgs], None]]
    """Occurs when symbol sentiment data is updated."""

class SymbolSentimentUpdatedEventArgs:
    """Provides data for the price alert added event."""
    Sentiment: SymbolSentiment
    """Gets sentiment."""
    SymbolName: str
    """Gets symbol name."""

class SymbolSwapCalculationType:
    """Defines the types of calculation for symbol SWAP Long/Short."""
    Pips: SymbolSwapCalculationType
    Percentage: SymbolSwapCalculationType
    Points: SymbolSwapCalculationType

class SymbolTickEventArgs:
    """Provides data for the symbol tick event."""
    Ask: float
    """Gets the ask price."""
    Bid: float
    """Gets the bid price."""
    Symbol: Symbol
    """Gets the symbol."""
    SymbolName: str
    """Gets the symbol name."""

class SymbolTradingMode:
    """Defines symbol trading modes."""
    FullAccess: SymbolTradingMode
    CloseOnly: SymbolTradingMode
    DisabledWithPendingOrderExecution: SymbolTradingMode
    FullyDisabled: SymbolTradingMode

class SymbolUpdatedEventArgs:
    """Provides data for the symbols updated event."""
    SymbolName: str
    """Gets updated symbol name."""

class Symbols:
    """Represents the list of all the symbols with the symbol names as string values."""
    def Exists(self, symbolName: str) -> bool:
        """Defines if the specific symbol name exists in the list."""
        ...
    def GetSymbol(self, symbolName: str) -> Symbol:
        """Gets the specific symbol."""
        ...
    def GetSymbols(self, symbolNames: list[str]) -> list[Symbol]:
        """Get multiple symbols at once."""
        ...
    Archived: IReadOnlySet[str]
    """Gets the set of only archived symbol names."""
    Count: int
    """Gets the total number of the symbols in the list."""
    Custom: IReadOnlySet[str]
    """Gets the set of only custom symbol names."""
    Enabled: IReadOnlySet[str]
    """Gets the set of only enabled symbol names."""
    Item: str
    """Gets the desired symbol."""
    Added: Event[Callable[[SymbolAddedEventArgs], None]]
    """Occurs when a symbol is added."""
    Removed: Event[Callable[[SymbolRemovedEventArgs], None]]
    """Occurs when a symbol is removed."""
    Updated: Event[Callable[[SymbolUpdatedEventArgs], None]]
    """Occurs when a symbol is updated."""

class TabControl(Control):
    """Represents the Tab control."""
    def __init__(self) -> None: ...
    def AddTab(self, tab: TabItem) -> None:
        """Adds a new tab."""
        ...
    def RemoveTab(self, tab: TabItem) -> bool:
        """Removes an existing tab."""
        ...
    SelectedTab: TabItem
    """Gets or sets the SelectedTab."""
    TabStripPlacement: Dock
    """Gets or sets the TabStripPlacement (Default: Top)."""
    Tabs: IReadonlyList[TabItem]
    """Get tabs."""
    SelectedTabChanged: Event[Callable[[TabControlSelectedTabChangedEventArgs], None]]
    """Occurs when the selected tab is changed."""

class TabControlSelectedTabChangedEventArgs:
    """Provides data for the TabControl SelectedTabChanged event."""
    SelectedTab: TabItem
    """Gets selected tab item."""
    TabControl: TabControl
    """Gets tab control."""

class TabItem(Control):
    """Represents the Tab item."""
    def __init__(self) -> None: ...
    Content: ControlBase
    """Gets or sets the content."""
    Header: ControlBase
    """Gets or sets the content."""

class TextAlignment:
    """The text alignment regarding the anchor point."""
    Left: TextAlignment
    Right: TextAlignment
    Center: TextAlignment
    Justify: TextAlignment

class TextBlock(Control):
    """Represents the Text Block - the control to display a non-interactive text."""
    def __init__(self) -> None: ...
    LineHeight: float
    """Gets or sets the height of the line."""
    LineStackingStrategy: LineStackingStrategy
    """Gets or sets the mechanism by which a line box is determined for each line of text within the TextBlock."""
    Text: str
    """Gets or sets the text."""
    TextAlignment: TextAlignment
    """Gets or sets the text alignment."""
    TextTrimming: TextTrimming
    """Gets or sets the text trimming behavior when the content overflows the content area."""
    TextWrapping: TextWrapping
    """Gets or sets the way how the TextBlock should wrap the text."""

class TextBox(Control):
    """Represents the text box class."""
    def __init__(self) -> None: ...
    AcceptsReturn: bool
    """Gets or sets a value that indicates how the text editing control responds when the user presses the ENTER key."""
    AcceptsTab: bool
    """Gets or sets a value that indicates how the text editing control responds when the user presses the TAB key."""
    BorderColor: Color
    """Gets or sets the color of the text box border."""
    BorderThickness: Thickness
    """Gets or sets the border thickness. Property value can be set using Thickness, number, or a string new Thickness(5), new Thickness(1, 2, 3, 4), 5, "5", "1 2 3 4"."""
    CaretColor: Color
    """Gets or sets the color of the insertion caret."""
    CharacterCasing: CharacterCasing
    """Gets or sets whether the TextBox control modifies the case of characters as they are typed."""
    HorizontalScrollBarVisibility: ScrollBarVisibility
    """Defines the horizontal scroll bar visibility."""
    IsReadOnly: bool
    """Gets or sets a value indicating whether the current text box is read-only."""
    IsReadOnlyCaretVisible: bool
    """Gets or sets a value that indicates whether a read-only text box displays a caret."""
    MaxLength: int
    """Gets or sets the maximum number of characters that can be manually entered into the text box."""
    MaxLines: int
    """Gets or sets the maximum number of visible lines."""
    MinLines: int
    """Gets or sets the minimum number of visible lines."""
    SelectionColor: Color
    """Gets or sets the text color of the current text selection."""
    SelectionOpacity: float
    """Gets or sets the opacity of the selected text."""
    Text: str
    """Gets or sets the text."""
    TextAlignment: TextAlignment
    """Gets or sets a value that indicates the horizontal alignment of text content."""
    TextWrapping: TextWrapping
    """Gets or sets how the text box should wrap text."""
    VerticalScrollBarVisibility: ScrollBarVisibility
    """Defines the vertical scroll bar visibility."""
    TextChanged: Event[Callable[[TextChangedEventArgs], None]]
    """Occurs when the text has changed."""

class TextChangedEventArgs:
    """Provides data for the TextChanged event."""
    TextBox: TextBox
    """Gets the texbox."""

class TextTrimming:
    """Describes how text is trimmed when it overflows the edge of its containing box."""
    None: TextTrimming
    CharacterEllipsis: TextTrimming
    WordEllipsis: TextTrimming

class TextWrapping:
    """Specifies whether text wraps when it reaches the edge of the containing box."""
    WrapWithOverflow: TextWrapping
    NoWrap: TextWrapping
    Wrap: TextWrapping

class Thickness:
    """Defines the thickness of the frame around the rectangle."""
    @overload
    def __init__(self, left: float, top: float, right: float, bottom: float) -> None: ...
    @overload
    def __init__(self, uniformLength: float) -> None: ...
    Bottom: float
    """Gets or sets the thickness of the bottom side of the retangle."""
    Left: float
    """Gets or sets the thickness of the left side of the retangle."""
    Right: float
    """Gets or sets the thickness of the right side of the retangle."""
    Top: float
    """Gets or sets the thickness of the top side of the retangle."""

class Tick:
    """Represents the Tick object."""
    Ask: float
    """Gets the Ask price of tick."""
    Bid: float
    """Gets the Bid price of tick."""
    Time: DateTime
    """Gets the Tick time."""

class TickVolume(StandardIndicator):
    """The Tick Volume indicator shows number of ticks for each bar."""
    Result: IndicatorDataSeries
    """The resulting time series of the calculation."""

class Ticks:
    """Represents the Ticks interface - the collection of Tick objects."""
    def GetServerFirstTime(self) -> DateTime:
        """Returns the first available server tick time."""
        ...
    def Last(self, index: int) -> Tick:
        """Gets the tick from the end of the list."""
        ...
    def LoadMoreHistory(self) -> int:
        """Loads more historical ticks. Method returns the number of loaded ticks that were added to the beginning of the collection."""
        ...
    @overload
    def LoadMoreHistoryAsync(self) -> None:
        """Loads more historical ticks asynchronously."""
        ...
    @overload
    def LoadMoreHistoryAsync(self, callback: Callable[[TicksHistoryLoadedEventArgs], None]) -> None:
        """Loads more historical ticks asynchronously."""
        ...
    Count: int
    """Gets the number of objects."""
    Item: Tick
    """Gets the specific tick data."""
    LastTick: Tick
    """Gets the last tick in the chart."""
    SymbolName: str
    """Gets the symbol name."""
    HistoryLoaded: Event[Callable[[TicksHistoryLoadedEventArgs], None]]
    """Occurs when more history is loaded due to chart scroll to the left or due to API call."""
    Reloaded: Event[Callable[[TicksHistoryLoadedEventArgs], None]]
    """Occurs when ticks are refreshed due to reconnect."""
    Tick: Event[Callable[[TicksTickEventArgs], None]]
    """Occurs when a new tick appears."""

class TicksHistoryLoadedEventArgs:
    """Provides data for the tick history loaded event."""
    Count: int
    """Gets the number of the ticks."""
    Ticks: Ticks
    """Gets the tick data."""

class TicksTickEventArgs:
    """Provides data for the tick event."""
    Ticks: Ticks
    """Gets the Ticks data."""

class TimeFrame:
    """Contains supported timeframe values."""
    @staticmethod
    def Parse(value: str) -> TimeFrame:
        """It parses a string and if it matched to a timeframe name it returns that time frame otherwise it throws FormatException"""
        ...
    @staticmethod
    def TryParse(value: str, timeFrame: TimeFrame) -> bool:
        """It parses a string and if it matched to a timeframe name it sets it to the passed timeFrame parameter"""
        ...
    Name: str
    """Returns the name of timeframe"""
    ShortName: str
    """Returns the short name of timeframe"""
    Daily: TimeFrame
    """Daily / D1"""
    Day2: TimeFrame
    """Day2 / D2"""
    Day3: TimeFrame
    """Day3 / D3"""
    HeikinDaily: TimeFrame
    """HeikinDaily / HD1"""
    HeikinDay2: TimeFrame
    """HeikinDay2 / HD2"""
    HeikinDay3: TimeFrame
    """HeikinDay3 / HD3"""
    HeikinHour: TimeFrame
    """HeikinHour / Hh1"""
    HeikinHour12: TimeFrame
    """HeikinHour12 / Hh12"""
    HeikinHour2: TimeFrame
    """HeikinHour2 / Hh2"""
    HeikinHour3: TimeFrame
    """HeikinHour3 / Hh3"""
    HeikinHour4: TimeFrame
    """HeikinHour4 / Hh4"""
    HeikinHour6: TimeFrame
    """HeikinHour6 / Hh6"""
    HeikinHour8: TimeFrame
    """HeikinHour8 / Hh8"""
    HeikinMinute: TimeFrame
    """HeikinMinute / Hm1"""
    HeikinMinute10: TimeFrame
    """HeikinMinute10 / Hm10"""
    HeikinMinute15: TimeFrame
    """HeikinMinute15 / Hm15"""
    HeikinMinute2: TimeFrame
    """HeikinMinute2 / Hm2"""
    HeikinMinute20: TimeFrame
    """HeikinMinute20 / Hm20"""
    HeikinMinute3: TimeFrame
    """HeikinMinute3 / Hm3"""
    HeikinMinute30: TimeFrame
    """HeikinMinute30 / Hm30"""
    HeikinMinute4: TimeFrame
    """HeikinMinute4 / Hm4"""
    HeikinMinute45: TimeFrame
    """HeikinMinute45 / Hm45"""
    HeikinMinute5: TimeFrame
    """HeikinMinute5 / Hm5"""
    HeikinMinute6: TimeFrame
    """HeikinMinute6 / Hm6"""
    HeikinMinute7: TimeFrame
    """HeikinMinute7 / Hm7"""
    HeikinMinute8: TimeFrame
    """HeikinMinute8 / Hm8"""
    HeikinMinute9: TimeFrame
    """HeikinMinute9 / Hm9"""
    HeikinMonthly: TimeFrame
    """HeikinMonthly / HMonth1"""
    HeikinWeekly: TimeFrame
    """HeikinWeekly / HW1"""
    Hour: TimeFrame
    """Hour / h1"""
    Hour12: TimeFrame
    """Hour12 / h12"""
    Hour2: TimeFrame
    """Hour2 / h2"""
    Hour3: TimeFrame
    """Hour3 / h3"""
    Hour4: TimeFrame
    """Hour4 / h4"""
    Hour6: TimeFrame
    """Hour6 / h6"""
    Hour8: TimeFrame
    """Hour8 / h8"""
    Minute: TimeFrame
    """Minute / m1"""
    Minute10: TimeFrame
    """Minute10 / m10"""
    Minute15: TimeFrame
    """Minute15 / m15"""
    Minute2: TimeFrame
    """Minute2 / m2"""
    Minute20: TimeFrame
    """Minute20 / m20"""
    Minute3: TimeFrame
    """Minute3 / m3"""
    Minute30: TimeFrame
    """Minute30 / m30"""
    Minute4: TimeFrame
    """Minute4 / m4"""
    Minute45: TimeFrame
    """Minute45 / m45"""
    Minute5: TimeFrame
    """Minute5 / m5"""
    Minute6: TimeFrame
    """Minute6 / m6"""
    Minute7: TimeFrame
    """Minute7 / m7"""
    Minute8: TimeFrame
    """Minute8 / m8"""
    Minute9: TimeFrame
    """Minute9 / m9"""
    Monthly: TimeFrame
    """Monthly / Month1"""
    Range1: TimeFrame
    """Range1 / Ra1"""
    Range10: TimeFrame
    """Range10 / Ra10"""
    Range100: TimeFrame
    """Range100 / Ra100"""
    Range1000: TimeFrame
    """Range1000 / Ra1000"""
    Range10000: TimeFrame
    """Range10000 / Ra10000"""
    Range150: TimeFrame
    """Range150 / Ra150"""
    Range2: TimeFrame
    """Range2 / Ra2"""
    Range20: TimeFrame
    """Range20 / Ra20"""
    Range200: TimeFrame
    """Range200 / Ra200"""
    Range2000: TimeFrame
    """Range2000 / Ra2000"""
    Range3: TimeFrame
    """Range3 / Ra3"""
    Range30: TimeFrame
    """Range30 / Ra30"""
    Range300: TimeFrame
    """Range300 / Ra300"""
    Range4: TimeFrame
    """Range4 / Ra4"""
    Range5: TimeFrame
    """Range5 / Ra5"""
    Range50: TimeFrame
    """Range50 / Ra50"""
    Range500: TimeFrame
    """Range500 / Ra500"""
    Range5000: TimeFrame
    """Range5000 / Ra5000"""
    Range7500: TimeFrame
    """Range7500 / Ra7500"""
    Range8: TimeFrame
    """Range8 / Ra8"""
    Range80: TimeFrame
    """Range80 / Ra80"""
    Range800: TimeFrame
    """Range800 / Ra800"""
    Renko1: TimeFrame
    """Renko1 / Re1"""
    Renko10: TimeFrame
    """Renko10 / Re10"""
    Renko100: TimeFrame
    """Renko100 / Re100"""
    Renko1000: TimeFrame
    """Renko1000 / Re1000"""
    Renko15: TimeFrame
    """Renko15 / Re15"""
    Renko150: TimeFrame
    """Renko150 / Re150"""
    Renko2: TimeFrame
    """Renko2 / Re2"""
    Renko20: TimeFrame
    """Renko20 / Re20"""
    Renko200: TimeFrame
    """Renko200 / Re200"""
    Renko2000: TimeFrame
    """Renko2000 / Re2000"""
    Renko25: TimeFrame
    """Renko25 / Re25"""
    Renko3: TimeFrame
    """Renko3 / Re3"""
    Renko30: TimeFrame
    """Renko30 / Re30"""
    Renko300: TimeFrame
    """Renko300 / Re300"""
    Renko35: TimeFrame
    """Renko35 / Re35"""
    Renko4: TimeFrame
    """Renko4 / Re4"""
    Renko40: TimeFrame
    """Renko40 / Re40"""
    Renko45: TimeFrame
    """Renko45 / Re45"""
    Renko5: TimeFrame
    """Renko5 / Re5"""
    Renko50: TimeFrame
    """Renko50 / Re50"""
    Renko500: TimeFrame
    """Renko500 / Re500"""
    Renko6: TimeFrame
    """Renko6 / Re6"""
    Renko7: TimeFrame
    """Renko7 / Re7"""
    Renko8: TimeFrame
    """Renko8 / Re8"""
    Renko800: TimeFrame
    """Renko800 / Re800"""
    Renko9: TimeFrame
    """Renko9 / Re9"""
    Tick: TimeFrame
    """Tick / t1"""
    Tick10: TimeFrame
    """Tick10 / t10"""
    Tick100: TimeFrame
    """Tick100 / t100"""
    Tick1000: TimeFrame
    """Tick1000 / t1000"""
    Tick15: TimeFrame
    """Tick15 / t15"""
    Tick150: TimeFrame
    """Tick150 / t150"""
    Tick2: TimeFrame
    """Tick2 / t2"""
    Tick20: TimeFrame
    """Tick20 / t20"""
    Tick200: TimeFrame
    """Tick200 / t200"""
    Tick25: TimeFrame
    """Tick25 / t25"""
    Tick250: TimeFrame
    """Tick250 / t250"""
    Tick3: TimeFrame
    """Tick3 / t3"""
    Tick30: TimeFrame
    """Tick30 / t30"""
    Tick300: TimeFrame
    """Tick300 / t300"""
    Tick4: TimeFrame
    """Tick4 / t4"""
    Tick40: TimeFrame
    """Tick40 / t40"""
    Tick5: TimeFrame
    """Tick5 / t5"""
    Tick50: TimeFrame
    """Tick50 / t50"""
    Tick500: TimeFrame
    """Tick500 / t500"""
    Tick6: TimeFrame
    """Tick6 / t6"""
    Tick60: TimeFrame
    """Tick60 / t60"""
    Tick7: TimeFrame
    """Tick7 / t7"""
    Tick750: TimeFrame
    """Tick750 / t750"""
    Tick8: TimeFrame
    """Tick8 / t8"""
    Tick80: TimeFrame
    """Tick80 / t80"""
    Tick9: TimeFrame
    """Tick9 / t9"""
    Tick90: TimeFrame
    """Tick90 / t90"""
    Weekly: TimeFrame
    """Weekly / W1"""

class TimeFrameManager:
    """Provides access to TimeFrames API for plugins."""
    Custom: CustomTimeFrames
    """Provides access to Custom TimeFrames API."""
    Favorite: FavoriteTimeFrames
    """Provides access to Favorite TimeFrames API."""

class TimeFrames:
    """Represents collection of all time frames including custom time frames."""
    Added: Event[Callable[[TimeFramesAddedEventArgs], None]]
    """Occurs when new TimeFrames are added."""
    Removed: Event[Callable[[TimeFramesRemovedEventArgs], None]]
    """Occurs when TimeFrames are removed."""

class TimeFramesAddedEventArgs:
    """Provides data for the TimeFrames Added event."""
    TimeFrames: list[TimeFrame]
    """Gets the added time frames."""

class TimeFramesRemovedEventArgs:
    """Provides data for the TimeFrames Removed event."""
    TimeFrames: list[TimeFrame]
    """Gets the removed time frames."""

class TimeSeries:
    """A series of values that represent time like Bars.OpenTimes"""
    def GetIndexByExactTime(self, dateTime: DateTime) -> int:
        """Find the index in the different time frame series."""
        ...
    def GetIndexByTime(self, dateTime: DateTime) -> int:
        """Find the index in the different time frame series."""
        ...
    def Last(self, index: int) -> DateTime:
        """Access a value in the data series certain number of bars ago."""
        ...
    Count: int
    """Gets the number of elements contained in the series."""
    Item: DateTime
    """Returns the DateTime value at the specified index."""
    LastValue: DateTime
    """Gets the last value of this time series."""

class TimeSeriesMovingAverage(MovingAverage, StandardIndicator):
    """A Time Series Moving Average is moving average based on linear regression forecast."""
    ...

class TimeZones:
    """Standard TimeZones class."""
    AlaskanStandardTime: str
    """(GMT-09:00) Alaska"""
    ArabStandardTime: str
    """(GMT+03:00) Kuwait, Riyadh"""
    ArabianStandardTime: str
    """(GMT+04:00) Abu Dhabi, Muscat"""
    ArabicStandardTime: str
    """(GMT+03:00) Baghdad"""
    AtlanticStandardTime: str
    """(GMT-04:00) Atlantic Time (Canada)"""
    AzoresStandardTime: str
    """(GMT-01:00) Azores"""
    CanadaCentralStandardTime: str
    """(GMT-06:00) Saskatchewan"""
    CapeVerdeStandardTime: str
    """(GMT-01:00) Cape Verde Islands"""
    CaucasusStandardTime: str
    """(GMT+04:00) Baku, Tbilisi, Yerevan"""
    CenAustraliaStandardTime: str
    """(GMT+09:30) Adelaide"""
    CentralAmericaStandardTime: str
    """(GMT-06:00) Central America"""
    CentralAsiaStandardTime: str
    """(GMT+06:00) Astana, Dhaka"""
    CentralEuropeStandardTime: str
    """(GMT+01:00) Belgrade, Bratislava, Budapest, Ljubljana, Prague"""
    CentralEuropeanStandardTime: str
    """(GMT+01:00) Sarajevo, Skopje, Warsaw, Zagreb"""
    CentralPacificStandardTime: str
    """(GMT+11:00) Magadan, Solomon Islands, New Caledonia"""
    CentralStandardTime: str
    """(GMT-06:00) Central Time (US and Canada"""
    ChinaStandardTime: str
    """(GMT+08:00) Beijing, Chongqing, Hong Kong SAR, Urumqi"""
    DatelineStandardTime: str
    """(GMT-12:00) International Date Line West"""
    EAfricaStandardTime: str
    """(GMT+03:00) Nairobi"""
    EAustraliaStandardTime: str
    """(GMT+10:00) Brisbane"""
    EEuropeStandardTime: str
    """(GMT+02:00) Bucharest"""
    ESouthAmericaStandardTime: str
    """(GMT-03:00) Brasilia"""
    EasternStandardTime: str
    """(GMT-05:00) Eastern Time (US and Canada)"""
    EgyptStandardTime: str
    """(GMT+02:00) Cairo"""
    EkaterinburgStandardTime: str
    """(GMT+05:00) Ekaterinburg"""
    FLEStandardTime: str
    """(GMT+02:00) Helsinki, Kiev, Riga, Sofia, Tallinn, Vilnius"""
    GMTStandardTime: str
    """(GMT) Greenwich Mean Time: Dublin, Edinburgh, Lisbon, London"""
    GTBStandardTime: str
    """(GMT+02:00) Athens, Istanbul, Minsk"""
    GreenlandStandardTime: str
    """(GMT-03:00) Greenland"""
    GreenwichStandardTime: str
    """(GMT) Casablanca, Monrovia"""
    HawaiianStandardTime: str
    """(GMT-10:00) Hawaii"""
    IndiaStandardTime: str
    """(GMT+05:30) Chennai, Kolkata, Mumbai, New Delhi"""
    IranStandardTime: str
    """(GMT+03:30) Tehran"""
    IsraelStandardTime: str
    """(GMT+02:00) Jerusalem"""
    KoreaStandardTime: str
    """(GMT+09:00) Seoul"""
    MidAtlanticStandardTime: str
    """(GMT-02:00) Mid-Atlantic"""
    MountainStandardTime: str
    """(GMT-07:00) Mountain Time (US and Canada)"""
    MyanmarStandardTime: str
    """(GMT+06:30) Yangon Rangoon"""
    NCentralAsiaStandardTime: str
    """(GMT+06:00) Almaty, Novosibirsk"""
    NepalStandardTime: str
    """(GMT+05:45) Kathmandu"""
    NewZealandStandardTime: str
    """(GMT+12:00) Auckland, Wellington"""
    NorthAsiaEastStandardTime: str
    """(GMT+08:00) Irkutsk, Ulaanbaatar"""
    NorthAsiaStandardTime: str
    """(GMT+07:00) Krasnoyarsk"""
    PacificStandardTime: str
    """(GMT-08:00) Pacific Time (US and Canada); Tijuana"""
    RomanceStandardTime: str
    """(GMT+01:00) Brussels, Copenhagen, Madrid, Paris"""
    RussianStandardTime: str
    """(GMT+03:00) Moscow, St. Petersburg, Volgograd"""
    SamoaStandardTime: str
    """(GMT-11:00) Midway Island, Samoa"""
    SingaporeStandardTime: str
    """(GMT+08:00) Kuala Lumpur, Singapore"""
    SouthAfricaStandardTime: str
    """(GMT+02:00) Harare, Pretoria"""
    SriLankaStandardTime: str
    """(GMT+06:00) Sri Jayawardenepura"""
    TaipeiStandardTime: str
    """(GMT+08:00) Taipei"""
    TasmaniaStandardTime: str
    """(GMT+10:00) Hobart"""
    TokyoStandardTime: str
    """(GMT+09:00) Osaka, Sapporo, Tokyo"""
    TongaStandardTime: str
    """(GMT+13:00) Nuku'alofa"""
    UTC: str
    """Coordinated Universal Time"""
    VladivostokStandardTime: str
    """(GMT+10:00) Vladivostok"""
    WAustraliaStandardTime: str
    """(GMT+08:00) Perth"""
    WCentralAfricaStandardTime: str
    """(GMT+01:00) West Central Africa"""
    WEuropeStandardTime: str
    """(GMT+01:00) Amsterdam, Berlin, Bern, Rome, Stockholm, Vienna"""
    WestAsiaStandardTime: str
    """(GMT+05:00) Islamabad, Karachi, Tashkent"""
    WestPacificStandardTime: str
    """(GMT+10:00) Guam, Port Moresby"""
    YakutskStandardTime: str
    """(GMT+09:00) Yakutsk"""

class Timer:
    """Schedules execution of virtual OnTimer method with specified interval."""
    @overload
    def Start(self, interval: TimeSpan) -> None:
        """Starts the Timer"""
        ...
    @overload
    def Start(self, intervalInSeconds: int) -> None:
        """Starts the Timer"""
        ...
    def Stop(self) -> None:
        """Stops the Timer"""
        ...
    Interval: TimeSpan
    """Gets the interval of timer. Returns -1 millisecond if the timer is stopped"""
    TimerTick: Event[Action]
    """Occurs when the interval elapses"""

class ToggleButton(Control):
    """Represents the Toggle button."""
    def __init__(self) -> None: ...
    BorderColor: Color
    """Gets or sets the border line color."""
    BorderThickness: Thickness
    """Gets or sets the border thickness. Property value can be set using Thickness, number, or a string new Thickness(5), new Thickness(1, 2, 3, 4), 5, "5", "1 2 3 4"."""
    Content: ControlBase
    """Gets or sets the content."""
    CornerRadius: CornerRadius
    """Gets or sets the border corner radius. Property value can be set using CornerRadius, number, or a string: new CornerRadius(5), new CornerRadius(1, 2, 3, 4)."""
    IsChecked: bool
    """Defines whether the Toggle button is checked."""
    Text: str
    """Gets or sets the text."""
    Checked: Event[Callable[[ToggleButtonEventArgs], None]]
    """Occurs when checked."""
    Click: Event[Callable[[ToggleButtonEventArgs], None]]
    """Occurs when clicked."""
    Unchecked: Event[Callable[[ToggleButtonEventArgs], None]]
    """Occurs when unchecked."""

class ToggleButtonEventArgs:
    """Represents the toggle button event class."""
    ToggleButton: ToggleButton
    """Gets the toggle button data."""

class TotalMarginCalculationType:
    """Defines types of total margin requirements per Symbol."""
    Sum: TotalMarginCalculationType
    Max: TotalMarginCalculationType
    Net: TotalMarginCalculationType

class TradeOperation:
    """Provides access to the properties describing an asynchronous trade operation."""
    IsExecuting: bool
    """True if a trade operation is being executed, false if it completed"""
    TradeResult: TradeResult
    """The result of a trade operation"""

class TradeResult:
    """The result of a trade operation."""
    Error: ErrorCode | None
    """The error code of an unsuccessful trade."""
    IsSuccessful: bool
    """True if the trade is successful, false if there is an error."""
    PendingOrder: PendingOrder
    """The resulting pending order of a trade request."""
    Position: Position
    """The resulting position of a trade request."""

class TradeType:
    """The direction of a trade order."""
    Buy: TradeType
    Sell: TradeType

class TradeVolumeIndex(StandardIndicator):
    """Trade Volume Index measures the amount of money flowing in and out of an asset."""
    Result: IndicatorDataSeries
    """Gets the time series of Trade Volume Index indicator."""

class TradeWatch:
    """Represents the trade watch panel."""
    def AddTab(self, title: str) -> TradeWatchTab:
        """Adds a new tab."""
        ...
    @overload
    def RemoveTab(self, id: str) -> bool:
        """Removes a tab by ID."""
        ...
    @overload
    def RemoveTab(self, tab: TradeWatchTab) -> bool:
        """Removes a tab."""
        ...
    Height: float
    """Get / set height of trade watch."""
    IsVisible: bool
    """Get / set visibility of trade watch."""
    Width: float
    """Get / set width of trade watch."""
    IsVisibleChanged: Event[Callable[[TradeWatchIsVisibleChangedEventArgs], None]]
    """Occurs after trade watch visibility (IsVisible) changed."""
    SizeChanged: Event[Callable[[TradeWatchSizeChangedEventArgs], None]]
    """Occurs after trade watch size (height / width) changed."""

class TradeWatchIsVisibleChangedEventArgs:
    """Provides data for plugin trade watch IsVisibleChanged event."""
    TradeWatch: TradeWatch
    """Trade watch."""

class TradeWatchSizeChangedEventArgs:
    """Provides data for plugin trade watch SizeChanged event."""
    TradeWatch: TradeWatch
    """Trade watch."""

class TradeWatchTab:
    """Represents a trade watch panel tab."""
    def Attach(self) -> bool:
        """Attaches current tab back to trade watch."""
        ...
    def Detach(self) -> bool:
        """Detaches current tab to a separate window."""
        ...
    Child: ControlBase
    """Get / set content of current tab."""
    DetachedWindow: DetachedWindow
    """Returns detached window properties."""
    Height: float
    """Returns current height of tab."""
    Id: str
    """Returns unique ID of the current tab."""
    Index: int
    """Get / set the index of the tab."""
    IsBalanceBarVisible: bool
    """Get / set the visibility of balance bar for the tab."""
    IsSelected: bool
    """Get / set selected state of current tab."""
    Title: str
    """Returns title of the current tab."""
    Width: float
    """Returns current width of tab."""
    Attached: Event[Callable[[TradeWatchTabAttachedEventArgs], None]]
    """Occurs when tab attached."""
    Detached: Event[Callable[[TradeWatchTabDetachedEventArgs], None]]
    """Occurs when tab detached."""
    IsSelectedChanged: Event[Callable[[TradeWatchTabIsSelectedChangedEventArgs], None]]
    """Occurs after tab IsSelected value change."""
    SizeChanged: Event[Callable[[TradeWatchTabSizeChangedEventArgs], None]]
    """Occurs after tab size (height / width) value change."""

class TradeWatchTabAttachedEventArgs:
    """Provides data for plugin trade watch tab attached event."""
    TradeWatchTab: TradeWatchTab
    """Attached tab."""

class TradeWatchTabDetachedEventArgs:
    """Provides data for plugin trade watch tab detached event."""
    TradeWatchTab: TradeWatchTab
    """Detached tab."""

class TradeWatchTabIsSelectedChangedEventArgs:
    """Provides data for plugin trade watch tab IsSelectedChanged event."""
    TradeWatchTab: TradeWatchTab
    """Trade watch tab."""

class TradeWatchTabSizeChangedEventArgs:
    """Provides data for plugin trade watch tab SizeChanged event."""
    TradeWatchTab: TradeWatchTab
    """Trade watch tab."""

class TradingHoliday:
    """Represents a symbol trading holiday."""
    EndTime: DateTime
    """Gets the end date and time of the trading holiday."""
    IsRecurring: bool
    """Gets a value indicating whether the trading holiday is recurring."""
    Name: str
    """Gets the name of the trading holiday."""
    StartTime: DateTime
    """Gets the start date and time of the trading holiday."""

class TradingPermission(Permission):
    """Trading Permission"""
    ...

class TradingSession:
    """Trading session schedule"""
    EndDay: DayOfWeek
    """Day of week when trading session ends"""
    EndTime: TimeSpan
    """Time when trading session ends"""
    StartDay: DayOfWeek
    """Day of week when trading session starts"""
    StartTime: TimeSpan
    """Time when trading session starts"""

class Transaction:
    """Represents an account transaction."""
    Amount: float
    """Gets transaction amount."""
    Balance: float
    """Gets account balance after transaction."""
    Equity: float | None
    """Gets account equity after transaction or null."""
    Id: int
    """Gets transaction Id."""
    MaxEquity: float | None
    """Gets account max equity after transaction or null."""
    MinEquity: float | None
    """Gets account min equity after transaction or null."""
    Note: str
    """Gets transaction note if has otherwise null."""
    Time: DateTime
    """Gets transaction time."""
    Type: TransactionType
    """Gets transaction type."""

class TransactionType:
    """Represents the different types of account transactions."""
    Deposit: TransactionType
    Withdrawal: TransactionType

class Transactions:
    """Represents account transactions collection."""
    Count: int
    """Gets count of transactions."""
    Item: Transaction
    """Gets transaction by index."""

class TriangularMovingAverage(MovingAverage, StandardIndicator):
    """The Triangular Moving Average is a moving average that gives more weith to values located in the middle of aggregated period."""
    ...

class TripleExponentialMovingAverage(MovingAverage, StandardIndicator):
    """The Triple Exponential Moving Average (TEMA) is a technical indicator that provides a smoothed representation of price data by applying three levels of exponential smoothing"""
    ...

class Trix(StandardIndicator):
    """TRIX was developed by Jack Huton. It is a momentum oscillator that will help you filter unimportant price movement."""
    Result: IndicatorDataSeries
    """Gets the resulting time series of the Trix indicator calculation."""

class TrueRange(StandardIndicator):
    """The Average True Range is a measure of market volatility developed by Wilder."""
    Result: IndicatorDataSeries
    """Gets the resulting time series of the True Range indicator calculation."""

class TypicalPrice(StandardIndicator):
    """A Typical Price is an average of high, low and close values for a single period."""
    Result: IndicatorDataSeries
    """Gets the resulting time series of the Typical Price indicator calculation."""

class UltimateOscillator(StandardIndicator):
    """The Ultimate Oscillator is a technical analysis oscillator based on a notion of buying or selling "pressure"."""
    Result: IndicatorDataSeries
    """Gets the resulting time series of the Ultimate Oscillator indicator calculation."""

class UserTimeOffsetChangedEventArgs:
    """Represents the user time offset change event data."""
    UserTimeOffset: TimeSpan
    """Gets the user time offset."""

class VariableIndexDynamicAverage(MovingAverage, StandardIndicator):
    """The Variable Index Dynamic Average (VIDYA) indicator is a type of moving average that dynamically adjusts its smoothing period based on market volatility."""
    ...

class VerticalAlignment:
    """Describes vertical position related to an anchor point or a parent element."""
    Center: VerticalAlignment
    Top: VerticalAlignment
    Bottom: VerticalAlignment
    Stretch: VerticalAlignment

class VerticalHorizontalFilter(StandardIndicator):
    """Vertical Horizontal Filter determines whether a price is going through a congestion phase or a trending phase."""
    Result: IndicatorDataSeries
    """Gets the resulting time series of the Vertical Horizontal Filter indicator calculation."""

class Vidya(MovingAverage, StandardIndicator):
    """Volatility Index Dynamic Average (VIDYA) is a smoothing (moving average) based on dynamically changing periods."""
    ...

class VolumeOscillator(StandardIndicator):
    """The Volume Oscillator identifies trends in volume using a two moving average system. A strong trend is signaled when it is positive. Falling volume indicates trend weakness."""
    Result: IndicatorDataSeries
    """Gets or sets the time series of the Volume Oscillator indicator."""

class VolumeROC(StandardIndicator):
    """The Volume Rate of Change indicator measures the Rate Of Change of the tick volume."""
    Result: IndicatorDataSeries
    """Gets or sets the time series of the Volume ROC indicator."""

class Watchlist:
    """Represents the Watchlist interface."""
    Name: str
    """Gets the watchlist name."""
    SymbolNames: IReadonlyList[str]
    """Gets the names of the symbols in the watchlist."""

class WatchlistAddedEventArgs:
    """Occurs when a new watchlist is added."""
    Watchlist: Watchlist
    """Gets the watchlist."""

class WatchlistRemovedEventArgs:
    """Occurs when a watchlist is removed from the marketwatch."""
    Watchlist: Watchlist
    """Gets the watchlist."""

class WatchlistRenamedEventArgs:
    """Occurs when the watchlist is renamed."""
    Watchlist: Watchlist
    """Gets the watchlist."""

class WatchlistSymbolAddedEventArgs:
    """Occurs when a new symbol is added to the watchlist."""
    SymbolName: str
    """Gets the symbol name."""
    Watchlist: Watchlist
    """Gets the watchlist."""

class WatchlistSymbolRemovedEventArgs:
    """Occurs when the symbol is removed from the watchlist."""
    SymbolName: str
    """Gets the symbol name."""
    Watchlist: Watchlist
    """Gets the watchlist."""

class Watchlists:
    """Represents the Watchlists interface - allows getting all the watchlists and symbols in them, and receiving the relevant events."""
    Item: Watchlist
    """Gets the desired Watchlist."""
    Added: Event[Callable[[WatchlistAddedEventArgs], None]]
    """Occurs when a new watchlist is added."""
    Removed: Event[Callable[[WatchlistRemovedEventArgs], None]]
    """Occurs when a watchlist is removed."""
    WatchlistRenamed: Event[Callable[[WatchlistRenamedEventArgs], None]]
    """Occurs when the name of the watchlist is changed."""
    WatchlistSymbolAdded: Event[Callable[[WatchlistSymbolAddedEventArgs], None]]
    """Occurs when a new symbol is added to the watchlist."""
    WatchlistSymbolRemoved: Event[Callable[[WatchlistSymbolRemovedEventArgs], None]]
    """Occurs when a symbol is removed from the watchlist."""

class WebSocketClient:
    """Represents a web socket client."""
    @overload
    def __init__(self) -> None: ...
    @overload
    def __init__(self, options: WebSocketClientOptions) -> None: ...
    def Close(self, closeStatus: WebSocketClientCloseStatus, closeStatusDescription: str) -> None:
        """Disconnects WebSocketClient."""
        ...
    def Connect(self, uri: Uri) -> None:
        """Connects WebSocketClient to passed URI."""
        ...
    def Dispose(self) -> None:
        """Releases the unmanaged resources used by the WebSocketClient instance."""
        ...
    @overload
    def Send(self, text: str) -> None:
        """Sends passed text."""
        ...
    @overload
    def Send(self, data: list[int]) -> None:
        """Sends passed binary data."""
        ...
    CloseStatus: WebSocketClientCloseStatus | None
    """Gets close status / reason."""
    CloseStatusDescription: str
    """Gets a description of the reason why the instance was closed."""
    State: WebSocketClientState
    """Gets current state of WebSocketClient instance."""
    BinaryReceived: Event[Callable[[WebSocketClientBinaryReceivedEventArgs], None]]
    """Occurs when WebSocketClient receives binary data."""
    Connected: Event[Callable[[WebSocketClientConnectedEventArgs], None]]
    """Occurs when WebSocketClient is connected."""
    Disconnected: Event[Callable[[WebSocketClientDisconnectEventArgs], None]]
    """Occurs when WebSocketClient is disconnected."""
    TextReceived: Event[Callable[[WebSocketClientTextReceivedEventArgs], None]]
    """Occurs when WebSocketClient receives text data."""

class WebSocketClientBinaryReceivedEventArgs:
    """Provides data for WebSocketClient binary data received event."""
    Client: WebSocketClient
    """Websocket client instance."""
    Data: list[int]
    """Received data."""

class WebSocketClientCloseStatus:
    """An enumeration of different Web socket client close states / reasons."""
    Empty: WebSocketClientCloseStatus
    EndpointUnavailable: WebSocketClientCloseStatus
    InternalServerError: WebSocketClientCloseStatus
    InvalidMessageType: WebSocketClientCloseStatus
    InvalidPayloadData: WebSocketClientCloseStatus
    MandatoryExtension: WebSocketClientCloseStatus
    MessageTooBig: WebSocketClientCloseStatus
    NormalClosure: WebSocketClientCloseStatus
    PolicyViolation: WebSocketClientCloseStatus
    ProtocolError: WebSocketClientCloseStatus

class WebSocketClientConnectedEventArgs:
    """Provides data for Websocket client connected event."""
    Client: WebSocketClient
    """Connected websocket client instance."""

class WebSocketClientDisconnectEventArgs:
    """Provides data for Websocket client disconnected event."""
    Client: WebSocketClient
    """Disconnected websocket client instance."""

class WebSocketClientOptions:
    """Websocket client options."""
    def __init__(self) -> None: ...
    KeepAliveInterval: TimeSpan
    """Gets or sets the WebSocket protocol keep-alive interval. Default value is set to 30 seconds."""
    SubProtocols: Iterable[str]
    """Gets or sets sub-protocols to be negotiated during the WebSocket connection handshake."""
    Timeout: TimeSpan
    """Gets or sets the operation timeout. Default value is set to 60 seconds."""
    UseDefaultCredentials: bool
    """Gets or sets a Boolean value that indicates if default credentials should be used during WebSocket handshake. Default value is false."""

class WebSocketClientState:
    """An enumeration of different Web socket client states."""
    None: WebSocketClientState
    Connecting: WebSocketClientState
    Open: WebSocketClientState
    CloseSent: WebSocketClientState
    CloseReceived: WebSocketClientState
    Closed: WebSocketClientState
    Aborted: WebSocketClientState

class WebSocketClientTextReceivedEventArgs:
    """Provides data for WebSocketClient text data received event."""
    Client: WebSocketClient
    """Websocket client instance."""
    Text: str
    """Received text."""

class WebView(ControlBase):
    """Represents the web view control."""
    def __init__(self) -> None: ...
    def ExecuteScript(self, javaScript: str) -> ExecuteScriptResult:
        """Executes JavaScript code from the javaScript parameter in the current top level document rendered in the WebView and returns the result. You can only use this method after control is fully loaded and navigation is completed."""
        ...
    @overload
    def ExecuteScriptAsync(self, javaScript: str) -> None:
        """Executes JavaScript code from the javaScript parameter in the current top level document rendered in the WebView. You can only use this method after control is fully loaded and navigation is completed."""
        ...
    @overload
    def ExecuteScriptAsync(self, javaScript: str, callback: Callable[[ExecuteScriptResult], None]) -> None:
        """Executes asynchronously JavaScript code from the javaScript parameter in the current top level document rendered in the WebView. You can only use this method after control is fully loaded and navigation is completed."""
        ...
    def GoBackAsync(self) -> None:
        """Navigates asynchronously the WebView to the previous page in the navigation history."""
        ...
    def GoForwardAsync(self) -> None:
        """Navigates asynchronously the WebView to the next page in the navigation history."""
        ...
    def NavigateAsync(self, url: str) -> None:
        """Navigate asynchronously to another URL."""
        ...
    def NavigateToStringAsync(self, html: str) -> None:
        """Initiates a navigation asynchronously to html content as source HTML of a new document."""
        ...
    def OpenDevToolsWindow(self) -> None:
        """Opens the DevTools window for the current WebView."""
        ...
    def ReloadAsync(self) -> None:
        """Reloads asynchronously the current page."""
        ...
    def StopAsync(self) -> None:
        """Stops asynchronously all navigations and pending resource fetches."""
        ...
    DefaultBackgroundColor: Color
    """Default background color of WebView."""
    IsLoaded: bool
    """Returns True if WebView is loaded otherwise False."""
    Loaded: Event[Callable[[WebViewLoadedEventArgs], None]]
    """Occurs after web view is loaded"""
    NavigationCompleted: Event[Callable[[WebViewNavigationCompletedEventArgs], None]]
    """Occurs when navigation of a page is completed."""
    Unloaded: Event[Callable[[WebViewUnloadedEventArgs], None]]
    """Occurs after web view is unloaded"""
    WebMessageReceived: Event[Callable[[WebViewWebMessageReceivedEventArgs], None]]
    """Occurs after web content sends a message"""

class WebViewLoadedEventArgs:
    """Provides data for the WebView control Loaded event."""
    WebView: WebView
    """The WebView control."""

class WebViewNavigationCompletedEventArgs:
    """Provides data for the WebView control NavigationCompleted event."""
    HttpStatusCode: int
    """Response HTTP status code."""
    IsSuccessful: bool
    """True if navigation was successful otherwise false."""
    Url: str
    """URL from WebView Source property at the moment of NavigationCompleted in big process."""
    WebView: WebView
    """The WebView control."""

class WebViewUnloadedEventArgs:
    """Provides data for the WebView control Unloaded event."""
    WebView: WebView
    """The WebView control."""

class WebViewWebMessageReceivedEventArgs:
    """Provides data for the WebView control WebMessageReceived event."""
    Message: str
    """The message that was received."""
    Source: str
    """Gets the URI of the document that sent this web message."""
    WebView: WebView
    """WebView Control."""

class WeightedClose(StandardIndicator):
    """Weighted Close is an average of high, low and close prices where close has greater weight."""
    Result: IndicatorDataSeries
    """Gets the resulting time series of the Weighted Close indicator calculation."""

class WeightedMovingAverage(MovingAverage, StandardIndicator):
    """The Weighted Moving Average is a moving average that gives more weith to the latest values."""
    Result: IndicatorDataSeries
    """Gets the resulting time series of the Weighted Moving Average indicator calculation."""

class WellesWilderSmoothing(MovingAverage, StandardIndicator):
    """The Welles Wilder's Smoothing indicator is an exponential moving average, but it has different alpha ration. As a result it responds to price changes slower."""
    ...

class WilliamsAccumulationDistribution(StandardIndicator):
    """William's Accumulation Distribution is an oscillator that can identify if the market is driven by buyers (accumulation) or by sellers (distribution)"""
    Result: IndicatorDataSeries
    """Gets the resulting time series of the Williams Accumulation Distribution indicator calculation."""

class WilliamsPctR(StandardIndicator):
    """Williams %R is an effective momentum oscillator and was described by Larry Williams for the first time in 1973."""
    Result: IndicatorDataSeries
    """Gets the resulting time series of the Williams PctR indicator calculation."""

class Window:
    """The window class, you can use it to show a window that can contain other chart controls"""
    def __init__(self) -> None: ...
    def Close(self) -> None:
        """Closes the window"""
        ...
    def Hide(self) -> None:
        """Hides the window"""
        ...
    def Show(self) -> None:
        """Shows the window"""
        ...
    BackgroundColor: Color
    """Get / Set the window background color"""
    Child: ControlBase
    """Get / Set the main content control of window"""
    Height: float
    """Get / Set height of the Window"""
    IsActive: bool
    """Get / Set the window active / de-active flag, if Yes then the window will be active"""
    IsVisible: bool
    """Get / Set the window visibility flag, if Yes then the window will be shown otherwise it will be hidden"""
    Left: float
    """Get / Set window left margin (X)"""
    MaxHeight: float
    """Get / Set the window maximum height"""
    MaxWidth: float
    """Get / Set the window maximum width"""
    MinHeight: float
    """Get / Set the window minimum height"""
    MinWidth: float
    """Get / Set the window minimum width"""
    OwnerType: OwnerType
    """Get / Set the window owner"""
    Padding: Thickness
    """Get / Set the window padding"""
    ResizeMode: ResizeMode
    """Get / Set the window resize mode"""
    Title: str
    """Get / Set the window title"""
    Top: float
    """Get / Set window top margin (Y)"""
    Topmost: bool
    """Get / Set the window topmost flag, if True then the window will appear on top of all other windows"""
    Width: float
    """Get / Set width of the window"""
    WindowStartupLocation: WindowStartupLocation
    """Get / Set the window startup location"""
    WindowState: WindowState
    """Get / Set the window state"""
    Activated: Event[Callable[[WindowActivatedEventArgs], None]]
    """This event gets triggered when window is activated"""
    Closed: Event[Callable[[WindowClosedEventArgs], None]]
    """This event gets triggered when window is closed"""
    Deactivated: Event[Callable[[WindowDeactivatedEventArgs], None]]
    """This event gets triggered when window is deactivated"""
    IsVisibleChanged: Event[Callable[[WindowIsVisibleChangedEventArgs], None]]
    """This event gets triggered when window visibility changes"""
    LocationChanged: Event[Callable[[WindowLocationChangedEventArgs], None]]
    """This event gets triggered when window location changes"""
    SizeChanged: Event[Callable[[WindowSizeChangedEventArgs], None]]
    """This event gets triggered when window is size changes"""

class WindowActivatedEventArgs:
    """Provides data for WindowActivated event handlers"""
    Window: Window
    """The Window that got activated"""

class WindowClosedEventArgs:
    """Provides data for WindowClosed event handlers"""
    Window: Window
    """The window the got closed"""

class WindowDeactivatedEventArgs:
    """Provides data for WindowDeactivated event handlers"""
    Window: Window
    """The window that got deactivated"""

class WindowIsVisibleChangedEventArgs:
    """Provides data for WindowIsVisibleChanged event handlers"""
    NewValue: bool
    """The value of window IsVisible property after got changed"""
    OldValue: bool
    """The value of window IsVisible property before got changed"""
    Window: Window
    """The window which it is IsVisible property got changed"""

class WindowLocationChangedEventArgs:
    """Provides data for WindowLocationChanged event handlers"""
    Window: Window
    """The window which it is location changed"""

class WindowSizeChangedEventArgs:
    """Provides data for WindowSizeChanged event handlers"""
    Window: Window
    """The window which it is size changed"""

class WindowStartupLocation:
    """Types of startup locations that you can use for windows"""
    Manual: WindowStartupLocation
    CenterScreen: WindowStartupLocation
    CenterOwner: WindowStartupLocation

class WindowState:
    """Types of states for windows"""
    Normal: WindowState
    Minimized: WindowState
    Maximized: WindowState

class WrapPanel(Panel):
    """Positions the child elements in sequential position from left to right, breaking content to the next line at the end of the containing box, from top to bottom, or from right to left."""
    def __init__(self) -> None: ...
    ItemHeight: float
    """Gets or sets the height of the item."""
    ItemWidth: float
    """Gets or sets the width of the item."""
    Orientation: Orientation
    """Gets or sets the orientation of the child element."""

class _AlgoApi(Robot, Indicator, Plugin): ...

api: _AlgoApi
"""The running algo: a Robot in a cBot, an Indicator in an indicator, a Plugin in a plugin."""