"""
Copyright 2019 Goldman Sachs.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

  http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied.  See the License for the
specific language governing permissions and limitations
under the License.
"""

from gs_quant.target.common import *
import datetime
from typing import Tuple, Union
from enum import Enum
from gs_quant.base import Base, EnumBase, InstrumentBase, camel_case_translate, get_enum_value


class AssetProperties(EnumBase, Enum):    
    
    """Enum listing supported asset properties"""

    assetClass = 'assetClass'
    currency = 'currency'
    createdTime = 'createdTime'
    description = 'description'
    exchange = 'exchange'
    id = 'id'
    liveDate = 'liveDate'
    name = 'name'
    region = 'region'
    shortName = 'shortName'
    type = 'type'
    xref_bbid = 'xref.bbid'
    xref_bcid = 'xref.bcid'
    xref_ticker = 'xref.ticker'
    xref_ric = 'xref.ric'
    date = 'date'
    value = 'value'
    slope = 'slope'
    OIS_value = 'OIS value'
    
    def __repr__(self):
        return self.value


class AvailableUnitTypes(EnumBase, Enum):    
    
    """Enum listing supported unit types"""

    percentage = 'percentage'
    percentageWithSymbol = 'percentageWithSymbol'
    bps = 'bps'
    bp = 'bp'
    x = 'x'
    
    def __repr__(self):
        return self.value


class EntitiesSupported(EnumBase, Enum):    
    
    """Enum listing supported entities"""

    assets = 'assets'
    tds = 'tds'
    
    def __repr__(self):
        return self.value


class ParameterPeriod(EnumBase, Enum):    
    
    """Enum listing supported parameter periods"""

    _1d = '1d'
    _1w = '1w'
    _1m = '1m'
    _3m = '3m'
    _6m = '6m'
    _1y = '1y'
    _2y = '2y'
    _5y = '5y'
    _10y = '10y'
    _30y = '30y'
    mtd = 'mtd'
    ytd = 'ytd'
    
    def __repr__(self):
        return self.value


class ParameterRender(EnumBase, Enum):    
    
    """Enum listing supported column definition render types"""

    boxplot = 'boxplot'
    default = 'default'
    direction = 'direction'
    hidden = 'hidden'
    bar = 'bar'
    sparkline = 'sparkline'
    heatmap = 'heatmap'
    simpleCandlestick = 'simpleCandlestick'
    progress = 'progress'
    chart = 'chart'
    range = 'range'
    
    def __repr__(self):
        return self.value


class RateIds(EnumBase, Enum):    
    
    """Enum listing supported rate ids"""

    USD = 'USD'
    EUR = 'EUR'
    JPY = 'JPY'
    GBP = 'GBP'
    CAD = 'CAD'
    AUD = 'AUD'
    
    def __repr__(self):
        return self.value


class SortDirection(EnumBase, Enum):    
    
    """Enum with available sort directions"""

    asc = 'asc'
    desc = 'desc'
    default = 'default'
    
    def __repr__(self):
        return self.value


class SortType(EnumBase, Enum):    
    
    """Enum listing supported sort types"""

    value = 'value'
    abs = 'abs'
    
    def __repr__(self):
        return self.value


class WipiFilterOperation(EnumBase, Enum):    
    
    """Enum listing supported operations for wipi filters."""

    eq = 'eq'
    ne = 'ne'
    gt = 'gt'
    lt = 'lt'
    gte = 'gte'
    lte = 'lte'
    last = 'last'
    
    def __repr__(self):
        return self.value


class WipiFilterType(EnumBase, Enum):    
    
    """Enum listing supported wipi filter types."""

    AND = 'AND'
    OR = 'OR'
    
    def __repr__(self):
        return self.value


class ColumnOperation(Base):
        
    """Object used to describe function chaining and column operations."""

    @camel_case_translate
    def __init__(
        self,
        column_names: Tuple[str, ...] = None,
        function_name: str = None,
        type_: str = None,
        name: str = None
    ):        
        super().__init__()
        self.column_names = column_names
        self.function_name = function_name
        self.__type = type_
        self.name = name

    @property
    def column_names(self) -> Tuple[str, ...]:
        """Name of the columns to get results from in order and put into the given
           function."""
        return self.__column_names

    @column_names.setter
    def column_names(self, value: Tuple[str, ...]):
        self._property_changed('column_names')
        self.__column_names = value        

    @property
    def function_name(self) -> str:
        """Name of the function to pass column results into."""
        return self.__function_name

    @function_name.setter
    def function_name(self, value: str):
        self._property_changed('function_name')
        self.__function_name = value        

    @property
    def type(self) -> str:
        """Type of inputs into the function. Series means pass the whole series into the
           function, value means just gets the result of the column and pass it
           into the given function"""
        return self.__type

    @type.setter
    def type(self, value: str):
        self._property_changed('type')
        self.__type = value        


class ColumnProperty(Base):
        
    """Object used to reference a column mapping"""

    @camel_case_translate
    def __init__(
        self,
        column_name: str = None,
        property_: str = None,
        name: str = None
    ):        
        super().__init__()
        self.column_name = column_name
        self.__property = property_
        self.name = name

    @property
    def column_name(self) -> str:
        """Name of the column to get property"""
        return self.__column_name

    @column_name.setter
    def column_name(self, value: str):
        self._property_changed('column_name')
        self.__column_name = value        

    @property
    def property(self) -> str:
        """Name of the property to get from column mapping"""
        return self.__property

    @property.setter
    def property(self, value: str):
        self._property_changed('property')
        self.__property = value        


class ExportParameters(Base):
        
    """Object with properties specifying how to export individual row or complete
       monitor data."""

    @camel_case_translate
    def __init__(
        self,
        tokens: Tuple[str, ...],
        data_set_id: str = None,
        fields: Tuple[str, ...] = None,
        label: str = None,
        start_date: str = None,
        name: str = None
    ):        
        super().__init__()
        self.data_set_id = data_set_id
        self.fields = fields
        self.label = label
        self.start_date = start_date
        self.tokens = tokens
        self.name = name

    @property
    def data_set_id(self) -> str:
        """Id of the DataSet in which the export will retrieve data from."""
        return self.__data_set_id

    @data_set_id.setter
    def data_set_id(self, value: str):
        self._property_changed('data_set_id')
        self.__data_set_id = value        

    @property
    def fields(self) -> Tuple[str, ...]:
        """The fields to be exported from the DataSet."""
        return self.__fields

    @fields.setter
    def fields(self, value: Tuple[str, ...]):
        self._property_changed('fields')
        self.__fields = value        

    @property
    def label(self) -> str:
        """The label for the export button. For example: Export Historical Data."""
        return self.__label

    @label.setter
    def label(self, value: str):
        self._property_changed('label')
        self.__label = value        

    @property
    def start_date(self) -> str:
        """The relative start date for the history of data to retrieve. Eg: -1y."""
        return self.__start_date

    @start_date.setter
    def start_date(self, value: str):
        self._property_changed('start_date')
        self.__start_date = value        

    @property
    def tokens(self) -> Tuple[str, ...]:
        return self.__tokens

    @tokens.setter
    def tokens(self, value: Tuple[str, ...]):
        self._property_changed('tokens')
        self.__tokens = value        


class FieldMap(Base):
        
    @camel_case_translate
    def __init__(
        self,
        name: str = None
    ):        
        super().__init__()
        self.name = name


class Historical(Base):
        
    """value and date for historical data"""

    @camel_case_translate
    def __init__(
        self,
        value: Union[float, str] = None,
        name: str = None
    ):        
        super().__init__()
        self.value = value
        self.name = name

    @property
    def value(self) -> Union[float, str]:
        return self.__value

    @value.setter
    def value(self, value: Union[float, str]):
        self._property_changed('value')
        self.__value = value        


class MonitorResponseData(Base):
        
    """Monitor calculated response data"""

    @camel_case_translate
    def __init__(
        self,
        id_: str,
        result: dict,
        name: str = None
    ):        
        super().__init__()
        self.__id = id_
        self.result = result
        self.name = name

    @property
    def id(self) -> str:
        """Marquee unique identifier"""
        return self.__id

    @id.setter
    def id(self, value: str):
        self._property_changed('id')
        self.__id = value        

    @property
    def result(self) -> dict:
        return self.__result

    @result.setter
    def result(self, value: dict):
        self._property_changed('result')
        self.__result = value        


class Movers(Base):
        
    """Object that allows to specify the case in which we only want to return the n top
       or bottom entities"""

    @camel_case_translate
    def __init__(
        self,
        column_name: str,
        top: float = None,
        bottom: float = None,
        name: str = None
    ):        
        super().__init__()
        self.top = top
        self.bottom = bottom
        self.column_name = column_name
        self.name = name

    @property
    def top(self) -> float:
        """Integer in the range from 0 to 10000"""
        return self.__top

    @top.setter
    def top(self, value: float):
        self._property_changed('top')
        self.__top = value        

    @property
    def bottom(self) -> float:
        """Integer in the range from 0 to 10000"""
        return self.__bottom

    @bottom.setter
    def bottom(self, value: float):
        self._property_changed('bottom')
        self.__bottom = value        

    @property
    def column_name(self) -> str:
        """Required small string with a length from empty string to 50 characters"""
        return self.__column_name

    @column_name.setter
    def column_name(self, value: str):
        self._property_changed('column_name')
        self.__column_name = value        


class ColumnFormat(Base):
        
    """Object used to specify the column formatting"""

    @camel_case_translate
    def __init__(
        self,
        precision: float,
        unit: Union[AvailableUnitTypes, str] = None,
        human_readable: bool = None,
        axis_key: str = None,
        show_tooltip: bool = None,
        name: str = None
    ):        
        super().__init__()
        self.precision = precision
        self.unit = unit
        self.human_readable = human_readable
        self.axis_key = axis_key
        self.show_tooltip = show_tooltip
        self.name = name

    @property
    def precision(self) -> float:
        """Number of decimals to show"""
        return self.__precision

    @precision.setter
    def precision(self, value: float):
        self._property_changed('precision')
        self.__precision = value        

    @property
    def unit(self) -> Union[AvailableUnitTypes, str]:
        """Unit to show next to number"""
        return self.__unit

    @unit.setter
    def unit(self, value: Union[AvailableUnitTypes, str]):
        self._property_changed('unit')
        self.__unit = get_enum_value(AvailableUnitTypes, value)        

    @property
    def human_readable(self) -> bool:
        """Formats number to have commas"""
        return self.__human_readable

    @human_readable.setter
    def human_readable(self, value: bool):
        self._property_changed('human_readable')
        self.__human_readable = value        

    @property
    def axis_key(self) -> str:
        """Applicable for render type chart, determines line to be on the left or right
           axis"""
        return self.__axis_key

    @axis_key.setter
    def axis_key(self, value: str):
        self._property_changed('axis_key')
        self.__axis_key = value        

    @property
    def show_tooltip(self) -> bool:
        """Whether to show the cell timestamp in a tooltip"""
        return self.__show_tooltip

    @show_tooltip.setter
    def show_tooltip(self, value: bool):
        self._property_changed('show_tooltip')
        self.__show_tooltip = value        


class ColumnMappings(Base):
        
    """Object used to map parameters to a column"""

    @camel_case_translate
    def __init__(
        self,
        column_name: str = None,
        parameters: FieldMap = None,
        name: str = None
    ):        
        super().__init__()
        self.column_name = column_name
        self.parameters = parameters
        self.name = name

    @property
    def column_name(self) -> str:
        """Required small string with a length from empty string to 50 characters"""
        return self.__column_name

    @column_name.setter
    def column_name(self, value: str):
        self._property_changed('column_name')
        self.__column_name = value        

    @property
    def parameters(self) -> FieldMap:
        return self.__parameters

    @parameters.setter
    def parameters(self, value: FieldMap):
        self._property_changed('parameters')
        self.__parameters = value        


class Function(Base):
        
    """Function or Measure to be applied to the column."""

    @camel_case_translate
    def __init__(
        self,
        measure: str,
        frequency: str,
        name: str = None,
        start_date: str = None,
        end_date: str = None,
        start_time: str = None,
        end_time: str = None,
        fields: Tuple[str, ...] = None,
        parameters: FieldMap = None,
        where: FieldMap = None,
        vendor: str = None,
        data_set_id: str = None
    ):        
        super().__init__()
        self.name = name
        self.measure = measure
        self.frequency = frequency
        self.start_date = start_date
        self.end_date = end_date
        self.start_time = start_time
        self.end_time = end_time
        self.fields = fields
        self.parameters = parameters
        self.where = where
        self.vendor = vendor
        self.data_set_id = data_set_id

    @property
    def name(self) -> str:
        """The name of the function to be applied to the column."""
        return self.__name

    @name.setter
    def name(self, value: str):
        self._property_changed('name')
        self.__name = value        

    @property
    def measure(self) -> str:
        """The asset data measure to be applied to the column."""
        return self.__measure

    @measure.setter
    def measure(self, value: str):
        self._property_changed('measure')
        self.__measure = value        

    @property
    def frequency(self) -> str:
        """The frequency of the column data changes which dataset the values are retrieved
           from."""
        return self.__frequency

    @frequency.setter
    def frequency(self, value: str):
        self._property_changed('frequency')
        self.__frequency = value        

    @property
    def start_date(self) -> str:
        """The relative start date for columns requiring historical data. Eg: -1y."""
        return self.__start_date

    @start_date.setter
    def start_date(self, value: str):
        self._property_changed('start_date')
        self.__start_date = value        

    @property
    def end_date(self) -> str:
        """The relative end date for columns requiring historical data. Eg: -1y."""
        return self.__end_date

    @end_date.setter
    def end_date(self, value: str):
        self._property_changed('end_date')
        self.__end_date = value        

    @property
    def start_time(self) -> str:
        """The relative start time for columns requiring historical data. Eg: -1y."""
        return self.__start_time

    @start_time.setter
    def start_time(self, value: str):
        self._property_changed('start_time')
        self.__start_time = value        

    @property
    def end_time(self) -> str:
        """The relative end time for columns requiring historical data. Eg: -1y."""
        return self.__end_time

    @end_time.setter
    def end_time(self, value: str):
        self._property_changed('end_time')
        self.__end_time = value        

    @property
    def fields(self) -> Tuple[str, ...]:
        """Fields to be passed into Measure Service. i.e. sum(value)"""
        return self.__fields

    @fields.setter
    def fields(self, value: Tuple[str, ...]):
        self._property_changed('fields')
        self.__fields = value        

    @property
    def parameters(self) -> FieldMap:
        """Parameters to be passed into GS Quant functions. For example, window (w)."""
        return self.__parameters

    @parameters.setter
    def parameters(self, value: FieldMap):
        self._property_changed('parameters')
        self.__parameters = value        

    @property
    def where(self) -> FieldMap:
        return self.__where

    @where.setter
    def where(self, value: FieldMap):
        self._property_changed('where')
        self.__where = value        

    @property
    def vendor(self) -> str:
        """The vendor the dataset is owned by."""
        return self.__vendor

    @vendor.setter
    def vendor(self, value: str):
        self._property_changed('vendor')
        self.__vendor = value        

    @property
    def data_set_id(self) -> str:
        """The name of a DataSet to directly query."""
        return self.__data_set_id

    @data_set_id.setter
    def data_set_id(self, value: str):
        self._property_changed('data_set_id')
        self.__data_set_id = value        


class RateRow(Base):
        
    """Rate row with calculated data"""

    @camel_case_translate
    def __init__(
        self,
        period: Union[ParameterPeriod, str],
        last: float,
        change: float,
        std: float,
        slope: float,
        historical: Historical = None,
        percentage_change: float = None,
        name: str = None
    ):        
        super().__init__()
        self.period = period
        self.last = last
        self.historical = historical
        self.change = change
        self.percentage_change = percentage_change
        self.std = std
        self.slope = slope
        self.name = name

    @property
    def period(self) -> Union[ParameterPeriod, str]:
        """Calculated period"""
        return self.__period

    @period.setter
    def period(self, value: Union[ParameterPeriod, str]):
        self._property_changed('period')
        self.__period = get_enum_value(ParameterPeriod, value)        

    @property
    def last(self) -> float:
        """Last available price"""
        return self.__last

    @last.setter
    def last(self, value: float):
        self._property_changed('last')
        self.__last = value        

    @property
    def historical(self) -> Historical:
        """EOD price and date"""
        return self.__historical

    @historical.setter
    def historical(self, value: Historical):
        self._property_changed('historical')
        self.__historical = value        

    @property
    def change(self) -> float:
        """One day prince change"""
        return self.__change

    @change.setter
    def change(self, value: float):
        self._property_changed('change')
        self.__change = value        

    @property
    def percentage_change(self) -> float:
        """One day prince change in percentage"""
        return self.__percentage_change

    @percentage_change.setter
    def percentage_change(self, value: float):
        self._property_changed('percentage_change')
        self.__percentage_change = value        

    @property
    def std(self) -> float:
        """2 year standard deviation of daily changes for given tenor swaps"""
        return self.__std

    @std.setter
    def std(self, value: float):
        self._property_changed('std')
        self.__std = value        

    @property
    def slope(self) -> float:
        """Number in the range from -1000000000000 to 1000000000000"""
        return self.__slope

    @slope.setter
    def slope(self, value: float):
        self._property_changed('slope')
        self.__slope = value        


class Sort(Base):
        
    """Object used to define sorting"""

    @camel_case_translate
    def __init__(
        self,
        column_name: str,
        type_: Union[SortType, str] = None,
        direction: Union[SortDirection, str] = None,
        name: str = None
    ):        
        super().__init__()
        self.__type = get_enum_value(SortType, type_)
        self.column_name = column_name
        self.direction = direction
        self.name = name

    @property
    def type(self) -> Union[SortType, str]:
        """Enum listing supported sort types"""
        return self.__type

    @type.setter
    def type(self, value: Union[SortType, str]):
        self._property_changed('type')
        self.__type = get_enum_value(SortType, value)        

    @property
    def column_name(self) -> str:
        """Required small string with a length from empty string to 50 characters"""
        return self.__column_name

    @column_name.setter
    def column_name(self, value: str):
        self._property_changed('column_name')
        self.__column_name = value        

    @property
    def direction(self) -> Union[SortDirection, str]:
        """Enum with available sort directions"""
        return self.__direction

    @direction.setter
    def direction(self, value: Union[SortDirection, str]):
        self._property_changed('direction')
        self.__direction = get_enum_value(SortDirection, value)        


class WipiRequestFilter(Base):
        
    """A filter used for transforming data"""

    @camel_case_translate
    def __init__(
        self,
        column: str,
        operation: Union[WipiFilterOperation, str],
        value: Union[float, str],
        type_: Union[WipiFilterType, str] = None,
        name: str = None
    ):        
        super().__init__()
        self.column = column
        self.operation = operation
        self.value = value
        self.__type = get_enum_value(WipiFilterType, type_)
        self.name = name

    @property
    def column(self) -> str:
        """The column to perform the operation on."""
        return self.__column

    @column.setter
    def column(self, value: str):
        self._property_changed('column')
        self.__column = value        

    @property
    def operation(self) -> Union[WipiFilterOperation, str]:
        """Enum listing supported operations for wipi filters."""
        return self.__operation

    @operation.setter
    def operation(self, value: Union[WipiFilterOperation, str]):
        self._property_changed('operation')
        self.__operation = get_enum_value(WipiFilterOperation, value)        

    @property
    def value(self) -> Union[float, str]:
        """The value of the operation is used with. Relative dates are used against the
           last valuationDate."""
        return self.__value

    @value.setter
    def value(self, value: Union[float, str]):
        self._property_changed('value')
        self.__value = value        

    @property
    def type(self) -> Union[WipiFilterType, str]:
        """Enum listing supported wipi filter types."""
        return self.__type

    @type.setter
    def type(self, value: Union[WipiFilterType, str]):
        self._property_changed('type')
        self.__type = get_enum_value(WipiFilterType, value)        


class ColumnDefinition(Base):
        
    """Object defining the columns to be calculated in the monitor"""

    @camel_case_translate
    def __init__(
        self,
        render: Union[ParameterRender, str],
        name: str,
        enable_cell_flashing: bool = None,
        entity_property: Union[AssetProperties, str] = None,
        function: Function = None,
        format_: ColumnFormat = None,
        width: float = None,
        column_property: ColumnProperty = None,
        column_operation: ColumnOperation = None,
        expression: str = None,
        expressions: Tuple[str, ...] = None,
        start_date: str = None,
        end_date: str = None,
        tooltip: str = None,
        parent_column_name: str = None
    ):        
        super().__init__()
        self.enable_cell_flashing = enable_cell_flashing
        self.name = name
        self.render = render
        self.entity_property = entity_property
        self.function = function
        self.__format = format_
        self.width = width
        self.column_property = column_property
        self.column_operation = column_operation
        self.expression = expression
        self.expressions = expressions
        self.start_date = start_date
        self.end_date = end_date
        self.tooltip = tooltip
        self.parent_column_name = parent_column_name

    @property
    def enable_cell_flashing(self) -> bool:
        """Enable cell flashing for the column"""
        return self.__enable_cell_flashing

    @enable_cell_flashing.setter
    def enable_cell_flashing(self, value: bool):
        self._property_changed('enable_cell_flashing')
        self.__enable_cell_flashing = value        

    @property
    def name(self) -> str:
        """Column name"""
        return self.__name

    @name.setter
    def name(self, value: str):
        self._property_changed('name')
        self.__name = value        

    @property
    def render(self) -> Union[ParameterRender, str]:
        """Enum listing supported column definition render types"""
        return self.__render

    @render.setter
    def render(self, value: Union[ParameterRender, str]):
        self._property_changed('render')
        self.__render = get_enum_value(ParameterRender, value)        

    @property
    def entity_property(self) -> Union[AssetProperties, str]:
        """Property to fetch from an entity"""
        return self.__entity_property

    @entity_property.setter
    def entity_property(self, value: Union[AssetProperties, str]):
        self._property_changed('entity_property')
        self.__entity_property = get_enum_value(AssetProperties, value)        

    @property
    def function(self) -> Function:
        """Function or Measure to be applied to the column."""
        return self.__function

    @function.setter
    def function(self, value: Function):
        self._property_changed('function')
        self.__function = value        

    @property
    def format(self) -> ColumnFormat:
        """Object used to specify the column formatting"""
        return self.__format

    @format.setter
    def format(self, value: ColumnFormat):
        self._property_changed('format')
        self.__format = value        

    @property
    def width(self) -> float:
        """Width of the column"""
        return self.__width

    @width.setter
    def width(self, value: float):
        self._property_changed('width')
        self.__width = value        

    @property
    def column_property(self) -> ColumnProperty:
        """Column name"""
        return self.__column_property

    @column_property.setter
    def column_property(self, value: ColumnProperty):
        self._property_changed('column_property')
        self.__column_property = value        

    @property
    def column_operation(self) -> ColumnOperation:
        """Object that describes function chaining and operations."""
        return self.__column_operation

    @column_operation.setter
    def column_operation(self, value: ColumnOperation):
        self._property_changed('column_operation')
        self.__column_operation = value        

    @property
    def expression(self) -> str:
        """String that represents the column in the form of a PlotTool expression."""
        return self.__expression

    @expression.setter
    def expression(self, value: str):
        self._property_changed('expression')
        self.__expression = value        

    @property
    def expressions(self) -> Tuple[str, ...]:
        """Array of PlotTool Expressions for /v1/plots/expansionRunner"""
        return self.__expressions

    @expressions.setter
    def expressions(self, value: Tuple[str, ...]):
        self._property_changed('expressions')
        self.__expressions = value        

    @property
    def start_date(self) -> str:
        """String that represents the start date for expressions."""
        return self.__start_date

    @start_date.setter
    def start_date(self, value: str):
        self._property_changed('start_date')
        self.__start_date = value        

    @property
    def end_date(self) -> str:
        """String that represents the end date for expressions"""
        return self.__end_date

    @end_date.setter
    def end_date(self, value: str):
        self._property_changed('end_date')
        self.__end_date = value        

    @property
    def tooltip(self) -> str:
        """Tooltip that is displayed on the column header"""
        return self.__tooltip

    @tooltip.setter
    def tooltip(self, value: str):
        self._property_changed('tooltip')
        self.__tooltip = value        

    @property
    def parent_column_name(self) -> str:
        """Name of the top level column name."""
        return self.__parent_column_name

    @parent_column_name.setter
    def parent_column_name(self, value: str):
        self._property_changed('parent_column_name')
        self.__parent_column_name = value        


class EntityId(Base):
        
    """Object used to define entities"""

    @camel_case_translate
    def __init__(
        self,
        id_: str = None,
        column_mappings: Tuple[ColumnMappings, ...] = None,
        name: str = None
    ):        
        super().__init__()
        self.__id = id_
        self.column_mappings = column_mappings
        self.name = name

    @property
    def id(self) -> str:
        """Marquee unique identifier"""
        return self.__id

    @id.setter
    def id(self, value: str):
        self._property_changed('id')
        self.__id = value        

    @property
    def column_mappings(self) -> Tuple[ColumnMappings, ...]:
        """Array of column mappings for the entity"""
        return self.__column_mappings

    @column_mappings.setter
    def column_mappings(self, value: Tuple[ColumnMappings, ...]):
        self._property_changed('column_mappings')
        self.__column_mappings = value        


class RatesResponseData(Base):
        
    """Rates calculated response data."""

    @camel_case_translate
    def __init__(
        self,
        name: Union[RateIds, str],
        id_: str,
        rows: Tuple[RateRow, ...],
        libor_id: str = None
    ):        
        super().__init__()
        self.name = name
        self.__id = id_
        self.libor_id = libor_id
        self.rows = rows

    @property
    def name(self) -> Union[RateIds, str]:
        """Enum listing supported rate ids"""
        return self.__name

    @name.setter
    def name(self, value: Union[RateIds, str]):
        self._property_changed('name')
        self.__name = get_enum_value(RateIds, value)        

    @property
    def id(self) -> str:
        """Marquee unique identifier"""
        return self.__id

    @id.setter
    def id(self, value: str):
        self._property_changed('id')
        self.__id = value        

    @property
    def libor_id(self) -> str:
        """Marquee unique identifier"""
        return self.__libor_id

    @libor_id.setter
    def libor_id(self, value: str):
        self._property_changed('libor_id')
        self.__libor_id = value        

    @property
    def rows(self) -> Tuple[RateRow, ...]:
        """Calculated rows for given rate ID"""
        return self.__rows

    @rows.setter
    def rows(self, value: Tuple[RateRow, ...]):
        self._property_changed('rows')
        self.__rows = value        


class RowGroup(Base):
        
    """Object specifying a group name and a list of assets to be calculated in a
       monitor"""

    @camel_case_translate
    def __init__(
        self,
        name: str,
        entity_ids: Tuple[EntityId, ...],
        movers: Movers = None,
        sort: Sort = None,
        export: ExportParameters = None
    ):        
        super().__init__()
        self.name = name
        self.movers = movers
        self.entity_ids = entity_ids
        self.sort = sort
        self.export = export

    @property
    def name(self) -> str:
        """Group name"""
        return self.__name

    @name.setter
    def name(self, value: str):
        self._property_changed('name')
        self.__name = value        

    @property
    def movers(self) -> Movers:
        """Object that allows to specify the case in which we only want to return the n top
           or bottom entities"""
        return self.__movers

    @movers.setter
    def movers(self, value: Movers):
        self._property_changed('movers')
        self.__movers = value        

    @property
    def entity_ids(self) -> Tuple[EntityId, ...]:
        """Array of entity objects that belong to the group"""
        return self.__entity_ids

    @entity_ids.setter
    def entity_ids(self, value: Tuple[EntityId, ...]):
        self._property_changed('entity_ids')
        self.__entity_ids = value        

    @property
    def sort(self) -> Sort:
        """Object used to define sorting"""
        return self.__sort

    @sort.setter
    def sort(self, value: Sort):
        self._property_changed('sort')
        self.__sort = value        

    @property
    def export(self) -> ExportParameters:
        """Object with properties specifying how to export individual row or complete
           monitor data."""
        return self.__export

    @export.setter
    def export(self, value: ExportParameters):
        self._property_changed('export')
        self.__export = value        


class MonitorParameters(Base):
        
    """Parameters provided for a monitor"""

    @camel_case_translate
    def __init__(
        self,
        column_definitions: Tuple[ColumnDefinition, ...],
        row_groups: Tuple[RowGroup, ...],
        export: ExportParameters = None,
        ignore_business_day_logic: bool = None,
        name: str = None
    ):        
        super().__init__()
        self.column_definitions = column_definitions
        self.row_groups = row_groups
        self.export = export
        self.ignore_business_day_logic = ignore_business_day_logic
        self.name = name

    @property
    def column_definitions(self) -> Tuple[ColumnDefinition, ...]:
        """Array of monitor column definitions"""
        return self.__column_definitions

    @column_definitions.setter
    def column_definitions(self, value: Tuple[ColumnDefinition, ...]):
        self._property_changed('column_definitions')
        self.__column_definitions = value        

    @property
    def row_groups(self) -> Tuple[RowGroup, ...]:
        """Monitor row groups"""
        return self.__row_groups

    @row_groups.setter
    def row_groups(self, value: Tuple[RowGroup, ...]):
        self._property_changed('row_groups')
        self.__row_groups = value        

    @property
    def export(self) -> ExportParameters:
        """Object with properties specifying how to export individual row or complete
           monitor data."""
        return self.__export

    @export.setter
    def export(self, value: ExportParameters):
        self._property_changed('export')
        self.__export = value        

    @property
    def ignore_business_day_logic(self) -> bool:
        """Whether or not to apply business day logic for relative dates."""
        return self.__ignore_business_day_logic

    @ignore_business_day_logic.setter
    def ignore_business_day_logic(self, value: bool):
        self._property_changed('ignore_business_day_logic')
        self.__ignore_business_day_logic = value        


class Monitor(Base):
        
    """A marquee monitor object"""

    @camel_case_translate
    def __init__(
        self,
        name: str,
        type_: Union[EntitiesSupported, str],
        id_: str = None,
        parameters: MonitorParameters = None,
        created_time: datetime.datetime = None,
        last_updated_time: datetime.datetime = None,
        created_by_id: str = None,
        last_updated_by_id: str = None,
        owner_id: str = None,
        entitlements: Entitlements = None,
        folder_name: str = None,
        polling_time: float = None,
        tags: Tuple[str, ...] = None
    ):        
        super().__init__()
        self.__id = id_
        self.name = name
        self.__type = get_enum_value(EntitiesSupported, type_)
        self.parameters = parameters
        self.created_time = created_time
        self.last_updated_time = last_updated_time
        self.created_by_id = created_by_id
        self.last_updated_by_id = last_updated_by_id
        self.owner_id = owner_id
        self.entitlements = entitlements
        self.folder_name = folder_name
        self.polling_time = polling_time
        self.tags = tags

    @property
    def id(self) -> str:
        """Marquee unique identifier"""
        return self.__id

    @id.setter
    def id(self, value: str):
        self._property_changed('id')
        self.__id = value        

    @property
    def name(self) -> str:
        """Display name of monitor"""
        return self.__name

    @name.setter
    def name(self, value: str):
        self._property_changed('name')
        self.__name = value        

    @property
    def type(self) -> Union[EntitiesSupported, str]:
        """Enum listing supported entities"""
        return self.__type

    @type.setter
    def type(self, value: Union[EntitiesSupported, str]):
        self._property_changed('type')
        self.__type = get_enum_value(EntitiesSupported, value)        

    @property
    def parameters(self) -> MonitorParameters:
        """Parameters provided for a monitor"""
        return self.__parameters

    @parameters.setter
    def parameters(self, value: MonitorParameters):
        self._property_changed('parameters')
        self.__parameters = value        

    @property
    def created_time(self) -> datetime.datetime:
        """Time created. ISO 8601 formatted string"""
        return self.__created_time

    @created_time.setter
    def created_time(self, value: datetime.datetime):
        self._property_changed('created_time')
        self.__created_time = value        

    @property
    def last_updated_time(self) -> datetime.datetime:
        """Timestamp of when the object was last updated"""
        return self.__last_updated_time

    @last_updated_time.setter
    def last_updated_time(self, value: datetime.datetime):
        self._property_changed('last_updated_time')
        self.__last_updated_time = value        

    @property
    def created_by_id(self) -> str:
        """Unique identifier of user who created the object"""
        return self.__created_by_id

    @created_by_id.setter
    def created_by_id(self, value: str):
        self._property_changed('created_by_id')
        self.__created_by_id = value        

    @property
    def last_updated_by_id(self) -> str:
        """Unique identifier of user who last updated the object"""
        return self.__last_updated_by_id

    @last_updated_by_id.setter
    def last_updated_by_id(self, value: str):
        self._property_changed('last_updated_by_id')
        self.__last_updated_by_id = value        

    @property
    def owner_id(self) -> str:
        """Marquee unique identifier"""
        return self.__owner_id

    @owner_id.setter
    def owner_id(self, value: str):
        self._property_changed('owner_id')
        self.__owner_id = value        

    @property
    def entitlements(self) -> Entitlements:
        """Defines the entitlements of a given resource"""
        return self.__entitlements

    @entitlements.setter
    def entitlements(self, value: Entitlements):
        self._property_changed('entitlements')
        self.__entitlements = value        

    @property
    def folder_name(self) -> str:
        """Folder name of the monitor"""
        return self.__folder_name

    @folder_name.setter
    def folder_name(self, value: str):
        self._property_changed('folder_name')
        self.__folder_name = value        

    @property
    def polling_time(self) -> float:
        """Polling time to use in milliseconds. A polling time of zero denotes no
           streaming."""
        return self.__polling_time

    @polling_time.setter
    def polling_time(self, value: float):
        self._property_changed('polling_time')
        self.__polling_time = value        

    @property
    def tags(self) -> Tuple[str, ...]:
        """Array of tag strings"""
        return self.__tags

    @tags.setter
    def tags(self, value: Tuple[str, ...]):
        self._property_changed('tags')
        self.__tags = value        
