from enum import Enum
from typing import TypeVar, Generic

T = TypeVar('T')
K = TypeVar('K', bound=Enum)

class DifferentialValueDto(Generic[T, K]):
    """description of class"""
    def __init__(self, **kargs):
        """

        :param kargs: 
        """
        self.__element_id = kargs.get('element_id', None)
        self.__value = kargs.get('value', None)
        self.__is_highly_significant = kargs.get('is_highly_significant', None)
        self.__status = kargs.get('status', None)

    def __hash__(self):
        return hash(self.element_id)

    def __eq__(self, other):
        return isinstance(other, DifferentialValueDto) and \
               self.element_id == other.element_id

    @property
    def element_id(self) -> T:
        """description of property"""
        return self.__element_id

    @element_id.setter
    def element_id(self, value: T):
        """

        :param value: 
        :return: 
        """
        self.__element_id = value

    @property
    def value(self) -> float:
        """description of property"""
        return self.__value

    @value.setter
    def value(self, value: float):
        """

        :param value: 
        :return: 
        """
        self.__value = value

    @property
    def is_highly_significant(self) -> bool:
        """description of property"""
        return self.__is_highly_significant

    @is_highly_significant.setter
    def is_highly_significant(self, value: bool):
        """

        :param value: 
        :return: 
        """
        self.__is_highly_significant = value

    @property
    def status(self) -> K:
        """description of property"""
        return self.__status

    @status.setter
    def status(self, value: K):
        """

        :param value: 
        :return: 
        """
        self.__status = value