"""Auto-generated type stubs for AAComm .NET assembly.

Generated from: AAComm.xml
Assembly: AAComm v10.0.0.0

Do not edit manually. Regenerate with:
    python generate_stubs.py
"""

from typing import Callable, Any


class CommAPI:
    """
    An API for handling communication with the AACommServer executable. The API
    provides low-level send/receive capabilities + special functionality. All
    *synchronous* functions are mutually-locking, and should not be called from
    multiple threads Proper work-flow: (see usage details at every function
    description) 0. subscribe to events: Reset: , General Error: , Push: (TBD)
    1. 2. (not mandatory, can be used to determine ) 3. 4. (multi-threaded
    environment) or (single-threaded environment) 5. 6. (not mandatory)
    """
    OnCommsError: Callable[[str], None]  # Indicates a general communications error occurred due to some problem, specified within the [...]
    OnPushMessageReceived: Callable[[str], None]  # Raised when an unsolicited "push" message is received from the controller. The event delivers [...]
    OnResetProgress: Callable[[bool], None]  # Fired when a Reset message is handled. Parameter: true for reset started, false for reset [...]
    DocsAppFolder: str  # the folder under "(Windows)\Documents" containing API and PCSuite settings and other data [...]
    MaxTheoreticalNumOfAxes: int  # maximal theoretical number of axes
    @property
    def AACommServerVersion(self) -> object:
        """
        AACommServer version, as reported by AACommServer upon Valid only when
        is true (0.0.0 if disconnected)
        """
        ...
    @property
    def ApplyUserUnits(self) -> bool:
        """
        specifies whether this AAComm instance should automatically apply user
        units to sent/received messages always returns 'false' if feature not
        supported by connected controller FW
        """
        ...
    @ApplyUserUnits.setter
    def ApplyUserUnits(self, value: bool) -> None: ...
    @property
    def CurrentConnectionData(self) -> ConnectionData:
        """
        API state: get current ConnectionData (NULL if not connected)
        """
        ...
    @property
    def IdentityContainer(self) -> ControllerIdentityContainer:
        """
        do NOT MODIFY internal container data!! Controller Identity Container,
        initialized at cleared at NOT initialized by and
        """
        ...
    @property
    def IsAACommServerRunning(self) -> bool:
        """
        API state: is AACommServer process is currently running (static
        property!) NOTE: execution is up to 100 msec!
        """
        ...
    @property
    def IsConnected(self) -> bool:
        """
        API state: is API connected
        """
        ...
    @property
    def IsQueueEmpty(self) -> bool:
        """
        API state: returns whether messages queue is empty. Atomic. May be used
        whether it's safe to switch from "async" to "sync" API usage.
        """
        ...
    @property
    def MaxNumOfAxes(self) -> int:
        """
        maximal theoretical number of axes
        """
        ...
    @property
    def MessagesContainer(self) -> ControllerMessagesContainer:
        """
        do NOT MODIFY internal container data!! Messages Data Container,
        initialized fully at Initialized partially (ONLY by default messages) at
        and cleared at NOT initialized by and
        """
        ...
    @property
    def MessagesInBulk(self) -> int:
        """
        returns max number of messages in a 'Bulk" packet (50) (Returns '1' if
        ConnectionType is NOT )
        """
        ...
    @property
    def NumberOfAxes(self) -> int:
        """
        reports the maximal number of Axes supported by connected controller. (
        if not connected)
        """
        ...
    @property
    def UserProgAdapter(self) -> UserProgVarsAdapter:
        """
        do NOT MODIFY internal container data!! User Program global variables
        and Task names map: from User Program literals to controller-
        identifiable parameters. Refreshed automatically at and Supported
        according to
        """
        ...
    @staticmethod
    def StartAACommServer(aaCommServerFile: str = None) -> ConnectResult:
        """
        Synchronous STATIC function NOT thread-safe Starts the AACommServer (if
        not already running) Checks to make sure process has started, up to 5
        seconds should be called once, at beginning of API usage may be called
        again to restart the AACommServer Resolve priorities: 1.
        'aaCommServerFile' function parameter: Obligatory for non-Windows
        clients! 2. Working directory of the executing process (Windows only!!)
        3. PCSuite installation directory (if installed, Windows only!!)
        
        Args:
            aaCommServerFile: AACommServer file to run
        """
        ...
    def CloseAACommServer(self, isForceClose: bool = None) -> None:
        """
        Synchronous function NOT thread-safe (protected vs. re-entry) called at
        the end of API usage. Sends "ShutDown" command to AACommServer.
        (AACommServer process will terminate, if current client is the last one)
        Disconnects if connected
        
        Args:
            isForceClose: indicates whether the ShutDownForce command should be sent to the AACommServer
        """
        ...
    def Connect(self, connectionData: ConnectionData, forceAboutData: bool = None) -> ConnectResult:
        """
        Synchronous function, tries to establish a required connection NOT
        thread-safe (protected vs. re-entry) Call state: NOT connected Exit
        state: Connected if success, Clean disconnected state if failure
        initializes containers: and
        
        Args:
            connectionData: the required connection data
            forceAboutData: Specifies whether to forcefully overwrite local about data with whatever the controller reports
        """
        ...
    def ConnectSilent(self, connData: ConnectionData) -> ConnectResult:
        """
        Synchronous function, tries to establish a required connection NOT
        thread-safe (protected vs. re-entry) Call state: NOT connected Exit
        state: Connected if success, Clean disconnected state if failure should
        be used for connecting in order to download FW in boot mode does NOT
        query the controller for any data (except clear RS-232 buffer, if RS-232
        channel)
        
        Args:
            connData: the required connection data
        """
        ...
    def Disconnect(self) -> None:
        """
        Synchronous function NOT thread-safe (protected vs. re-entry) clears
        queue and sends Disconnect request to AACommServer all messages left in
        send queue will NOT be processed clears containers: and
        """
        ...
    def Send(self, commMessage: AACommMessage) -> None:
        """
        Asynchronous function Sends a message to the controller, over the
        channel connected at thread-safe the event is invoked if API is in
        invalid state, with prefix/>
        
        Args:
            commMessage: the message to be sent. The callback should NOT be null if commMessage is null, function returns taking no action
        """
        ...
    def SendReceive(self, commMessage: AACommMessage) -> AACommEventArgs:
        """
        Synchronous send/receive function Sends a message to the controller,
        over the CommHandler connected at NOT thread-safe, must not be used
        while asynchronous operations are in progress function can NOT be called
        from reply callback the will NOT be fired, rather the reply will contain
        the error description if the operation times out - AAComm state will be
        "Disconnected" if Reset is sent over Ethernet - function will always
        timeout
        
        Args:
            commMessage: the message to be sent. should be null
        
        Returns:
            controller reply event args
        """
        ...
    def TestConnection(self, connectionData: ConnectionData, isKnownControllerType: bool) -> ConnectResult:
        """
        Synchronous function, used for testing a connection NOT thread-safe
        (protected vs. re-entry) Call state: NOT connected Exit state: NOT
        connected Note: does NOT query controller About data and Identity
        (except Identity[1] => Controller Type) Note: verifies controller type,
        unless called with knownControllerType == false, in which case sets the
        discovered controller type at Note: in case
        connectionData.CommChannelType == RS_232, Identity[22] => RS232 cable
        type is also queried, and is updated
        
        Args:
            connectionData: the required connection data
            isKnownControllerType: set to FALSE, if testing connection vs. an unknown controller
        """
        ...


class CommAPIWrapper:
    """
    this class is used to wrap the CommAPI as a singleton useful for single-user
    API usage scenario
    """
    @property
    def Connectivity(self) -> ControllerIdentityConnectivity:
        """
        Provides direct access to the "Connectivity" container
        """
        ...
    @property
    def Features_01(self) -> ControllerIdentityFeature_01:
        """
        Provides direct access to the "New Features 1" bitfield (Identity[26])
        """
        ...
    @property
    def Features_02(self) -> ControllerIdentityFeature_02:
        """
        Provides direct access to the "New Features 2" bitfield (Identity[62])
        """
        ...
    @property
    def IdentityContainer(self) -> ControllerIdentityContainer:
        """
        public property to access the Controller Identity Container within the
        API for proper behavior, make sure is 'Connected'!
        """
        ...
    @property
    def Instance(self) -> CommAPI:
        """
        public property to access the singleton API instance
        """
        ...
    @property
    def MessagesContainer(self) -> ControllerMessagesContainer:
        """
        public property to access the Messages Data Container within the API for
        proper behavior, make sure is 'Connected'!
        """
        ...
    @property
    def MessagesInBulk(self) -> int:
        """
        returns max number of messages in a 'Bulk" packet (50) (If
        ConnectionType is NOT - returns '1')
        """
        ...
    @property
    def Versions(self) -> ControllerIdentityVersions:
        """
        Provides direct access to the "Versions" container
        """
        ...
    @staticmethod
    def GetCanDescriptionFromParameter(mnemonic: str) -> int:
        """
        Get Complex CAN Code (CCC) description using Throws on errors for proper
        behavior, make sure is 'Connected'!
        
        Args:
            mnemonic: full message (including axis and array index, if applicable)
        
        Returns:
            complex CAN description (Throws on errors!!)
        """
        ...
    @staticmethod
    def GetFormattedErrorText(e: AACommEventArgs) -> str:
        """
        function to resolve controller error codes using
        
        Args:
            e: AAComm reply to a sent message
        
        Returns:
            formatted error text
        """
        ...


class Extensions:

    class AACommDownloadFPGA:
        """
        Asynchronous service class used for downloading FPGA to controller (NOT
        in BOOT mode) When starting the DL process, the API state must be NOT
        connected. Process ends with API state: Disconnected (success or error)
        """
        @property
        def OnDownloadStarted(self) -> Callable[[], None]:
            """
            this event is invoked when FPGA data download is started. will work
            only AFTER this event was fired
            """
            ...
        @OnDownloadStarted.setter
        def OnDownloadStarted(self, value: Callable[[], None]) -> None: ...
        @property
        def OnProcessEnded(self) -> Callable[[str], None]:
            """
            indicated the end of the FPGA DL process. String parameters
            indicates status. Empty for success, error description otherwise.
            """
            ...
        @OnProcessEnded.setter
        def OnProcessEnded(self, value: Callable[[str], None]) -> None: ...
        @property
        def OnProgress(self) -> Callable[[int], None]:
            """
            reports the binary data download progress, in fractions of 1000(!)
            (for fluent progress bar, if need)
            """
            ...
        @OnProgress.setter
        def OnProgress(self, value: Callable[[int], None]) -> None: ...
        @property
        def OnStatus(self) -> Callable[[str], None]:
            """
            reports the current status of FPGA DL process as string
            """
            ...
        @OnStatus.setter
        def OnStatus(self, value: Callable[[str], None]) -> None: ...
        def CancelProcess(self) -> None:
            """
            used for canceling the DL FPGA process, will work AFTER has been
            invoked
            """
            ...
        def StartDownloading(self, api: CommAPI, connData: ConnectionData, fpgaDataFile: str, verFile: str, password: str) -> None:
            """
            asynchronous function, starts downloading FPGA the API object must
            be NOT connected!
            
            Args:
                api: instance of the API class to perform the download
                connData: connection data
                fpgaDataFile: full FPGA file path (.dat)
                verFile: full FPGA version file path (.ver)
                password: the password for the FPGA download (contact API provider for more info)
            """
            ...

    class AACommDownloadFPGAEtherCat:
        """
        Asynchronous service class used for downloading FPGA to controller (NOT
        in BOOT mode) When starting the DL process, the API state must be NOT
        connected. Process ends with API state: Disconnected (success or error)
        """
        @property
        def OnDownloadStarted(self) -> Callable[[], None]:
            """
            this event is invoked when FPGA data download is started
            """
            ...
        @OnDownloadStarted.setter
        def OnDownloadStarted(self, value: Callable[[], None]) -> None: ...
        @property
        def OnProcessEnded(self) -> Callable[[str], None]:
            """
            indicated the end of the FPGA DL process. String parameters
            indicates status. Empty for success, error description otherwise.
            """
            ...
        @OnProcessEnded.setter
        def OnProcessEnded(self, value: Callable[[str], None]) -> None: ...
        @property
        def OnProgress(self) -> Callable[[int], None]:
            """
            reports the binary data download progress, in fractions of 1000(!)
            (for fluent progress bar, if need)
            """
            ...
        @OnProgress.setter
        def OnProgress(self, value: Callable[[int], None]) -> None: ...
        @property
        def OnStatus(self) -> Callable[[str], None]:
            """
            reports the current status of FPGA DL process as string
            """
            ...
        @OnStatus.setter
        def OnStatus(self, value: Callable[[str], None]) -> None: ...
        def StartDownloading(self, api: CommAPI, connData: ConnectionData, password: str, binaryData: list[int]) -> None:
            """
            asynchronous function, starts downloading FPGA the API object must
            be NOT connected!
            
            Args:
                api: instance of the API class to perform the download
                connData: connection data
                password: the password for the FPGA download (contact API provider for more info)
                binaryData: the FPGA binary data to download
            """
            ...

    class AACommDownloadFPGARemote:
        """
        Asynchronous service class used for downloading FPGA to AGM400 and
        AGM800 products Remote Unit Make sure to set the correct and (if need)
        When starting the DL process, the API state must be NOT connected.
        Process ends with API state: Disconnected (success or error) Process
        can't be canceled in the middle.
        """
        @property
        def OnProcessEnded(self) -> Callable[[str], None]:
            """
            indicated the end of the Remote FPGA DL process. String parameters
            indicates status. Empty for success, error description otherwise. In
            case "Force" is set to "false", but force may be needed, an
            appropriate error is reported. See for "Force" download options!
            """
            ...
        @OnProcessEnded.setter
        def OnProcessEnded(self, value: Callable[[str], None]) -> None: ...
        @property
        def OnProgress(self) -> Callable[[int], None]:
            """
            reports the binary data download progress, 0 to 100
            """
            ...
        @OnProgress.setter
        def OnProgress(self, value: Callable[[int], None]) -> None: ...
        @property
        def OnStatus(self) -> Callable[[str], None]:
            """
            reports the current status of Remote FPGA DL process as string
            """
            ...
        @OnStatus.setter
        def OnStatus(self, value: Callable[[str], None]) -> None: ...
        def StartDownloading(self, api: CommAPI, connData: ConnectionData, fpgaInfo: AACommRemoteFpgaInfo) -> None:
            """
            asynchronous function, starts downloading Remote FPGA Make sure to
            set the correct and (if need) the API object must be NOT connected!
            
            Args:
                api: instance of the API class to perform the download
                connData: connection data
                fpgaInfo: remote FPGA data/version container, see for details!
            """
            ...

    class AACommDownloadFW:
        """
        Asynchronous service class used for downloading FW to controller (in
        regular or BOOT mode) When starting the DL process, the API state must
        be NOT connected. Process ends with API state: Disconnected (success or
        error) NOTE: non - AGM800 products do NOT support flashing FW on other
        than 172.1.1 subnets
        """
        @property
        def OnDownloadStarted(self) -> Callable[[], None]:
            """
            this event is invoked when FW data download is started. will work
            only AFTER this event was fired
            """
            ...
        @OnDownloadStarted.setter
        def OnDownloadStarted(self, value: Callable[[], None]) -> None: ...
        @property
        def OnProcessEnded(self) -> Callable[[str], None]:
            """
            indicated the end of the FW DL process. String parameters indicates
            status. Empty for success, error description otherwise.
            """
            ...
        @OnProcessEnded.setter
        def OnProcessEnded(self, value: Callable[[str], None]) -> None: ...
        @property
        def OnProgress(self) -> Callable[[int], None]:
            """
            reports the binary data download progress, in fractions of 1000(!)
            (for fluent progress bar, if need)
            """
            ...
        @OnProgress.setter
        def OnProgress(self, value: Callable[[int], None]) -> None: ...
        @property
        def OnStatus(self) -> Callable[[str], None]:
            """
            reports the current status of FW DL process as string (i.e. "erasing
            flash", "restarting controller", etc.)
            """
            ...
        @OnStatus.setter
        def OnStatus(self, value: Callable[[str], None]) -> None: ...
        def CancelProcess(self) -> None:
            """
            used for canceling the DL FW process, will work AFTER has been
            invoked controller will NOT be operational until FW is downloaded
            successfully!
            """
            ...
        def StartDownloading(self, api: CommAPI, connData: ConnectionData, fwDataFile: str, password: str, target: Targets = None) -> None:
            ...
        def StartDownloadingSafe(self, api: CommAPI, connData: ConnectionData, fwDataFile: str, verFile: str, password: str, verifyCurrentRatings: bool, target: Targets = None) -> None:
            ...

    class AACommDownloadUP:
        """
        Asynchronous service class used for downloading User Program to
        controller The API object passed in CTOR must be connected, and NOT used
        during download process
        """
        @property
        def OnProcessEnded(self) -> Callable[[str], None]:
            """
            indicated the end of the User Program DL process. String parameters
            indicates status. Empty for success, error description otherwise.
            """
            ...
        @OnProcessEnded.setter
        def OnProcessEnded(self, value: Callable[[str], None]) -> None: ...
        @property
        def OnProgress(self) -> Callable[[int], None]:
            """
            report the download progress, 0-100%
            """
            ...
        @OnProgress.setter
        def OnProgress(self, value: Callable[[int], None]) -> None: ...
        def DownloadUserProgram(self, api: CommAPI, filePath: str) -> None:
            """
            asynchronous function, starts downloading User Program performs
            Binary download (if supported) the API object passed in CTOR must be
            connected! waits for API queue to become empty, fails if times out
            (5 sec) during download, do NOT use the API! Upon a successful
            download, updates the API (In case of download failure, the
            container is cleared)
            
            Args:
                api: instance of the API class to perform the download
                filePath: compiled User Program file (binary or ASCII)
            """
            ...

    class AACommFwInfo:
        """
        Helper class used to read HEX files FW info, and to validate HEX/BIN and
        VER files prior to FW download For reading FW info, create an instance
        of this class For validating FW files prior to FW download, use the
        method Older FW HEX files don't contain FW information. Opening such
        files will result in all the properties being invalid. Use to verify
        that the FW information was read successfully.
        """
        Bin: str  # AGM800 FW binary file
        Hex: str  # non-AGM800 FW file
        Ver: str  # non-AGM800 FW version file
        @property
        def BypassAddVelFilt(self) -> int:
            """
            Bypass additional velocity filters flag -1/0: NA 1: Additional Bi-
            Quad Filters bypassed Other: Unknown special feature, item 26
            """
            ...
        @property
        def DataValid(self) -> bool:
            """
            indicated whether the analyzed HEX file contains FW information. If
            false - all fields are initialized to "-1"
            """
            ...
        @property
        def FullScaleMa(self) -> int:
            """
            FullScaleMa, as reported by FW file
            """
            ...
        @property
        def FwIdentityText(self) -> list[str]:
            """
            empty, if old HEX format
            """
            ...
        @property
        def FwSystemVersion(self) -> object:
            """
            FW object, as read from analyzed FW file. Format: as
            """
            ...
        @property
        def FwVersion(self) -> str:
            """
            FW version, as read from analyzed FW file. Format: as
            """
            ...
        @property
        def GregVQCA1(self) -> bool:
            """
            GregVQCA1 feature, as reported by FW file
            """
            ...
        @property
        def HesseAG100(self) -> bool:
            """
            HesseAG100 feature, as reported by FW file
            """
            ...
        @property
        def IsEssentium(self) -> bool:
            """
            IsEssentium feature, as reported by FW file
            """
            ...
        @property
        def IsFourPorts(self) -> bool:
            """
            IsFourPorts feature, as reported by FW file
            """
            ...
        @property
        def IsMdd(self) -> bool:
            """
            IsMdd feature, as reported by FW file
            """
            ...
        @property
        def IsNoIcnqc(self) -> bool:
            """
            IsNoIcnqc feature, as reported by FW file
            """
            ...
        @property
        def IsPhilips(self) -> bool:
            """
            IsPhilips feature, as reported by FW file
            """
            ...
        @property
        def IsUser1(self) -> bool:
            """
            DEPRECATED!! IsUser1 feature, as reported by FW file
            """
            ...
        @property
        def IsUser2(self) -> bool:
            """
            IsUser2 feature, as reported by FW file
            """
            ...
        @property
        def IsVariant71(self) -> bool:
            """
            IsVariant71 feature, as reported by FW file
            """
            ...
        @property
        def Magal(self) -> bool:
            """
            Magal feature, as reported by FW file
            """
            ...
        @property
        def MaxContCL(self) -> int:
            """
            MaxContCL, as reported by FW file
            """
            ...
        @property
        def MaxPeakCL(self) -> int:
            """
            MaxPeakCL, as reported by FW file
            """
            ...
        @property
        def MoreVelFilt(self) -> bool:
            """
            MoreVelFilt feature, as reported by FW file
            """
            ...
        @property
        def NumOfAxes(self) -> int:
            """
            NumOfAxes, as reported by FW file
            """
            ...
        @property
        def ProductIdToNameCopy(self) -> dict[int, str]:
            """
            list of all products. for API users, that don't have PCSuite
            ApplicationIniData.xml file
            """
            ...
        @property
        def ProductType(self) -> int:
            """
            Numeric product type/>
            """
            ...
        @property
        def ProductTypeStr(self) -> str:
            """
            Literal product type. May contain PATH-ILLEGAL characters, i.e. '/'
            For AGM800 family products (types 6, 10, 15), always returns
            "AGM800" regardless of source file type (.bin or .hex) and specific
            product ID. This handles the deprecated AGM400 ID (6) and ensures
            consistent display name.
            """
            ...
        @property
        def ReadmeText(self) -> str:
            """
            content of '.readme' accompanying file. Null, if no file found.
            """
            ...
        @property
        def Target(self) -> Targets:
            """
            The controller type this FW is designed for, enum
            """
            ...
        @property
        def TwUser(self) -> bool:
            """
            TwUser feature, as reported by FW file
            """
            ...
        @property
        def Variant(self) -> int:
            """
            Variant feature, as reported by FW file
            """
            ...
        @property
        def Variant72(self) -> bool:
            """
            Variant72 feature, as reported by FW file
            """
            ...
        def __init__(self, fwFile: str, cd: ConnectionData) -> None:
            """
            throws on data reading/parsing errors
            
            Args:
                fwFile: FW HEX/BIN file
                cd: target controller (to resolve the controller type)
            """
            ...
        @staticmethod
        def AACommVersionFromString(verStr: str) -> str:
            """
            reformat VER file version string to AAComm-style version format
            should be used for display purposes, or not used at all. throws on
            invalid numerics format
            
            Args:
                verStr: VER file version string (line #1)
            
            Returns:
                reformatted string, or input string in case of failure
            """
            ...
        def GetSpecialFeaturesStr(self, sep: str) -> str:
            """
            Builds a string that describes all the special features supported by
            analyzed FW
            
            Args:
                sep: features 'separator' within the resulting string
            
            Returns:
                features string
            """
            ...
        def ValidateFwFiles(self, cd: ConnectionData, verFile: str) -> None:
            """
            Validates FW hex/bin and ver files: (THROWS on errors) Can be called
            if is 'false' => will skip internal FW file data checks 0. files
            existence, extensions, FW and ver names matching 1. only bin files
            can be flashed to AGM800 FOR AGM800: If .ver file exists, performs
            validation (MD5, version, type). If not, download proceeds without
            validation (backward compatible). FOR NON-AGM800: 2. fw vs. ver file
            version (if fw file supports this feature) 3. fw product type vs.
            defined connection product type (if fw file supports) 4. ver MD5 vs
            fw computed hash (if supported) 5. ver product type vs. defined
            connection product type (if ver file supports)
            
            Args:
                cd: ConnectionData object that describes the product to be flashed
                verFile: full FW version file path (.ver, can be null for AGM800)
            """
            ...
        def VerifyCurrents(self, api: CommAPI, connData: ConnectionData) -> None:
            """
            Checks whether provided MaxPeakCL and MaxContCL match the ones
            specified within the FW file Supported for HEX files with embedded
            identity data. NOT supported for AGM800 family products. Product
            must not be in boot mode. If is 'false' - exception is thrown object
            must be in 'disconnected' state Connects to controller to query
            required data, disconnects when done Throws on verification failure
            and on errors
            
            Args:
                api: instance of the API class to perform the verification, must be disconnected
                connData: connection data
            """
            ...

    class AACommRemoteFpgaInfo:
        """
        Helper class used to read and validate Master Remote Unit FPGA RPD
        (data) and VER (version) files. Class instance is passed as an argument
        to Make sure to set the correct
        """
        RPD: str  # Remote FPGA binary file extension
        Size4K: str  # string describing the FPGA model size "4K"
        Size8K: str  # string describing the FPGA model size "8K"
        @property
        def AllowForce(self) -> bool:
            """
            a user-set property that specifies whether to allow force FPGA
            download in case of: 1. Version mismatch, when the Remote Unit
            reports 'NA' (0), but VER file indicates a valid version 2. Remote
            Unit is Disconnected from the Master (CiStatus[1] != 3)
            """
            ...
        @AllowForce.setter
        def AllowForce(self, value: bool) -> None: ...
        @property
        def AmpVersion(self) -> int:
            """
            The remote FPGA file is only for this Remote Unit Amplifier Version
            ('0' means NA)
            """
            ...
        @property
        def AmpVersionStr(self) -> str:
            """
            Remote Unit Amplifier Version string representation
            """
            ...
        @property
        def CommVersion(self) -> int:
            """
            The remote FPGA file is only for this Remote Unit Comm Version ('0'
            means NA)
            """
            ...
        @property
        def CommVersionStr(self) -> str:
            """
            Remote Unit Comm Version string representation
            """
            ...
        @property
        def DataFileName(self) -> str:
            """
            The RPD Data file used at CTOR
            """
            ...
        @property
        def FPGASize(self) -> str:
            """
            Remote FPGA 'size' identifier: 4K or 8K
            """
            ...
        @property
        def FPGAVersion(self) -> object:
            """
            Remote FPGA Version, i.e. 2.4.3
            """
            ...
        @property
        def Port(self) -> int:
            """
            a user-set property to indicate the target download Port index (i.e.
            'A' = '0', 'B' = '1', etc.)
            """
            ...
        @Port.setter
        def Port(self, value: int) -> None: ...
        @property
        def UnitSubType(self) -> int:
            """
            The remote FPGA only for this Remote Unit Type/SubType
            """
            ...
        @property
        def UnitType(self) -> int:
            """
            The remote FPGA only for this Remote Unit Type/SubType
            """
            ...
        @property
        def Variant(self) -> int:
            """
            The remote FPGA file is only for this Remote Unit Variant ('0' means
            NA)
            """
            ...
        @property
        def VariantStr(self) -> str:
            """
            Remote Unit Variant string representation
            """
            ...
        @property
        def VersionFileName(self) -> str:
            """
            The accompanying Remote FPGA Version file
            """
            ...
        def __init__(self, rpdFile: str) -> None:
            """
            Reads the RPD data and VER version files, and initializes the
            properties members The VER file must be of the same name as the RPD
            file, residing in the same directory Throws on
            IO/reading/parsing/mismatch errors
            
            Args:
                rpdFile: full path to the RPD data file
            """
            ...

    class Targets:
        Legacy: int
        EC_MCU1: int
        EC_CM: int
        EC_ESI: int
        Unsupported: int

    class RecData:

        class AACommDataRecManager:
            """
            Asynchronous service for data recording The API object passed in all
            functions must be connected!
            """
            @property
            def OnError(self) -> Callable[[str], None]:
                """
                Indicates that an error has occurred. String parameter is the
                error description
                """
                ...
            @OnError.setter
            def OnError(self, value: Callable[[str], None]) -> None: ...
            @property
            def OnForceTrigger(self) -> Callable[[], None]:
                """
                Fired when the completes successfully
                """
                ...
            @OnForceTrigger.setter
            def OnForceTrigger(self, value: Callable[[], None]) -> None: ...
            @property
            def OnSendRecordingParams(self) -> Callable[[], None]:
                """
                Fired when the completes successfully
                """
                ...
            @OnSendRecordingParams.setter
            def OnSendRecordingParams(self, value: Callable[[], None]) -> None: ...
            @property
            def OnStartRecording(self) -> Callable[[], None]:
                """
                Fired when the completes successfully
                """
                ...
            @OnStartRecording.setter
            def OnStartRecording(self, value: Callable[[], None]) -> None: ...
            @property
            def OnStopRecording(self) -> Callable[[], None]:
                """
                Fired when the completes successfully
                """
                ...
            @OnStopRecording.setter
            def OnStopRecording(self, value: Callable[[], None]) -> None: ...
            @property
            def OnUploadRecData(self) -> Callable[[RecordingDataContainer], None]:
                """
                Fired when RecUpload process completes successfully.
                RecordingDataContainer parameter contains the recorded data
                """
                ...
            @OnUploadRecData.setter
            def OnUploadRecData(self, value: Callable[[RecordingDataContainer], None]) -> None: ...
            @property
            def OnWaitForRecToEnd(self) -> Callable[[], None]:
                """
                Fired when the completes successfully
                """
                ...
            @OnWaitForRecToEnd.setter
            def OnWaitForRecToEnd(self, value: Callable[[], None]) -> None: ...
            def ForceTrigger(self, api: CommAPI) -> None:
                """
                Asynchronous function, sends the Force Trigger command The API
                object passed must be connected! In case of incorrect argument
                or error is invoked on a new thread Use event to know when the
                setting process is finished
                
                Args:
                    api: CONNECTED instance of class
                """
                ...
            def SendRecordingParams(self, recSetup: RecordingSetupContainer, api: CommAPI) -> None:
                """
                Asynchronous function, starts setting the recording parameters
                The API object passed must be connected! In case of incorrect
                argument or error is invoked on a new thread Use event to know
                when the setting process is finished
                
                Args:
                    recSetup: recording setup
                    api: CONNECTED instance of class
                """
                ...
            def StartRecording(self, api: CommAPI) -> None:
                """
                Asynchronous function, sends the Start Recording command The API
                object passed must be connected! In case of incorrect argument
                or error is invoked on a new thread Use event to know when the
                setting process is finished
                
                Args:
                    api: CONNECTED instance of class
                """
                ...
            def StopRecording(self, api: CommAPI) -> None:
                """
                Asynchronous function, sends the Stop Recording command The API
                object passed must be connected! In case of incorrect argument
                or error is invoked on a new thread Use event to know when the
                setting process is finished
                
                Args:
                    api: CONNECTED instance of class
                """
                ...
            def UploadRecData(self, api: CommAPI) -> None:
                """
                Asynchronous function, starts uploading the recorded data The
                API object passed must be connected! In case of incorrect
                argument, is invoked on a new thread Use event to get the
                uploaded data
                
                Args:
                    api: CONNECTED instance of class
                """
                ...
            def WaitForRecToEnd(self, timeoutMs: int, api: CommAPI) -> None:
                """
                Asynchronous function, queries 'RecStat' until recording is
                complete, or operation times-out The API object passed must be
                connected! In case of incorrect argument or error is invoked on
                a new thread Use event to know when the recording process is
                finished
                
                Args:
                    timeoutMs: the maximum allowed time to wait for the recording to complete
                    api: CONNECTED instance of class
                """
                ...

        class AACommDataRecManagerSync:
            """
            synchronous wrapper for the functionality of NOT thread-safe !!!
            """
            def ForceTrigger(self, api: CommAPI) -> str:
                """
                NOTE: a 'sleep' may be required between 'ForceTrigger' and calls
                
                Args:
                    api: CONNECTED instance of class
                
                Returns:
                    empty string for success, error description for 'error'
                """
                ...
            def SendRecordingParams(self, recSetup: RecordingSetupContainer, api: CommAPI) -> str:
                """
                Args:
                    recSetup: recording setup
                    api: CONNECTED instance of class
                
                Returns:
                    empty string for success, error description for 'error'
                """
                ...
            def StartRecording(self, api: CommAPI) -> str:
                """
                Args:
                    api: CONNECTED instance of class
                
                Returns:
                    empty string for success, error description for 'error'
                """
                ...
            def StopRecording(self, api: CommAPI) -> str:
                """
                Args:
                    api: CONNECTED instance of class
                
                Returns:
                    empty string for success, error description for 'error'
                """
                ...
            def UploadRecData(self, api: CommAPI, error: str) -> RecordingDataContainer:
                """
                Args:
                    api: CONNECTED instance of class
                    error: empty string in case of success, error description for 'error'
                
                Returns:
                    recording results container, NULL in case of error
                """
                ...
            def WaitForRecToEnd(self, timeoutMs: int, api: CommAPI) -> str:
                """
                Args:
                    timeoutMs: the maximum allowed time to wait for the recording to complete
                    api: CONNECTED instance of class
                
                Returns:
                    empty string for success, error description for 'error'
                """
                ...

        class LogicalTriggerRelation:
            """
            an enum to set the behavior of multiple logical triggers,
            """
            And: int
            Or: int  # Represents logical 'OR' relation (i.e. Trig_1 OR Trig_2)

        class MultiTriggerModes:
            """
            an enum to set the behavior of multiple triggers
            """
            Logical: int
            Serial: int  # Trigger mode: serial (triggers conditions must be met sequentially)

        class RecordingDataContainer:
            """
            An object that contains all the data of a recording (setup and
            recorded data points)
            """
            @property
            def RecGap(self) -> int:
                """
                The gap of the recording (# counts per recorded data point)
                """
                ...
            @property
            def RecLength(self) -> int:
                """
                Length of the recording (# recorded data points per vector)
                """
                ...
            @property
            def RecTimeSec(self) -> list[float]:
                """
                A list of the recorded time points (in seconds), according to
                and
                """
                ...
            @property
            def Triggers(self) -> TriggersDataContainer:
                """
                An object describing the triggers defined for the recording
                """
                ...
            @property
            def VectorsData(self) -> list[VectorDataContainer]:
                """
                A list of objects describing recorded parameters and the
                recorded data
                """
                ...

        class RecordingSetupContainer:
            """
            An object that contains all parameters required for a recording
            """
            @property
            def DurationSec(self) -> float:
                """
                the duration of the recording, in seconds
                """
                ...
            @DurationSec.setter
            def DurationSec(self, value: float) -> None: ...
            @property
            def Gap(self) -> float:
                """
                the gap of the recording
                """
                ...
            @Gap.setter
            def Gap(self, value: float) -> None: ...
            @property
            def ParamsToRecord(self) -> list[str]:
                """
                list of parameters to record (full message, i.e. AVel[3],
                CGenData[13])
                """
                ...
            @property
            def TriggersContainer(self) -> TriggersDataContainer:
                """
                triggers data to be used
                """
                ...
            @TriggersContainer.setter
            def TriggersContainer(self, value: TriggersDataContainer) -> None: ...

        class TriggerContainer:
            """
            A container to store information for a trigger Intended to be used
            for recording data through "AACommDataRecManager"
            """
            @property
            def Mask(self) -> int:
                """
                The mask of the trigger (RecTrigMask)
                """
                ...
            @property
            def MaxValue(self) -> float:
                """
                Maximum value of trigger, relevant for some of the triggers type
                (RecTrigValMax)
                """
                ...
            @property
            def SrcCCC(self) -> int:
                """
                The complex can code of the trigger parameter
                """
                ...
            @property
            def SrcMnemonic(self) -> str:
                """
                Full massage of the parameter (for example: AVel[2])
                """
                ...
            @property
            def Type(self) -> int:
                """
                The type of the trigger (RecTrigTyp)
                """
                ...
            @property
            def Value(self) -> float:
                """
                The value of the trigger (RecTrigVal)
                """
                ...
            def __init__(self, api: CommAPI, trigType: int, trigMnemonic: str, trigVal: float, trigMask: int, trigValMax: float = None) -> None:
                """
                The API object passed in CTOR must be connected! In case of
                incorrect arguments given, exception will be thrown
                
                Args:
                    api: CONNECTED instance of class
                    trigType: the type of the trigger (RecTrigTyp)
                    trigMnemonic: trigger parameter full massage ([Axis][Mnemonic][index], "AVel[2]")
                    trigVal: trigger value
                    trigMask: trigger mask
                    trigValMax: trigger max value, relevant for some of the triggers
                """
                ...

        class TriggersDataContainer:
            """
            a class that contains recording trigger parameters for Rec. System A
            """
            @property
            def Triggers(self) -> list[TriggerContainer]:
                """
                List of object describe the triggers for the recording
                """
                ...
            @property
            def TriggersLogicalConnection(self) -> list[LogicalTriggerRelation]:
                """
                index[0]: logical connection between trigger1 / trigger2
                index[1]: logical connection between trigger2 / trigger3 enum
                """
                ...
            @property
            def TriggersMode(self) -> MultiTriggerModes:
                """
                Mode of the complex triggers Serial/Logical Relevant when using
                more then one trigger
                """
                ...
            @property
            def TriggersPosition(self) -> int:
                """
                RecTrigPos
                """
                ...
            def __init__(self, trigger: TriggerContainer, triggerPosition: int) -> None:
                """
                Constructor for using ONE 'simple trigger' for Rec. System A
                Throws on invalid arguments
                
                Args:
                    trigger: object of type TriggerContainer, describe the trigger for the recording
                    triggerPosition: position of the triggers (RecTrigPos; [1:100])
                """
                ...
            def __init__(self, triggers: list[TriggerContainer], triggersMode: MultiTriggerModes, triggerPosition: int, triggersLogicalConnection: list[LogicalTriggerRelation] = None) -> None:
                ...

        class VectorDataContainer:
            """
            a class that contains recorded vector parameters
            """
            @property
            def CanCode(self) -> int:
                """
                complex CAN code of the recorded parameter
                """
                ...
            @property
            def Parameter(self) -> str:
                """
                recorded parameter literal (i.e 'AGenData[13]', or 'CVel[1]':
                with axis and index if applicable)
                """
                ...
            @property
            def UserUnits(self) -> int:
                """
                User units of the recorded parameter
                """
                ...
            @property
            def Values(self) -> list[float]:
                """
                the recorded values
                """
                ...


class Services:

    class AACommAxisHelper:
        """
        a helper class for controller parameters Axis manipulations
        """
        AAxis: str  # the 'first' controller Axis letter, upper case
        PAxis: str  # 'Dynamic' axis letter, see ChooseAxis keyword for usage details
        @staticmethod
        def ToAxis(axisIdx: int) -> str:
            """
            returns axis char according to axis index, ZERO-based ('0' -> 'A')
            does NOT check input range!
            """
            ...
        @staticmethod
        def ToAxisIdx(axis: str) -> int:
            """
            returns axis index according to axis letter, ZERO-based ('A' -> '0')
            does NOT check input axis validity!
            """
            ...
        @staticmethod
        def ToAxisIdx(axis: str) -> int:
            """
            returns axis index according to axis letter, ZERO-based ('A' -> '0')
            does NOT check input string for null / zero length!
            """
            ...
        @staticmethod
        def ToAxisStr(axisIdx: int) -> str:
            """
            returns axis string according to axis index, ZERO-based ('0' -> "A")
            does NOT check input range!
            """
            ...

    class AACommEventArgs:
        """
        this class is used as an argument, when invoking passed to /> and as the
        return value of
        """
        @property
        def IsBoot(self) -> bool:
            """
            returns whether message contains indicates that the controller is in
            boot mode.
            """
            ...
        @property
        def IsError(self) -> bool:
            """
            returns true, if starts with or or VALIDITY ISN'T GUARANTEED when
            using multi-message packets!! (and other) error text is in
            """
            ...
        @property
        def MsgReceived(self) -> str:
            """
            message received from controller
            """
            ...
        @property
        def MsgSent(self) -> str:
            """
            message sent to controller
            """
            ...
        def __init__(self, msgReceived: str, msgSent: str) -> None:
            """
            ctor
            
            Args:
                msgReceived: message received from controller
                msgSent: message sent to controller
            """
            ...

    class AACommExclusiveCommsManager:
        """
        a class to start/stop AACommServer hardware channel "exclusive
        communication" mode
        """
        @property
        def MinSupportedAACSVersion(self) -> object:
            """
            minimal AACommServer version that supports this feature (property is
            valid only when Connected!)
            """
            ...
        def End(self, api: CommAPI, onDone: Callable[[str], None]) -> None:
            ...
        def Start(self, api: CommAPI, onDone: Callable[[str], None]) -> None:
            ...

    class AACommMessage:
        """
        This class describes the message sent to AAComm and methods Two CTOR
        sets are available: for the synchronous SendReceive() function, and the
        asynchronous Send() function Every CTOR set has 2 "sub-types" regarding
        and The 'implicit' CTOR resolves these parameters automatically from the
        argument The 'explicit' CTOR expects the user to specify these
        arguments. For expert use only. To use the "Bulk Message" functionality:
        use the 'explicit' CTOR, set MessageType to and Timeout to To use the
        "Special CNCA Bulk Message" functionality: use the 'explicit' CTOR, set
        MessageType to and Timeout to To use the "Special CNCB Bulk Message"
        functionality: use the 'explicit' CTOR, set MessageType to and Timeout
        to To use the "Special Bulk Message for CNCA" functionality: use the
        'explicit' CTOR, set MessageType to and Timeout to To use the "Special
        Bulk Message for CNCB" functionality: use the 'explicit' CTOR, set
        MessageType to and Timeout to
        """
        @property
        def Message(self) -> str:
            """
            the message to be sent to controller
            """
            ...
        @property
        def MessageType(self) -> MessageType:
            """
            indicates a special message type, automatically resolved
            """
            ...
        @property
        def OnReplyReceived(self) -> Callable[[object, AACommEventArgs], None]:
            """
            the event handler to be called, when reply is received. Use with
            IMPORTANT: do not block or perform long tasks on the callback thread
            context, as it'll block AAComm operation
            """
            ...
        @property
        def TimeoutMs(self) -> int:
            """
            message timeout, automatically resolved, can be overridden using
            """
            ...
        def __init__(self, onReplyReceived: Callable[[object, AACommEventArgs], None], message: str) -> None:
            ...
        def __init__(self, message: str) -> None:
            """
            IMPLICIT Constructor for SYNCHRONOUS method and are set
            automatically, according to the message being sent
            
            Args:
                message: the message to be sent
            """
            ...
        def __init__(self, onReplyReceived: Callable[[object, AACommEventArgs], None], message: str, messageType: MessageType, timeoutMs: int) -> None:
            ...
        def __init__(self, message: str, messageType: MessageType, timeoutMs: int) -> None:
            """
            ADVANCED!! EXPLICIT constructor for SYNCHRONOUS method Explicit
            MessageType and Timeout must be set! If AProgErase is sent using
            this CTOR, must be called!
            
            Args:
                message: the message to be sent
                messageType: the message type
                timeoutMs: the message timeout
            """
            ...
        @staticmethod
        def IsSpecialEthernetOnly(message: str) -> bool:
            """
            ADVANCED!! for INTERNAL use!! returns whether message is a special
            "Ethernet only" message
            
            Args:
                message: the message to controller
            
            Returns:
                whether the message is of "special" type
            """
            ...
        @staticmethod
        def StartsWithPAxis(msg: str) -> bool:
            """
            Helper function to checks whether a message starts with (case
            insensitive)
            
            Args:
                msg: parameter to check
            
            Returns:
                whether the string starts with
            """
            ...
        def SetTimeoutMs(self, timeoutMs: int) -> None:
            """
            ADVANCED!! Helper function for the rare case has to be modified
            """
            ...

    class AACommVerifySingleClient:
        """
        a helper class used to verify if the AACommServer is used by a single
        (the querying) client
        """
        @property
        def Error(self) -> str:
            """
            for : error message if the query failed
            """
            ...
        @property
        def IsError(self) -> bool:
            """
            for : true if the query failed
            """
            ...
        @property
        def IsSingle(self) -> bool:
            """
            after and query, this property will be true if the AACommServer is
            in single channel mode
            """
            ...
        @property
        def MinSupportedAACSVersion(self) -> object:
            """
            minimal AACommServer version that supports this feature (property is
            valid only when Connected!)
            """
            ...
        def SendQueryAsync(self, api: CommAPI, onDone: Callable[[], None]) -> None:
            """
            perform the query asynchronously. is invoked when done does NOT fail
            if AACommServer version is below
            
            Args:
                api: CONNECTED AAComm instance
                onDone: a callback to be invoked on operation completion
            """
            ...
        def SendQuerySync(self, api: CommAPI) -> None:
            """
            perform the query synchronously. Throws if not single or query error
            does NOT fail if AACommServer version is below CONNECTED AAComm
            instance
            """
            ...

    class ARPTools:
        """
        a helper class for discovering Ethernet connections
        """
        @staticmethod
        def GetInterNetworkEthernetInterfaces() -> EthernetLookupResults:
            ...
        @staticmethod
        def GetSubnetActiveIPs(DeviceSubnet: str) -> list[object]:
            """
            searches for devices across subnet, will THROW if argument is in
            incorrect format
            
            Args:
                DeviceSubnet: i.e. 172.1.1
            
            Returns:
                list of discovered IP addresses
            """
            ...
        @staticmethod
        def PingAddress(deviceIP: str) -> bool:
            """
            sends ARP request (or Ping on non-Windows OS) to device will THROW
            if argument is in incorrect format
            
            Args:
                deviceIP: IP string, i.e. 172.1.1.101
            
            Returns:
                whether address responded
            """
            ...
        @staticmethod
        def PingAddress(deviceIP: object) -> bool:
            """
            sends ARP request (or Ping on non-Windows OS) to device may throw on
            
            Args:
                deviceIP: IP object,
            
            Returns:
                whether address responded
            """
            ...

    class AllStatInterpreter:
        """
        AllStat controller reply interpreter class See and
        """
        def __init__(self, newFeatures: int) -> None:
            """
            CTOR with parameter that indicates AllStat features extensions. See
            
            Args:
                newFeatures: the controller reply to Identity[25]
            """
            ...
        def ParseAllStatData(self, axesMask: int, numOfAxes: int, groupsMask: int, allStatReply: str) -> AllStatData:
            """
            parses the controller reply to AllStat request
            
            Args:
                axesMask: bit-wise axes mask. i.e. axes A (0) + C (2) is 0x00000101 is "5"
                numOfAxes: number of axes supported by controller
                groupsMask: bit-wise groups mask. i.e. groups 1 and 5 is 0x0010001 is "17" (see for groups details)
                allStatReply: the controller reply to AllStat
            
            Returns:
                a container filled with parsed data, according to required axes and groups
            """
            ...

    class COMTools:
        """
        a helper class for listing relevant (or ALL) COM ports Windows .NET
        ONLY!!! (returns empty list on .NET 6.0, etc.)
        """
        @staticmethod
        def GetFTDI_COMs(getAll: bool = None) -> list[str]:
            """
            gets a list of 'FTDIBUS' / 'Z-TEK' / 'Prolific' COM ports Windows
            .NET ONLY!!!
            
            Args:
                getAll: set to 'true' to get ALL COM ports, as detected by Windows, and NOT use the 'System.Management' filtering
            
            Returns:
                list of COM ports, empty if none or error
            """
            ...

    class CanDescriptionBuilder:
        """
        a helper class, used for building CAN/Ethernet description codes and the
        other way around used at very specific cases, i.e. user program. please
        refer to Controller communications protocol, or contact API provider for
        more information
        """
        def GetCanDescription(self, axis: str, CANCode: int, isArray: bool, index: int) -> int:
            """
            get Complex CAN Code (CCC) description according to provided
            parameters No validity checks are performed!
            
            Args:
                axis: "A" to "numOfAxes", NOT null or empty
                CANCode: the mnemonic CAN code
                isArray: whether it's an array
                index: array index (disregarded, if not array)
            
            Returns:
                int CAN description
            """
            ...
        def GetCanDescriptionFromParameter(self, parameter: str, numOfAxes: int, dataContainer: ControllerMessagesContainer) -> int:
            """
            Get Complex CAN Code (CCC) description according to provided
            mnemonic and data container Throws on error
            
            Args:
                parameter: full message (including axis and array index)
                numOfAxes: number of axes supported by connected controller,
                dataContainer: messages data container to use,
            
            Returns:
                complex CAN description
            """
            ...
        def GetCanDescriptionFromParameterIDE(self, parameter: str, api: CommAPI, dataContainer: ControllerMessagesContainer) -> int:
            """
            Get Complex CAN Code (CCC) description according to provided
            mnemonic and data container Allows ZERO array index for indirect
            User Program indexing! Throws on error
            
            Args:
                parameter: full message (including axis and array index)
                api: CommAPI object
                dataContainer: messages data container to use,
            
            Returns:
                complex CAN description
            """
            ...
        def GetCanMessageFromMessage(self, message: str, numberOfAxes: int, dataContainer: ControllerMessagesContainer, canMessageBytes: list[int], messageLength: int) -> None:
            """
            builds low-level Tx data byte array, throws on errors!!
            
            Args:
                message: full message (including axis and array index)
                numberOfAxes: number of controller axes
                canMessageBytes: out parameter, message bytes
                messageLength: out parameter, message length
            """
            ...
        def GetCanMessageFromMessageIDE(self, message: str, api: CommAPI, dataContainer: ControllerMessagesContainer, canMessageBytes: list[int], messageLength: int) -> None:
            """
            builds low-level Tx data byte array, throws on errors!! Allows ZERO
            array index for indirect User Program indexing!
            
            Args:
                message: full message (including axis and array index)
                api: CommAPI object
                canMessageBytes: out parameter, message bytes
                messageLength: out parameter, message length
            """
            ...
        def GetParameterFromCanDescription(self, complexCanCode: int, dataContainer: ControllerMessagesContainer) -> str:
            """
            get full parameter (i.e. AGenData[17]) according to provided Complex
            CAN Code (CCC) description
            
            Args:
                complexCanCode: complex CAN code, describing Mnemonic, Axis and Index
                dataContainer: currently used messages data container,
            
            Returns:
                parameter, complexCanCode.ToString() if failed
            """
            ...
        def ParseCanDescription(self, canDescription: int, canCode: int, axis: str, arrayIndex: int) -> None:
            """
            parses a complex CAN description (CCC, created by
            
            Args:
                canDescription: CAN description
                canCode: out CAN code
                axis: out axis letter (i.e. "A")
                arrayIndex: out array index, '0' if no index
            """
            ...

    class ConnectionData:
        """
        this class is the connection data container, used for connecting to a
        controller. See see for defaults
        """
        @property
        def CAN_BaudRate(self) -> int:
            """
            CAN bus baud rate, default
            """
            ...
        @CAN_BaudRate.setter
        def CAN_BaudRate(self, value: int) -> None: ...
        @property
        def CAN_Channel(self) -> int:
            """
            CAN channel, default
            """
            ...
        @CAN_Channel.setter
        def CAN_Channel(self, value: int) -> None: ...
        @property
        def CAN_Delay(self) -> int:
            """
            CAN delay, default
            """
            ...
        @CAN_Delay.setter
        def CAN_Delay(self, value: int) -> None: ...
        @property
        def CAN_ReceiveAddress(self) -> int:
            """
            CAN receive address, default
            """
            ...
        @CAN_ReceiveAddress.setter
        def CAN_ReceiveAddress(self, value: int) -> None: ...
        @property
        def CAN_SendAddress(self) -> int:
            """
            CAN send address, default
            """
            ...
        @CAN_SendAddress.setter
        def CAN_SendAddress(self, value: int) -> None: ...
        @property
        def CommChannelType(self) -> ChannelType:
            """
            required communication channel type , default
            """
            ...
        @CommChannelType.setter
        def CommChannelType(self, value: ChannelType) -> None: ...
        @property
        def ControllerType(self) -> int:
            """
            controller type. Must correspond with actual type, as reported by
            may be modified by when invoked with "knownControllerType == false"
            """
            ...
        @ControllerType.setter
        def ControllerType(self, value: int) -> None: ...
        @property
        def ET_IP_1(self) -> int:
            """
            Ethernet IP, byte 1, default
            """
            ...
        @ET_IP_1.setter
        def ET_IP_1(self, value: int) -> None: ...
        @property
        def ET_IP_2(self) -> int:
            """
            Ethernet IP, byte 2, default
            """
            ...
        @ET_IP_2.setter
        def ET_IP_2(self, value: int) -> None: ...
        @property
        def ET_IP_3(self) -> int:
            """
            Ethernet IP, byte 3, default
            """
            ...
        @ET_IP_3.setter
        def ET_IP_3(self, value: int) -> None: ...
        @property
        def ET_IP_4(self) -> int:
            """
            Ethernet IP, byte 4, default
            """
            ...
        @ET_IP_4.setter
        def ET_IP_4(self, value: int) -> None: ...
        @property
        def ET_IP_Default(self) -> str:
            """
            Default Ethernet IP string (X.Y.Z.W)
            """
            ...
        @property
        def ET_IP_DefaultSubnet(self) -> str:
            """
            Default Ethernet IP subnet string (X.Y.Z)
            """
            ...
        @property
        def ET_IP_Str(self) -> str:
            """
            Ethernet IP string
            """
            ...
        @property
        def ET_Port(self) -> int:
            """
            Ethernet port, default
            """
            ...
        @ET_Port.setter
        def ET_Port(self, value: int) -> None: ...
        @property
        def IsAGM800(self) -> bool:
            """
            specifies whether is or "/>
            """
            ...
        @property
        def IsEC(self) -> bool:
            """
            specifies whether is or " or "/>
            """
            ...
        @property
        def Name(self) -> str:
            """
            connection name, not mandatory
            """
            ...
        @Name.setter
        def Name(self, value: str) -> None: ...
        @property
        def Rs232_BaudRate(self) -> int:
            """
            baud rate, default
            """
            ...
        @Rs232_BaudRate.setter
        def Rs232_BaudRate(self, value: int) -> None: ...
        @property
        def Rs232_CableType(self) -> int:
            """
            RS-232 cable type. Modified by (no need to set manually) -1:
            unknown, 1: Micro USB, else: RS-232
            """
            ...
        @Rs232_CableType.setter
        def Rs232_CableType(self, value: int) -> None: ...
        @property
        def Rs232_DataBits(self) -> int:
            """
            data bits, default
            """
            ...
        @Rs232_DataBits.setter
        def Rs232_DataBits(self, value: int) -> None: ...
        @property
        def Rs232_Parity(self) -> Parity:
            """
            parity, default
            """
            ...
        @Rs232_Parity.setter
        def Rs232_Parity(self, value: Parity) -> None: ...
        @property
        def Rs232_PortName(self) -> str:
            """
            port name, i.e. COM3
            """
            ...
        @Rs232_PortName.setter
        def Rs232_PortName(self, value: str) -> None: ...
        @property
        def Rs232_StopBit(self) -> StopBits:
            """
            stop bit, default
            """
            ...
        @Rs232_StopBit.setter
        def Rs232_StopBit(self, value: StopBits) -> None: ...
        @staticmethod
        def Deserialize(serialized: str) -> ConnectionData:
            """
            tries to de-serialize a string, returns a ConnectionData item filled
            with RELEVANT data. for INTERNAL use. Connection type is decided by
            NUMBER OF SERIALIZED ITEMS!!!
            
            Returns:
                resulting ConnectionData object
            """
            ...
        def Clone(self) -> ConnectionData:
            """
            a method for cloning a connection data object
            
            Returns:
                new object, identical to invoking object
            """
            ...
        def GetChannelKeyStr(self) -> str:
            """
            returns a string describing the a unique HW channel identifier
            
            Returns:
                string describing the CommChannelType enum
            """
            ...
        def GetChannelTypeStr(self) -> str:
            """
            returns a string describing the CommChannelType enum
            
            Returns:
                string describing the CommChannelType enum
            """
            ...
        def Serialize(self) -> str:
            """
            returns serialized connection data for sending the message to
            Communicator. for INTERNAL use Connection type is decided by NUMBER
            OF SERIALIZED ITEMS!!!
            
            Returns:
                serialized string
            """
            ...

    class ControllerErrorInterpreter:
        """
        a singleton container for controller error codes and their description
        initialized once for all API instances provides parsing and
        interpretation functionality
        """
        BootErr: str  # any message returned by the API with this prefix, indicates the controller is in BOOT mode, [...]
        ErrPrefix: str  # any message returned by the API with this prefix, indicates an error has occurred see
        PcSuiteErr: str  # any message returned by the API with this prefix, indicates an incorrect message format was [...]
        PcSuiteStr: str  # prefix indicates that a message is generated by PCSuite, and NOT by controller
        SyncErr: str  # any message returned by the API with this prefix, indicates a synchronization-related error [...]
        @property
        def Instance(self) -> ControllerErrorInterpreter:
            """
            static instance to access the singleton
            """
            ...
        @staticmethod
        def IsAssignedValOutOfRange(errCode: int) -> bool:
            """
            static function to check whether a controller error code indicates
            that the assigned value is out of range
            
            Args:
                errCode: controller error code
            
            Returns:
                whether the error is "assigned value is out of range"
            """
            ...
        def GetErrorCodeFromErrorString(self, error: str) -> int:
            """
            gets the error code from error string
            
            Args:
                error: the string containing
            
            Returns:
                error code, "4005" if not found
            """
            ...
        def GetErrorDescriptionByAACommEventArgs(self, e: AACommEventArgs) -> str:
            """
            returns the error description, Code + Description (i.e. ERR123:
            Description)
            
            Args:
                e: controller reply
            
            Returns:
                error description, "Unknown" if not found
            """
            ...
        def GetErrorDescriptionByCode(self, errorCode: int) -> str:
            """
            returns the error description text
            
            Args:
                errorCode: the error code
            
            Returns:
                error description, "Unknown" if not found
            """
            ...
        def GetFormattedErrorText(self, e: AACommEventArgs, messagesContainer: ControllerMessagesContainer) -> str:
            """
            returns a string describing the error
            
            Args:
                e: the message containing
                messagesContainer: API controller messages container
            
            Returns:
                formatted error text
            """
            ...

    class ControllerIdentityConnectivity:
        """
        Provides information about the connectivity identities of a controller:
        Ethernet IP, MAC address, RS232 port, etc.
        """
        @property
        def CAN_Address(self) -> int:
            """
            Identity[37] CAN address
            """
            ...
        @property
        def CAN_Baud(self) -> int:
            """
            Identity[38] CAN baud rate
            """
            ...
        @property
        def ConnectedCableType(self) -> int:
            """
            Identity[22] the type of RS232 cable connected: micro-USB or RJ-45
            (NA for CAN and Ethernet)
            """
            ...
        @property
        def DIP_Switches(self) -> int:
            """
            Identity[36] DIP switches state (bit-wise mask, contact Agito for
            mapping)
            """
            ...
        @property
        def EthernetIP(self) -> list[int]:
            """
            Identity[42-45] 4-digit IP address (default or unsupported is
            0.0.0.0)
            """
            ...
        @property
        def EthernetPort(self) -> int:
            """
            Ethernet port
            """
            ...
        @property
        def MACAddress(self) -> list[int]:
            """
            Identity[46-51] 6-digit MAC address (default or unsupported is
            0.0.0.0.0.0)
            """
            ...
        @property
        def MACAddressStr(self) -> str:
            """
            Identity[46-51] 6-digit MAC address string (default or unsupported
            is 0.0.0.0.0.0)
            """
            ...
        @property
        def RS232_MiniUSB_Baud(self) -> int:
            """
            Identity[39] RS 232 MiniUSB baud rate
            """
            ...
        @property
        def RS232_RJ45_Baud(self) -> int:
            """
            Identity[40] RS 232 RJ45 baud rate
            """
            ...
        @property
        def RS485_Address(self) -> int:
            """
            Identity[41] RS 485 address
            """
            ...

    class ControllerIdentityContainer:
        """
        a container class that contains connected controller identity parameters
        also indicates whether the controller is in boot mode automatically
        initialized by may be re-initialized (if need) by using
        """
        BootPrefix: str  # this is the controller reply prefix, when queried in Boot mode. i.e. BOOT OK> or BOOT ERR 13>
        MaxNumOfRecParams: int  # DEPRECATED!! USE number of supported data recording parameters
        @property
        def AnalogInputSampleRate(self) -> int:
            """
            Identity[24] analog input sampling rate
            """
            ...
        @property
        def Connectivity(self) -> ControllerIdentityConnectivity:
            """
            Provides connectivity information: Ethernet IP, MAC address, RS232
            port, etc.
            """
            ...
        @property
        def CurrentLoopSampleRate(self) -> int:
            """
            Identity[13] controller current loop sample rate (samples per
            second)
            """
            ...
        @property
        def CustomerCode(self) -> int:
            """
            Identity[8] customer code
            """
            ...
        @property
        def DrawMaxBlocksPerScheme(self) -> int:
            """
            Identity[56] Draw Control data: maximum number of blocks per scheme
            ('-1' if not supported or not applicable)
            """
            ...
        @property
        def DrawMaxFlashSize(self) -> int:
            """
            Identity[59] Draw Control data: Number of bytes dedicated in the
            Flash for Draw Control code ('-1' if not supported or not
            applicable)
            """
            ...
        @property
        def DrawMaxParamsPerBlocks(self) -> int:
            """
            Identity[57] Draw Control data: maximum number of parameters per
            block ('-1' if not supported or not applicable)
            """
            ...
        @property
        def DrawNumOfSchemes(self) -> int:
            """
            Identity[58] Draw Control data: number of schemes ('-1' if not
            supported or not applicable)
            """
            ...
        @property
        def FIFOPositionTrackingSize(self) -> int:
            """
            Identity[55] the size of the FIFO position tracking buffer ('-1' if
            not supported or not applicable)
            """
            ...
        @property
        def Features_01(self) -> ControllerIdentityFeature_01:
            """
            Provides bit-wise interpretation of flags
            """
            ...
        @property
        def Features_02(self) -> ControllerIdentityFeature_02:
            """
            Provides bit-wise interpretation of flags
            """
            ...
        @property
        def InBootMode(self) -> bool:
            """
            specifies whether the queried controller is in BOOT mode determined
            if reply to Identity requests is with "BOOT"
            """
            ...
        @property
        def IsCiMaster(self) -> bool:
            """
            specifies whether the connected controller is of type Ci Master
            """
            ...
        @property
        def IsEtherCAT(self) -> bool:
            """
            specifies whether the connected controller is of type EtherCAT
            """
            ...
        @property
        def ManufacturingDate(self) -> int:
            """
            Identity[6] controller manufacturing date
            """
            ...
        @property
        def MaxContCurrent(self) -> int:
            """
            Identity[9] controller maximal continuous current
            """
            ...
        @property
        def MaxDataRecordingPoints(self) -> int:
            """
            Identity[14] maximum number of recording points supported by
            controller
            """
            ...
        @property
        def MaxNumOfRecVectors(self) -> int:
            """
            Identity[15] maximum number of vectors supported for parallel
            recording
            """
            ...
        @property
        def MaxPeakCurrent(self) -> int:
            """
            Identity[10] controller maximal peak current
            """
            ...
        @property
        def MaximalBusVoltage(self) -> int:
            """
            Identity[12] controller maximal bus voltage
            """
            ...
        @property
        def MinimalBusVoltage(self) -> int:
            """
            Identity[11] controller minimal bus voltage
            """
            ...
        @property
        def NewFeatures_01(self) -> int:
            """
            Identity[25] bit-wise value indicating whether certain features are
            supported Use for explicit bit-wise interpretation
            """
            ...
        @property
        def NewFeatures_02(self) -> int:
            """
            Identity[62] bit-wise value indicating whether certain features are
            supported Use for explicit bit-wise interpretation
            """
            ...
        @property
        def NumOfMotorAxes(self) -> int:
            """
            indicates the number of axes that support a motor. for example, if
            Master has 12 axes, and is 8, axes 'A' to 'H' will support motors
            """
            ...
        @property
        def NumOfServoAxes(self) -> int:
            """
            Identity[23] number of servo axes supported by controller (for Ci
            Master only)
            """
            ...
        @property
        def NumberOfAxes(self) -> int:
            """
            Identity[16] number of axes supported by controller
            """
            ...
        @property
        def NumberOfMessages(self) -> int:
            """
            Identity[21] total number of messages supported by controller
            """
            ...
        @property
        def PWMMax(self) -> int:
            """
            Identity[20] controller serial number
            """
            ...
        @property
        def ProductType(self) -> int:
            """
            Identity[1] controller type. 5=AG300, 6=Ci Master, etc. (refer to
            product documentation)
            """
            ...
        @property
        def SerialNumber(self) -> int:
            """
            Identity[2] controller serial number: Concatenation of {Year - 2
            digits, Week - 2 digits, # of Controllers - 4 digits}
            """
            ...
        @property
        def TesterCode(self) -> int:
            """
            Identity[7] tester code
            """
            ...
        @property
        def UP_DepthOfNumStack(self) -> int:
            """
            Identity[19] depth of numerical stack supported by controller
            """
            ...
        @property
        def UP_NumOfThreads(self) -> int:
            """
            Identity[18] number of user-program threads supported by controller
            """
            ...
        @property
        def UnitStat(self) -> int:
            """
            Indicates that the connected unit has a faulty/mismatched/old
            FW/FPGA images Also can indicate a 'Golden' image is missing
            Enabling motors will be blocked and in general, the unit behavior is
            unexpected Please download correct FW/FPGA files, and/or contact
            Agito support Please contact Agito for bit-wise interpretation of
            the UnitStat flags.
            """
            ...
        @property
        def Versions(self) -> ControllerIdentityVersions:
            """
            Provides controller versions information: FW, FPGA, CM, etc.
            """
            ...
        @staticmethod
        def DefaultSamplingRate(type_: int) -> int:
            """
            default sampling rate by controller type
            """
            ...
        def Clear(self) -> None:
            """
            clears all container fields to (0) default value
            """
            ...
        def ReadIdentity(self, api: CommAPI) -> ConnectResult:
            """
            Synchronously reads the Identity data from the controller Throws
            exception if AAComm argument is null or disconnected
            
            Args:
                api: API instance, must be connected
            
            Returns:
                operation result
            """
            ...

    class ControllerIdentityFeature_01:
        """
        a container class for the "New Features 1" bitfield (Identity[26])
        """
        @property
        def AllStat_MotorTemp_Supported(self) -> bool:
            """
            Indicates whether MotorTemp data is reported by AllStat/>
            """
            ...
        @property
        def CNC_Feature_1_Supported(self) -> bool:
            """
            CNC: Indicates whether more than 1 circle in ARC segment is
            supported />
            """
            ...
        @property
        def CNC_Feature_2_Supported(self) -> bool:
            """
            CNC: Indicates whether 4 participating axes in Linear Motion and
            SetPosition is supported />
            """
            ...
        @property
        def CNC_Feature_3_Supported(self) -> bool:
            """
            CNC: Indicates whether Set Corner Parameters, Automatic Corner
            Motion segments and End Speed Automation are supported />
            """
            ...
        @property
        def CNC_Feature_5_Supported(self) -> bool:
            """
            CNC: Indicates support for 5 participating axes in Linear Motion and
            Set Positions and other relevant CNC segments/>
            """
            ...
        @property
        def CNC_Feature_6_Supported(self) -> bool:
            """
            CNC: Indicates support for 6 participating axes in Linear Motion and
            Set Positions and other relevant CNC segments/>
            """
            ...
        @property
        def CNC_Feature_7_Supported(self) -> bool:
            """
            CNC: Indicates CNC support for 3D Arc (in CNCA)/>
            """
            ...
        @property
        def CNC_Feature_8_Supported(self) -> bool:
            """
            CNC: Indicates CNC support for 'Wait using Input'/>
            """
            ...
        @property
        def CNC_TrueJerk_Supported(self) -> bool:
            """
            CNC: Indicates support for true Jerk in CNC motions/>
            """
            ...
        @property
        def CommutationLearnVBus(self) -> bool:
            """
            Indicates the FW supports the commutation 'learn VBus' process/>
            """
            ...
        @property
        def DInFault_Supported(self) -> bool:
            """
            Indicates whether DInMode value "Fault (ext. drive) is supported />
            """
            ...
        @property
        def DataLoggerByTime(self) -> bool:
            """
            Indicates that the Data Logger reports packets by Time (samples)
            rather than ID/>
            """
            ...
        @property
        def DoubleFlash_Supported(self) -> bool:
            """
            Indicates the AGM800 device supports double flash />
            """
            ...
        @property
        def DoublePhase_1_Supported(self) -> bool:
            """
            Indicates Double and Long 64bit parameters are supported/>
            """
            ...
        @property
        def DynamicArrayIndexing(self) -> bool:
            """
            Indicates that indirect array indexing is supported by 'user
            program'/>
            """
            ...
        @property
        def FloatPhase_1_Supported(self) -> bool:
            """
            Indicates Floating point is supported for some parameters and user
            program/>
            """
            ...
        @property
        def FullCurrDirOperation(self) -> bool:
            """
            Indicates that Current Direction operation is fully supported/>
            """
            ...
        @property
        def GearMasterProfiler(self) -> bool:
            """
            Indicates that Gear Master Profiler is fully supported/>
            """
            ...
        @property
        def HallsOnlyCommutation(self) -> bool:
            """
            Indicates that Halls-only Commutation is fully supported/>
            """
            ...
        @property
        def HighPrecGainScale_Supported(self) -> bool:
            """
            Indicates the controller uses 'high precision gain scale'/>
            """
            ...
        @property
        def HomingByLock_Supported(self) -> bool:
            """
            Indicates support for Homing steps 14 to 16/>
            """
            ...
        @property
        def HomingSteps_17_18_Supported(self) -> bool:
            """
            Indicates Homing support step #17 'Write to Motion Mode' and #18
            'Write to Map Type'/>
            """
            ...
        @property
        def HomingSteps_19_20_Supported(self) -> bool:
            """
            Indicates Homing support step #19 'Set UserParam' and #20 'Wait
            UserParam'/>
            """
            ...
        @property
        def InjectTypeBeforeMotorOn(self) -> bool:
            """
            Indicates the FW supports setting InjectType in Motor OFF state/>
            """
            ...
        @property
        def LearnProcess_Supported(self) -> bool:
            """
            Indicates whether Auto-Phasing Learn feature is supported />
            """
            ...
        @property
        def MasterPWM_Supported(self) -> bool:
            """
            Indicates the Ci Master supports User PWM Outputs/>
            """
            ...
        @property
        def MultipleGantry_Supported(self) -> bool:
            """
            Indicates Multiple Gantry mode is supported for AGM800/>
            """
            ...
        @property
        def PwrTempMergedWithBoardTemp(self) -> bool:
            """
            Indicates whether PwrTemp warnings at StatReg are merged with
            BoardTemp/>
            """
            ...
        @property
        def SmoothAutophase(self) -> bool:
            """
            Indicates that Smooth Auto-phasing is fully supported/>
            """
            ...
        @property
        def UserProgVarNames_Supported(self) -> bool:
            """
            Indicates support for User Program header with 'Global Variables
            Names'/>
            """
            ...
        @property
        def VectorMotion_Supported(self) -> bool:
            """
            Indicates support for Vector Motion Mode/>
            """
            ...

    class ControllerIdentityFeature_02:
        """
        a container class for the "New Features 2" bitfield (Identity[62])
        """
        @property
        def DrawModeProfiler_Supported(self) -> bool:
            """
            Indicates that DrawMode supports 'before/after/replace profiler'
            modes/>
            """
            ...
        @property
        def HomingStep_21_Supported(self) -> bool:
            """
            Indicates Homing support step #21 'Jog to home change extended'/>
            """
            ...

    class ControllerIdentityVersions:
        """
        Provides controller versions information: FW, FPGA, CM, etc.
        """
        NewVersioningNumber: int  # new FW/FPGA version indicator. If or are larger, then , are used
        @property
        def BootFirmwareVersion(self) -> int:
            """
            Identity[17] controller boot FW version
            """
            ...
        @property
        def CMBootFirmwareVersion(self) -> int:
            """
            Identity[68] CM boot firmware version applicable only for ECAT
            controllers '-1' if not supported, i.e. old FW version
            """
            ...
        @property
        def CMFirmwareVersionStr(self) -> str:
            """
            Identity[63-67] CM firmware version string (applicable only for ECAT
            controllers) Format: AA.BB.CC FW under development format:
            AA.BB.CC.DD-XXX (ALPHA)
            """
            ...
        @property
        def ESIExpectedVersionMajor(self) -> int:
            """
            Identity[71] ESI expected version: major applicable only for ECAT
            controllers '-1' if not supported, i.e. old FW version
            """
            ...
        @property
        def ESIExpectedVersionMinor(self) -> int:
            """
            Identity[72], ESI expected version: minor applicable only for ECAT
            controllers '-1' if not supported, i.e. old FW version
            """
            ...
        @property
        def ESIVersionMajor(self) -> int:
            """
            Identity[69] ESI version: major (applicable only for ECAT
            controllers) '-1' if not supported, i.e. old FW version
            """
            ...
        @property
        def ESIVersionMinor(self) -> int:
            """
            Identity[70] ESI version: minor applicable only for ECAT controllers
            '-1' if not supported, i.e. old FW version
            """
            ...
        @property
        def FPGAVersion(self) -> int:
            """
            Identity[5] controller FPGA version and
            """
            ...
        @property
        def FPGAVersionStr(self) -> str:
            """
            Identity[31-35] extended FPGA version string Format: AA.BB.CC FPGA
            under development format: AA.BB.CC.DD-XXX (ALPHA) OLD FPGA format:
            A.BBB (deprecated)
            """
            ...
        @property
        def FirmwareSystemVersion(self) -> object:
            """
            Firmware version as object Format: AA.BB.CC FW under development
            format: AA.BB.CC.(DD * 10,000 + XXX) OLD FW format: A.BBB
            (deprecated)
            """
            ...
        @property
        def FirmwareVersion(self) -> int:
            """
            Identity[4] controller FW version. and
            """
            ...
        @property
        def FirmwareVersionStr(self) -> str:
            """
            Identity[26-30] extended FW version string Format: AA.BB.CC FW under
            development format: AA.BB.CC.DD-XXX (ALPHA) OLD FW format: A.BBB
            (deprecated)
            """
            ...
        @property
        def HardwareVersion(self) -> int:
            """
            Identity[3] controller HW version
            """
            ...
        @property
        def ProductVariant(self) -> int:
            """
            Identity[54] Product Variant ('-1' if not supported or not
            applicable) Applicable to , , ,
            """
            ...
        @staticmethod
        def BuildSystemVersion(verArr: list[int]) -> object:
            """
            helper function to build the extended Firmware version as object
            Format: AA.BB.CC FW under development format: AA.BB.CC.(DD * 10,000
            + XXX)
            
            Args:
                verArr: array of 5 version numbers
            
            Returns:
                Version object (null for invalid input)
            """
            ...
        @staticmethod
        def BuildVersionString(verArr: list[int]) -> str:
            """
            helper function to build the extended Firmware and FPGA version
            string Format: AA.BB.CC FW/FPGA under development format:
            AA.BB.CC.DD-XXX (ALPHA)
            
            Args:
                verArr: array of 5 version numbers
            
            Returns:
                version string (empty string for invalid input)
            """
            ...
        def IsFPGAVersionEqualOrGreater(self, version: list[int]) -> bool:
            """
            Helper function to check whether Connected Controller FPGA version
            is equal/greater than input parameter version Format: AA.BB.CC.DD.EE
            (DD and EE are ignored, and may be discarded) Returns 'false' for
            invalid arguments!!
            
            Args:
                version: array of at least 3 version numbers (array index '0' is 'major' version)
            
            Returns:
                whether 'neededVersion' >= 'Connected Controller FPGA version'
            """
            ...

    class ControllerMessagesContainer:
        """
        a container class that contains connected controller messages data
        automatically initialized by automatically cleared by (or any event that
        leads to disconnection) may be re-initialized (if need) by using NOTE:
        CTOR will throw if failed initializing container with default messages
        (indicates API package corruption) In case of , see for "corruption"
        reason
        """
        @property
        def AllMnemonics(self) -> list[str]:
            """
            SORTED list of all mnemonics supported by the controller (as read
            from the controller "About" data)
            """
            ...
        @property
        def CanCodeToData(self) -> dict[int, MessageData]:
            """
            dictionary of CAN code vs. message data ()
            """
            ...
        @property
        def CategoriesList(self) -> list[MessageCategory]:
            """
            list of all messages categories (as read from the controller "About"
            data)
            """
            ...
        @property
        def InitErr(self) -> str:
            """
            contains summary of initialization error , empty if initialized OK
            """
            ...
        @property
        def IsInitialized(self) -> bool:
            """
            specifies whether the container is initialized
            """
            ...
        @property
        def MnemonicAsIsToData(self) -> dict[str, MessageData]:
            """
            dictionary of mnemonic as read from controller "About" vs. message
            data ()
            """
            ...
        @property
        def UserUnitsSupported(self) -> bool:
            """
            specifies whether the User Units feature is supported by connected
            controller
            """
            ...
        def Contains(self, mnemonic: str) -> bool:
            """
            a method to check whether the specified mnemonic is supported by the
            controller (case insensitive)
            
            Args:
                mnemonic: mnemonic to check
            
            Returns:
                true if supported
            """
            ...
        def GetDataFromMnemonic(self, mnemonic: str) -> MessageData:
            """
            a method to (safely) get the MessageData associated with certain
            controller mnemonic (case insensitive)
            
            Args:
                mnemonic: required mnemonic, any case
            
            Returns:
                associated message data, null if not found or not initialized
            """
            ...
        def InitContainerFromFile(self, aboutFile: str) -> str:
            """
            initializes the container with messages data described within a XML
            file used with the"About" data read from controller
            
            Args:
                aboutFile: commands list XML file (controller 'About' data)
            
            Returns:
                empty string on success, error description on failure
            """
            ...
        def MaxUserUnitNameLen(self, g: UUGroups) -> int:
            """
            the maximum length of the units name in the group, '0' if not
            supported
            
            Args:
                g: the User Units group
            
            Returns:
                max. length
            """
            ...
        def SetToUseDefaults(self) -> None:
            """
            initializes the container with default messages data used for
            communicating with a newly connected controller, before the "About"
            data has been read
            """
            ...
        def TryGetUserUnitsGroup(self, group: UUGroups) -> UserUnitGroup:
            """
            returns a COPY of the User Units group by the specified key, or NULL
            if not found
            
            Args:
                group: required group
            
            Returns:
                group description or null if not supported
            """
            ...
        def TrySetUnitsSync(self, api: CommAPI, group: UUGroups, axis: str, uuName: str, uuFactor: float) -> UUErrors:
            """
            attempts to set the requested user units group 'units name' and
            'scaling factor' values to the controller
            
            Args:
                api: the AAComm API instance to use, must be "connected"
                group: the group to set,
                axis: axis to set, 'A' to highest motor axis
                uuName: the user units 'name', i.e. 'mm'. Max length is according to UnitsUnits[] array length
                uuFactor: the scaling factor, must not be 0, inf, nan
            
            Returns:
                error code,
            """
            ...

    class EthernetLookupResults:
        @property
        def Error(self) -> str:
            ...
        @Error.setter
        def Error(self, value: str) -> None: ...
        @property
        def Results(self) -> list[LookupResult]:
            ...
        def GetSubnetMismatchString(self, requiredSubnet: str) -> str:
            ...
        def IsSubnetSetOnAny(self, subnet: str) -> bool:
            ...

    class GlobalVar:
        """
        user program Header Info "Global Variable" description
        """
        VC: str  # indicates a "Global Var" in the user program Header Info section
        @property
        def Name(self) -> str:
            """
            variable user-provided name, i.e. MyGlobalVar_1[x][y]... (array
            sizes!)
            """
            ...
        @property
        def Targets(self) -> dict[str, str]:
            """
            all the allocated (array or single) user-names vs. "controller"
            names
            """
            ...
        @staticmethod
        def ParseMultiDimDefine(name: str, arrDims: list[int], target: str, allocStart: int) -> dict[str, str]:
            ...
        def ToInfoString(self) -> str:
            """
            generates a readable description string
            
            Returns:
                description string
            """
            ...

    class HeaderParser:
        """
        a service class to parse the currently loaded User Program Header data,
        obtained by inquiring "AProgInfo"
        """
        AddressChar: str  # indicates the start of a function address or define target in the user program Header Info section
        NamePadChar: str  # The character used to "pad" names in the user program Header Info section
        @property
        def CheckSum(self) -> int:
            """
            user program checksum
            """
            ...
        @property
        def Date(self) -> str:
            """
            user program compilation date
            """
            ...
        @property
        def FileName(self) -> str:
            """
            compiled user program file name (.cup2/.cupb2)
            """
            ...
        @property
        def Funcs(self) -> list[TaskFunc]:
            """
            user program "Functions" information
            """
            ...
        @property
        def GlobalVars(self) -> list[GlobalVar]:
            """
            user program "Global Variables" information (declared by #globalvar
            directive in IDE+)
            """
            ...
        @property
        def InfoLines(self) -> list[str]:
            """
            user program header "information" lines
            """
            ...
        @property
        def Tasks(self) -> list[TaskFunc]:
            """
            user program "Tasks" information
            """
            ...
        def __init__(self, header: str) -> None:
            """
            in case of a parsing error, and will contain the error description
            will be '-1', and all containers - empty
            
            Args:
                header: Controller reply to "AProgInfo"
            """
            ...
        def GetChecksumNoDate(self) -> int:
            """
            returns the checksum value disregarding the "date" header part
            
            Returns:
                checksum without "date" part
            """
            ...

    class LocaleProvider:
        """
        Singleton object that provides localized Error and Status strings
        Currently supported languages: "en-US", "zh-CN" Use for localized
        Controller Errors strings
        """
        @property
        def Instance(self) -> LocaleProvider:
            """
            Singleton access property
            """
            ...
        @property
        def Locale(self) -> str:
            """
            Locale setter property; Default or unsupported is set to "en-US"
            """
            ...
        @Locale.setter
        def Locale(self, value: str) -> None: ...
        @property
        def Unresolved(self) -> str:
            """
            Get localized "Unresolved" string
            """
            ...
        @staticmethod
        def IsDrawConFlt(conFlt: int) -> bool:
            """
            returns whether the controller error code is defined for DrawControl
            use
            """
            ...
        def GetError(self, val: int) -> str:
            """
            Get localized string by Controller Error Code
            
            Args:
                val: the key to look for in the DB
            
            Returns:
                localized string, if not found
            """
            ...
        def GetString(self, key: str) -> str:
            """
            Get localized string by key
            
            Args:
                key: the key to look for in the DB
            
            Returns:
                localized string. If failed to initialize: "ERR...". If not found: "Unresolved"
            """
            ...

    class LookupResult:
        @property
        def Ipv4IPs(self) -> list[object]:
            ...
        @property
        def Ipv4Interface(self) -> object:
            ...
        def __init__(self, ipv4Interface: object) -> None:
            ...
        def DoesIpv4SubnetMatch(self, subnet: str) -> bool:
            ...

    class MessageCategory:
        @property
        def CategoryName(self) -> str:
            ...
        @property
        def MessagesList(self) -> list[str]:
            ...
        def __init__(self, categoryName: str, messagesList: list[str]) -> None:
            ...
        def ToString(self) -> str:
            ...

    class MessageData:
        """
        this class describes and contains the different parameters every
        controller message has
        """
        @property
        def CANCode(self) -> int:
            """
            message CAN code, i.e 24 for PosRef
            """
            ...
        @property
        def DefaultValue(self) -> float:
            """
            default value, see also
            """
            ...
        @property
        def DefaultValueInt(self) -> int:
            """
            default parameter value (rounded 32 bit integral)/>
            """
            ...
        @property
        def DefaultValueLong(self) -> int:
            """
            default parameter value (rounded 64 bit integral)/>
            """
            ...
        @property
        def DefaultValueStr(self) -> str:
            """
            string representation of the default value according to the
            parameter type may contain commas or EXP notation!
            """
            ...
        @property
        def DynamicPtr(self) -> int:
            """
            dynamic value, applicable to Ci Master controller type
            """
            ...
        @property
        def ExtendedInfo(self) -> ParameterInfo:
            """
            extended parameter information: indexes, bit-wise (NULL if NA)
            """
            ...
        @property
        def Implemented(self) -> int:
            """
            DEPRECATED!!! is implemented
            """
            ...
        @property
        def InUserUnits(self) -> int:
            """
            is in User Units
            """
            ...
        @property
        def Is64_bit(self) -> bool:
            """
            indicates that the parameter is a 64 bit value (either or )
            """
            ...
        @property
        def IsArray(self) -> bool:
            """
            is array, i.e GenData[...]
            """
            ...
        @property
        def IsAxisRelated(self) -> bool:
            """
            is value related to Axis
            """
            ...
        @property
        def IsCommand(self) -> bool:
            """
            is this a command
            """
            ...
        @property
        def IsDouble(self) -> bool:
            """
            indicates that the parameter is represented as a 'double' 64 bit
            value ( == 2)
            """
            ...
        @property
        def IsDynamicPtr(self) -> bool:
            """
            is dynamic value
            """
            ...
        @property
        def IsFloat(self) -> bool:
            """
            indicates that the parameter is represented as a 'float' 32 bit
            value ( == 1)
            """
            ...
        @property
        def IsFloatingPoint(self) -> bool:
            """
            indicates that the parameter is a floating point value (either or )
            """
            ...
        @property
        def IsInt(self) -> bool:
            """
            indicates that the parameter is an 'int' 32 bit value ( == 0)
            """
            ...
        @property
        def IsLong(self) -> bool:
            """
            indicates that the parameter is a 'long' 64 bit value ( == 3)
            """
            ...
        @property
        def IsSaveToFlash(self) -> bool:
            """
            is need to save to flash
            """
            ...
        @property
        def MaxArrayIndex(self) -> int:
            """
            maximum array index (0 if not an array)
            """
            ...
        @property
        def MaxValue(self) -> float:
            """
            maximum value, see also
            """
            ...
        @property
        def MaxValueInt(self) -> int:
            """
            maximum parameter value (rounded 32 bit integral)/>
            """
            ...
        @property
        def MaxValueLong(self) -> int:
            """
            maximum parameter value (rounded 64 bit integral)/>
            """
            ...
        @property
        def MaxValueStr(self) -> str:
            """
            string representation of the maximum value according to the
            parameter type may contain commas or EXP notation!
            """
            ...
        @property
        def MinValue(self) -> float:
            """
            minimum value, see also
            """
            ...
        @property
        def MinValueInt(self) -> int:
            """
            minimum parameter value (rounded 32 bit integral)/>
            """
            ...
        @property
        def MinValueLong(self) -> int:
            """
            minimum parameter value (rounded 64 bit integral)/>
            """
            ...
        @property
        def MinValueStr(self) -> str:
            """
            string representation of the minimum value according to the
            parameter type may contain commas or EXP notation!
            """
            ...
        @property
        def Mnemonic(self) -> str:
            """
            message ASCII mnemonic, i.e PosRef
            """
            ...
        @property
        def OKInMotion(self) -> bool:
            """
            is OK while in motion
            """
            ...
        @property
        def OKMotorOn(self) -> bool:
            """
            is OK while motor is ON
            """
            ...
        @property
        def ParamType(self) -> int:
            """
            reports the parameter type: 0 - int, 1 - float, 2 - double, 3 - long
            """
            ...
        @ParamType.setter
        def ParamType(self, value: int) -> None: ...
        @property
        def ParamTypeStr(self) -> str:
            """
            reports the parameter type string description (i.e. "'float' 32
            bit")
            """
            ...
        @property
        def ParamWithFunc(self) -> bool:
            """
            is function can be associated with it
            """
            ...
        @property
        def ReadOnly(self) -> bool:
            """
            is read only
            """
            ...
        @property
        def ScalingFact(self) -> int:
            """
            scaling factor
            """
            ...
        def GetCanMessage(self, axis: str, arrayIndex: int) -> int:
            """
            get complex CAN message, that includes Axis, keyword, and array
            index (if applicable)
            
            Args:
                axis: "A" to "numOfAxes", NOT null or empty
                arrayIndex: one based, i.e. 17
            
            Returns:
                complex CAN message
            """
            ...
        def ToString(self) -> str:
            """
            ToString override for UI display
            
            Returns:
                textual description of the parameter
            """
            ...

    class NumberFormatter:
        """
        a service class for formatting numbers to UI display strings
        """
        @staticmethod
        def ValToString(val: float, isFloat: bool, allowCommas: bool) -> str:
            """
            returns a formatted 7 digits value string according to 'isFloat'/>
            Float format includes ',' as thousands separator, and E+/-
            scientific notation may be used according to the value magnitude
            
            Args:
                val: value to convert to string
                isFloat: specifies whether float format is required
                allowCommas: specifies whether to use commas (for integer and float values)
            
            Returns:
                string representing the value
            """
            ...
        @staticmethod
        def ValToString(val: float, isFloat: bool, allowCommas: bool, nDig: int) -> str:
            """
            returns a formatted 4 digits value string according to 'isFloat'/>
            Float format includes ',' as thousands separator, and E+/-
            scientific notation may be used according to the value magnitude If
            there is a sequence of zeros (2 or more) until the end of the
            number, only one will remain
            
            Args:
                val: value to convert to string
                isFloat: specifies whether float format is required
                allowCommas: specifies whether to use commas (for integer and float values)
                nDig: number of digits to display
            
            Returns:
                string representing the value
            """
            ...

    class TaskFunc:
        """
        user program Header Info "Task"/"Function" description
        """
        EventStart: str  # indicates a "Function Event" in the user program Header Info section
        FC: str  # indicates a "Function" in the user program Header Info section
        NameStart: str  # indicates start of a Task/Function name in the user program Header Info section
        TC: str  # indicates a "Task" in the user program Header Info section
        @property
        def Address(self) -> int:
            """
            Task/Function code "jump" address
            """
            ...
        @property
        def Event(self) -> int:
            """
            Function ONLY: Event number ('0' for Tasks)
            """
            ...
        @property
        def IsTask(self) -> bool:
            """
            true for Task, false for Function
            """
            ...
        @property
        def Name(self) -> str:
            """
            Task/Function name, as defined in IDE+
            """
            ...
        @property
        def Number(self) -> int:
            """
            Task/Function allocation index, as recognized by controller
            """
            ...
        def __init__(self, name: str, number: int) -> None:
            """
            Task CTOR, for internal PCSuite use
            """
            ...
        def __init__(self, name: str, number: int, eventNum: int) -> None:
            """
            Function CTOR, for internal PCSuite use
            """
            ...
        def ToInfoString(self) -> str:
            """
            generates a readable description string
            
            Returns:
                description string
            """
            ...
        def ToString(self) -> str:
            """
            generates a readable description string,
            
            Returns:
                description string
            """
            ...

    class TextNodeData:
        NodeName: str
        NodeText: str

    class UserProgVarsAdapter:
        """
        a container class for uploading, managing and storing User Program Tasks
        and Global Variables names for 'transparent' use in AAComm applications
        can be used only after AAComm object has been initialized and has been
        successfully called
        """
        @property
        def GlobalVars(self) -> dict[str, str]:
            """
            contains Global Variables names as declared in downloaded user
            program, vs. the matching GenData (or UserParam) parameter
            recognized by the controller global variable names are Case
            Sensitive!
            """
            ...
        @property
        def TaskNames(self) -> dict[str, int]:
            """
            contains Tasks names as declared in downloaded user program, vs. the
            task id# recognized by the controller Task names are Case Sensitive!
            """
            ...
        def AdaptUserProgMessage(self, message: AACommMessage) -> AACommMessage:
            """
            Creates an "adapted" AAComm message, where all recognized
            Tasks/GlobalVars have been replaced according to the information
            stored in the containers Does NOT modify original message
            properties, i.e. and
            
            Args:
                message: original message with 'literal' tasks/global vars names
            
            Returns:
                adapted message with controller-recognized parameters
            """
            ...
        def Clear(self) -> None:
            """
            clears and containers
            """
            ...
        def Refresh(self, api: CommAPI) -> str:
            """
            explicit function to refresh the User Program data, by reading it
            from the controller uses Synchronous , so must be called without any
            parallel communications can be used only after AAComm object has
            been initialized and has been successfully called
            
            Args:
                api: the AAComm API instance to use, must be "connected"
            
            Returns:
                empty string for success, error description on error
            """
            ...

    class XmlHandler:
        """
        a helper class, used internally by API to parse XML settings and data
        files
        """
        def __init__(self, xmlFilePath: str) -> None:
            """
            constructor, THROWS in case of bad file!
            
            Args:
                xmlFilePath: XML file path
            """
            ...
        def GetFirstChild(self) -> object:
            """
            gets the main (first) XML node
            
            Returns:
                first XML node
            """
            ...
        def GetXmlNodeByName(self, nodeName: str) -> object:
            """
            returns a list of nodes by name
            
            Args:
                nodeName: node name to look for
            
            Returns:
                list of found nodes
            """
            ...
        def ReadSubNodesTextNodes(self, nodeToSearch: str) -> list[list[TextNodeData]]:
            """
            nodeToSearch is of structure like "/RootNode/SubNode/SubSubNode".
            The function assumes that the nodes SubSubNode have only text nodes.
            The function returns the text for all the text nodes in all the
            nodes tagged as "SubSubNode" in the document
            
            Args:
                nodeToSearch: i.e "/RootNode/SubNode/SubSubNode"
            
            Returns:
                list of sub-node lists
            """
            ...
        def ReadTextNode(self, nodeName: str) -> str:
            """
            read the inner text of the FIRST node found by name
            
            Args:
                nodeName: the node name to search
            
            Returns:
                inner text, null if not found
            """
            ...
        def SaveXml(self) -> None:
            """
            saves the XML file
            """
            ...
        def WriteNodeText(self, nodeName: str, nodeText: str) -> None:
            """
            writes a text node into the XML loaded at CTOR
            
            Args:
                nodeName: node name
                nodeText: node text
            """
            ...

    class ParamInfo:

        class ParameterDescription:
            """
            Contains the Parameter index or bit description
            """
            @property
            def Desc(self) -> str:
                """
                index/bit description use for save value acquisition
                """
                ...
            @Desc.setter
            def Desc(self, value: str) -> None: ...
            @property
            def ShortDesc(self) -> str:
                """
                short index/bit description use for save value acquisition
                """
                ...
            @ShortDesc.setter
            def ShortDesc(self, value: str) -> None: ...
            def Get(self, isShort: bool = None) -> str:
                """
                returns the desired description, falls-back to , empty string if
                no description
                """
                ...

        class ParameterIndexInfo:
            """
            Contains the Parameter index and/or bits information
            """
            @property
            def Bits(self) -> dict[int, ParameterDescription]:
                """
                '0' - based known/recognizable parameter bits vs. their
                descriptions (mutually exclusive with )
                """
                ...
            @Bits.setter
            def Bits(self, value: dict[int, ParameterDescription]) -> None: ...
            @property
            def IndexDesc(self) -> ParameterDescription:
                """
                parameter index info/description
                """
                ...
            @IndexDesc.setter
            def IndexDesc(self, value: ParameterDescription) -> None: ...
            @property
            def Values(self) -> dict[int, ParameterDescription]:
                """
                known/recognizable parameter values vs. their descriptions
                (mutually exclusive with )
                """
                ...
            @Values.setter
            def Values(self, value: dict[int, ParameterDescription]) -> None: ...

        class ParameterInfo:
            """
            Contains the Parameter Name, all indexes and/or bits information
            """
            @property
            def Indexes(self) -> dict[int, ParameterIndexInfo]:
                """
                '1' - based known/recognizable parameter indexes '0' index is
                used for non-array bit-wise parameters OR non-array parameters
                with known Value descriptions
                """
                ...
            @Indexes.setter
            def Indexes(self, value: dict[int, ParameterIndexInfo]) -> None: ...
            @property
            def Name(self) -> str:
                """
                controller parameter name, i.e. MotionStat
                """
                ...
            @Name.setter
            def Name(self, value: str) -> None: ...
            def TryResolve(self, index: int) -> ParameterDescription:
                """
                Attempts to resolve the description of a specified Index
                
                Args:
                    index: desired index [1, MAX_INDEX], set to '0' if parameter is NOT an array
                
                Returns:
                    the description, or null if unresolved
                """
                ...
            def TryResolve(self, index: int, bit: int) -> ParameterDescription:
                """
                Attempts to resolve the description of a specified Index + bit
                combination Note: 'index' and 'bit' are NOT mutually exclusive
                
                Args:
                    index: desired index [1, MAX_INDEX], set to '0' if parameter is NOT an array
                    bit: desired bit [0, 31]
                
                Returns:
                    the description, or null if unresolved
                """
                ...
            def TryResolve(self, index: int, value: int) -> ParameterDescription:
                """
                Attempts to resolve the description of a specified Value
                
                Args:
                    index: desired index [1, MAX_INDEX], set to '0' if parameter is NOT an array
                    value: desired value
                
                Returns:
                    the description, or null if unresolved
                """
                ...

        class ParametersInfoDB:
            """
            Singleton object that provides localized descriptions for Array
            and/or bit-wise controller keywords Currently supported languages:
            "en-US", "zh-CN"
            """
            @property
            def Instance(self) -> ParametersInfoDB:
                """
                Singleton access property
                """
                ...
            @property
            def Locale(self) -> str:
                """
                Locale setter property; Default or unsupported is set to "en-US"
                """
                ...
            @Locale.setter
            def Locale(self, value: str) -> None: ...
            def TryGetParamInfo(self, name: str) -> ParameterInfo:
                """
                tries resolving object for required parameter
                
                Args:
                    name: required parameter name
                
                Returns:
                    info object, null if unresolved
                """
                ...
            def TryResolve(self, name: str) -> ParameterDescription:
                """
                Attempts to resolve 'name' description
                
                Args:
                    name: controller parameter name, i.e. 'Pos' (parameter can be an array)
                
                Returns:
                    description object. If not found: description is
                """
                ...
            def TryResolve(self, name: str, index: int) -> ParameterDescription:
                """
                Attempts to resolve 'name[index]' description
                
                Args:
                    name: controller parameter name, i.e. 'Vel[3]'
                    index: desired index [1, MAX_INDEX]
                
                Returns:
                    description object. If not found: description is
                """
                ...
            def TryResolveBit(self, name: str, bit: int) -> ParameterDescription:
                """
                Attempts to resolve 'name_bit#' description
                
                Args:
                    name: controller parameter name, i.e. 'StatReg' bit #13
                    bit: desired bit [0, 31]
                
                Returns:
                    description object. If not found: description is
                """
                ...
            def TryResolveBit(self, name: str, index: int, bit: int) -> ParameterDescription:
                """
                Attempts to resolve 'name[index]_bit#' description
                
                Args:
                    name: controller parameter name, i.e. 'CNCAStatus[10]' bit #5
                    index: desired index [1, MAX_INDEX]
                    bit: desired bit [0, 31]
                
                Returns:
                    description object. If not found: description is
                """
                ...
            def TryResolveValue(self, name: str, value: int) -> ParameterDescription:
                """
                Attempts to resolve the description of a specified Value of a
                non-array parameter
                
                Args:
                    name: controller parameter name, i.e. 'HomingStat'
                    value: desired value
                
                Returns:
                    description object. If not found: description is
                """
                ...
            def TryResolveValue(self, name: str, index: int, value: int) -> ParameterDescription:
                """
                Attempts to resolve the description of a specified Value of an
                array parameter
                
                Args:
                    name: controller parameter name, i.e. 'Vel'
                    index: desired index [1, MAX_INDEX], set to '0' if parameter is NOT an array
                    value: desired value
                
                Returns:
                    description object. If not found: description is
                """
                ...

    class UserUnits:

        class UUErrors:
            """
            User Units operations error codes
            """
            Success: int  # Operation successful
            Unsupported: int  # Operation not supported
            NotConnected: int  # Not connected to the device or service
            NoUserUnits: int  # No user units found
            FW_FaultDuplicatedParameter: int  # Firmware fault: duplicated parameter
            ErrorReadingData: int  # Error reading data
            UnsupportedGroup: int  # Unsupported group
            UnsupportedAxis: int  # Unsupported axis
            InvalidState: int  # Invalid state
            InvalidName: int  # Invalid name
            InvalidFactor: int  # Invalid factor
            ErrorWritingData: int  # Error writing data

        class UUGroups:
            """
            User Units groups enumerator (support might be partial by a given
            product)
            """
            Pos: int  # Position
            Vel: int  # Velocity
            Acc: int  # Acceleration
            Frc: int  # Force

        class UserUnitAxis:
            """
            contains the scaling factor and units for a single axis
            """
            @property
            def Factor(self) -> float:
                """
                scaling factor: the controller parameter value is multiplied by
                'Factor': for example, controller parameter is 10 and factor is
                0.01 => the resulting value is 10 * 0.01 = 0.1
                """
                ...
            @property
            def Units(self) -> str:
                """
                the units of the scaled parameter (i.e. mm, deg, etc.)
                """
                ...

        class UserUnitGroup:
            """
            a class describing a group of user units
            """
            @property
            def Group(self) -> UUGroups:
                """
                the type of the group
                """
                ...
            @property
            def GroupMnemonics(self) -> list[str]:
                """
                returns a list of the group parameters
                """
                ...
            @property
            def HasUnits(self) -> bool:
                """
                specifies whether this group has any units defined for any axis
                """
                ...
            @property
            def Name(self) -> str:
                """
                the name of the group, i.e. 'Position'
                """
                ...
            def AxisUnits(self, axis: str) -> UserUnitAxis:
                """
                returns the units for the specified axis, case invariant, null
                if not found
                
                Args:
                    axis: required axis
                
                Returns:
                    units for the specified axis, null if not found
                """
                ...


class Shared:

    class AllStatAxisData:
        """
        container for AllStat data, per axis. Used by please refer to the user
        manual for more information shared for AAComm and AACommNative Group 1:
        MotorOn; InjectType; Pos; Vel_1; PosErr; VelErr; MotionStat; ConFlt;
        MotionReason; StatReg; LimitStat; HomingStat; DInPort; Group 2: Vel_2 =>
        4; MotorCurr; ScheduleSet; MotionSamples_1 => 3; InTargetStat;
        ComtStatus_1; Group 3: ProgStat_1 => 8; ProgErr_1 => 8; Group 4:
        FifoStatus_1 => 5; CNCAStatus_1 => 12 Group 5: CiStatus_1 => 7 Group 6:
        Ia; Ib; Id; Iq; Va; Vb; Vc; AInPort_1 => 4; VBus; VLogic; PwrTemp;
        MotorTemp(FW >= 1.3.0); Time; Group 7: PosRef; VelRef; CurrRef; dPosRef;
        CNCAPosRef; CNCAdPosRef; Group 8: LockEn; LockCntr; LockVal; EventOn;
        EventCntr; EventNextPos; EventSelect; Group 9: UserParam_1 => 5 Group
        10: DInPortHigh, BoardTemp
        """
        AInPort_1: int  # Group 6 AInPort[1]
        AInPort_2: int  # Group 6 AInPort[2]
        AInPort_3: int  # Group 6 AInPort[3]
        AInPort_4: int  # Group 6 AInPort[4]
        BoardTemp: int  # Group 10 BoardTemp
        CNCAPosRef: int  # Group 7 CNCAPosRef
        CNCAStatus_1: int  # Group 4 CNCAStatus[1]
        CNCAStatus_10: int  # Group 4 CNCAStatus[10]
        CNCAStatus_11: int  # Group 4 CNCAStatus[11]
        CNCAStatus_12: int  # Group 4 CNCAStatus[12]
        CNCAStatus_2: int  # Group 4 CNCAStatus[2]
        CNCAStatus_3: int  # Group 4 CNCAStatus[3]
        CNCAStatus_4: int  # Group 4 CNCAStatus[4]
        CNCAStatus_5: int  # Group 4 CNCAStatus[5]
        CNCAStatus_6: int  # Group 4 CNCAStatus[6]
        CNCAStatus_7: int  # Group 4 CNCAStatus[7]
        CNCAStatus_8: int  # Group 4 CNCAStatus[8]
        CNCAStatus_9: int  # Group 4 CNCAStatus[9]
        CNCAdPosRef: int  # Group 7 CNCAdPosRef
        CiStatus_1: int  # Group 5 CiStatus[1]
        CiStatus_2: int  # Group 5 CiStatus[2]
        CiStatus_3: int  # Group 5 CiStatus[3]
        CiStatus_4: int  # Group 5 CiStatus[4]
        CiStatus_5: int  # Group 5 CiStatus[5]
        CiStatus_6: int  # Group 5 CiStatus[6]
        CiStatus_7: int  # Group 5 CiStatus[7]
        ComtStatus_1: int  # Group 2 ComtStatus[1]
        ConFlt: int  # Group 1 ConFlt
        CurrRef: int  # Group 7 CurrRef
        DInPort: int  # Group 1 DInPort
        DInPortHigh: int  # Group 10 DInPortHigh
        EventCntr: int  # Group 8 EventCntr
        EventNextPos: int  # Group 8 EventNextPos
        EventOn: int  # Group 8 EventOn
        EventSelect: int  # Group 8 EventSelect
        FifoStatus_1: int  # Group 4 FifoStatus[1]
        FifoStatus_2: int  # Group 4 FifoStatus[2]
        FifoStatus_3: int  # Group 4 FifoStatus[3]
        FifoStatus_4: int  # Group 4 FifoStatus[4]
        FifoStatus_5: int  # Group 4 FifoStatus[5]
        HomingStat: int  # Group 1 HomingStat
        Ia: int  # Group 6 Ia
        Ib: int  # Group 6 Ib
        Id: int  # Group 6 Id
        InTargetStat: int  # Group 2 InTargetStat
        InjectType: int  # Group 1 InjectType
        Iq: int  # Group 6 Iq
        LimitStat: int  # Group 1 LimitStat
        LockCntr: int  # Group 8 LockCntr
        LockEn: int  # Group 8 LockEn
        LockVal: int  # Group 8 LockVal
        MotionReason: int  # Group 1 MotionReason
        MotionSamples_1: int  # Group 2 MotionSamples[1]
        MotionSamples_2: int  # Group 2 MotionSamples[2]
        MotionSamples_3: int  # Group 2 MotionSamples[3]
        MotionStat: int  # Group 1 MotionStat
        MotorCurr: int  # Group 2 MotorCurr
        MotorOn: int  # Group 1 MotorOn
        MotorTemp: int  # Group 6 MotorTemp This parameter is available only from FW 1.3.0 and on
        Pos: int  # Group 1 Pos
        PosErr: int  # Group 1 PosErr
        PosRef: int  # Group 7 PosRef
        ProgErr_1: int  # Group 3 ProgErr[1]
        ProgErr_2: int  # Group 3 ProgErr[2]
        ProgErr_3: int  # Group 3 ProgErr[3]
        ProgErr_4: int  # Group 3 ProgErr[4]
        ProgErr_5: int  # Group 3 ProgErr[5]
        ProgErr_6: int  # Group 3 ProgErr[6]
        ProgErr_7: int  # Group 3 ProgErr[7]
        ProgErr_8: int  # Group 3 ProgErr[8]
        ProgStat_1: int  # Group 3 ProgStat[1]
        ProgStat_2: int  # Group 3 ProgStat[2]
        ProgStat_3: int  # Group 3 ProgStat[3]
        ProgStat_4: int  # Group 3 ProgStat[4]
        ProgStat_5: int  # Group 3 ProgStat[5]
        ProgStat_6: int  # Group 3 ProgStat[6]
        ProgStat_7: int  # Group 3 ProgStat[7]
        ProgStat_8: int  # Group 3 ProgStat[8]
        PwrTemp: int  # Group 6 PwrTemp
        ScheduleSet: int  # Group 2 ScheduleSet
        StatReg: int  # Group 1 StatReg
        Time: int  # Group 6 Time
        UserParam_1: int  # Group 9 UserParam[1]
        UserParam_2: int  # Group 9 UserParam[2]
        UserParam_3: int  # Group 9 UserParam[3]
        UserParam_4: int  # Group 9 UserParam[4]
        UserParam_5: int  # Group 9 UserParam[5]
        VBus: int  # Group 6 VBus
        VLogic: int  # Group 6 VLogic
        Va: int  # Group 6 Va
        Vb: int  # Group 6 Vb
        Vc: int  # Group 6 Vc
        VelErr: int  # Group 1 VelErr
        VelRef: int  # Group 7 VelRef
        Vel_1: int  # Group 1 Vel[1]
        Vel_2: int  # Group 2 Vel[2]
        Vel_3: int  # Group 2 Vel[3]
        Vel_4: int  # Group 2 Vel[4]
        dPosRef: int  # Group 7 dPosRef

    class AllStatData:
        """
        container for ALL axes AllStat data. Used by NOTE: shared for AAComm and
        AACommNative
        """
        A: AllStatAxisData  # AllStat A axis data
        B: AllStatAxisData  # AllStat B axis data
        C: AllStatAxisData  # AllStat C axis data
        D: AllStatAxisData  # AllStat D axis data
        E: AllStatAxisData  # AllStat E axis data
        F: AllStatAxisData  # AllStat F axis data
        G: AllStatAxisData  # AllStat G axis data
        H: AllStatAxisData  # AllStat H axis data
        I: AllStatAxisData  # AllStat I axis data
        IsParsedOK: bool  # Indicates whether parsing was successful
        J: AllStatAxisData  # AllStat J axis data
        K: AllStatAxisData  # AllStat K axis data
        L: AllStatAxisData  # AllStat L axis data

    class ChannelType:
        """
        connection data communication channel types shared enum for AAComm and
        AACommNative!
        """
        RS_232: int  # indicates a RS-232 communication channel
        CAN: int  # indicates a CAN bus communication channel
        Ethernet: int  # indicates Ethernet communication channel
        Simulator: int  # indicates Simulation communications (TBD)
        User1UDP: int

    class ConnectResult:
        """
        enum to indicate the result of calling AAComm functions shared enum for
        AAComm and AACommNative!
        """
        Success: int  # 0 - indicates operation successful
        AACommServerNotRunning: int
        CorruptAboutFile: int
        InvalidConnectionData: int  # 3 - invalid connection data object was passed to
        AlreadyConnected: int  # 4 - method was invoked while already connected. Disconnect first.
        RequiredConnectionUnavailable: int  # 5 - the connection channel specified in ConnectionData is unavailable
        FailIOOperation: int
        FailSocketConnect: int  # 7 - system error - failed initializing communications socket
        FailOpenCommHandler: int
        FailRS232ClearBuffer: int  # 9 - communications error - failed clearing RS-232 buffer
        FailControllerInBootMode: int  # 10 - connection error - the controller is in boot mode
        FailControllerType: int  # 11 - connection error - bad controller reply to AIdentity[1]
        FailRS232CableType: int
        FailCANDelay: int  # 13 - connection error - bad controller reply to setting ACANDelay
        FailIdentity: int  # 14 - connection error - timeout reading controller Identity data
        FailAboutData: int  # 15 - connection error - failed parsing controller 'About' reply
        InvalidControllerType: int
        CANLibMissing: int  # 17 - environment error - canlibCLSNET.dll CAN library is missing
        FwInfoMismatch: int  # 18 - indicates a mismatch between local and controller FwInfo data
        NoEthernetInterfaces: int  # 19 - environment error - no Ethernet interfaces detected
        EthernetInterfaceDisconnected: int  # 20 - environment error - no Ethernet cable connected
        EthernetInterfaceMismatch: int  # 21 - environment error - Ethernet subnet doesn't match requested subnet
        EthernetInterfaceAbnormal: int
        FailFwInfo: int  # 23 - connection error - FwInfo message timed-out during Connect sequence
        FailMacAddress: int
        FailUserProgInfo: int  # 25 - connection error - Failed reading ProgInfo
        SimNotEnabled: int  # 26 - connection error - 'Simulation' mode isn't enabled in AACommServer
        SimOnlyOneSupported: int
        EthernetFailARP: int
        InvalidCANBaud: int  # 29 - communications error - Invalid CAN baud rate
        OpenChannelTimeout: int
        InvalidAboutReply: int  # 31 - connection error - controller 'About' reply is in incorrect format
        AACommServerFailedToOpenProperly: int
        ChannelInExclusiveCommsMode: int
        DuplicateUserUnit: int  # 34 - system error - indicates duplicated UserUnits definitions
        AACS_SocketConnectTimeout: int  # 35 - Timed-out while connecting to AACommServer process socket
        AACS_SocketConnectFail: int  # 36 - Failed connecting to AACommServer process socket
        AACS_SocketConnectException: int  # 37 - Exception when trying to connect to AACommServer process socket
        AACS_FileMissing: int  # 38 - Specified AACommServer application file is missing
        AACS_ProcessStartFail: int  # 39 - Failed process.Start() call
        AACS_ProcessStartException: int  # 40 - Exception while starting AACommServer process
        AACS_ResolveWrongOS: int
        AACS_ResolvePCSuiteDirMissing: int
        AACS_ResolveFileMissing: int
        FailIdentityIndex: int
        FailIdentityParsing: int

    class ConnectResultInterpreter:
        """
        Helper class to get a literal interpretation of a enumerator
        """
        @staticmethod
        def Interpret(cr: ConnectResult, provideAACommTip: bool = None) -> str:
            """
            Helper function to get a literal interpretation of a enumerator
            
            Args:
                provideAACommTip: specifies whether to include AAComm-specific "troubleshooting suggestions" in the interpretation
            
            Returns:
                literal interpretation of the enum value
            """
            ...

    class ConnectionDataDefaults:
        """
        commons class with defaults shared for AAComm and AACommNative: items
        are members of the C# class, and global when included from C++
        """
        DCD_CAN_BaudRate: int  # default CAN baud rate, "1000000"
        DCD_CAN_Channel: int  # default CAN channel, "0"
        DCD_CAN_Delay: int  # default CAN delay, "6"
        DCD_CAN_ReceiveAddress: int  # default CAN receive address, + 1
        DCD_CAN_SendAddress: int  # default CAN send address, "64"
        DCD_ChannelType: int  # default channel type, "2" for Ethernet
        DCD_ControllerType: int  # default controller type, "-1" for unknown etc.
        DCD_ET_Port: int  # default Ethernet port, "50000"
        DCD_IP_1: int  # default Ethernet IP byte 1, "172"
        DCD_IP_2: int  # default Ethernet IP byte 2, "1"
        DCD_IP_3: int  # default Ethernet IP byte 3, "1"
        DCD_IP_4: int  # default Ethernet IP byte 4, "101"
        DCD_Rs232_BaudRate: int  # default RS-232 baud rate, "115200"
        DCD_Rs232_DataBits: int  # default RS-232 data bits, "8"
        DCD_Rs232_Parity: int  # default RS-232 parity, "Parity.None"
        DCD_Rs232_StopBits: int  # default RS-232 stop bits, "StopBits.One"

    class DataRecParams:
        """
        a class that contains all parameters required for a recording + helper
        functions
        """
        RecDataS: str  # Controller parameter: RecData
        RecGapS: str  # Controller parameter: RecGap
        RecLengthS: str  # Controller parameter: RecLength
        RecParamS: str  # Controller parameter: RecParam
        RecStartS: str  # Controller parameter: RecStart
        RecStatS: str  # Controller parameter: RecStat
        RecStopS: str  # Controller parameter: RecStop
        RecTrigForceS: str  # Controller parameter: RecTrigForce
        RecTrigMaskS: str  # Controller parameter: RecTrigMask
        RecTrigPosS: str  # Controller parameter: RecTrigPos
        RecTrigSrcS: str  # Controller parameter: RecTrigSrc
        RecTrigTypS: str  # Controller parameter: RecTrigTyp
        RecTrigValMaxS: str  # Controller parameter: RecTrigValMax
        RecTrigValS: str  # Controller parameter: RecTrigVal
        RecTrigsLogicS: str  # Controller parameter: RecTrigsLogic
        RecTrigsModeS: str  # Controller parameter: RecTrigsMode
        RecUploadNextS: str  # Controller parameter: RecUploadNext
        RecUploadS: str  # Controller parameter: RecUpload
        @staticmethod
        def CalculateActualGapValue(gap: float, api: CommAPI) -> int:
            """
            THROWS if 'api' is null or not connected calculates the gap value
            for the recording
            
            Args:
                gap: requested gap
                api: CONNECTED instance of class
            
            Returns:
                actual gap value to be sent to controller
            """
            ...
        @staticmethod
        def CalculateLengthValue(gap: float, duration: float, api: CommAPI) -> int:
            """
            THROWS if 'api' is not connected calculates the length value for the
            recording Duration = ARecGap / CurrentLoopSampleRate * ARecLength
            Gap = ARecGap / CurrentLoopSampleRate * 1000
            
            Args:
                gap: requested gap
                duration: requested recording duration, in seconds
                api: CONNECTED instance of class
            
            Returns:
                actual length value to be sent to controller
            """
            ...
        @staticmethod
        def ParamsToRecParamArray(recParams: list[str], api: CommAPI) -> list[str]:
            ...

    class MessageType:
        """
        enum to indicate special messages types for communication over CAN and
        Ethernet for details. disregarded for RS-232 channel shared enum for
        AAComm and AACommNative!
        """
        Regular: int  # for messages that don't require special handling
        ResetRequest: int
        Continuous: int
        Firmware: int  # Firmware download, refer to FW download instructions document Timeout:
        UserProgram: int
        UserProgramBin: int
        EraseUserProg: int  # User Program Erase command, refer to User Program manual
        BulkMessage: int
        BulkMessageIgnore: int
        EthernetASCII: int  # reserved
        SpecialBulk: int
        SpecialBulkB: int
        BulkMessageCNC: int
        BulkMessageCNCB: int
        InternalAACS: int  # reserved

    class ProductTypes:
        """
        Supported products,
        """
        AGD101_EC: str  # AGD101-EC
        AGD101_EC_ID: int  # the AGD101-EC
        AGD155: str  # AGD155 (previously AG100-DRV50)
        AGD155_EC: str  # AGD155-EC
        AGD155_EC_ID: int  # the AGD155-EC
        AGD155_ID: int  # the of AGD155 (previously AG100-DRV50)
        AGD156_EC: str  # AGD156-EC
        AGD156_EC_ID: int  # the AGD156-EC
        AGD200_AGC300: str  # AGD200/AGC300 (previously AG300-CTL01)
        AGD200_AGC300_ID: int  # the of AGD200/AGC300 (previously AG300-CTL01)
        AGD301_AGC301: str  # AGD301/AGC301 (previously of AG300-CTL02)
        AGD301_AGC301_ID: int  # the AGD301/AGC301 (previously AG300-CTL02)
        AGM400: str  # [!!!DEPRECATED!!!] AGM400 (previously CiG1-MAS01)
        AGM400_ID: int  # [!!!DEPRECATED!!!] the of AGM400 (previously CiG1-MAS01)
        AGM800: str  # AGM800 (previously CiG1-MAS02)
        AGM800_ID: int  # the of AGM800 (previously CiG1-MAS02)
        DRV6_V3: str  # DRV6-V3
        DRV6_V3_ID: int  # the of DRV6-V3
        PULSE_SYNC: str  # AGD156-EC
        PULSE_SYNC_ID: int  # the PULSE_SYNC
        @staticmethod
        def IdToName(id: int) -> str:
            """
            Attempts to resolve a product 'ID' Returns 'NA' if unrecognized.
            
            Args:
                id: product ID
            
            Returns:
                product name
            """
            ...
        @staticmethod
        def IsAGM800(type_: int) -> bool:
            """
            resolves whether the input controller type is of type Ci Master
            (DEPRECATED!), ,
            
            Args:
                type_: controller type
            
            Returns:
                whether type is Ci Master
            """
            ...
        @staticmethod
        def IsEtherCAT(type_: int) -> bool:
            """
            resolves whether the input controller type is of type EtherCAT , ,
            />
            
            Args:
                type_: controller type
            
            Returns:
                whether type is EtherCAT
            """
            ...
        @staticmethod
        def NameToId(name: str) -> int:
            """
            Attempts to resolve a product 'name', including old naming
            conventions. Returns '-1' if unrecognized.
            
            Args:
                name: product name
            
            Returns:
                product ID
            """
            ...

    class TimeoutMs:
        """
        commons class with timeouts shared for AAComm and AACommNative: items
        are members of the C# class, and global when included from C++
        """
        AfterResetWait: int  # after AReset is sent, this is the time it requires for the controller to recover. NOTE: [...]
        AfterResetWaitMAS02: int  # after AReset is sent, this is the time it requires for the AGM800 controller to recover. NOTE: [...]
        ContinuousMessage: int  # ARecUpload/A/B command timeout. Automatically used with
        Default: int  # Default timeout, the default parameter at Send() function
        DownloadFPGA: int  # the maximal time for FPGA download to finalize
        DownloadUPBin: int  # special timeout for the DownloadUPBin command
        EPPCalc: int  # special timeout for the EPPCalc command
        EraseFlash: int  # special timeout for the erasing flash process. part of Download Firmware process.
        EventCorrect: int  # special timeout for the EventCorrect command
        FirmwareDownload: int  # special Download Firmware timeout. Automatically used with
        LoadFromFlash: int  # special timeout for the ALoad command
        MotorOn: int  # special timeout for the MotorOn=1 command
        ProgErase: int  # special timeout for the ProgErase command
        Reset: int  # AReset command timeout. Automatically used for non-AGM800 products This value is a "magic [...]
        ResetMAS02: int  # AReset command timeout. Automatically used for AGM800 products This value is a "magic number" [...]
        SaveToFlash: int  # special timeout for the ASave command
        SaveUser: int  # special timeout for the SaveUser command

