# coding: utf-8

"""
    NFL v3 Stats

    NFL rosters, player stats, team stats, and fantasy stats API.  # 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_stats.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 are_games_in_progress(self, format, **kwargs):  # noqa: E501
        """Are Games In Progress  # noqa: E501

        Returns <code>true</code> if there is at least one game being played at the time of the request or <code>false</code> if there are none.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.are_games_in_progress(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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.are_games_in_progress_with_http_info(format, **kwargs)  # noqa: E501
        else:
            (data) = self.are_games_in_progress_with_http_info(format, **kwargs)  # noqa: E501
            return data

    def are_games_in_progress_with_http_info(self, format, **kwargs):  # noqa: E501
        """Are Games In Progress  # noqa: E501

        Returns <code>true</code> if there is at least one game being played at the time of the request or <code>false</code> if there are none.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.are_games_in_progress_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: bool
                 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 are_games_in_progress" % 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 `are_games_in_progress`")  # 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}/AreAnyGamesInProgress', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='bool',  # 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 box_score_by_scoreid_v(self, format, scoreid, **kwargs):  # noqa: E501
        """Box Score by ScoreID V3  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.box_score_by_scoreid_v(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 game. Possible values include: <code>16247</code>, <code>16245</code>, etc. (required)
        :return: NflStatsBoxScoreV3
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.box_score_by_scoreid_v_with_http_info(format, scoreid, **kwargs)  # noqa: E501
        else:
            (data) = self.box_score_by_scoreid_v_with_http_info(format, scoreid, **kwargs)  # noqa: E501
            return data

    def box_score_by_scoreid_v_with_http_info(self, format, scoreid, **kwargs):  # noqa: E501
        """Box Score by ScoreID V3  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.box_score_by_scoreid_v_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 game. Possible values include: <code>16247</code>, <code>16245</code>, etc. (required)
        :return: NflStatsBoxScoreV3
                 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 box_score_by_scoreid_v" % 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 `box_score_by_scoreid_v`")  # 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 `box_score_by_scoreid_v`")  # 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}/BoxScoreByScoreIDV3/{scoreid}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='NflStatsBoxScoreV3',  # 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 box_score_v(self, format, season, week, hometeam, **kwargs):  # noqa: E501
        """Box Score V3  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.box_score_v(format, season, week, hometeam, 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>2015REG</code>, <code>2015PRE</code>, <code>2015POST</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>          (required)
        :param str hometeam: Abbreviation of a team playing in this game. Example: <code>WAS</code>. (required)
        :return: NflStatsBoxScoreV3
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.box_score_v_with_http_info(format, season, week, hometeam, **kwargs)  # noqa: E501
        else:
            (data) = self.box_score_v_with_http_info(format, season, week, hometeam, **kwargs)  # noqa: E501
            return data

    def box_score_v_with_http_info(self, format, season, week, hometeam, **kwargs):  # noqa: E501
        """Box Score V3  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.box_score_v_with_http_info(format, season, week, hometeam, 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>2015REG</code>, <code>2015PRE</code>, <code>2015POST</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>          (required)
        :param str hometeam: Abbreviation of a team playing in this game. Example: <code>WAS</code>. (required)
        :return: NflStatsBoxScoreV3
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['format', 'season', 'week', 'hometeam']  # 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 box_score_v" % 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 `box_score_v`")  # 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 `box_score_v`")  # 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 `box_score_v`")  # noqa: E501
        # verify the required parameter 'hometeam' is set
        if ('hometeam' not in params or
                params['hometeam'] is None):
            raise ValueError("Missing the required parameter `hometeam` when calling `box_score_v`")  # 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 'hometeam' in params:
            path_params['hometeam'] = params['hometeam']  # 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}/BoxScoreV3/{season}/{week}/{hometeam}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='NflStatsBoxScoreV3',  # 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 box_scores_delta_v(self, format, season, week, playerstoinclude, minutes, **kwargs):  # noqa: E501
        """Box Scores Delta V3  # noqa: E501

        This method returns all box scores for a given season and week, but only returns player stats that have changed in the last X minutes. You can also filter by type of player stats to include, such as traditional fantasy players, IDP players or all players.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.box_scores_delta_v(format, season, week, playerstoinclude, minutes, 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>2015REG</code>, <code>2015PRE</code>, <code>2015POST</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>          (required)
        :param str playerstoinclude: The subcategory of players to include in the returned PlayerGame records. Possible values include:<br><br> <code>all</code> Returns all players<br> <code>fantasy</code> Returns traditional fantasy players (QB, RB, WR, TE, K, DST)<br> <code>idp</code> Returns traditional fantasy players and IDP players. (required)
        :param str minutes: Only returns player statistics that have changed in the last X minutes.  You specify how many minutes in time to go back.  Valid entries are:<br><code>1</code>,  <code>2</code>, etc.          (required)
        :return: list[NflStatsBoxScoreV3]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.box_scores_delta_v_with_http_info(format, season, week, playerstoinclude, minutes, **kwargs)  # noqa: E501
        else:
            (data) = self.box_scores_delta_v_with_http_info(format, season, week, playerstoinclude, minutes, **kwargs)  # noqa: E501
            return data

    def box_scores_delta_v_with_http_info(self, format, season, week, playerstoinclude, minutes, **kwargs):  # noqa: E501
        """Box Scores Delta V3  # noqa: E501

        This method returns all box scores for a given season and week, but only returns player stats that have changed in the last X minutes. You can also filter by type of player stats to include, such as traditional fantasy players, IDP players or all players.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.box_scores_delta_v_with_http_info(format, season, week, playerstoinclude, minutes, 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>2015REG</code>, <code>2015PRE</code>, <code>2015POST</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>          (required)
        :param str playerstoinclude: The subcategory of players to include in the returned PlayerGame records. Possible values include:<br><br> <code>all</code> Returns all players<br> <code>fantasy</code> Returns traditional fantasy players (QB, RB, WR, TE, K, DST)<br> <code>idp</code> Returns traditional fantasy players and IDP players. (required)
        :param str minutes: Only returns player statistics that have changed in the last X minutes.  You specify how many minutes in time to go back.  Valid entries are:<br><code>1</code>,  <code>2</code>, etc.          (required)
        :return: list[NflStatsBoxScoreV3]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['format', 'season', 'week', 'playerstoinclude', 'minutes']  # 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 box_scores_delta_v" % 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 `box_scores_delta_v`")  # 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 `box_scores_delta_v`")  # 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 `box_scores_delta_v`")  # noqa: E501
        # verify the required parameter 'playerstoinclude' is set
        if ('playerstoinclude' not in params or
                params['playerstoinclude'] is None):
            raise ValueError("Missing the required parameter `playerstoinclude` when calling `box_scores_delta_v`")  # noqa: E501
        # verify the required parameter 'minutes' is set
        if ('minutes' not in params or
                params['minutes'] is None):
            raise ValueError("Missing the required parameter `minutes` when calling `box_scores_delta_v`")  # 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 'playerstoinclude' in params:
            path_params['playerstoinclude'] = params['playerstoinclude']  # noqa: E501
        if 'minutes' in params:
            path_params['minutes'] = params['minutes']  # 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}/BoxScoresDeltaV3/{season}/{week}/{playerstoinclude}/{minutes}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsBoxScoreV3]',  # 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 box_scores_v_simulation(self, format, numberofplays, **kwargs):  # noqa: E501
        """Box Scores V3 Simulation  # noqa: E501

        Gets simulated live box scores of NFL games, covering the Conference Championship games on January 21, 2018.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.box_scores_v_simulation(format, numberofplays, 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 numberofplays: The number of plays to progress in this NFL live game simulation. Example entries are <code>0</code>, <code>1</code>, <code>2</code>, <code>3</code>, <code>150</code>, <code>200</code>, etc. (required)
        :return: list[NflStatsBoxScoreV3]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.box_scores_v_simulation_with_http_info(format, numberofplays, **kwargs)  # noqa: E501
        else:
            (data) = self.box_scores_v_simulation_with_http_info(format, numberofplays, **kwargs)  # noqa: E501
            return data

    def box_scores_v_simulation_with_http_info(self, format, numberofplays, **kwargs):  # noqa: E501
        """Box Scores V3 Simulation  # noqa: E501

        Gets simulated live box scores of NFL games, covering the Conference Championship games on January 21, 2018.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.box_scores_v_simulation_with_http_info(format, numberofplays, 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 numberofplays: The number of plays to progress in this NFL live game simulation. Example entries are <code>0</code>, <code>1</code>, <code>2</code>, <code>3</code>, <code>150</code>, <code>200</code>, etc. (required)
        :return: list[NflStatsBoxScoreV3]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['format', 'numberofplays']  # 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 box_scores_v_simulation" % 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 `box_scores_v_simulation`")  # noqa: E501
        # verify the required parameter 'numberofplays' is set
        if ('numberofplays' not in params or
                params['numberofplays'] is None):
            raise ValueError("Missing the required parameter `numberofplays` when calling `box_scores_v_simulation`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'format' in params:
            path_params['format'] = params['format']  # noqa: E501
        if 'numberofplays' in params:
            path_params['numberofplays'] = params['numberofplays']  # 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}/SimulatedBoxScoresV3/{numberofplays}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsBoxScoreV3]',  # 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 bye_weeks(self, format, season, **kwargs):  # noqa: E501
        """Bye Weeks  # noqa: E501

        Get bye weeks for the teams during a specified NFL 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.bye_weeks(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 and the season type. If no season type is provided, then the default is regular season.           <br>Examples: <code>2015REG</code>, <code>2015PRE</code>, <code>2015POST</code>.          (required)
        :return: list[NflStatsBye]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.bye_weeks_with_http_info(format, season, **kwargs)  # noqa: E501
        else:
            (data) = self.bye_weeks_with_http_info(format, season, **kwargs)  # noqa: E501
            return data

    def bye_weeks_with_http_info(self, format, season, **kwargs):  # noqa: E501
        """Bye Weeks  # noqa: E501

        Get bye weeks for the teams during a specified NFL 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.bye_weeks_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 and the season type. If no season type is provided, then the default is regular season.           <br>Examples: <code>2015REG</code>, <code>2015PRE</code>, <code>2015POST</code>.          (required)
        :return: list[NflStatsBye]
                 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 bye_weeks" % 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 `bye_weeks`")  # 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 `bye_weeks`")  # 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}/Byes/{season}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsBye]',  # 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 daily_fantasy_players(self, format, _date, **kwargs):  # noqa: E501
        """Daily Fantasy Players  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.daily_fantasy_players(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 contest for which you're pulling players           <code>2014-SEP-21</code>,           <code>2014-NOV-15</code>, etc          (required)
        :return: list[NflStatsDailyFantasyPlayer]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.daily_fantasy_players_with_http_info(format, _date, **kwargs)  # noqa: E501
        else:
            (data) = self.daily_fantasy_players_with_http_info(format, _date, **kwargs)  # noqa: E501
            return data

    def daily_fantasy_players_with_http_info(self, format, _date, **kwargs):  # noqa: E501
        """Daily Fantasy Players  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.daily_fantasy_players_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 contest for which you're pulling players           <code>2014-SEP-21</code>,           <code>2014-NOV-15</code>, etc          (required)
        :return: list[NflStatsDailyFantasyPlayer]
                 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 daily_fantasy_players" % 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 `daily_fantasy_players`")  # 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 `daily_fantasy_players`")  # 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}/DailyFantasyPlayers/{date}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsDailyFantasyPlayer]',  # 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 daily_fantasy_scoring(self, format, _date, **kwargs):  # noqa: E501
        """Daily Fantasy Scoring  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.daily_fantasy_scoring(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 contest for which you're pulling players           <code>2014-SEP-21</code>,           <code>2014-NOV-15</code>, etc (required)
        :return: list[NflStatsDailyFantasyScoring]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.daily_fantasy_scoring_with_http_info(format, _date, **kwargs)  # noqa: E501
        else:
            (data) = self.daily_fantasy_scoring_with_http_info(format, _date, **kwargs)  # noqa: E501
            return data

    def daily_fantasy_scoring_with_http_info(self, format, _date, **kwargs):  # noqa: E501
        """Daily Fantasy Scoring  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.daily_fantasy_scoring_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 contest for which you're pulling players           <code>2014-SEP-21</code>,           <code>2014-NOV-15</code>, etc (required)
        :return: list[NflStatsDailyFantasyScoring]
                 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 daily_fantasy_scoring" % 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 `daily_fantasy_scoring`")  # 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 `daily_fantasy_scoring`")  # 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}/DailyFantasyPoints/{date}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsDailyFantasyScoring]',  # 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 dfs_slates_by_date(self, format, _date, **kwargs):  # noqa: E501
        """DFS Slates 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.dfs_slates_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 slates. <br>Examples: <code>2017-SEP-25</code>, <code>2017-10-31</code>. (required)
        :return: list[NflStatsDfsSlate]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.dfs_slates_by_date_with_http_info(format, _date, **kwargs)  # noqa: E501
        else:
            (data) = self.dfs_slates_by_date_with_http_info(format, _date, **kwargs)  # noqa: E501
            return data

    def dfs_slates_by_date_with_http_info(self, format, _date, **kwargs):  # noqa: E501
        """DFS Slates 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.dfs_slates_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 slates. <br>Examples: <code>2017-SEP-25</code>, <code>2017-10-31</code>. (required)
        :return: list[NflStatsDfsSlate]
                 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 dfs_slates_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 `dfs_slates_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 `dfs_slates_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}/DfsSlatesByDate/{date}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsDfsSlate]',  # 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 dfs_slates_by_week(self, format, season, week, **kwargs):  # noqa: E501
        """DFS Slates 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.dfs_slates_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>2015REG</code>, <code>2015PRE</code>, <code>2015POST</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>          (required)
        :return: list[NflStatsDfsSlate]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.dfs_slates_by_week_with_http_info(format, season, week, **kwargs)  # noqa: E501
        else:
            (data) = self.dfs_slates_by_week_with_http_info(format, season, week, **kwargs)  # noqa: E501
            return data

    def dfs_slates_by_week_with_http_info(self, format, season, week, **kwargs):  # noqa: E501
        """DFS Slates 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.dfs_slates_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>2015REG</code>, <code>2015PRE</code>, <code>2015POST</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>          (required)
        :return: list[NflStatsDfsSlate]
                 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 dfs_slates_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 `dfs_slates_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 `dfs_slates_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 `dfs_slates_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}/DfsSlatesByWeek/{season}/{week}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsDfsSlate]',  # 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 fantasy_defense_game_stats(self, format, season, week, **kwargs):  # noqa: E501
        """Fantasy Defense Game Stats  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.fantasy_defense_game_stats(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>2015REG</code>, <code>2015PRE</code>, <code>2015POST</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>          (required)
        :return: list[NflStatsFantasyDefenseGame]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.fantasy_defense_game_stats_with_http_info(format, season, week, **kwargs)  # noqa: E501
        else:
            (data) = self.fantasy_defense_game_stats_with_http_info(format, season, week, **kwargs)  # noqa: E501
            return data

    def fantasy_defense_game_stats_with_http_info(self, format, season, week, **kwargs):  # noqa: E501
        """Fantasy Defense Game Stats  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.fantasy_defense_game_stats_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>2015REG</code>, <code>2015PRE</code>, <code>2015POST</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>          (required)
        :return: list[NflStatsFantasyDefenseGame]
                 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 fantasy_defense_game_stats" % 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 `fantasy_defense_game_stats`")  # 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 `fantasy_defense_game_stats`")  # 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 `fantasy_defense_game_stats`")  # 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}/FantasyDefenseByGame/{season}/{week}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsFantasyDefenseGame]',  # 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 fantasy_defense_game_stats_by_team(self, format, season, week, team, **kwargs):  # noqa: E501
        """Fantasy Defense Game Stats 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.fantasy_defense_game_stats_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>2015REG</code>, <code>2015PRE</code>, <code>2015POST</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>          (required)
        :param str team: Abbreviation of the team. Example: <code>WAS</code>. (required)
        :return: NflStatsFantasyDefenseGame
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.fantasy_defense_game_stats_by_team_with_http_info(format, season, week, team, **kwargs)  # noqa: E501
        else:
            (data) = self.fantasy_defense_game_stats_by_team_with_http_info(format, season, week, team, **kwargs)  # noqa: E501
            return data

    def fantasy_defense_game_stats_by_team_with_http_info(self, format, season, week, team, **kwargs):  # noqa: E501
        """Fantasy Defense Game Stats 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.fantasy_defense_game_stats_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>2015REG</code>, <code>2015PRE</code>, <code>2015POST</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>          (required)
        :param str team: Abbreviation of the team. Example: <code>WAS</code>. (required)
        :return: NflStatsFantasyDefenseGame
                 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 fantasy_defense_game_stats_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 `fantasy_defense_game_stats_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 `fantasy_defense_game_stats_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 `fantasy_defense_game_stats_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 `fantasy_defense_game_stats_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}/FantasyDefenseByGameByTeam/{season}/{week}/{team}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='NflStatsFantasyDefenseGame',  # 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 fantasy_defense_season_stats(self, format, season, **kwargs):  # noqa: E501
        """Fantasy Defense Season Stats  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.fantasy_defense_season_stats(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 and the season type. If no season type is provided, then the default is regular season.           <br>Examples: <code>2015REG</code>, <code>2015PRE</code>, <code>2015POST</code>.          (required)
        :return: list[NflStatsFantasyDefenseSeason]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.fantasy_defense_season_stats_with_http_info(format, season, **kwargs)  # noqa: E501
        else:
            (data) = self.fantasy_defense_season_stats_with_http_info(format, season, **kwargs)  # noqa: E501
            return data

    def fantasy_defense_season_stats_with_http_info(self, format, season, **kwargs):  # noqa: E501
        """Fantasy Defense Season Stats  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.fantasy_defense_season_stats_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 and the season type. If no season type is provided, then the default is regular season.           <br>Examples: <code>2015REG</code>, <code>2015PRE</code>, <code>2015POST</code>.          (required)
        :return: list[NflStatsFantasyDefenseSeason]
                 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 fantasy_defense_season_stats" % 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 `fantasy_defense_season_stats`")  # 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 `fantasy_defense_season_stats`")  # 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}/FantasyDefenseBySeason/{season}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsFantasyDefenseSeason]',  # 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 fantasy_defense_season_stats_by_team(self, format, season, team, **kwargs):  # noqa: E501
        """Fantasy Defense Season Stats 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.fantasy_defense_season_stats_by_team(format, season, 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>2015REG</code>, <code>2015PRE</code>, <code>2015POST</code>.          (required)
        :param str team: Abbreviation of the team. Example: <code>WAS</code>. (required)
        :return: NflStatsFantasyDefenseSeason
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.fantasy_defense_season_stats_by_team_with_http_info(format, season, team, **kwargs)  # noqa: E501
        else:
            (data) = self.fantasy_defense_season_stats_by_team_with_http_info(format, season, team, **kwargs)  # noqa: E501
            return data

    def fantasy_defense_season_stats_by_team_with_http_info(self, format, season, team, **kwargs):  # noqa: E501
        """Fantasy Defense Season Stats 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.fantasy_defense_season_stats_by_team_with_http_info(format, season, 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>2015REG</code>, <code>2015PRE</code>, <code>2015POST</code>.          (required)
        :param str team: Abbreviation of the team. Example: <code>WAS</code>. (required)
        :return: NflStatsFantasyDefenseSeason
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['format', 'season', '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 fantasy_defense_season_stats_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 `fantasy_defense_season_stats_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 `fantasy_defense_season_stats_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 `fantasy_defense_season_stats_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 '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}/FantasyDefenseBySeasonByTeam/{season}/{team}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='NflStatsFantasyDefenseSeason',  # 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 fantasy_player_ownership_percentages_season_long(self, format, season, week, **kwargs):  # noqa: E501
        """Fantasy Player Ownership Percentages (Season-Long)  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.fantasy_player_ownership_percentages_season_long(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>2015REG</code>, <code>2015PRE</code>, <code>2015POST</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>          (required)
        :return: list[NflStatsPlayerOwnership]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.fantasy_player_ownership_percentages_season_long_with_http_info(format, season, week, **kwargs)  # noqa: E501
        else:
            (data) = self.fantasy_player_ownership_percentages_season_long_with_http_info(format, season, week, **kwargs)  # noqa: E501
            return data

    def fantasy_player_ownership_percentages_season_long_with_http_info(self, format, season, week, **kwargs):  # noqa: E501
        """Fantasy Player Ownership Percentages (Season-Long)  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.fantasy_player_ownership_percentages_season_long_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>2015REG</code>, <code>2015PRE</code>, <code>2015POST</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>          (required)
        :return: list[NflStatsPlayerOwnership]
                 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 fantasy_player_ownership_percentages_season_long" % 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 `fantasy_player_ownership_percentages_season_long`")  # 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 `fantasy_player_ownership_percentages_season_long`")  # 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 `fantasy_player_ownership_percentages_season_long`")  # 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}/PlayerOwnership/{season}/{week}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsPlayerOwnership]',  # 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 fantasy_players_with_adp(self, format, **kwargs):  # noqa: E501
        """Fantasy Players with ADP  # noqa: E501

        This method returns a comprehensive list of draftable fantasy football players, including QB, RB, WR, TE, K and DEF.  Players are sorted by ADP (AverageDraftPosition).  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.fantasy_players_with_adp(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[NflStatsFantasyPlayer]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.fantasy_players_with_adp_with_http_info(format, **kwargs)  # noqa: E501
        else:
            (data) = self.fantasy_players_with_adp_with_http_info(format, **kwargs)  # noqa: E501
            return data

    def fantasy_players_with_adp_with_http_info(self, format, **kwargs):  # noqa: E501
        """Fantasy Players with ADP  # noqa: E501

        This method returns a comprehensive list of draftable fantasy football players, including QB, RB, WR, TE, K and DEF.  Players are sorted by ADP (AverageDraftPosition).  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.fantasy_players_with_adp_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[NflStatsFantasyPlayer]
                 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 fantasy_players_with_adp" % 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 `fantasy_players_with_adp`")  # 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}/FantasyPlayers', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsFantasyPlayer]',  # 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 game_stats_by_season_deprecated_use_team_game_stats_instead(self, format, season, **kwargs):  # noqa: E501
        """Game Stats by Season (Deprecated, use Team Game Stats instead)  # noqa: E501

        Game stats for a specified 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.game_stats_by_season_deprecated_use_team_game_stats_instead(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 and the season type. If no season type is provided, then the default is regular season.           <br>Examples: <code>2015REG</code>, <code>2015PRE</code>, <code>2015POST</code>.          (required)
        :return: list[NflStatsGame]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.game_stats_by_season_deprecated_use_team_game_stats_instead_with_http_info(format, season, **kwargs)  # noqa: E501
        else:
            (data) = self.game_stats_by_season_deprecated_use_team_game_stats_instead_with_http_info(format, season, **kwargs)  # noqa: E501
            return data

    def game_stats_by_season_deprecated_use_team_game_stats_instead_with_http_info(self, format, season, **kwargs):  # noqa: E501
        """Game Stats by Season (Deprecated, use Team Game Stats instead)  # noqa: E501

        Game stats for a specified 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.game_stats_by_season_deprecated_use_team_game_stats_instead_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 and the season type. If no season type is provided, then the default is regular season.           <br>Examples: <code>2015REG</code>, <code>2015PRE</code>, <code>2015POST</code>.          (required)
        :return: list[NflStatsGame]
                 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 game_stats_by_season_deprecated_use_team_game_stats_instead" % 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 `game_stats_by_season_deprecated_use_team_game_stats_instead`")  # 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 `game_stats_by_season_deprecated_use_team_game_stats_instead`")  # 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}/GameStats/{season}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsGame]',  # 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 game_stats_by_week_deprecated_use_team_game_stats_instead(self, format, season, week, **kwargs):  # noqa: E501
        """Game Stats by Week (Deprecated, use Team Game Stats instead)  # noqa: E501

        Game stats for a specified season and 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.game_stats_by_week_deprecated_use_team_game_stats_instead(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>2015REG</code>, <code>2015PRE</code>, <code>2015POST</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>          (required)
        :return: list[NflStatsGame]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.game_stats_by_week_deprecated_use_team_game_stats_instead_with_http_info(format, season, week, **kwargs)  # noqa: E501
        else:
            (data) = self.game_stats_by_week_deprecated_use_team_game_stats_instead_with_http_info(format, season, week, **kwargs)  # noqa: E501
            return data

    def game_stats_by_week_deprecated_use_team_game_stats_instead_with_http_info(self, format, season, week, **kwargs):  # noqa: E501
        """Game Stats by Week (Deprecated, use Team Game Stats instead)  # noqa: E501

        Game stats for a specified season and 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.game_stats_by_week_deprecated_use_team_game_stats_instead_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>2015REG</code>, <code>2015PRE</code>, <code>2015POST</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>          (required)
        :return: list[NflStatsGame]
                 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 game_stats_by_week_deprecated_use_team_game_stats_instead" % 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 `game_stats_by_week_deprecated_use_team_game_stats_instead`")  # 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 `game_stats_by_week_deprecated_use_team_game_stats_instead`")  # 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 `game_stats_by_week_deprecated_use_team_game_stats_instead`")  # 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}/GameStatsByWeek/{season}/{week}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsGame]',  # 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 idp_fantasy_players_with_adp(self, format, **kwargs):  # noqa: E501
        """IDP Fantasy Players with ADP  # noqa: E501

        This method returns the top 300+ IDP Fantasy Players for the current or upcoming season, ordered by AverageDraftPositionIDP.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.idp_fantasy_players_with_adp(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[NflStatsFantasyPlayer]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.idp_fantasy_players_with_adp_with_http_info(format, **kwargs)  # noqa: E501
        else:
            (data) = self.idp_fantasy_players_with_adp_with_http_info(format, **kwargs)  # noqa: E501
            return data

    def idp_fantasy_players_with_adp_with_http_info(self, format, **kwargs):  # noqa: E501
        """IDP Fantasy Players with ADP  # noqa: E501

        This method returns the top 300+ IDP Fantasy Players for the current or upcoming season, ordered by AverageDraftPositionIDP.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.idp_fantasy_players_with_adp_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[NflStatsFantasyPlayer]
                 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 idp_fantasy_players_with_adp" % 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 `idp_fantasy_players_with_adp`")  # 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}/FantasyPlayersIDP', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsFantasyPlayer]',  # 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 injuries(self, format, season, week, **kwargs):  # noqa: E501
        """Injuries  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.injuries(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>2015REG</code>, <code>2015PRE</code>, <code>2015POST</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>          (required)
        :return: list[NflStatsInjury]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.injuries_with_http_info(format, season, week, **kwargs)  # noqa: E501
        else:
            (data) = self.injuries_with_http_info(format, season, week, **kwargs)  # noqa: E501
            return data

    def injuries_with_http_info(self, format, season, week, **kwargs):  # noqa: E501
        """Injuries  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.injuries_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>2015REG</code>, <code>2015PRE</code>, <code>2015POST</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>          (required)
        :return: list[NflStatsInjury]
                 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 injuries" % 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 `injuries`")  # 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 `injuries`")  # 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 `injuries`")  # 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}/Injuries/{season}/{week}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsInjury]',  # 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 injuries_by_team(self, format, season, week, team, **kwargs):  # noqa: E501
        """Injuries 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.injuries_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>2015REG</code>, <code>2015PRE</code>, <code>2015POST</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>          (required)
        :param str team: Abbreviation of the team. Example: <code>WAS</code>. (required)
        :return: list[NflStatsInjury]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.injuries_by_team_with_http_info(format, season, week, team, **kwargs)  # noqa: E501
        else:
            (data) = self.injuries_by_team_with_http_info(format, season, week, team, **kwargs)  # noqa: E501
            return data

    def injuries_by_team_with_http_info(self, format, season, week, team, **kwargs):  # noqa: E501
        """Injuries 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.injuries_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>2015REG</code>, <code>2015PRE</code>, <code>2015POST</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>          (required)
        :param str team: Abbreviation of the team. Example: <code>WAS</code>. (required)
        :return: list[NflStatsInjury]
                 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 injuries_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 `injuries_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 `injuries_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 `injuries_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 `injuries_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}/Injuries/{season}/{week}/{team}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsInjury]',  # 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 league_leaders_by_season(self, format, season, position, column, **kwargs):  # noqa: E501
        """League Leaders 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.league_leaders_by_season(format, season, position, column, 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>2015REG</code>, <code>2015PRE</code>, <code>2015POST</code>.          (required)
        :param str position: Playerâ€™s position that you would like to filter by. (required)
        :param str column: Response member you would like results sorted by. (required)
        :return: list[NflStatsPlayerSeason]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.league_leaders_by_season_with_http_info(format, season, position, column, **kwargs)  # noqa: E501
        else:
            (data) = self.league_leaders_by_season_with_http_info(format, season, position, column, **kwargs)  # noqa: E501
            return data

    def league_leaders_by_season_with_http_info(self, format, season, position, column, **kwargs):  # noqa: E501
        """League Leaders 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.league_leaders_by_season_with_http_info(format, season, position, column, 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>2015REG</code>, <code>2015PRE</code>, <code>2015POST</code>.          (required)
        :param str position: Playerâ€™s position that you would like to filter by. (required)
        :param str column: Response member you would like results sorted by. (required)
        :return: list[NflStatsPlayerSeason]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['format', 'season', 'position', 'column']  # 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 league_leaders_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 `league_leaders_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 `league_leaders_by_season`")  # noqa: E501
        # verify the required parameter 'position' is set
        if ('position' not in params or
                params['position'] is None):
            raise ValueError("Missing the required parameter `position` when calling `league_leaders_by_season`")  # noqa: E501
        # verify the required parameter 'column' is set
        if ('column' not in params or
                params['column'] is None):
            raise ValueError("Missing the required parameter `column` when calling `league_leaders_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
        if 'position' in params:
            path_params['position'] = params['position']  # noqa: E501
        if 'column' in params:
            path_params['column'] = params['column']  # 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}/SeasonLeagueLeaders/{season}/{position}/{column}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsPlayerSeason]',  # 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 league_leaders_by_week(self, format, season, week, position, column, **kwargs):  # noqa: E501
        """League Leaders 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.league_leaders_by_week(format, season, week, position, column, 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>2015REG</code>, <code>2015PRE</code>, <code>2015POST</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>          (required)
        :param str position: Playerâ€™s position that you would like to filter by. (required)
        :param str column: Response member you would like results sorted by. (required)
        :return: list[NflStatsPlayerGame]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.league_leaders_by_week_with_http_info(format, season, week, position, column, **kwargs)  # noqa: E501
        else:
            (data) = self.league_leaders_by_week_with_http_info(format, season, week, position, column, **kwargs)  # noqa: E501
            return data

    def league_leaders_by_week_with_http_info(self, format, season, week, position, column, **kwargs):  # noqa: E501
        """League Leaders 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.league_leaders_by_week_with_http_info(format, season, week, position, column, 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>2015REG</code>, <code>2015PRE</code>, <code>2015POST</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>          (required)
        :param str position: Playerâ€™s position that you would like to filter by. (required)
        :param str column: Response member you would like results sorted by. (required)
        :return: list[NflStatsPlayerGame]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['format', 'season', 'week', 'position', 'column']  # 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 league_leaders_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 `league_leaders_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 `league_leaders_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 `league_leaders_by_week`")  # noqa: E501
        # verify the required parameter 'position' is set
        if ('position' not in params or
                params['position'] is None):
            raise ValueError("Missing the required parameter `position` when calling `league_leaders_by_week`")  # noqa: E501
        # verify the required parameter 'column' is set
        if ('column' not in params or
                params['column'] is None):
            raise ValueError("Missing the required parameter `column` when calling `league_leaders_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
        if 'position' in params:
            path_params['position'] = params['position']  # noqa: E501
        if 'column' in params:
            path_params['column'] = params['column']  # 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}/GameLeagueLeaders/{season}/{week}/{position}/{column}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsPlayerGame]',  # 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 legacy_box_score(self, format, season, week, hometeam, **kwargs):  # noqa: E501
        """Legacy Box Score  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.legacy_box_score(format, season, week, hometeam, 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>2015REG</code>, <code>2015PRE</code>, <code>2015POST</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>          (required)
        :param str hometeam: Abbreviation of the home team. Example: <code>WAS</code>. (required)
        :return: NflStatsBoxScore
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.legacy_box_score_with_http_info(format, season, week, hometeam, **kwargs)  # noqa: E501
        else:
            (data) = self.legacy_box_score_with_http_info(format, season, week, hometeam, **kwargs)  # noqa: E501
            return data

    def legacy_box_score_with_http_info(self, format, season, week, hometeam, **kwargs):  # noqa: E501
        """Legacy Box Score  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.legacy_box_score_with_http_info(format, season, week, hometeam, 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>2015REG</code>, <code>2015PRE</code>, <code>2015POST</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>          (required)
        :param str hometeam: Abbreviation of the home team. Example: <code>WAS</code>. (required)
        :return: NflStatsBoxScore
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['format', 'season', 'week', 'hometeam']  # 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 legacy_box_score" % 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 `legacy_box_score`")  # 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 `legacy_box_score`")  # 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 `legacy_box_score`")  # noqa: E501
        # verify the required parameter 'hometeam' is set
        if ('hometeam' not in params or
                params['hometeam'] is None):
            raise ValueError("Missing the required parameter `hometeam` when calling `legacy_box_score`")  # 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 'hometeam' in params:
            path_params['hometeam'] = params['hometeam']  # 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}/BoxScore/{season}/{week}/{hometeam}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='NflStatsBoxScore',  # 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 legacy_box_scores(self, format, season, week, **kwargs):  # noqa: E501
        """Legacy Box Scores  # noqa: E501

        This method returns all box scores for a given season and 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.legacy_box_scores(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>2015REG</code>, <code>2015PRE</code>, <code>2015POST</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>          (required)
        :return: list[NflStatsBoxScore]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.legacy_box_scores_with_http_info(format, season, week, **kwargs)  # noqa: E501
        else:
            (data) = self.legacy_box_scores_with_http_info(format, season, week, **kwargs)  # noqa: E501
            return data

    def legacy_box_scores_with_http_info(self, format, season, week, **kwargs):  # noqa: E501
        """Legacy Box Scores  # noqa: E501

        This method returns all box scores for a given season and 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.legacy_box_scores_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>2015REG</code>, <code>2015PRE</code>, <code>2015POST</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>          (required)
        :return: list[NflStatsBoxScore]
                 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 legacy_box_scores" % 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 `legacy_box_scores`")  # 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 `legacy_box_scores`")  # 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 `legacy_box_scores`")  # 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}/BoxScores/{season}/{week}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsBoxScore]',  # 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 legacy_box_scores_active(self, format, **kwargs):  # noqa: E501
        """Legacy Box Scores Active  # noqa: E501

        This method returns box scores for all games that are either in-progress or have been updated within the last 30 minutes.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.legacy_box_scores_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[NflStatsBoxScore]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.legacy_box_scores_active_with_http_info(format, **kwargs)  # noqa: E501
        else:
            (data) = self.legacy_box_scores_active_with_http_info(format, **kwargs)  # noqa: E501
            return data

    def legacy_box_scores_active_with_http_info(self, format, **kwargs):  # noqa: E501
        """Legacy Box Scores Active  # noqa: E501

        This method returns box scores for all games that are either in-progress or have been updated within the last 30 minutes.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.legacy_box_scores_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[NflStatsBoxScore]
                 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 legacy_box_scores_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 `legacy_box_scores_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}/ActiveBoxScores', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsBoxScore]',  # 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 legacy_box_scores_delta(self, format, season, week, minutes, **kwargs):  # noqa: E501
        """Legacy Box Scores Delta  # noqa: E501

        This method returns all box scores for a given season and week, but only returns player stats that have changed in the last X minutes.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.legacy_box_scores_delta(format, season, week, minutes, 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>2015REG</code>, <code>2015PRE</code>, <code>2015POST</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>          (required)
        :param str minutes: Only returns player statistics that have changed in the last X minutes.  You specify how many minutes in time to go back.  Valid entries are:<br>           <code>1</code> or <code>2</code>.          (required)
        :return: list[NflStatsBoxScore]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.legacy_box_scores_delta_with_http_info(format, season, week, minutes, **kwargs)  # noqa: E501
        else:
            (data) = self.legacy_box_scores_delta_with_http_info(format, season, week, minutes, **kwargs)  # noqa: E501
            return data

    def legacy_box_scores_delta_with_http_info(self, format, season, week, minutes, **kwargs):  # noqa: E501
        """Legacy Box Scores Delta  # noqa: E501

        This method returns all box scores for a given season and week, but only returns player stats that have changed in the last X minutes.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.legacy_box_scores_delta_with_http_info(format, season, week, minutes, 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>2015REG</code>, <code>2015PRE</code>, <code>2015POST</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>          (required)
        :param str minutes: Only returns player statistics that have changed in the last X minutes.  You specify how many minutes in time to go back.  Valid entries are:<br>           <code>1</code> or <code>2</code>.          (required)
        :return: list[NflStatsBoxScore]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['format', 'season', 'week', 'minutes']  # 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 legacy_box_scores_delta" % 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 `legacy_box_scores_delta`")  # 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 `legacy_box_scores_delta`")  # 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 `legacy_box_scores_delta`")  # noqa: E501
        # verify the required parameter 'minutes' is set
        if ('minutes' not in params or
                params['minutes'] is None):
            raise ValueError("Missing the required parameter `minutes` when calling `legacy_box_scores_delta`")  # 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 'minutes' in params:
            path_params['minutes'] = params['minutes']  # 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}/BoxScoresDelta/{season}/{week}/{minutes}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsBoxScore]',  # 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 legacy_box_scores_delta_current_week(self, format, minutes, **kwargs):  # noqa: E501
        """Legacy Box Scores Delta (Current 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.legacy_box_scores_delta_current_week(format, minutes, 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 minutes: Only returns player statistics that have changed in the last X minutes.  You specify how many minutes in time to go back.  Valid entries are:<br>           <code>1</code> or <code>2</code>.          (required)
        :return: list[NflStatsBoxScore]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.legacy_box_scores_delta_current_week_with_http_info(format, minutes, **kwargs)  # noqa: E501
        else:
            (data) = self.legacy_box_scores_delta_current_week_with_http_info(format, minutes, **kwargs)  # noqa: E501
            return data

    def legacy_box_scores_delta_current_week_with_http_info(self, format, minutes, **kwargs):  # noqa: E501
        """Legacy Box Scores Delta (Current 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.legacy_box_scores_delta_current_week_with_http_info(format, minutes, 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 minutes: Only returns player statistics that have changed in the last X minutes.  You specify how many minutes in time to go back.  Valid entries are:<br>           <code>1</code> or <code>2</code>.          (required)
        :return: list[NflStatsBoxScore]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['format', 'minutes']  # 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 legacy_box_scores_delta_current_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 `legacy_box_scores_delta_current_week`")  # noqa: E501
        # verify the required parameter 'minutes' is set
        if ('minutes' not in params or
                params['minutes'] is None):
            raise ValueError("Missing the required parameter `minutes` when calling `legacy_box_scores_delta_current_week`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'format' in params:
            path_params['format'] = params['format']  # noqa: E501
        if 'minutes' in params:
            path_params['minutes'] = params['minutes']  # 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}/RecentlyUpdatedBoxScores/{minutes}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsBoxScore]',  # 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 legacy_box_scores_final(self, format, **kwargs):  # noqa: E501
        """Legacy Box Scores Final  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.legacy_box_scores_final(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[NflStatsBoxScore]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.legacy_box_scores_final_with_http_info(format, **kwargs)  # noqa: E501
        else:
            (data) = self.legacy_box_scores_final_with_http_info(format, **kwargs)  # noqa: E501
            return data

    def legacy_box_scores_final_with_http_info(self, format, **kwargs):  # noqa: E501
        """Legacy Box Scores Final  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.legacy_box_scores_final_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[NflStatsBoxScore]
                 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 legacy_box_scores_final" % 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 `legacy_box_scores_final`")  # 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}/FinalBoxScores', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsBoxScore]',  # 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 legacy_box_scores_live(self, format, **kwargs):  # noqa: E501
        """Legacy Box Scores Live  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.legacy_box_scores_live(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[NflStatsBoxScore]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.legacy_box_scores_live_with_http_info(format, **kwargs)  # noqa: E501
        else:
            (data) = self.legacy_box_scores_live_with_http_info(format, **kwargs)  # noqa: E501
            return data

    def legacy_box_scores_live_with_http_info(self, format, **kwargs):  # noqa: E501
        """Legacy Box Scores Live  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.legacy_box_scores_live_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[NflStatsBoxScore]
                 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 legacy_box_scores_live" % 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 `legacy_box_scores_live`")  # 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}/LiveBoxScores', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsBoxScore]',  # 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 news(self, format, **kwargs):  # noqa: E501
        """News  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.news(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[NflStatsNews]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.news_with_http_info(format, **kwargs)  # noqa: E501
        else:
            (data) = self.news_with_http_info(format, **kwargs)  # noqa: E501
            return data

    def news_with_http_info(self, format, **kwargs):  # noqa: E501
        """News  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.news_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[NflStatsNews]
                 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 news" % 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 `news`")  # 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}/News', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsNews]',  # 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 news_by_date(self, format, _date, **kwargs):  # noqa: E501
        """News 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.news_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 news. <br>Examples: <code>2017-JUL-31</code>, <code>2017-SEP-01</code>. (required)
        :return: list[NflStatsNews]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.news_by_date_with_http_info(format, _date, **kwargs)  # noqa: E501
        else:
            (data) = self.news_by_date_with_http_info(format, _date, **kwargs)  # noqa: E501
            return data

    def news_by_date_with_http_info(self, format, _date, **kwargs):  # noqa: E501
        """News 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.news_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 news. <br>Examples: <code>2017-JUL-31</code>, <code>2017-SEP-01</code>. (required)
        :return: list[NflStatsNews]
                 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 news_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 `news_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 `news_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}/NewsByDate/{date}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsNews]',  # 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 news_by_player(self, format, playerid, **kwargs):  # noqa: E501
        """News 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.news_by_player(format, 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 playerid: Each NFL player has a unique ID assigned by FantasyData. Player IDs can be determined by pulling player related data. Example:<code>14257</code>. (required)
        :return: list[NflStatsNews]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.news_by_player_with_http_info(format, playerid, **kwargs)  # noqa: E501
        else:
            (data) = self.news_by_player_with_http_info(format, playerid, **kwargs)  # noqa: E501
            return data

    def news_by_player_with_http_info(self, format, playerid, **kwargs):  # noqa: E501
        """News 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.news_by_player_with_http_info(format, 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 playerid: Each NFL player has a unique ID assigned by FantasyData. Player IDs can be determined by pulling player related data. Example:<code>14257</code>. (required)
        :return: list[NflStatsNews]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['format', '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 news_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 `news_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 `news_by_player`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'format' in params:
            path_params['format'] = params['format']  # 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}/NewsByPlayerID/{playerid}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsNews]',  # 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 news_by_team(self, format, team, **kwargs):  # noqa: E501
        """News 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.news_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 the team. Example: <code>WAS</code>. (required)
        :return: list[NflStatsNews]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.news_by_team_with_http_info(format, team, **kwargs)  # noqa: E501
        else:
            (data) = self.news_by_team_with_http_info(format, team, **kwargs)  # noqa: E501
            return data

    def news_by_team_with_http_info(self, format, team, **kwargs):  # noqa: E501
        """News 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.news_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 the team. Example: <code>WAS</code>. (required)
        :return: list[NflStatsNews]
                 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 news_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 `news_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 `news_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}/NewsByTeam/{team}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsNews]',  # 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 player_details_by_available(self, format, **kwargs):  # noqa: E501
        """Player Details by Available  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.player_details_by_available(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[NflStatsPlayer]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.player_details_by_available_with_http_info(format, **kwargs)  # noqa: E501
        else:
            (data) = self.player_details_by_available_with_http_info(format, **kwargs)  # noqa: E501
            return data

    def player_details_by_available_with_http_info(self, format, **kwargs):  # noqa: E501
        """Player Details by Available  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.player_details_by_available_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[NflStatsPlayer]
                 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 player_details_by_available" % 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 `player_details_by_available`")  # 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}/Players', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsPlayer]',  # 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 player_details_by_free_agents(self, format, **kwargs):  # noqa: E501
        """Player Details by Free Agents  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.player_details_by_free_agents(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[NflStatsPlayer]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.player_details_by_free_agents_with_http_info(format, **kwargs)  # noqa: E501
        else:
            (data) = self.player_details_by_free_agents_with_http_info(format, **kwargs)  # noqa: E501
            return data

    def player_details_by_free_agents_with_http_info(self, format, **kwargs):  # noqa: E501
        """Player Details by Free Agents  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.player_details_by_free_agents_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[NflStatsPlayer]
                 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 player_details_by_free_agents" % 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 `player_details_by_free_agents`")  # 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}/FreeAgents', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsPlayer]',  # 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 player_details_by_player(self, format, playerid, **kwargs):  # noqa: E501
        """Player Details 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.player_details_by_player(format, 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 playerid: Each NFL player has a unique ID assigned by FantasyData. Player IDs can be determined by pulling player related data. Example:<code>732</code>. (required)
        :return: NflStatsPlayerDetail
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.player_details_by_player_with_http_info(format, playerid, **kwargs)  # noqa: E501
        else:
            (data) = self.player_details_by_player_with_http_info(format, playerid, **kwargs)  # noqa: E501
            return data

    def player_details_by_player_with_http_info(self, format, playerid, **kwargs):  # noqa: E501
        """Player Details 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.player_details_by_player_with_http_info(format, 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 playerid: Each NFL player has a unique ID assigned by FantasyData. Player IDs can be determined by pulling player related data. Example:<code>732</code>. (required)
        :return: NflStatsPlayerDetail
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['format', '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 player_details_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 `player_details_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 `player_details_by_player`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'format' in params:
            path_params['format'] = params['format']  # 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}/Player/{playerid}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='NflStatsPlayerDetail',  # 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 player_details_by_rookie_draft_year(self, format, season, **kwargs):  # noqa: E501
        """Player Details by Rookie Draft Year  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.player_details_by_rookie_draft_year(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>2018</code>, <code>2019</code>, etc. (required)
        :return: list[NflStatsPlayer]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.player_details_by_rookie_draft_year_with_http_info(format, season, **kwargs)  # noqa: E501
        else:
            (data) = self.player_details_by_rookie_draft_year_with_http_info(format, season, **kwargs)  # noqa: E501
            return data

    def player_details_by_rookie_draft_year_with_http_info(self, format, season, **kwargs):  # noqa: E501
        """Player Details by Rookie Draft Year  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.player_details_by_rookie_draft_year_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>2018</code>, <code>2019</code>, etc. (required)
        :return: list[NflStatsPlayer]
                 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 player_details_by_rookie_draft_year" % 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 `player_details_by_rookie_draft_year`")  # 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 `player_details_by_rookie_draft_year`")  # 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}/Rookies/{season}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsPlayer]',  # 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 player_details_by_team(self, format, team, **kwargs):  # noqa: E501
        """Player Details 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.player_details_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 the team. Example: <code>WAS</code>. (required)
        :return: list[NflStatsPlayerDetail]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.player_details_by_team_with_http_info(format, team, **kwargs)  # noqa: E501
        else:
            (data) = self.player_details_by_team_with_http_info(format, team, **kwargs)  # noqa: E501
            return data

    def player_details_by_team_with_http_info(self, format, team, **kwargs):  # noqa: E501
        """Player Details 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.player_details_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 the team. Example: <code>WAS</code>. (required)
        :return: list[NflStatsPlayerDetail]
                 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 player_details_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 `player_details_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 `player_details_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}/Players/{team}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsPlayerDetail]',  # 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 player_game_logs_by_season(self, format, season, playerid, numberofgames, **kwargs):  # noqa: E501
        """Player Game Logs 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.player_game_logs_by_season(format, season, playerid, numberofgames, 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: Season to get games from. Example <code>2019POST</code>, <code>2020</code> (required)
        :param str playerid: Unique FantasyData Player ID. Example:<code>17920</code>. (required)
        :param str numberofgames: How many games to return. Example <code>all</code>, <code>10</code>, <code>25</code> (required)
        :return: list[NflStatsPlayerGame]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.player_game_logs_by_season_with_http_info(format, season, playerid, numberofgames, **kwargs)  # noqa: E501
        else:
            (data) = self.player_game_logs_by_season_with_http_info(format, season, playerid, numberofgames, **kwargs)  # noqa: E501
            return data

    def player_game_logs_by_season_with_http_info(self, format, season, playerid, numberofgames, **kwargs):  # noqa: E501
        """Player Game Logs 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.player_game_logs_by_season_with_http_info(format, season, playerid, numberofgames, 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: Season to get games from. Example <code>2019POST</code>, <code>2020</code> (required)
        :param str playerid: Unique FantasyData Player ID. Example:<code>17920</code>. (required)
        :param str numberofgames: How many games to return. Example <code>all</code>, <code>10</code>, <code>25</code> (required)
        :return: list[NflStatsPlayerGame]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['format', 'season', 'playerid', 'numberofgames']  # 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 player_game_logs_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 `player_game_logs_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 `player_game_logs_by_season`")  # 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 `player_game_logs_by_season`")  # noqa: E501
        # verify the required parameter 'numberofgames' is set
        if ('numberofgames' not in params or
                params['numberofgames'] is None):
            raise ValueError("Missing the required parameter `numberofgames` when calling `player_game_logs_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
        if 'playerid' in params:
            path_params['playerid'] = params['playerid']  # noqa: E501
        if 'numberofgames' in params:
            path_params['numberofgames'] = params['numberofgames']  # 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}/PlayerGameStatsBySeason/{season}/{playerid}/{numberofgames}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsPlayerGame]',  # 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 player_game_red_zone_stats(self, format, season, week, **kwargs):  # noqa: E501
        """Player Game Red Zone Stats  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.player_game_red_zone_stats(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>2015REG</code>, <code>2015PRE</code>, <code>2015POST</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>          (required)
        :return: list[NflStatsPlayerGameRedZone]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.player_game_red_zone_stats_with_http_info(format, season, week, **kwargs)  # noqa: E501
        else:
            (data) = self.player_game_red_zone_stats_with_http_info(format, season, week, **kwargs)  # noqa: E501
            return data

    def player_game_red_zone_stats_with_http_info(self, format, season, week, **kwargs):  # noqa: E501
        """Player Game Red Zone Stats  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.player_game_red_zone_stats_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>2015REG</code>, <code>2015PRE</code>, <code>2015POST</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>          (required)
        :return: list[NflStatsPlayerGameRedZone]
                 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 player_game_red_zone_stats" % 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 `player_game_red_zone_stats`")  # 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 `player_game_red_zone_stats`")  # 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 `player_game_red_zone_stats`")  # 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}/PlayerGameRedZoneStats/{season}/{week}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsPlayerGameRedZone]',  # 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 player_game_red_zone_stats_inside_five(self, format, season, week, **kwargs):  # noqa: E501
        """Player Game Red Zone Stats Inside Five  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.player_game_red_zone_stats_inside_five(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>2015REG</code>, <code>2015PRE</code>, <code>2015POST</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>          (required)
        :return: list[NflStatsPlayerGameRedZone]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.player_game_red_zone_stats_inside_five_with_http_info(format, season, week, **kwargs)  # noqa: E501
        else:
            (data) = self.player_game_red_zone_stats_inside_five_with_http_info(format, season, week, **kwargs)  # noqa: E501
            return data

    def player_game_red_zone_stats_inside_five_with_http_info(self, format, season, week, **kwargs):  # noqa: E501
        """Player Game Red Zone Stats Inside Five  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.player_game_red_zone_stats_inside_five_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>2015REG</code>, <code>2015PRE</code>, <code>2015POST</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>          (required)
        :return: list[NflStatsPlayerGameRedZone]
                 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 player_game_red_zone_stats_inside_five" % 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 `player_game_red_zone_stats_inside_five`")  # 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 `player_game_red_zone_stats_inside_five`")  # 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 `player_game_red_zone_stats_inside_five`")  # 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}/PlayerGameRedZoneInsideFiveStats/{season}/{week}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsPlayerGameRedZone]',  # 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 player_game_red_zone_stats_inside_ten(self, format, season, week, **kwargs):  # noqa: E501
        """Player Game Red Zone Stats Inside Ten  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.player_game_red_zone_stats_inside_ten(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>2015REG</code>, <code>2015PRE</code>, <code>2015POST</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>          (required)
        :return: list[NflStatsPlayerGameRedZone]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.player_game_red_zone_stats_inside_ten_with_http_info(format, season, week, **kwargs)  # noqa: E501
        else:
            (data) = self.player_game_red_zone_stats_inside_ten_with_http_info(format, season, week, **kwargs)  # noqa: E501
            return data

    def player_game_red_zone_stats_inside_ten_with_http_info(self, format, season, week, **kwargs):  # noqa: E501
        """Player Game Red Zone Stats Inside Ten  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.player_game_red_zone_stats_inside_ten_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>2015REG</code>, <code>2015PRE</code>, <code>2015POST</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>          (required)
        :return: list[NflStatsPlayerGameRedZone]
                 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 player_game_red_zone_stats_inside_ten" % 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 `player_game_red_zone_stats_inside_ten`")  # 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 `player_game_red_zone_stats_inside_ten`")  # 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 `player_game_red_zone_stats_inside_ten`")  # 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}/PlayerGameRedZoneInsideTenStats/{season}/{week}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsPlayerGameRedZone]',  # 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 player_game_stats_by_player(self, format, season, week, playerid, **kwargs):  # noqa: E501
        """Player Game Stats 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.player_game_stats_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>2015REG</code>, <code>2015PRE</code>, <code>2015POST</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>          (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>732</code>. (required)
        :return: NflStatsPlayerGame
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.player_game_stats_by_player_with_http_info(format, season, week, playerid, **kwargs)  # noqa: E501
        else:
            (data) = self.player_game_stats_by_player_with_http_info(format, season, week, playerid, **kwargs)  # noqa: E501
            return data

    def player_game_stats_by_player_with_http_info(self, format, season, week, playerid, **kwargs):  # noqa: E501
        """Player Game Stats 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.player_game_stats_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>2015REG</code>, <code>2015PRE</code>, <code>2015POST</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>          (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>732</code>. (required)
        :return: NflStatsPlayerGame
                 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 player_game_stats_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 `player_game_stats_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 `player_game_stats_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 `player_game_stats_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 `player_game_stats_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}/PlayerGameStatsByPlayerID/{season}/{week}/{playerid}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='NflStatsPlayerGame',  # 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 player_game_stats_by_team(self, format, season, week, team, **kwargs):  # noqa: E501
        """Player Game Stats 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.player_game_stats_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>2015REG</code>, <code>2015PRE</code>, <code>2015POST</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>          (required)
        :param str team: Abbreviation of the team. Example: <code>WAS</code>. (required)
        :return: list[NflStatsPlayerGame]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.player_game_stats_by_team_with_http_info(format, season, week, team, **kwargs)  # noqa: E501
        else:
            (data) = self.player_game_stats_by_team_with_http_info(format, season, week, team, **kwargs)  # noqa: E501
            return data

    def player_game_stats_by_team_with_http_info(self, format, season, week, team, **kwargs):  # noqa: E501
        """Player Game Stats 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.player_game_stats_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>2015REG</code>, <code>2015PRE</code>, <code>2015POST</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>          (required)
        :param str team: Abbreviation of the team. Example: <code>WAS</code>. (required)
        :return: list[NflStatsPlayerGame]
                 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 player_game_stats_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 `player_game_stats_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 `player_game_stats_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 `player_game_stats_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 `player_game_stats_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}/PlayerGameStatsByTeam/{season}/{week}/{team}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsPlayerGame]',  # 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 player_game_stats_by_week(self, format, season, week, **kwargs):  # noqa: E501
        """Player Game Stats 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.player_game_stats_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>2015REG</code>, <code>2015PRE</code>, <code>2015POST</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>          (required)
        :return: list[NflStatsPlayerGame]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.player_game_stats_by_week_with_http_info(format, season, week, **kwargs)  # noqa: E501
        else:
            (data) = self.player_game_stats_by_week_with_http_info(format, season, week, **kwargs)  # noqa: E501
            return data

    def player_game_stats_by_week_with_http_info(self, format, season, week, **kwargs):  # noqa: E501
        """Player Game Stats 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.player_game_stats_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>2015REG</code>, <code>2015PRE</code>, <code>2015POST</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>          (required)
        :return: list[NflStatsPlayerGame]
                 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 player_game_stats_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 `player_game_stats_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 `player_game_stats_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 `player_game_stats_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}/PlayerGameStatsByWeek/{season}/{week}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsPlayerGame]',  # 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 player_game_stats_by_week_delta(self, format, season, week, minutes, **kwargs):  # noqa: E501
        """Player Game Stats by Week Delta  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.player_game_stats_by_week_delta(format, season, week, minutes, 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>2015REG</code>, <code>2015PRE</code>, <code>2015POST</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>          (required)
        :param str minutes: Only returns player statistics that have changed in the last X minutes.  You specify how many minutes in time to go back.  Valid entries are:<br>           <code>1</code> or <code>2</code>.          (required)
        :return: list[NflStatsPlayerGame]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.player_game_stats_by_week_delta_with_http_info(format, season, week, minutes, **kwargs)  # noqa: E501
        else:
            (data) = self.player_game_stats_by_week_delta_with_http_info(format, season, week, minutes, **kwargs)  # noqa: E501
            return data

    def player_game_stats_by_week_delta_with_http_info(self, format, season, week, minutes, **kwargs):  # noqa: E501
        """Player Game Stats by Week Delta  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.player_game_stats_by_week_delta_with_http_info(format, season, week, minutes, 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>2015REG</code>, <code>2015PRE</code>, <code>2015POST</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>          (required)
        :param str minutes: Only returns player statistics that have changed in the last X minutes.  You specify how many minutes in time to go back.  Valid entries are:<br>           <code>1</code> or <code>2</code>.          (required)
        :return: list[NflStatsPlayerGame]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['format', 'season', 'week', 'minutes']  # 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 player_game_stats_by_week_delta" % 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 `player_game_stats_by_week_delta`")  # 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 `player_game_stats_by_week_delta`")  # 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 `player_game_stats_by_week_delta`")  # noqa: E501
        # verify the required parameter 'minutes' is set
        if ('minutes' not in params or
                params['minutes'] is None):
            raise ValueError("Missing the required parameter `minutes` when calling `player_game_stats_by_week_delta`")  # 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 'minutes' in params:
            path_params['minutes'] = params['minutes']  # 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}/PlayerGameStatsByWeekDelta/{season}/{week}/{minutes}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsPlayerGame]',  # 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 player_game_stats_delta(self, format, minutes, **kwargs):  # noqa: E501
        """Player Game Stats Delta  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.player_game_stats_delta(format, minutes, 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 minutes:            Only returns player statistics that have changed in the last X minutes.  You specify how many minutes in time to go back.  Valid entries are:           <code>1</code> or <code>2</code>.          (required)
        :return: list[NflStatsPlayerGame]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.player_game_stats_delta_with_http_info(format, minutes, **kwargs)  # noqa: E501
        else:
            (data) = self.player_game_stats_delta_with_http_info(format, minutes, **kwargs)  # noqa: E501
            return data

    def player_game_stats_delta_with_http_info(self, format, minutes, **kwargs):  # noqa: E501
        """Player Game Stats Delta  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.player_game_stats_delta_with_http_info(format, minutes, 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 minutes:            Only returns player statistics that have changed in the last X minutes.  You specify how many minutes in time to go back.  Valid entries are:           <code>1</code> or <code>2</code>.          (required)
        :return: list[NflStatsPlayerGame]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['format', 'minutes']  # 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 player_game_stats_delta" % 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 `player_game_stats_delta`")  # noqa: E501
        # verify the required parameter 'minutes' is set
        if ('minutes' not in params or
                params['minutes'] is None):
            raise ValueError("Missing the required parameter `minutes` when calling `player_game_stats_delta`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'format' in params:
            path_params['format'] = params['format']  # noqa: E501
        if 'minutes' in params:
            path_params['minutes'] = params['minutes']  # 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}/PlayerGameStatsDelta/{minutes}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsPlayerGame]',  # 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 player_season_red_zone_stats(self, format, season, **kwargs):  # noqa: E501
        """Player Season Red Zone Stats  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.player_season_red_zone_stats(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 and the season type. If no season type is provided, then the default is regular season.           <br>Examples: <code>2015REG</code>, <code>2015PRE</code>, <code>2015POST</code>.          (required)
        :return: list[NflStatsPlayerSeasonRedZone]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.player_season_red_zone_stats_with_http_info(format, season, **kwargs)  # noqa: E501
        else:
            (data) = self.player_season_red_zone_stats_with_http_info(format, season, **kwargs)  # noqa: E501
            return data

    def player_season_red_zone_stats_with_http_info(self, format, season, **kwargs):  # noqa: E501
        """Player Season Red Zone Stats  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.player_season_red_zone_stats_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 and the season type. If no season type is provided, then the default is regular season.           <br>Examples: <code>2015REG</code>, <code>2015PRE</code>, <code>2015POST</code>.          (required)
        :return: list[NflStatsPlayerSeasonRedZone]
                 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 player_season_red_zone_stats" % 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 `player_season_red_zone_stats`")  # 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 `player_season_red_zone_stats`")  # 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}/PlayerSeasonRedZoneStats/{season}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsPlayerSeasonRedZone]',  # 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 player_season_red_zone_stats_inside_five(self, format, season, **kwargs):  # noqa: E501
        """Player Season Red Zone Stats Inside Five  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.player_season_red_zone_stats_inside_five(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 and the season type. If no season type is provided, then the default is regular season.           <br>Examples: <code>2015REG</code>, <code>2015PRE</code>, <code>2015POST</code>.          (required)
        :return: list[NflStatsPlayerSeasonRedZone]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.player_season_red_zone_stats_inside_five_with_http_info(format, season, **kwargs)  # noqa: E501
        else:
            (data) = self.player_season_red_zone_stats_inside_five_with_http_info(format, season, **kwargs)  # noqa: E501
            return data

    def player_season_red_zone_stats_inside_five_with_http_info(self, format, season, **kwargs):  # noqa: E501
        """Player Season Red Zone Stats Inside Five  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.player_season_red_zone_stats_inside_five_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 and the season type. If no season type is provided, then the default is regular season.           <br>Examples: <code>2015REG</code>, <code>2015PRE</code>, <code>2015POST</code>.          (required)
        :return: list[NflStatsPlayerSeasonRedZone]
                 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 player_season_red_zone_stats_inside_five" % 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 `player_season_red_zone_stats_inside_five`")  # 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 `player_season_red_zone_stats_inside_five`")  # 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}/PlayerSeasonRedZoneInsideFiveStats/{season}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsPlayerSeasonRedZone]',  # 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 player_season_red_zone_stats_inside_ten(self, format, season, **kwargs):  # noqa: E501
        """Player Season Red Zone Stats Inside Ten  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.player_season_red_zone_stats_inside_ten(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 and the season type. If no season type is provided, then the default is regular season.           <br>Examples: <code>2015REG</code>, <code>2015PRE</code>, <code>2015POST</code>.          (required)
        :return: list[NflStatsPlayerSeasonRedZone]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.player_season_red_zone_stats_inside_ten_with_http_info(format, season, **kwargs)  # noqa: E501
        else:
            (data) = self.player_season_red_zone_stats_inside_ten_with_http_info(format, season, **kwargs)  # noqa: E501
            return data

    def player_season_red_zone_stats_inside_ten_with_http_info(self, format, season, **kwargs):  # noqa: E501
        """Player Season Red Zone Stats Inside Ten  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.player_season_red_zone_stats_inside_ten_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 and the season type. If no season type is provided, then the default is regular season.           <br>Examples: <code>2015REG</code>, <code>2015PRE</code>, <code>2015POST</code>.          (required)
        :return: list[NflStatsPlayerSeasonRedZone]
                 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 player_season_red_zone_stats_inside_ten" % 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 `player_season_red_zone_stats_inside_ten`")  # 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 `player_season_red_zone_stats_inside_ten`")  # 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}/PlayerSeasonRedZoneInsideTenStats/{season}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsPlayerSeasonRedZone]',  # 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 player_season_stats(self, format, season, **kwargs):  # noqa: E501
        """Player Season Stats  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.player_season_stats(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 and the season type. If no season type is provided, then the default is regular season.           <br>Examples: <code>2015REG</code>, <code>2015PRE</code>, <code>2015POST</code>.          (required)
        :return: list[NflStatsPlayerSeason]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.player_season_stats_with_http_info(format, season, **kwargs)  # noqa: E501
        else:
            (data) = self.player_season_stats_with_http_info(format, season, **kwargs)  # noqa: E501
            return data

    def player_season_stats_with_http_info(self, format, season, **kwargs):  # noqa: E501
        """Player Season Stats  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.player_season_stats_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 and the season type. If no season type is provided, then the default is regular season.           <br>Examples: <code>2015REG</code>, <code>2015PRE</code>, <code>2015POST</code>.          (required)
        :return: list[NflStatsPlayerSeason]
                 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 player_season_stats" % 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 `player_season_stats`")  # 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 `player_season_stats`")  # 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}/PlayerSeasonStats/{season}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsPlayerSeason]',  # 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 player_season_stats_by_player(self, format, season, playerid, **kwargs):  # noqa: E501
        """Player Season Stats 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.player_season_stats_by_player(format, season, 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>2015REG</code>, <code>2015PRE</code>, <code>2015POST</code>.          (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>732</code>. (required)
        :return: list[NflStatsPlayerSeason]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.player_season_stats_by_player_with_http_info(format, season, playerid, **kwargs)  # noqa: E501
        else:
            (data) = self.player_season_stats_by_player_with_http_info(format, season, playerid, **kwargs)  # noqa: E501
            return data

    def player_season_stats_by_player_with_http_info(self, format, season, playerid, **kwargs):  # noqa: E501
        """Player Season Stats 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.player_season_stats_by_player_with_http_info(format, season, 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>2015REG</code>, <code>2015PRE</code>, <code>2015POST</code>.          (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>732</code>. (required)
        :return: list[NflStatsPlayerSeason]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['format', 'season', '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 player_season_stats_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 `player_season_stats_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 `player_season_stats_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 `player_season_stats_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 '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}/PlayerSeasonStatsByPlayerID/{season}/{playerid}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsPlayerSeason]',  # 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 player_season_stats_by_team(self, format, season, team, **kwargs):  # noqa: E501
        """Player Season Stats 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.player_season_stats_by_team(format, season, 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>2015REG</code>, <code>2015PRE</code>, <code>2015POST</code>.          (required)
        :param str team: Abbreviation of the team. Example: <code>WAS</code>. (required)
        :return: list[NflStatsPlayerSeason]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.player_season_stats_by_team_with_http_info(format, season, team, **kwargs)  # noqa: E501
        else:
            (data) = self.player_season_stats_by_team_with_http_info(format, season, team, **kwargs)  # noqa: E501
            return data

    def player_season_stats_by_team_with_http_info(self, format, season, team, **kwargs):  # noqa: E501
        """Player Season Stats 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.player_season_stats_by_team_with_http_info(format, season, 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>2015REG</code>, <code>2015PRE</code>, <code>2015POST</code>.          (required)
        :param str team: Abbreviation of the team. Example: <code>WAS</code>. (required)
        :return: list[NflStatsPlayerSeason]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['format', 'season', '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 player_season_stats_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 `player_season_stats_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 `player_season_stats_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 `player_season_stats_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 '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}/PlayerSeasonStatsByTeam/{season}/{team}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsPlayerSeason]',  # 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 player_season_third_down_stats(self, format, season, **kwargs):  # noqa: E501
        """Player Season Third Down Stats  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.player_season_third_down_stats(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 and the season type. If no season type is provided, then the default is regular season.           <br>Examples: <code>2015REG</code>, <code>2015PRE</code>, <code>2015POST</code>.          (required)
        :return: list[NflStatsPlayerSeasonThirdDown]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.player_season_third_down_stats_with_http_info(format, season, **kwargs)  # noqa: E501
        else:
            (data) = self.player_season_third_down_stats_with_http_info(format, season, **kwargs)  # noqa: E501
            return data

    def player_season_third_down_stats_with_http_info(self, format, season, **kwargs):  # noqa: E501
        """Player Season Third Down Stats  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.player_season_third_down_stats_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 and the season type. If no season type is provided, then the default is regular season.           <br>Examples: <code>2015REG</code>, <code>2015PRE</code>, <code>2015POST</code>.          (required)
        :return: list[NflStatsPlayerSeasonThirdDown]
                 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 player_season_third_down_stats" % 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 `player_season_third_down_stats`")  # 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 `player_season_third_down_stats`")  # 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}/PlayerSeasonThirdDownStats/{season}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsPlayerSeasonThirdDown]',  # 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 pro_bowlers(self, format, season, **kwargs):  # noqa: E501
        """Pro Bowlers  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.pro_bowlers(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>2016</code>, <code>2017</code> (required)
        :return: list[NflStatsPlayerInfo]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.pro_bowlers_with_http_info(format, season, **kwargs)  # noqa: E501
        else:
            (data) = self.pro_bowlers_with_http_info(format, season, **kwargs)  # noqa: E501
            return data

    def pro_bowlers_with_http_info(self, format, season, **kwargs):  # noqa: E501
        """Pro Bowlers  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.pro_bowlers_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>2016</code>, <code>2017</code> (required)
        :return: list[NflStatsPlayerInfo]
                 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 pro_bowlers" % 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 `pro_bowlers`")  # 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 `pro_bowlers`")  # 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}/ProBowlers/{season}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsPlayerInfo]',  # 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 schedule(self, format, season, **kwargs):  # noqa: E501
        """Schedule  # noqa: E501

        Game schedule for a specified 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.schedule(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>2018</code>, <code>2018PRE</code>, <code>2018POST</code>, <code>2018STAR</code>, <code>2019</code>, etc. (required)
        :return: list[NflStatsSchedule]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.schedule_with_http_info(format, season, **kwargs)  # noqa: E501
        else:
            (data) = self.schedule_with_http_info(format, season, **kwargs)  # noqa: E501
            return data

    def schedule_with_http_info(self, format, season, **kwargs):  # noqa: E501
        """Schedule  # noqa: E501

        Game schedule for a specified 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.schedule_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>2018</code>, <code>2018PRE</code>, <code>2018POST</code>, <code>2018STAR</code>, <code>2019</code>, etc. (required)
        :return: list[NflStatsSchedule]
                 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 schedule" % 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 `schedule`")  # 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 `schedule`")  # 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}/Schedules/{season}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsSchedule]',  # 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 scores_by_date(self, format, _date, **kwargs):  # noqa: E501
        """Scores by Date  # noqa: E501

        Get game scores for a specified week of a 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.scores_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 games.<br>Examples: <code>2021-SEP-12</code>, <code>2021-NOV-28</code>. (required)
        :return: list[NflStatsScore]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.scores_by_date_with_http_info(format, _date, **kwargs)  # noqa: E501
        else:
            (data) = self.scores_by_date_with_http_info(format, _date, **kwargs)  # noqa: E501
            return data

    def scores_by_date_with_http_info(self, format, _date, **kwargs):  # noqa: E501
        """Scores by Date  # noqa: E501

        Get game scores for a specified week of a 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.scores_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 games.<br>Examples: <code>2021-SEP-12</code>, <code>2021-NOV-28</code>. (required)
        :return: list[NflStatsScore]
                 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 scores_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 `scores_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 `scores_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}/ScoresByDate/{date}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsScore]',  # 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 scores_by_season(self, format, season, **kwargs):  # noqa: E501
        """Scores by Season   # noqa: E501

        Game scores for a specified 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.scores_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>2018</code>, <code>2018PRE</code>, <code>2018POST</code>, <code>2018STAR</code>, <code>2019</code>, etc. (required)
        :return: list[NflStatsScore]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.scores_by_season_with_http_info(format, season, **kwargs)  # noqa: E501
        else:
            (data) = self.scores_by_season_with_http_info(format, season, **kwargs)  # noqa: E501
            return data

    def scores_by_season_with_http_info(self, format, season, **kwargs):  # noqa: E501
        """Scores by Season   # noqa: E501

        Game scores for a specified 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.scores_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>2018</code>, <code>2018PRE</code>, <code>2018POST</code>, <code>2018STAR</code>, <code>2019</code>, etc. (required)
        :return: list[NflStatsScore]
                 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 scores_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 `scores_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 `scores_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}/Scores/{season}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsScore]',  # 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 scores_by_week(self, format, season, week, **kwargs):  # noqa: E501
        """Scores by Week  # noqa: E501

        Get game scores for a specified week of a 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.scores_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>2015REG</code>, <code>2015PRE</code>, <code>2015POST</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>          (required)
        :return: list[NflStatsScore]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.scores_by_week_with_http_info(format, season, week, **kwargs)  # noqa: E501
        else:
            (data) = self.scores_by_week_with_http_info(format, season, week, **kwargs)  # noqa: E501
            return data

    def scores_by_week_with_http_info(self, format, season, week, **kwargs):  # noqa: E501
        """Scores by Week  # noqa: E501

        Get game scores for a specified week of a 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.scores_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>2015REG</code>, <code>2015PRE</code>, <code>2015POST</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>          (required)
        :return: list[NflStatsScore]
                 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 scores_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 `scores_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 `scores_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 `scores_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}/ScoresByWeek/{season}/{week}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsScore]',  # 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 scores_by_week_simulation(self, format, numberofplays, **kwargs):  # noqa: E501
        """Scores by Week Simulation  # noqa: E501

        Gets simulated live scores of NFL games, covering the Conference Championship games on January 21, 2018.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.scores_by_week_simulation(format, numberofplays, 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 numberofplays: The number of plays to progress in this NFL live game simulation. Example entries are <code>0</code>, <code>1</code>, <code>2</code>, <code>3</code>, <code>150</code>, <code>200</code>, etc. (required)
        :return: list[NflStatsScore]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.scores_by_week_simulation_with_http_info(format, numberofplays, **kwargs)  # noqa: E501
        else:
            (data) = self.scores_by_week_simulation_with_http_info(format, numberofplays, **kwargs)  # noqa: E501
            return data

    def scores_by_week_simulation_with_http_info(self, format, numberofplays, **kwargs):  # noqa: E501
        """Scores by Week Simulation  # noqa: E501

        Gets simulated live scores of NFL games, covering the Conference Championship games on January 21, 2018.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.scores_by_week_simulation_with_http_info(format, numberofplays, 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 numberofplays: The number of plays to progress in this NFL live game simulation. Example entries are <code>0</code>, <code>1</code>, <code>2</code>, <code>3</code>, <code>150</code>, <code>200</code>, etc. (required)
        :return: list[NflStatsScore]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['format', 'numberofplays']  # 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 scores_by_week_simulation" % 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 `scores_by_week_simulation`")  # noqa: E501
        # verify the required parameter 'numberofplays' is set
        if ('numberofplays' not in params or
                params['numberofplays'] is None):
            raise ValueError("Missing the required parameter `numberofplays` when calling `scores_by_week_simulation`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'format' in params:
            path_params['format'] = params['format']  # noqa: E501
        if 'numberofplays' in params:
            path_params['numberofplays'] = params['numberofplays']  # 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}/SimulatedScores/{numberofplays}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsScore]',  # 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 season_current(self, format, **kwargs):  # noqa: E501
        """Season Current  # noqa: E501

        Year of the current NFL season. This value changes on July 1st. The earliest season for Fantasy data is 2001. The earliest season for Team data is 1985. The earliest season for Fantasy data is 2001. The earliest season for Team data is 1985.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.season_current(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: int
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.season_current_with_http_info(format, **kwargs)  # noqa: E501
        else:
            (data) = self.season_current_with_http_info(format, **kwargs)  # noqa: E501
            return data

    def season_current_with_http_info(self, format, **kwargs):  # noqa: E501
        """Season Current  # noqa: E501

        Year of the current NFL season. This value changes on July 1st. The earliest season for Fantasy data is 2001. The earliest season for Team data is 1985. The earliest season for Fantasy data is 2001. The earliest season for Team data is 1985.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.season_current_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: int
                 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 season_current" % 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 `season_current`")  # 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}/CurrentSeason', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='int',  # 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 season_last_completed(self, format, **kwargs):  # noqa: E501
        """Season Last Completed  # noqa: E501

        Year of the most recently completed season. this value changes immediately after the Super Bowl. The earliest season for Fantasy data is 2001. The earliest season for Team data is 1985.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.season_last_completed(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: int
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.season_last_completed_with_http_info(format, **kwargs)  # noqa: E501
        else:
            (data) = self.season_last_completed_with_http_info(format, **kwargs)  # noqa: E501
            return data

    def season_last_completed_with_http_info(self, format, **kwargs):  # noqa: E501
        """Season Last Completed  # noqa: E501

        Year of the most recently completed season. this value changes immediately after the Super Bowl. The earliest season for Fantasy data is 2001. The earliest season for Team data is 1985.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.season_last_completed_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: int
                 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 season_last_completed" % 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 `season_last_completed`")  # 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}/LastCompletedSeason', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='int',  # 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 season_upcoming(self, format, **kwargs):  # noqa: E501
        """Season Upcoming  # noqa: E501

        Year of the current NFL season, if we are in the mid-season. If we are in the off-season, then year of the next upcoming season. This value changes immediately after the Super Bowl. The earliest season for Fantasy data is 2001. The earliest season for Team data is 1985.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.season_upcoming(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: int
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.season_upcoming_with_http_info(format, **kwargs)  # noqa: E501
        else:
            (data) = self.season_upcoming_with_http_info(format, **kwargs)  # noqa: E501
            return data

    def season_upcoming_with_http_info(self, format, **kwargs):  # noqa: E501
        """Season Upcoming  # noqa: E501

        Year of the current NFL season, if we are in the mid-season. If we are in the off-season, then year of the next upcoming season. This value changes immediately after the Super Bowl. The earliest season for Fantasy data is 2001. The earliest season for Team data is 1985.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.season_upcoming_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: int
                 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 season_upcoming" % 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 `season_upcoming`")  # 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}/UpcomingSeason', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='int',  # 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 stadiums(self, format, **kwargs):  # noqa: E501
        """Stadiums  # noqa: E501

        This method returns all stadiums.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.stadiums(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[NflStatsStadium]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.stadiums_with_http_info(format, **kwargs)  # noqa: E501
        else:
            (data) = self.stadiums_with_http_info(format, **kwargs)  # noqa: E501
            return data

    def stadiums_with_http_info(self, format, **kwargs):  # noqa: E501
        """Stadiums  # noqa: E501

        This method returns all stadiums.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.stadiums_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[NflStatsStadium]
                 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 stadiums" % 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 `stadiums`")  # 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}/Stadiums', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsStadium]',  # 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 standings(self, format, season, **kwargs):  # noqa: E501
        """Standings  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.standings(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 and the season type. If no season type is provided, then the default is regular season.           <br>Examples: <code>2015REG</code>, <code>2015PRE</code>, <code>2015POST</code>.          (required)
        :return: list[NflStatsStanding]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.standings_with_http_info(format, season, **kwargs)  # noqa: E501
        else:
            (data) = self.standings_with_http_info(format, season, **kwargs)  # noqa: E501
            return data

    def standings_with_http_info(self, format, season, **kwargs):  # noqa: E501
        """Standings  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.standings_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 and the season type. If no season type is provided, then the default is regular season.           <br>Examples: <code>2015REG</code>, <code>2015PRE</code>, <code>2015POST</code>.          (required)
        :return: list[NflStatsStanding]
                 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 standings" % 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 `standings`")  # 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 `standings`")  # 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}/Standings/{season}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsStanding]',  # 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 team_game_stats(self, format, season, week, **kwargs):  # noqa: E501
        """Team Game Stats  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.team_game_stats(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>2015REG</code>, <code>2015PRE</code>, <code>2015POST</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>          (required)
        :return: list[NflStatsTeamGame]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.team_game_stats_with_http_info(format, season, week, **kwargs)  # noqa: E501
        else:
            (data) = self.team_game_stats_with_http_info(format, season, week, **kwargs)  # noqa: E501
            return data

    def team_game_stats_with_http_info(self, format, season, week, **kwargs):  # noqa: E501
        """Team Game Stats  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.team_game_stats_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>2015REG</code>, <code>2015PRE</code>, <code>2015POST</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>          (required)
        :return: list[NflStatsTeamGame]
                 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 team_game_stats" % 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 `team_game_stats`")  # 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 `team_game_stats`")  # 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 `team_game_stats`")  # 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}/TeamGameStats/{season}/{week}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsTeamGame]',  # 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 team_season_stats(self, format, season, **kwargs):  # noqa: E501
        """Team Season Stats  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.team_season_stats(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 and the season type. If no season type is provided, then the default is regular season.           <br>Examples: <code>2015REG</code>, <code>2015PRE</code>, <code>2015POST</code>.          (required)
        :return: list[NflStatsTeamSeason]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.team_season_stats_with_http_info(format, season, **kwargs)  # noqa: E501
        else:
            (data) = self.team_season_stats_with_http_info(format, season, **kwargs)  # noqa: E501
            return data

    def team_season_stats_with_http_info(self, format, season, **kwargs):  # noqa: E501
        """Team Season Stats  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.team_season_stats_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 and the season type. If no season type is provided, then the default is regular season.           <br>Examples: <code>2015REG</code>, <code>2015PRE</code>, <code>2015POST</code>.          (required)
        :return: list[NflStatsTeamSeason]
                 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 team_season_stats" % 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 `team_season_stats`")  # 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 `team_season_stats`")  # 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}/TeamSeasonStats/{season}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsTeamSeason]',  # 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 teams_active(self, format, **kwargs):  # noqa: E501
        """Teams (Active)  # noqa: E501

        Gets all active teams.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.teams_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[NflStatsTeam]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.teams_active_with_http_info(format, **kwargs)  # noqa: E501
        else:
            (data) = self.teams_active_with_http_info(format, **kwargs)  # noqa: E501
            return data

    def teams_active_with_http_info(self, format, **kwargs):  # noqa: E501
        """Teams (Active)  # noqa: E501

        Gets all active teams.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.teams_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[NflStatsTeam]
                 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 teams_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 `teams_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}/Teams', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsTeam]',  # 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 teams_all(self, format, **kwargs):  # noqa: E501
        """Teams (All)  # noqa: E501

        Gets all teams, including pro bowl teams.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.teams_all(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[NflStatsTeam]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.teams_all_with_http_info(format, **kwargs)  # noqa: E501
        else:
            (data) = self.teams_all_with_http_info(format, **kwargs)  # noqa: E501
            return data

    def teams_all_with_http_info(self, format, **kwargs):  # noqa: E501
        """Teams (All)  # noqa: E501

        Gets all teams, including pro bowl teams.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.teams_all_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[NflStatsTeam]
                 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 teams_all" % 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 `teams_all`")  # 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}/AllTeams', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsTeam]',  # 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 teams_by_season(self, format, season, **kwargs):  # noqa: E501
        """Teams by Season  # noqa: E501

        List of teams playing in a specified 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.teams_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 and the season type. If no season type is provided, then the default is regular season.           <br>Examples: <code>2015REG</code>, <code>2015PRE</code>, <code>2015POST</code>.          (required)
        :return: list[NflStatsTeam]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.teams_by_season_with_http_info(format, season, **kwargs)  # noqa: E501
        else:
            (data) = self.teams_by_season_with_http_info(format, season, **kwargs)  # noqa: E501
            return data

    def teams_by_season_with_http_info(self, format, season, **kwargs):  # noqa: E501
        """Teams by Season  # noqa: E501

        List of teams playing in a specified 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.teams_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 and the season type. If no season type is provided, then the default is regular season.           <br>Examples: <code>2015REG</code>, <code>2015PRE</code>, <code>2015POST</code>.          (required)
        :return: list[NflStatsTeam]
                 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 teams_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 `teams_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 `teams_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}/Teams/{season}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsTeam]',  # 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 timeframes(self, format, type, **kwargs):  # noqa: E501
        """Timeframes  # noqa: E501

        Get detailed information about past, present, and future timeframes.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.timeframes(format, type, 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 type: The type of timeframes to return.  Valid entries are <code>current</code> or <code>upcoming</code> or <code>completed</code> or <code>recent</code> or <code>all</code>. (required)
        :return: list[NflStatsTimeframe]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.timeframes_with_http_info(format, type, **kwargs)  # noqa: E501
        else:
            (data) = self.timeframes_with_http_info(format, type, **kwargs)  # noqa: E501
            return data

    def timeframes_with_http_info(self, format, type, **kwargs):  # noqa: E501
        """Timeframes  # noqa: E501

        Get detailed information about past, present, and future timeframes.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.timeframes_with_http_info(format, type, 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 type: The type of timeframes to return.  Valid entries are <code>current</code> or <code>upcoming</code> or <code>completed</code> or <code>recent</code> or <code>all</code>. (required)
        :return: list[NflStatsTimeframe]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['format', 'type']  # 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 timeframes" % 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 `timeframes`")  # noqa: E501
        # verify the required parameter 'type' is set
        if ('type' not in params or
                params['type'] is None):
            raise ValueError("Missing the required parameter `type` when calling `timeframes`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'format' in params:
            path_params['format'] = params['format']  # noqa: E501
        if 'type' in params:
            path_params['type'] = params['type']  # 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}/Timeframes/{type}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflStatsTimeframe]',  # 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 week_current(self, format, **kwargs):  # noqa: E501
        """Week Current  # noqa: E501

        Number of the current week of the NFL season. This value usually changes on Tuesday nights or Wednesday mornings at midnight ET.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.week_current(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: int
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.week_current_with_http_info(format, **kwargs)  # noqa: E501
        else:
            (data) = self.week_current_with_http_info(format, **kwargs)  # noqa: E501
            return data

    def week_current_with_http_info(self, format, **kwargs):  # noqa: E501
        """Week Current  # noqa: E501

        Number of the current week of the NFL season. This value usually changes on Tuesday nights or Wednesday mornings at midnight ET.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.week_current_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: int
                 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 week_current" % 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 `week_current`")  # 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}/CurrentWeek', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='int',  # 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 week_last_completed(self, format, **kwargs):  # noqa: E501
        """Week Last Completed  # noqa: E501

        Number of the current week of the NFL season. This value usually changes on Tuesday nights or Wednesday mornings at midnight ET.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.week_last_completed(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: int
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.week_last_completed_with_http_info(format, **kwargs)  # noqa: E501
        else:
            (data) = self.week_last_completed_with_http_info(format, **kwargs)  # noqa: E501
            return data

    def week_last_completed_with_http_info(self, format, **kwargs):  # noqa: E501
        """Week Last Completed  # noqa: E501

        Number of the current week of the NFL season. This value usually changes on Tuesday nights or Wednesday mornings at midnight ET.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.week_last_completed_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: int
                 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 week_last_completed" % 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 `week_last_completed`")  # 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}/LastCompletedWeek', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='int',  # 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 week_upcoming(self, format, **kwargs):  # noqa: E501
        """Week Upcoming  # noqa: E501

        Number of the current week of the NFL season. This value usually changes on Tuesday nights or Wednesday mornings at midnight ET.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.week_upcoming(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: int
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.week_upcoming_with_http_info(format, **kwargs)  # noqa: E501
        else:
            (data) = self.week_upcoming_with_http_info(format, **kwargs)  # noqa: E501
            return data

    def week_upcoming_with_http_info(self, format, **kwargs):  # noqa: E501
        """Week Upcoming  # noqa: E501

        Number of the current week of the NFL season. This value usually changes on Tuesday nights or Wednesday mornings at midnight ET.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.week_upcoming_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: int
                 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 week_upcoming" % 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 `week_upcoming`")  # 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}/UpcomingWeek', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='int',  # 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)
