# coding: utf-8

"""
    NFL v3 Odds

    No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen)  # noqa: E501

    OpenAPI spec version: 1.0
    
    Generated by: https://github.com/swagger-api/swagger-codegen.git
"""

from __future__ import absolute_import

import re  # noqa: F401

# python 2 and python 3 compatibility library
import six

from sportsdata.nfl_odds.api_client import ApiClient


class DefaultApi(object):
    """NOTE: This class is auto generated by the swagger code generator program.

    Do not edit the class manually.
    Ref: https://github.com/swagger-api/swagger-codegen
    """

    def __init__(self, api_client=None):
        if api_client is None:
            api_client = ApiClient()
        self.api_client = api_client

    def alternate_market_pre_game_odds_by_week(self, format, season, week, **kwargs):  # noqa: E501
        """Alternate Market Pre-Game Odds by Week  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.alternate_market_pre_game_odds_by_week(format, season, week, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str format: Desired response format. Valid entries are <code>XML</code> or <code>JSON</code>. (required)
        :param str season: Year of the season, with optional season type. <br>Examples: <code>2018</code>, <code>2018POST</code>, etc. (required)
        :param str week: The week of the scores (games). <br>Examples: <code>1</code>, <code>2</code>, etc. (required)
        :return: list[NflOddsGameInfo]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.alternate_market_pre_game_odds_by_week_with_http_info(format, season, week, **kwargs)  # noqa: E501
        else:
            (data) = self.alternate_market_pre_game_odds_by_week_with_http_info(format, season, week, **kwargs)  # noqa: E501
            return data

    def alternate_market_pre_game_odds_by_week_with_http_info(self, format, season, week, **kwargs):  # noqa: E501
        """Alternate Market Pre-Game Odds by Week  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.alternate_market_pre_game_odds_by_week_with_http_info(format, season, week, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str format: Desired response format. Valid entries are <code>XML</code> or <code>JSON</code>. (required)
        :param str season: Year of the season, with optional season type. <br>Examples: <code>2018</code>, <code>2018POST</code>, etc. (required)
        :param str week: The week of the scores (games). <br>Examples: <code>1</code>, <code>2</code>, etc. (required)
        :return: list[NflOddsGameInfo]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['format', 'season', 'week']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method alternate_market_pre_game_odds_by_week" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'format' is set
        if ('format' not in params or
                params['format'] is None):
            raise ValueError("Missing the required parameter `format` when calling `alternate_market_pre_game_odds_by_week`")  # noqa: E501
        # verify the required parameter 'season' is set
        if ('season' not in params or
                params['season'] is None):
            raise ValueError("Missing the required parameter `season` when calling `alternate_market_pre_game_odds_by_week`")  # noqa: E501
        # verify the required parameter 'week' is set
        if ('week' not in params or
                params['week'] is None):
            raise ValueError("Missing the required parameter `week` when calling `alternate_market_pre_game_odds_by_week`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'format' in params:
            path_params['format'] = params['format']  # noqa: E501
        if 'season' in params:
            path_params['season'] = params['season']  # noqa: E501
        if 'week' in params:
            path_params['week'] = params['week']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['apiKeyHeader', 'apiKeyQuery']  # noqa: E501

        return self.api_client.call_api(
            '/{format}/AlternateMarketGameOddsByWeek/{season}/{week}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflOddsGameInfo]',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def alternate_market_pre_game_odds_line_movement(self, format, scoreid, **kwargs):  # noqa: E501
        """Alternate Market Pre-Game Odds Line Movement   # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.alternate_market_pre_game_odds_line_movement(format, scoreid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str format: Desired response format. Valid entries are <code>XML</code> or <code>JSON</code>. (required)
        :param str scoreid: The ScoreID of an NFL score (game).  ScoreIDs can be found in the Scores API.  Valid entries are <code>16654</code> or <code>16667</code> (required)
        :return: list[NflOddsGameInfo]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.alternate_market_pre_game_odds_line_movement_with_http_info(format, scoreid, **kwargs)  # noqa: E501
        else:
            (data) = self.alternate_market_pre_game_odds_line_movement_with_http_info(format, scoreid, **kwargs)  # noqa: E501
            return data

    def alternate_market_pre_game_odds_line_movement_with_http_info(self, format, scoreid, **kwargs):  # noqa: E501
        """Alternate Market Pre-Game Odds Line Movement   # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.alternate_market_pre_game_odds_line_movement_with_http_info(format, scoreid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str format: Desired response format. Valid entries are <code>XML</code> or <code>JSON</code>. (required)
        :param str scoreid: The ScoreID of an NFL score (game).  ScoreIDs can be found in the Scores API.  Valid entries are <code>16654</code> or <code>16667</code> (required)
        :return: list[NflOddsGameInfo]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['format', 'scoreid']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method alternate_market_pre_game_odds_line_movement" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'format' is set
        if ('format' not in params or
                params['format'] is None):
            raise ValueError("Missing the required parameter `format` when calling `alternate_market_pre_game_odds_line_movement`")  # noqa: E501
        # verify the required parameter 'scoreid' is set
        if ('scoreid' not in params or
                params['scoreid'] is None):
            raise ValueError("Missing the required parameter `scoreid` when calling `alternate_market_pre_game_odds_line_movement`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'format' in params:
            path_params['format'] = params['format']  # noqa: E501
        if 'scoreid' in params:
            path_params['scoreid'] = params['scoreid']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['apiKeyHeader', 'apiKeyQuery']  # noqa: E501

        return self.api_client.call_api(
            '/{format}/AlternateMarketGameOddsLineMovement/{scoreid}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflOddsGameInfo]',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def betting_events_by_date(self, format, _date, **kwargs):  # noqa: E501
        """Betting Events by Date  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.betting_events_by_date(format, _date, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str format: Desired response format. Valid entries are <code>XML</code> or <code>JSON</code>. (required)
        :param str _date: The date of the game(s). <br>Examples: <code>2020-09-10</code>, <code>2020-09-13</code>. (required)
        :return: list[NflOddsBettingEvent]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.betting_events_by_date_with_http_info(format, _date, **kwargs)  # noqa: E501
        else:
            (data) = self.betting_events_by_date_with_http_info(format, _date, **kwargs)  # noqa: E501
            return data

    def betting_events_by_date_with_http_info(self, format, _date, **kwargs):  # noqa: E501
        """Betting Events by Date  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.betting_events_by_date_with_http_info(format, _date, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str format: Desired response format. Valid entries are <code>XML</code> or <code>JSON</code>. (required)
        :param str _date: The date of the game(s). <br>Examples: <code>2020-09-10</code>, <code>2020-09-13</code>. (required)
        :return: list[NflOddsBettingEvent]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['format', '_date']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method betting_events_by_date" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'format' is set
        if ('format' not in params or
                params['format'] is None):
            raise ValueError("Missing the required parameter `format` when calling `betting_events_by_date`")  # noqa: E501
        # verify the required parameter '_date' is set
        if ('_date' not in params or
                params['_date'] is None):
            raise ValueError("Missing the required parameter `_date` when calling `betting_events_by_date`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'format' in params:
            path_params['format'] = params['format']  # noqa: E501
        if '_date' in params:
            path_params['date'] = params['_date']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['apiKeyHeader', 'apiKeyQuery']  # noqa: E501

        return self.api_client.call_api(
            '/{format}/BettingEventsByDate/{date}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflOddsBettingEvent]',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def betting_events_by_season(self, format, season, **kwargs):  # noqa: E501
        """Betting Events by Season  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.betting_events_by_season(format, season, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str format: Desired response format. Valid entries are <code>XML</code> or <code>JSON</code>. (required)
        :param str season: Year of the season<br>Examples: <code>2020</code>, <code>2021</code>, etc. (required)
        :return: list[NflOddsBettingEvent]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.betting_events_by_season_with_http_info(format, season, **kwargs)  # noqa: E501
        else:
            (data) = self.betting_events_by_season_with_http_info(format, season, **kwargs)  # noqa: E501
            return data

    def betting_events_by_season_with_http_info(self, format, season, **kwargs):  # noqa: E501
        """Betting Events by Season  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.betting_events_by_season_with_http_info(format, season, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str format: Desired response format. Valid entries are <code>XML</code> or <code>JSON</code>. (required)
        :param str season: Year of the season<br>Examples: <code>2020</code>, <code>2021</code>, etc. (required)
        :return: list[NflOddsBettingEvent]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['format', 'season']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method betting_events_by_season" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'format' is set
        if ('format' not in params or
                params['format'] is None):
            raise ValueError("Missing the required parameter `format` when calling `betting_events_by_season`")  # noqa: E501
        # verify the required parameter 'season' is set
        if ('season' not in params or
                params['season'] is None):
            raise ValueError("Missing the required parameter `season` when calling `betting_events_by_season`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'format' in params:
            path_params['format'] = params['format']  # noqa: E501
        if 'season' in params:
            path_params['season'] = params['season']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['apiKeyHeader', 'apiKeyQuery']  # noqa: E501

        return self.api_client.call_api(
            '/{format}/BettingEvents/{season}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflOddsBettingEvent]',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def betting_futures_by_season(self, format, season, **kwargs):  # noqa: E501
        """Betting Futures by Season  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.betting_futures_by_season(format, season, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str format: Desired response format. Valid entries are <code>XML</code> or <code>JSON</code>. (required)
        :param str season: Year of the season (with optional season type).<br>Examples: <code>2020REG</code>, <code>2020PRE</code>, <code>2020POST</code>, <code>2021</code>, etc. (required)
        :return: list[NflOddsBettingEvent]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.betting_futures_by_season_with_http_info(format, season, **kwargs)  # noqa: E501
        else:
            (data) = self.betting_futures_by_season_with_http_info(format, season, **kwargs)  # noqa: E501
            return data

    def betting_futures_by_season_with_http_info(self, format, season, **kwargs):  # noqa: E501
        """Betting Futures by Season  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.betting_futures_by_season_with_http_info(format, season, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str format: Desired response format. Valid entries are <code>XML</code> or <code>JSON</code>. (required)
        :param str season: Year of the season (with optional season type).<br>Examples: <code>2020REG</code>, <code>2020PRE</code>, <code>2020POST</code>, <code>2021</code>, etc. (required)
        :return: list[NflOddsBettingEvent]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['format', 'season']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method betting_futures_by_season" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'format' is set
        if ('format' not in params or
                params['format'] is None):
            raise ValueError("Missing the required parameter `format` when calling `betting_futures_by_season`")  # noqa: E501
        # verify the required parameter 'season' is set
        if ('season' not in params or
                params['season'] is None):
            raise ValueError("Missing the required parameter `season` when calling `betting_futures_by_season`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'format' in params:
            path_params['format'] = params['format']  # noqa: E501
        if 'season' in params:
            path_params['season'] = params['season']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['apiKeyHeader', 'apiKeyQuery']  # noqa: E501

        return self.api_client.call_api(
            '/{format}/BettingFuturesBySeason/{season}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflOddsBettingEvent]',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def betting_market(self, format, market_id, **kwargs):  # noqa: E501
        """Betting Market  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.betting_market(format, market_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str format: Desired response format. Valid entries are <code>XML</code> or <code>JSON</code>. (required)
        :param str market_id: The MarketId of the desired market for which to pull all outcomes/bets. (required)
        :return: NflOddsBettingMarket
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.betting_market_with_http_info(format, market_id, **kwargs)  # noqa: E501
        else:
            (data) = self.betting_market_with_http_info(format, market_id, **kwargs)  # noqa: E501
            return data

    def betting_market_with_http_info(self, format, market_id, **kwargs):  # noqa: E501
        """Betting Market  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.betting_market_with_http_info(format, market_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str format: Desired response format. Valid entries are <code>XML</code> or <code>JSON</code>. (required)
        :param str market_id: The MarketId of the desired market for which to pull all outcomes/bets. (required)
        :return: NflOddsBettingMarket
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['format', 'market_id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method betting_market" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'format' is set
        if ('format' not in params or
                params['format'] is None):
            raise ValueError("Missing the required parameter `format` when calling `betting_market`")  # noqa: E501
        # verify the required parameter 'market_id' is set
        if ('market_id' not in params or
                params['market_id'] is None):
            raise ValueError("Missing the required parameter `market_id` when calling `betting_market`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'format' in params:
            path_params['format'] = params['format']  # noqa: E501
        if 'market_id' in params:
            path_params['marketId'] = params['market_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['apiKeyHeader', 'apiKeyQuery']  # noqa: E501

        return self.api_client.call_api(
            '/{format}/BettingMarket/{marketId}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='NflOddsBettingMarket',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def betting_markets_by_event(self, format, event_id, **kwargs):  # noqa: E501
        """Betting Markets by Event  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.betting_markets_by_event(format, event_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str format: Desired response format. Valid entries are <code>XML</code> or <code>JSON</code>. (required)
        :param str event_id: The EventId of the desired event/game for which to pull all betting markets (includes outcomes/bets). (required)
        :return: list[NflOddsBettingMarket]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.betting_markets_by_event_with_http_info(format, event_id, **kwargs)  # noqa: E501
        else:
            (data) = self.betting_markets_by_event_with_http_info(format, event_id, **kwargs)  # noqa: E501
            return data

    def betting_markets_by_event_with_http_info(self, format, event_id, **kwargs):  # noqa: E501
        """Betting Markets by Event  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.betting_markets_by_event_with_http_info(format, event_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str format: Desired response format. Valid entries are <code>XML</code> or <code>JSON</code>. (required)
        :param str event_id: The EventId of the desired event/game for which to pull all betting markets (includes outcomes/bets). (required)
        :return: list[NflOddsBettingMarket]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['format', 'event_id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method betting_markets_by_event" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'format' is set
        if ('format' not in params or
                params['format'] is None):
            raise ValueError("Missing the required parameter `format` when calling `betting_markets_by_event`")  # noqa: E501
        # verify the required parameter 'event_id' is set
        if ('event_id' not in params or
                params['event_id'] is None):
            raise ValueError("Missing the required parameter `event_id` when calling `betting_markets_by_event`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'format' in params:
            path_params['format'] = params['format']  # noqa: E501
        if 'event_id' in params:
            path_params['eventId'] = params['event_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['apiKeyHeader', 'apiKeyQuery']  # noqa: E501

        return self.api_client.call_api(
            '/{format}/BettingMarkets/{eventId}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflOddsBettingMarket]',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def betting_markets_by_market_type(self, format, event_id, market_type_id, **kwargs):  # noqa: E501
        """Betting Markets by Market Type  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.betting_markets_by_market_type(format, event_id, market_type_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str format: Desired response format. Valid entries are <code>XML</code> or <code>JSON</code>. (required)
        :param str event_id: The EventId of the desired event/game for which to pull all betting markets (includes outcomes/bets). (required)
        :param str market_type_id: The Market Type ID of the desired MarketTypes to pull. Some common types include: <code>1</code> for Game Lines, <code>2</code> for Player Props, <code>3</code> for Team Props, <code>6</code> for Game Props (required)
        :return: list[NflOddsBettingMarket]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.betting_markets_by_market_type_with_http_info(format, event_id, market_type_id, **kwargs)  # noqa: E501
        else:
            (data) = self.betting_markets_by_market_type_with_http_info(format, event_id, market_type_id, **kwargs)  # noqa: E501
            return data

    def betting_markets_by_market_type_with_http_info(self, format, event_id, market_type_id, **kwargs):  # noqa: E501
        """Betting Markets by Market Type  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.betting_markets_by_market_type_with_http_info(format, event_id, market_type_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str format: Desired response format. Valid entries are <code>XML</code> or <code>JSON</code>. (required)
        :param str event_id: The EventId of the desired event/game for which to pull all betting markets (includes outcomes/bets). (required)
        :param str market_type_id: The Market Type ID of the desired MarketTypes to pull. Some common types include: <code>1</code> for Game Lines, <code>2</code> for Player Props, <code>3</code> for Team Props, <code>6</code> for Game Props (required)
        :return: list[NflOddsBettingMarket]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['format', 'event_id', 'market_type_id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method betting_markets_by_market_type" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'format' is set
        if ('format' not in params or
                params['format'] is None):
            raise ValueError("Missing the required parameter `format` when calling `betting_markets_by_market_type`")  # noqa: E501
        # verify the required parameter 'event_id' is set
        if ('event_id' not in params or
                params['event_id'] is None):
            raise ValueError("Missing the required parameter `event_id` when calling `betting_markets_by_market_type`")  # noqa: E501
        # verify the required parameter 'market_type_id' is set
        if ('market_type_id' not in params or
                params['market_type_id'] is None):
            raise ValueError("Missing the required parameter `market_type_id` when calling `betting_markets_by_market_type`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'format' in params:
            path_params['format'] = params['format']  # noqa: E501
        if 'event_id' in params:
            path_params['eventId'] = params['event_id']  # noqa: E501
        if 'market_type_id' in params:
            path_params['marketTypeID'] = params['market_type_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['apiKeyHeader', 'apiKeyQuery']  # noqa: E501

        return self.api_client.call_api(
            '/{format}/BettingMarketsByMarketType/{eventId}/{marketTypeID}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflOddsBettingMarket]',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def betting_markets_by_scoreid(self, format, scoreid, **kwargs):  # noqa: E501
        """Betting Markets by ScoreID  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.betting_markets_by_scoreid(format, scoreid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str format: Desired response format. Valid entries are <code>XML</code> or <code>JSON</code>. (required)
        :param str scoreid: The ScoreID of the desired game/score for which to pull all betting markets (includes outcomes/bets). (required)
        :return: list[NflOddsBettingMarket]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.betting_markets_by_scoreid_with_http_info(format, scoreid, **kwargs)  # noqa: E501
        else:
            (data) = self.betting_markets_by_scoreid_with_http_info(format, scoreid, **kwargs)  # noqa: E501
            return data

    def betting_markets_by_scoreid_with_http_info(self, format, scoreid, **kwargs):  # noqa: E501
        """Betting Markets by ScoreID  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.betting_markets_by_scoreid_with_http_info(format, scoreid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str format: Desired response format. Valid entries are <code>XML</code> or <code>JSON</code>. (required)
        :param str scoreid: The ScoreID of the desired game/score for which to pull all betting markets (includes outcomes/bets). (required)
        :return: list[NflOddsBettingMarket]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['format', 'scoreid']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method betting_markets_by_scoreid" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'format' is set
        if ('format' not in params or
                params['format'] is None):
            raise ValueError("Missing the required parameter `format` when calling `betting_markets_by_scoreid`")  # noqa: E501
        # verify the required parameter 'scoreid' is set
        if ('scoreid' not in params or
                params['scoreid'] is None):
            raise ValueError("Missing the required parameter `scoreid` when calling `betting_markets_by_scoreid`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'format' in params:
            path_params['format'] = params['format']  # noqa: E501
        if 'scoreid' in params:
            path_params['scoreid'] = params['scoreid']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['apiKeyHeader', 'apiKeyQuery']  # noqa: E501

        return self.api_client.call_api(
            '/{format}/BettingMarketsByScoreID/{scoreid}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflOddsBettingMarket]',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def betting_metadata(self, format, **kwargs):  # noqa: E501
        """Betting Metadata  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.betting_metadata(format, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str format: Desired response format. Valid entries are <code>XML</code> or <code>JSON</code>. (required)
        :return: list[NflOddsBettingEntityMetadata]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.betting_metadata_with_http_info(format, **kwargs)  # noqa: E501
        else:
            (data) = self.betting_metadata_with_http_info(format, **kwargs)  # noqa: E501
            return data

    def betting_metadata_with_http_info(self, format, **kwargs):  # noqa: E501
        """Betting Metadata  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.betting_metadata_with_http_info(format, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str format: Desired response format. Valid entries are <code>XML</code> or <code>JSON</code>. (required)
        :return: list[NflOddsBettingEntityMetadata]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['format']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method betting_metadata" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'format' is set
        if ('format' not in params or
                params['format'] is None):
            raise ValueError("Missing the required parameter `format` when calling `betting_metadata`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'format' in params:
            path_params['format'] = params['format']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['apiKeyHeader', 'apiKeyQuery']  # noqa: E501

        return self.api_client.call_api(
            '/{format}/BettingMetadata', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflOddsBettingEntityMetadata]',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def betting_player_props_by_date(self, format, _date, **kwargs):  # noqa: E501
        """Betting Player Props by Date  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.betting_player_props_by_date(format, _date, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str format: Desired response format. Valid entries are <code>XML</code> or <code>JSON</code>. (required)
        :param str _date: The date of the game(s). <br>Examples: <code>2020-09-10</code>, <code>2020-09-13</code>. (required)
        :return: list[NflOddsBettingEvent]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.betting_player_props_by_date_with_http_info(format, _date, **kwargs)  # noqa: E501
        else:
            (data) = self.betting_player_props_by_date_with_http_info(format, _date, **kwargs)  # noqa: E501
            return data

    def betting_player_props_by_date_with_http_info(self, format, _date, **kwargs):  # noqa: E501
        """Betting Player Props by Date  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.betting_player_props_by_date_with_http_info(format, _date, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str format: Desired response format. Valid entries are <code>XML</code> or <code>JSON</code>. (required)
        :param str _date: The date of the game(s). <br>Examples: <code>2020-09-10</code>, <code>2020-09-13</code>. (required)
        :return: list[NflOddsBettingEvent]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['format', '_date']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method betting_player_props_by_date" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'format' is set
        if ('format' not in params or
                params['format'] is None):
            raise ValueError("Missing the required parameter `format` when calling `betting_player_props_by_date`")  # noqa: E501
        # verify the required parameter '_date' is set
        if ('_date' not in params or
                params['_date'] is None):
            raise ValueError("Missing the required parameter `_date` when calling `betting_player_props_by_date`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'format' in params:
            path_params['format'] = params['format']  # noqa: E501
        if '_date' in params:
            path_params['date'] = params['_date']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['apiKeyHeader', 'apiKeyQuery']  # noqa: E501

        return self.api_client.call_api(
            '/{format}/BettingPlayerPropsByDate/{date}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflOddsBettingEvent]',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def betting_player_props_by_scoreid(self, format, scoreid, **kwargs):  # noqa: E501
        """Betting Player Props by ScoreID  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.betting_player_props_by_scoreid(format, scoreid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str format: Desired response format. Valid entries are <code>XML</code> or <code>JSON</code>. (required)
        :param str scoreid: The unique ScoreID of the game in question. (required)
        :return: list[NflOddsBettingMarket]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.betting_player_props_by_scoreid_with_http_info(format, scoreid, **kwargs)  # noqa: E501
        else:
            (data) = self.betting_player_props_by_scoreid_with_http_info(format, scoreid, **kwargs)  # noqa: E501
            return data

    def betting_player_props_by_scoreid_with_http_info(self, format, scoreid, **kwargs):  # noqa: E501
        """Betting Player Props by ScoreID  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.betting_player_props_by_scoreid_with_http_info(format, scoreid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str format: Desired response format. Valid entries are <code>XML</code> or <code>JSON</code>. (required)
        :param str scoreid: The unique ScoreID of the game in question. (required)
        :return: list[NflOddsBettingMarket]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['format', 'scoreid']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method betting_player_props_by_scoreid" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'format' is set
        if ('format' not in params or
                params['format'] is None):
            raise ValueError("Missing the required parameter `format` when calling `betting_player_props_by_scoreid`")  # noqa: E501
        # verify the required parameter 'scoreid' is set
        if ('scoreid' not in params or
                params['scoreid'] is None):
            raise ValueError("Missing the required parameter `scoreid` when calling `betting_player_props_by_scoreid`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'format' in params:
            path_params['format'] = params['format']  # noqa: E501
        if 'scoreid' in params:
            path_params['scoreid'] = params['scoreid']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['apiKeyHeader', 'apiKeyQuery']  # noqa: E501

        return self.api_client.call_api(
            '/{format}/BettingPlayerPropsByScoreID/{scoreid}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflOddsBettingMarket]',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def betting_results_by_market(self, format, market_id, **kwargs):  # noqa: E501
        """Betting Results By Market  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.betting_results_by_market(format, market_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str format: Desired response format. Valid entries are <code>XML</code> or <code>JSON</code>. (required)
        :param str market_id: The MarketId of the desired market for which to pull all outcomes/bets.  (required)
        :return: NflOddsBettingMarketResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.betting_results_by_market_with_http_info(format, market_id, **kwargs)  # noqa: E501
        else:
            (data) = self.betting_results_by_market_with_http_info(format, market_id, **kwargs)  # noqa: E501
            return data

    def betting_results_by_market_with_http_info(self, format, market_id, **kwargs):  # noqa: E501
        """Betting Results By Market  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.betting_results_by_market_with_http_info(format, market_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str format: Desired response format. Valid entries are <code>XML</code> or <code>JSON</code>. (required)
        :param str market_id: The MarketId of the desired market for which to pull all outcomes/bets.  (required)
        :return: NflOddsBettingMarketResult
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['format', 'market_id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method betting_results_by_market" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'format' is set
        if ('format' not in params or
                params['format'] is None):
            raise ValueError("Missing the required parameter `format` when calling `betting_results_by_market`")  # noqa: E501
        # verify the required parameter 'market_id' is set
        if ('market_id' not in params or
                params['market_id'] is None):
            raise ValueError("Missing the required parameter `market_id` when calling `betting_results_by_market`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'format' in params:
            path_params['format'] = params['format']  # noqa: E501
        if 'market_id' in params:
            path_params['marketId'] = params['market_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['apiKeyHeader', 'apiKeyQuery']  # noqa: E501

        return self.api_client.call_api(
            '/{format}/BettingMarketResults/{marketId}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='NflOddsBettingMarketResult',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def betting_splits_by_bettingmarketid(self, format, market_id, **kwargs):  # noqa: E501
        """Betting Splits By BettingMarketId  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.betting_splits_by_bettingmarketid(format, market_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str format: Desired response format. Valid entries are <code>XML</code> or <code>JSON</code>. (required)
        :param str market_id: The BettingMarketID of the market you would like to get splits for. Note that markets we do not have split information on will return an empty response. (required)
        :return: NflOddsBettingMarketSplit
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.betting_splits_by_bettingmarketid_with_http_info(format, market_id, **kwargs)  # noqa: E501
        else:
            (data) = self.betting_splits_by_bettingmarketid_with_http_info(format, market_id, **kwargs)  # noqa: E501
            return data

    def betting_splits_by_bettingmarketid_with_http_info(self, format, market_id, **kwargs):  # noqa: E501
        """Betting Splits By BettingMarketId  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.betting_splits_by_bettingmarketid_with_http_info(format, market_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str format: Desired response format. Valid entries are <code>XML</code> or <code>JSON</code>. (required)
        :param str market_id: The BettingMarketID of the market you would like to get splits for. Note that markets we do not have split information on will return an empty response. (required)
        :return: NflOddsBettingMarketSplit
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['format', 'market_id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method betting_splits_by_bettingmarketid" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'format' is set
        if ('format' not in params or
                params['format'] is None):
            raise ValueError("Missing the required parameter `format` when calling `betting_splits_by_bettingmarketid`")  # noqa: E501
        # verify the required parameter 'market_id' is set
        if ('market_id' not in params or
                params['market_id'] is None):
            raise ValueError("Missing the required parameter `market_id` when calling `betting_splits_by_bettingmarketid`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'format' in params:
            path_params['format'] = params['format']  # noqa: E501
        if 'market_id' in params:
            path_params['marketId'] = params['market_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['apiKeyHeader', 'apiKeyQuery']  # noqa: E501

        return self.api_client.call_api(
            '/{format}/BettingSplitsByMarketId/{marketId}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='NflOddsBettingMarketSplit',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def betting_splits_by_scoreid(self, format, score_id, **kwargs):  # noqa: E501
        """Betting Splits By ScoreID  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.betting_splits_by_scoreid(format, score_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str format: Desired response format. Valid entries are <code>XML</code> or <code>JSON</code>. (required)
        :param str score_id: The ScoreID of the desired game to get Betting Market Splits for (required)
        :return: NflOddsGameBettingSplit
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.betting_splits_by_scoreid_with_http_info(format, score_id, **kwargs)  # noqa: E501
        else:
            (data) = self.betting_splits_by_scoreid_with_http_info(format, score_id, **kwargs)  # noqa: E501
            return data

    def betting_splits_by_scoreid_with_http_info(self, format, score_id, **kwargs):  # noqa: E501
        """Betting Splits By ScoreID  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.betting_splits_by_scoreid_with_http_info(format, score_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str format: Desired response format. Valid entries are <code>XML</code> or <code>JSON</code>. (required)
        :param str score_id: The ScoreID of the desired game to get Betting Market Splits for (required)
        :return: NflOddsGameBettingSplit
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['format', 'score_id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method betting_splits_by_scoreid" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'format' is set
        if ('format' not in params or
                params['format'] is None):
            raise ValueError("Missing the required parameter `format` when calling `betting_splits_by_scoreid`")  # noqa: E501
        # verify the required parameter 'score_id' is set
        if ('score_id' not in params or
                params['score_id'] is None):
            raise ValueError("Missing the required parameter `score_id` when calling `betting_splits_by_scoreid`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'format' in params:
            path_params['format'] = params['format']  # noqa: E501
        if 'score_id' in params:
            path_params['scoreId'] = params['score_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['apiKeyHeader', 'apiKeyQuery']  # noqa: E501

        return self.api_client.call_api(
            '/{format}/BettingSplitsByScoreId/{scoreId}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='NflOddsGameBettingSplit',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def betting_trends_by_matchup(self, format, team, opponent, **kwargs):  # noqa: E501
        """Betting Trends by Matchup  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.betting_trends_by_matchup(format, team, opponent, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str format: Desired response format. Valid entries are <code>XML</code> or <code>JSON</code>. (required)
        :param str team: Abbreviation of a team. Example: <code>PHI</code>. (required)
        :param str opponent: Abbreviation of an opponent. Example: <code>NE</code>. (required)
        :return: NflOddsMatchupTrends
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.betting_trends_by_matchup_with_http_info(format, team, opponent, **kwargs)  # noqa: E501
        else:
            (data) = self.betting_trends_by_matchup_with_http_info(format, team, opponent, **kwargs)  # noqa: E501
            return data

    def betting_trends_by_matchup_with_http_info(self, format, team, opponent, **kwargs):  # noqa: E501
        """Betting Trends by Matchup  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.betting_trends_by_matchup_with_http_info(format, team, opponent, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str format: Desired response format. Valid entries are <code>XML</code> or <code>JSON</code>. (required)
        :param str team: Abbreviation of a team. Example: <code>PHI</code>. (required)
        :param str opponent: Abbreviation of an opponent. Example: <code>NE</code>. (required)
        :return: NflOddsMatchupTrends
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['format', 'team', 'opponent']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method betting_trends_by_matchup" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'format' is set
        if ('format' not in params or
                params['format'] is None):
            raise ValueError("Missing the required parameter `format` when calling `betting_trends_by_matchup`")  # noqa: E501
        # verify the required parameter 'team' is set
        if ('team' not in params or
                params['team'] is None):
            raise ValueError("Missing the required parameter `team` when calling `betting_trends_by_matchup`")  # noqa: E501
        # verify the required parameter 'opponent' is set
        if ('opponent' not in params or
                params['opponent'] is None):
            raise ValueError("Missing the required parameter `opponent` when calling `betting_trends_by_matchup`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'format' in params:
            path_params['format'] = params['format']  # noqa: E501
        if 'team' in params:
            path_params['team'] = params['team']  # noqa: E501
        if 'opponent' in params:
            path_params['opponent'] = params['opponent']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['apiKeyHeader', 'apiKeyQuery']  # noqa: E501

        return self.api_client.call_api(
            '/{format}/MatchupTrends/{team}/{opponent}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='NflOddsMatchupTrends',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def betting_trends_by_team(self, format, team, **kwargs):  # noqa: E501
        """Betting Trends by Team  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.betting_trends_by_team(format, team, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str format: Desired response format. Valid entries are <code>XML</code> or <code>JSON</code>. (required)
        :param str team: Abbreviation of a team. Example: <code>PHI</code>. (required)
        :return: NflOddsTeamTrends
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.betting_trends_by_team_with_http_info(format, team, **kwargs)  # noqa: E501
        else:
            (data) = self.betting_trends_by_team_with_http_info(format, team, **kwargs)  # noqa: E501
            return data

    def betting_trends_by_team_with_http_info(self, format, team, **kwargs):  # noqa: E501
        """Betting Trends by Team  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.betting_trends_by_team_with_http_info(format, team, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str format: Desired response format. Valid entries are <code>XML</code> or <code>JSON</code>. (required)
        :param str team: Abbreviation of a team. Example: <code>PHI</code>. (required)
        :return: NflOddsTeamTrends
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['format', 'team']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method betting_trends_by_team" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'format' is set
        if ('format' not in params or
                params['format'] is None):
            raise ValueError("Missing the required parameter `format` when calling `betting_trends_by_team`")  # noqa: E501
        # verify the required parameter 'team' is set
        if ('team' not in params or
                params['team'] is None):
            raise ValueError("Missing the required parameter `team` when calling `betting_trends_by_team`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'format' in params:
            path_params['format'] = params['format']  # noqa: E501
        if 'team' in params:
            path_params['team'] = params['team']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['apiKeyHeader', 'apiKeyQuery']  # noqa: E501

        return self.api_client.call_api(
            '/{format}/TeamTrends/{team}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='NflOddsTeamTrends',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def generated_player_props_by_player(self, format, season, week, playerid, **kwargs):  # noqa: E501
        """Generated Player Props by Player  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generated_player_props_by_player(format, season, week, playerid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str format: Desired response format. Valid entries are <code>XML</code> or <code>JSON</code>. (required)
        :param str season: Year of the season and the season type. If no season type is provided, then the default is regular season. <br>Examples: <code>2018REG</code>, <code>2018PRE</code>, <code>2018POST</code> (required)
        :param str week: Week of the season. Valid values are as follows: Preseason 0 to 4, Regular Season 1 to 17, Postseason 1 to 4. Example: <code>1</code>, <code>2</code>, etc (required)
        :param str playerid: Each NFL player has a unique ID assigned by FantasyData. Player IDs can be determined by pulling player related data. Example: <code>17920</code>, <code>16771</code>, etc. (required)
        :return: list[NflOddsPlayerProp]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.generated_player_props_by_player_with_http_info(format, season, week, playerid, **kwargs)  # noqa: E501
        else:
            (data) = self.generated_player_props_by_player_with_http_info(format, season, week, playerid, **kwargs)  # noqa: E501
            return data

    def generated_player_props_by_player_with_http_info(self, format, season, week, playerid, **kwargs):  # noqa: E501
        """Generated Player Props by Player  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generated_player_props_by_player_with_http_info(format, season, week, playerid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str format: Desired response format. Valid entries are <code>XML</code> or <code>JSON</code>. (required)
        :param str season: Year of the season and the season type. If no season type is provided, then the default is regular season. <br>Examples: <code>2018REG</code>, <code>2018PRE</code>, <code>2018POST</code> (required)
        :param str week: Week of the season. Valid values are as follows: Preseason 0 to 4, Regular Season 1 to 17, Postseason 1 to 4. Example: <code>1</code>, <code>2</code>, etc (required)
        :param str playerid: Each NFL player has a unique ID assigned by FantasyData. Player IDs can be determined by pulling player related data. Example: <code>17920</code>, <code>16771</code>, etc. (required)
        :return: list[NflOddsPlayerProp]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['format', 'season', 'week', 'playerid']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method generated_player_props_by_player" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'format' is set
        if ('format' not in params or
                params['format'] is None):
            raise ValueError("Missing the required parameter `format` when calling `generated_player_props_by_player`")  # noqa: E501
        # verify the required parameter 'season' is set
        if ('season' not in params or
                params['season'] is None):
            raise ValueError("Missing the required parameter `season` when calling `generated_player_props_by_player`")  # noqa: E501
        # verify the required parameter 'week' is set
        if ('week' not in params or
                params['week'] is None):
            raise ValueError("Missing the required parameter `week` when calling `generated_player_props_by_player`")  # noqa: E501
        # verify the required parameter 'playerid' is set
        if ('playerid' not in params or
                params['playerid'] is None):
            raise ValueError("Missing the required parameter `playerid` when calling `generated_player_props_by_player`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'format' in params:
            path_params['format'] = params['format']  # noqa: E501
        if 'season' in params:
            path_params['season'] = params['season']  # noqa: E501
        if 'week' in params:
            path_params['week'] = params['week']  # noqa: E501
        if 'playerid' in params:
            path_params['playerid'] = params['playerid']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['apiKeyHeader', 'apiKeyQuery']  # noqa: E501

        return self.api_client.call_api(
            '/{format}/PlayerPropsByPlayerID/{season}/{week}/{playerid}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflOddsPlayerProp]',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def generated_player_props_by_team(self, format, season, week, team, **kwargs):  # noqa: E501
        """Generated Player Props by Team  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generated_player_props_by_team(format, season, week, team, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str format: Desired response format. Valid entries are <code>XML</code> or <code>JSON</code>. (required)
        :param str season: Year of the season and the season type. If no season type is provided, then the default is regular season. <br>Examples: <code>2018REG</code>, <code>2018PRE</code>, <code>2018POST</code> (required)
        :param str week: Week of the season. Valid values are as follows: Preseason 0 to 4, Regular Season 1 to 17, Postseason 1 to 4. Example: <code>1</code>, <code>2</code>, etc (required)
        :param str team: Abbreviation of the team. Example: <code>PHI</code>, <code>NE</code>, etc. (required)
        :return: list[NflOddsPlayerProp]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.generated_player_props_by_team_with_http_info(format, season, week, team, **kwargs)  # noqa: E501
        else:
            (data) = self.generated_player_props_by_team_with_http_info(format, season, week, team, **kwargs)  # noqa: E501
            return data

    def generated_player_props_by_team_with_http_info(self, format, season, week, team, **kwargs):  # noqa: E501
        """Generated Player Props by Team  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generated_player_props_by_team_with_http_info(format, season, week, team, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str format: Desired response format. Valid entries are <code>XML</code> or <code>JSON</code>. (required)
        :param str season: Year of the season and the season type. If no season type is provided, then the default is regular season. <br>Examples: <code>2018REG</code>, <code>2018PRE</code>, <code>2018POST</code> (required)
        :param str week: Week of the season. Valid values are as follows: Preseason 0 to 4, Regular Season 1 to 17, Postseason 1 to 4. Example: <code>1</code>, <code>2</code>, etc (required)
        :param str team: Abbreviation of the team. Example: <code>PHI</code>, <code>NE</code>, etc. (required)
        :return: list[NflOddsPlayerProp]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['format', 'season', 'week', 'team']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method generated_player_props_by_team" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'format' is set
        if ('format' not in params or
                params['format'] is None):
            raise ValueError("Missing the required parameter `format` when calling `generated_player_props_by_team`")  # noqa: E501
        # verify the required parameter 'season' is set
        if ('season' not in params or
                params['season'] is None):
            raise ValueError("Missing the required parameter `season` when calling `generated_player_props_by_team`")  # noqa: E501
        # verify the required parameter 'week' is set
        if ('week' not in params or
                params['week'] is None):
            raise ValueError("Missing the required parameter `week` when calling `generated_player_props_by_team`")  # noqa: E501
        # verify the required parameter 'team' is set
        if ('team' not in params or
                params['team'] is None):
            raise ValueError("Missing the required parameter `team` when calling `generated_player_props_by_team`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'format' in params:
            path_params['format'] = params['format']  # noqa: E501
        if 'season' in params:
            path_params['season'] = params['season']  # noqa: E501
        if 'week' in params:
            path_params['week'] = params['week']  # noqa: E501
        if 'team' in params:
            path_params['team'] = params['team']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['apiKeyHeader', 'apiKeyQuery']  # noqa: E501

        return self.api_client.call_api(
            '/{format}/PlayerPropsByTeam/{season}/{week}/{team}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflOddsPlayerProp]',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def generated_player_props_by_week(self, format, season, week, **kwargs):  # noqa: E501
        """Generated Player Props by Week  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generated_player_props_by_week(format, season, week, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str format: Desired response format. Valid entries are <code>XML</code> or <code>JSON</code>. (required)
        :param str season: Year of the season and the season type. If no season type is provided, then the default is regular season. <br>Examples: <code>2018REG</code>, <code>2018PRE</code>, <code>2018POST</code> (required)
        :param str week: Week of the season. Valid values are as follows: Preseason 0 to 4, Regular Season 1 to 17, Postseason 1 to 4. Example: <code>1</code>, <code>2</code>, etc (required)
        :return: list[NflOddsPlayerProp]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.generated_player_props_by_week_with_http_info(format, season, week, **kwargs)  # noqa: E501
        else:
            (data) = self.generated_player_props_by_week_with_http_info(format, season, week, **kwargs)  # noqa: E501
            return data

    def generated_player_props_by_week_with_http_info(self, format, season, week, **kwargs):  # noqa: E501
        """Generated Player Props by Week  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generated_player_props_by_week_with_http_info(format, season, week, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str format: Desired response format. Valid entries are <code>XML</code> or <code>JSON</code>. (required)
        :param str season: Year of the season and the season type. If no season type is provided, then the default is regular season. <br>Examples: <code>2018REG</code>, <code>2018PRE</code>, <code>2018POST</code> (required)
        :param str week: Week of the season. Valid values are as follows: Preseason 0 to 4, Regular Season 1 to 17, Postseason 1 to 4. Example: <code>1</code>, <code>2</code>, etc (required)
        :return: list[NflOddsPlayerProp]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['format', 'season', 'week']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method generated_player_props_by_week" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'format' is set
        if ('format' not in params or
                params['format'] is None):
            raise ValueError("Missing the required parameter `format` when calling `generated_player_props_by_week`")  # noqa: E501
        # verify the required parameter 'season' is set
        if ('season' not in params or
                params['season'] is None):
            raise ValueError("Missing the required parameter `season` when calling `generated_player_props_by_week`")  # noqa: E501
        # verify the required parameter 'week' is set
        if ('week' not in params or
                params['week'] is None):
            raise ValueError("Missing the required parameter `week` when calling `generated_player_props_by_week`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'format' in params:
            path_params['format'] = params['format']  # noqa: E501
        if 'season' in params:
            path_params['season'] = params['season']  # noqa: E501
        if 'week' in params:
            path_params['week'] = params['week']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['apiKeyHeader', 'apiKeyQuery']  # noqa: E501

        return self.api_client.call_api(
            '/{format}/PlayerPropsByWeek/{season}/{week}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflOddsPlayerProp]',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def in_game_odds_by_week(self, format, season, week, **kwargs):  # noqa: E501
        """In-Game Odds by Week  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.in_game_odds_by_week(format, season, week, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str format: Desired response format. Valid entries are <code>XML</code> or <code>JSON</code>. (required)
        :param str season: Year of the season, with optional season type. <br>Examples: <code>2018</code>, <code>2018POST</code>, etc. (required)
        :param str week: The week of the scores (games). <br>Examples: <code>1</code>, <code>2</code>, etc. (required)
        :return: list[NflOddsGameInfo]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.in_game_odds_by_week_with_http_info(format, season, week, **kwargs)  # noqa: E501
        else:
            (data) = self.in_game_odds_by_week_with_http_info(format, season, week, **kwargs)  # noqa: E501
            return data

    def in_game_odds_by_week_with_http_info(self, format, season, week, **kwargs):  # noqa: E501
        """In-Game Odds by Week  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.in_game_odds_by_week_with_http_info(format, season, week, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str format: Desired response format. Valid entries are <code>XML</code> or <code>JSON</code>. (required)
        :param str season: Year of the season, with optional season type. <br>Examples: <code>2018</code>, <code>2018POST</code>, etc. (required)
        :param str week: The week of the scores (games). <br>Examples: <code>1</code>, <code>2</code>, etc. (required)
        :return: list[NflOddsGameInfo]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['format', 'season', 'week']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method in_game_odds_by_week" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'format' is set
        if ('format' not in params or
                params['format'] is None):
            raise ValueError("Missing the required parameter `format` when calling `in_game_odds_by_week`")  # noqa: E501
        # verify the required parameter 'season' is set
        if ('season' not in params or
                params['season'] is None):
            raise ValueError("Missing the required parameter `season` when calling `in_game_odds_by_week`")  # noqa: E501
        # verify the required parameter 'week' is set
        if ('week' not in params or
                params['week'] is None):
            raise ValueError("Missing the required parameter `week` when calling `in_game_odds_by_week`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'format' in params:
            path_params['format'] = params['format']  # noqa: E501
        if 'season' in params:
            path_params['season'] = params['season']  # noqa: E501
        if 'week' in params:
            path_params['week'] = params['week']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['apiKeyHeader', 'apiKeyQuery']  # noqa: E501

        return self.api_client.call_api(
            '/{format}/LiveGameOddsByWeek/{season}/{week}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflOddsGameInfo]',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def in_game_odds_line_movement(self, format, scoreid, **kwargs):  # noqa: E501
        """In-Game Odds Line Movement  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.in_game_odds_line_movement(format, scoreid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str format: Desired response format. Valid entries are <code>XML</code> or <code>JSON</code>. (required)
        :param str scoreid: The ScoreID of an NFL score (game).  ScoreIDs can be found in the Scores API.  Valid entries are <code>16654</code> or <code>16667</code> (required)
        :return: list[NflOddsGameInfo]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.in_game_odds_line_movement_with_http_info(format, scoreid, **kwargs)  # noqa: E501
        else:
            (data) = self.in_game_odds_line_movement_with_http_info(format, scoreid, **kwargs)  # noqa: E501
            return data

    def in_game_odds_line_movement_with_http_info(self, format, scoreid, **kwargs):  # noqa: E501
        """In-Game Odds Line Movement  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.in_game_odds_line_movement_with_http_info(format, scoreid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str format: Desired response format. Valid entries are <code>XML</code> or <code>JSON</code>. (required)
        :param str scoreid: The ScoreID of an NFL score (game).  ScoreIDs can be found in the Scores API.  Valid entries are <code>16654</code> or <code>16667</code> (required)
        :return: list[NflOddsGameInfo]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['format', 'scoreid']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method in_game_odds_line_movement" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'format' is set
        if ('format' not in params or
                params['format'] is None):
            raise ValueError("Missing the required parameter `format` when calling `in_game_odds_line_movement`")  # noqa: E501
        # verify the required parameter 'scoreid' is set
        if ('scoreid' not in params or
                params['scoreid'] is None):
            raise ValueError("Missing the required parameter `scoreid` when calling `in_game_odds_line_movement`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'format' in params:
            path_params['format'] = params['format']  # noqa: E501
        if 'scoreid' in params:
            path_params['scoreid'] = params['scoreid']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['apiKeyHeader', 'apiKeyQuery']  # noqa: E501

        return self.api_client.call_api(
            '/{format}/LiveGameOddsLineMovement/{scoreid}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflOddsGameInfo]',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def pre_game_odds_by_week(self, format, season, week, **kwargs):  # noqa: E501
        """Pre-Game Odds by Week  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.pre_game_odds_by_week(format, season, week, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str format: Desired response format. Valid entries are <code>XML</code> or <code>JSON</code>. (required)
        :param str season: Year of the season, with optional season type. <br>Examples: <code>2018</code>, <code>2018POST</code>, etc. (required)
        :param str week: The week of the scores (games). <br>Examples: <code>1</code>, <code>2</code>, etc. (required)
        :return: list[NflOddsGameInfo]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.pre_game_odds_by_week_with_http_info(format, season, week, **kwargs)  # noqa: E501
        else:
            (data) = self.pre_game_odds_by_week_with_http_info(format, season, week, **kwargs)  # noqa: E501
            return data

    def pre_game_odds_by_week_with_http_info(self, format, season, week, **kwargs):  # noqa: E501
        """Pre-Game Odds by Week  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.pre_game_odds_by_week_with_http_info(format, season, week, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str format: Desired response format. Valid entries are <code>XML</code> or <code>JSON</code>. (required)
        :param str season: Year of the season, with optional season type. <br>Examples: <code>2018</code>, <code>2018POST</code>, etc. (required)
        :param str week: The week of the scores (games). <br>Examples: <code>1</code>, <code>2</code>, etc. (required)
        :return: list[NflOddsGameInfo]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['format', 'season', 'week']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method pre_game_odds_by_week" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'format' is set
        if ('format' not in params or
                params['format'] is None):
            raise ValueError("Missing the required parameter `format` when calling `pre_game_odds_by_week`")  # noqa: E501
        # verify the required parameter 'season' is set
        if ('season' not in params or
                params['season'] is None):
            raise ValueError("Missing the required parameter `season` when calling `pre_game_odds_by_week`")  # noqa: E501
        # verify the required parameter 'week' is set
        if ('week' not in params or
                params['week'] is None):
            raise ValueError("Missing the required parameter `week` when calling `pre_game_odds_by_week`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'format' in params:
            path_params['format'] = params['format']  # noqa: E501
        if 'season' in params:
            path_params['season'] = params['season']  # noqa: E501
        if 'week' in params:
            path_params['week'] = params['week']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['apiKeyHeader', 'apiKeyQuery']  # noqa: E501

        return self.api_client.call_api(
            '/{format}/GameOddsByWeek/{season}/{week}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflOddsGameInfo]',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def pre_game_odds_line_movement(self, format, scoreid, **kwargs):  # noqa: E501
        """Pre-Game Odds Line Movement  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.pre_game_odds_line_movement(format, scoreid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str format: Desired response format. Valid entries are <code>XML</code> or <code>JSON</code>. (required)
        :param str scoreid: The ScoreID of an NFL score (game).  ScoreIDs can be found in the Scores API.  Valid entries are <code>16654</code> or <code>16667</code> (required)
        :return: list[NflOddsGameInfo]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.pre_game_odds_line_movement_with_http_info(format, scoreid, **kwargs)  # noqa: E501
        else:
            (data) = self.pre_game_odds_line_movement_with_http_info(format, scoreid, **kwargs)  # noqa: E501
            return data

    def pre_game_odds_line_movement_with_http_info(self, format, scoreid, **kwargs):  # noqa: E501
        """Pre-Game Odds Line Movement  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.pre_game_odds_line_movement_with_http_info(format, scoreid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str format: Desired response format. Valid entries are <code>XML</code> or <code>JSON</code>. (required)
        :param str scoreid: The ScoreID of an NFL score (game).  ScoreIDs can be found in the Scores API.  Valid entries are <code>16654</code> or <code>16667</code> (required)
        :return: list[NflOddsGameInfo]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['format', 'scoreid']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method pre_game_odds_line_movement" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'format' is set
        if ('format' not in params or
                params['format'] is None):
            raise ValueError("Missing the required parameter `format` when calling `pre_game_odds_line_movement`")  # noqa: E501
        # verify the required parameter 'scoreid' is set
        if ('scoreid' not in params or
                params['scoreid'] is None):
            raise ValueError("Missing the required parameter `scoreid` when calling `pre_game_odds_line_movement`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'format' in params:
            path_params['format'] = params['format']  # noqa: E501
        if 'scoreid' in params:
            path_params['scoreid'] = params['scoreid']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['apiKeyHeader', 'apiKeyQuery']  # noqa: E501

        return self.api_client.call_api(
            '/{format}/GameOddsLineMovement/{scoreid}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflOddsGameInfo]',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def sportsbooks_active(self, format, **kwargs):  # noqa: E501
        """Sportsbooks (Active)  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.sportsbooks_active(format, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str format: Desired response format. Valid entries are <code>XML</code> or <code>JSON</code>. (required)
        :return: list[NflOddsSportsbook]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.sportsbooks_active_with_http_info(format, **kwargs)  # noqa: E501
        else:
            (data) = self.sportsbooks_active_with_http_info(format, **kwargs)  # noqa: E501
            return data

    def sportsbooks_active_with_http_info(self, format, **kwargs):  # noqa: E501
        """Sportsbooks (Active)  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.sportsbooks_active_with_http_info(format, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str format: Desired response format. Valid entries are <code>XML</code> or <code>JSON</code>. (required)
        :return: list[NflOddsSportsbook]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['format']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method sportsbooks_active" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'format' is set
        if ('format' not in params or
                params['format'] is None):
            raise ValueError("Missing the required parameter `format` when calling `sportsbooks_active`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'format' in params:
            path_params['format'] = params['format']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['apiKeyHeader', 'apiKeyQuery']  # noqa: E501

        return self.api_client.call_api(
            '/{format}/ActiveSportsbooks', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflOddsSportsbook]',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)
