# coding: utf-8

"""
    NFL v3 Projections

    NFL projected 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_projections.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 dfs_slate_ownership_projections_by_slateid(self, format, slate_id, **kwargs):  # noqa: E501
        """DFS Slate Ownership Projections by SlateID  # noqa: E501

        Slate Ownership Projections for a specific slate. Projections are for GPP format ownership. Will return an empty list if the slate is not yet projected or not a slate we have projections for.  # 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_slate_ownership_projections_by_slateid(format, slate_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str format: Desired response format. Valid entries are <code>XML</code> or <code>JSON</code>. (required)
        :param str slate_id: SlateID of the DFS Slate you wish to get ownership projections for. Will have an empty SlateOwnershipProjections if this slate was not projected (required)
        :return: NflProjectionsDfsSlateWithOwnershipProjection
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.dfs_slate_ownership_projections_by_slateid_with_http_info(format, slate_id, **kwargs)  # noqa: E501
        else:
            (data) = self.dfs_slate_ownership_projections_by_slateid_with_http_info(format, slate_id, **kwargs)  # noqa: E501
            return data

    def dfs_slate_ownership_projections_by_slateid_with_http_info(self, format, slate_id, **kwargs):  # noqa: E501
        """DFS Slate Ownership Projections by SlateID  # noqa: E501

        Slate Ownership Projections for a specific slate. Projections are for GPP format ownership. Will return an empty list if the slate is not yet projected or not a slate we have projections for.  # 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_slate_ownership_projections_by_slateid_with_http_info(format, slate_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str format: Desired response format. Valid entries are <code>XML</code> or <code>JSON</code>. (required)
        :param str slate_id: SlateID of the DFS Slate you wish to get ownership projections for. Will have an empty SlateOwnershipProjections if this slate was not projected (required)
        :return: NflProjectionsDfsSlateWithOwnershipProjection
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method dfs_slate_ownership_projections_by_slateid" % 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_slate_ownership_projections_by_slateid`")  # noqa: E501
        # verify the required parameter 'slate_id' is set
        if ('slate_id' not in params or
                params['slate_id'] is None):
            raise ValueError("Missing the required parameter `slate_id` when calling `dfs_slate_ownership_projections_by_slateid`")  # noqa: E501

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        return self.api_client.call_api(
            '/{format}/DfsSlateOwnershipProjectionsBySlateID/{slateId}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='NflProjectionsDfsSlateWithOwnershipProjection',  # 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[NflProjectionsDfsSlate]
                 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[NflProjectionsDfsSlate]
                 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[NflProjectionsDfsSlate]',  # 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[NflProjectionsDfsSlate]
                 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[NflProjectionsDfsSlate]
                 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[NflProjectionsDfsSlate]',  # 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_projected_player_game_stats_by_player_w_injuries_lineups_dfs_salaries(self, format, season, week, playerid, **kwargs):  # noqa: E501
        """IDP Projected Player Game Stats by Player (w/ Injuries, Lineups, DFS Salaries)  # 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_projected_player_game_stats_by_player_w_injuries_lineups_dfs_salaries(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>14257</code>. (required)
        :return: NflProjectionsPlayerGameProjection
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.idp_projected_player_game_stats_by_player_w_injuries_lineups_dfs_salaries_with_http_info(format, season, week, playerid, **kwargs)  # noqa: E501
        else:
            (data) = self.idp_projected_player_game_stats_by_player_w_injuries_lineups_dfs_salaries_with_http_info(format, season, week, playerid, **kwargs)  # noqa: E501
            return data

    def idp_projected_player_game_stats_by_player_w_injuries_lineups_dfs_salaries_with_http_info(self, format, season, week, playerid, **kwargs):  # noqa: E501
        """IDP Projected Player Game Stats by Player (w/ Injuries, Lineups, DFS Salaries)  # 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_projected_player_game_stats_by_player_w_injuries_lineups_dfs_salaries_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>14257</code>. (required)
        :return: NflProjectionsPlayerGameProjection
                 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 idp_projected_player_game_stats_by_player_w_injuries_lineups_dfs_salaries" % 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_projected_player_game_stats_by_player_w_injuries_lineups_dfs_salaries`")  # 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 `idp_projected_player_game_stats_by_player_w_injuries_lineups_dfs_salaries`")  # 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 `idp_projected_player_game_stats_by_player_w_injuries_lineups_dfs_salaries`")  # 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 `idp_projected_player_game_stats_by_player_w_injuries_lineups_dfs_salaries`")  # 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}/IdpPlayerGameProjectionStatsByPlayerID/{season}/{week}/{playerid}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='NflProjectionsPlayerGameProjection',  # 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_projected_player_game_stats_by_team_w_injuries_lineups_dfs_salaries(self, format, season, week, team, **kwargs):  # noqa: E501
        """IDP Projected Player Game Stats by Team (w/ Injuries, Lineups, DFS Salaries)  # 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_projected_player_game_stats_by_team_w_injuries_lineups_dfs_salaries(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[NflProjectionsPlayerGameProjection]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.idp_projected_player_game_stats_by_team_w_injuries_lineups_dfs_salaries_with_http_info(format, season, week, team, **kwargs)  # noqa: E501
        else:
            (data) = self.idp_projected_player_game_stats_by_team_w_injuries_lineups_dfs_salaries_with_http_info(format, season, week, team, **kwargs)  # noqa: E501
            return data

    def idp_projected_player_game_stats_by_team_w_injuries_lineups_dfs_salaries_with_http_info(self, format, season, week, team, **kwargs):  # noqa: E501
        """IDP Projected Player Game Stats by Team (w/ Injuries, Lineups, DFS Salaries)  # 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_projected_player_game_stats_by_team_w_injuries_lineups_dfs_salaries_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[NflProjectionsPlayerGameProjection]
                 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 idp_projected_player_game_stats_by_team_w_injuries_lineups_dfs_salaries" % 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_projected_player_game_stats_by_team_w_injuries_lineups_dfs_salaries`")  # 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 `idp_projected_player_game_stats_by_team_w_injuries_lineups_dfs_salaries`")  # 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 `idp_projected_player_game_stats_by_team_w_injuries_lineups_dfs_salaries`")  # 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 `idp_projected_player_game_stats_by_team_w_injuries_lineups_dfs_salaries`")  # 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}/IdpPlayerGameProjectionStatsByTeam/{season}/{week}/{team}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflProjectionsPlayerGameProjection]',  # 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_projected_player_game_stats_by_week_w_injuries_lineups_dfs_salaries(self, format, season, week, **kwargs):  # noqa: E501
        """IDP Projected Player Game Stats by Week (w/ Injuries, Lineups, DFS Salaries)  # 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_projected_player_game_stats_by_week_w_injuries_lineups_dfs_salaries(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[NflProjectionsPlayerGameProjection]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.idp_projected_player_game_stats_by_week_w_injuries_lineups_dfs_salaries_with_http_info(format, season, week, **kwargs)  # noqa: E501
        else:
            (data) = self.idp_projected_player_game_stats_by_week_w_injuries_lineups_dfs_salaries_with_http_info(format, season, week, **kwargs)  # noqa: E501
            return data

    def idp_projected_player_game_stats_by_week_w_injuries_lineups_dfs_salaries_with_http_info(self, format, season, week, **kwargs):  # noqa: E501
        """IDP Projected Player Game Stats by Week (w/ Injuries, Lineups, DFS Salaries)  # 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_projected_player_game_stats_by_week_w_injuries_lineups_dfs_salaries_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[NflProjectionsPlayerGameProjection]
                 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 idp_projected_player_game_stats_by_week_w_injuries_lineups_dfs_salaries" % 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_projected_player_game_stats_by_week_w_injuries_lineups_dfs_salaries`")  # 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 `idp_projected_player_game_stats_by_week_w_injuries_lineups_dfs_salaries`")  # 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 `idp_projected_player_game_stats_by_week_w_injuries_lineups_dfs_salaries`")  # 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}/IdpPlayerGameProjectionStatsByWeek/{season}/{week}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflProjectionsPlayerGameProjection]',  # 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 projected_fantasy_defense_game_stats_w_dfs_salaries(self, format, season, week, **kwargs):  # noqa: E501
        """Projected Fantasy Defense Game Stats (w/ DFS Salaries)  # noqa: E501

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

    def projected_fantasy_defense_game_stats_w_dfs_salaries_with_http_info(self, format, season, week, **kwargs):  # noqa: E501
        """Projected Fantasy Defense Game Stats (w/ DFS Salaries)  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.projected_fantasy_defense_game_stats_w_dfs_salaries_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[NflProjectionsFantasyDefenseGameProjection]
                 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 projected_fantasy_defense_game_stats_w_dfs_salaries" % 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 `projected_fantasy_defense_game_stats_w_dfs_salaries`")  # 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 `projected_fantasy_defense_game_stats_w_dfs_salaries`")  # 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 `projected_fantasy_defense_game_stats_w_dfs_salaries`")  # 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}/FantasyDefenseProjectionsByGame/{season}/{week}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflProjectionsFantasyDefenseGameProjection]',  # 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 projected_fantasy_defense_season_stats_w_bye_week_adp(self, format, season, **kwargs):  # noqa: E501
        """Projected Fantasy Defense Season Stats (w/ Bye Week, ADP)  # noqa: E501

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

    def projected_fantasy_defense_season_stats_w_bye_week_adp_with_http_info(self, format, season, **kwargs):  # noqa: E501
        """Projected Fantasy Defense Season Stats (w/ Bye Week, ADP)  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.projected_fantasy_defense_season_stats_w_bye_week_adp_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[NflProjectionsFantasyDefenseSeasonProjection]
                 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 projected_fantasy_defense_season_stats_w_bye_week_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 `projected_fantasy_defense_season_stats_w_bye_week_adp`")  # 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 `projected_fantasy_defense_season_stats_w_bye_week_adp`")  # 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}/FantasyDefenseProjectionsBySeason/{season}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflProjectionsFantasyDefenseSeasonProjection]',  # 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 projected_player_game_stats_by_player_w_injuries_lineups_dfs_salaries(self, format, season, week, playerid, **kwargs):  # noqa: E501
        """Projected Player Game Stats by Player (w/ Injuries, Lineups, DFS Salaries)  # noqa: E501

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

    def projected_player_game_stats_by_player_w_injuries_lineups_dfs_salaries_with_http_info(self, format, season, week, playerid, **kwargs):  # noqa: E501
        """Projected Player Game Stats by Player (w/ Injuries, Lineups, DFS Salaries)  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.projected_player_game_stats_by_player_w_injuries_lineups_dfs_salaries_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>14257</code>. (required)
        :return: NflProjectionsPlayerGameProjection
                 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 projected_player_game_stats_by_player_w_injuries_lineups_dfs_salaries" % 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 `projected_player_game_stats_by_player_w_injuries_lineups_dfs_salaries`")  # 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 `projected_player_game_stats_by_player_w_injuries_lineups_dfs_salaries`")  # 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 `projected_player_game_stats_by_player_w_injuries_lineups_dfs_salaries`")  # 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 `projected_player_game_stats_by_player_w_injuries_lineups_dfs_salaries`")  # 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}/PlayerGameProjectionStatsByPlayerID/{season}/{week}/{playerid}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='NflProjectionsPlayerGameProjection',  # 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 projected_player_game_stats_by_team_w_injuries_lineups_dfs_salaries(self, format, season, week, team, **kwargs):  # noqa: E501
        """Projected Player Game Stats by Team (w/ Injuries, Lineups, DFS Salaries)  # noqa: E501

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

    def projected_player_game_stats_by_team_w_injuries_lineups_dfs_salaries_with_http_info(self, format, season, week, team, **kwargs):  # noqa: E501
        """Projected Player Game Stats by Team (w/ Injuries, Lineups, DFS Salaries)  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.projected_player_game_stats_by_team_w_injuries_lineups_dfs_salaries_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[NflProjectionsPlayerGameProjection]
                 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 projected_player_game_stats_by_team_w_injuries_lineups_dfs_salaries" % 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 `projected_player_game_stats_by_team_w_injuries_lineups_dfs_salaries`")  # 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 `projected_player_game_stats_by_team_w_injuries_lineups_dfs_salaries`")  # 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 `projected_player_game_stats_by_team_w_injuries_lineups_dfs_salaries`")  # 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 `projected_player_game_stats_by_team_w_injuries_lineups_dfs_salaries`")  # 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}/PlayerGameProjectionStatsByTeam/{season}/{week}/{team}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflProjectionsPlayerGameProjection]',  # 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 projected_player_game_stats_by_week_w_injuries_lineups_dfs_salaries(self, format, season, week, **kwargs):  # noqa: E501
        """Projected Player Game Stats by Week (w/ Injuries, Lineups, DFS Salaries)  # noqa: E501

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

    def projected_player_game_stats_by_week_w_injuries_lineups_dfs_salaries_with_http_info(self, format, season, week, **kwargs):  # noqa: E501
        """Projected Player Game Stats by Week (w/ Injuries, Lineups, DFS Salaries)  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.projected_player_game_stats_by_week_w_injuries_lineups_dfs_salaries_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[NflProjectionsPlayerGameProjection]
                 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 projected_player_game_stats_by_week_w_injuries_lineups_dfs_salaries" % 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 `projected_player_game_stats_by_week_w_injuries_lineups_dfs_salaries`")  # 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 `projected_player_game_stats_by_week_w_injuries_lineups_dfs_salaries`")  # 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 `projected_player_game_stats_by_week_w_injuries_lineups_dfs_salaries`")  # 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}/PlayerGameProjectionStatsByWeek/{season}/{week}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflProjectionsPlayerGameProjection]',  # 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 projected_player_season_stats_by_player_w_bye_week_adp(self, format, season, playerid, **kwargs):  # noqa: E501
        """Projected Player Season Stats by Player (w/ Bye Week, ADP)  # noqa: E501

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

    def projected_player_season_stats_by_player_w_bye_week_adp_with_http_info(self, format, season, playerid, **kwargs):  # noqa: E501
        """Projected Player Season Stats by Player (w/ Bye Week, ADP)  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.projected_player_season_stats_by_player_w_bye_week_adp_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>14257</code>. (required)
        :return: NflProjectionsPlayerSeasonProjection
                 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 projected_player_season_stats_by_player_w_bye_week_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 `projected_player_season_stats_by_player_w_bye_week_adp`")  # 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 `projected_player_season_stats_by_player_w_bye_week_adp`")  # 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 `projected_player_season_stats_by_player_w_bye_week_adp`")  # 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}/PlayerSeasonProjectionStatsByPlayerID/{season}/{playerid}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='NflProjectionsPlayerSeasonProjection',  # 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 projected_player_season_stats_by_team_w_bye_week_adp(self, format, season, team, **kwargs):  # noqa: E501
        """Projected Player Season Stats by Team (w/ Bye Week, ADP)  # noqa: E501

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

    def projected_player_season_stats_by_team_w_bye_week_adp_with_http_info(self, format, season, team, **kwargs):  # noqa: E501
        """Projected Player Season Stats by Team (w/ Bye Week, ADP)  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.projected_player_season_stats_by_team_w_bye_week_adp_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[NflProjectionsPlayerSeasonProjection]
                 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 projected_player_season_stats_by_team_w_bye_week_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 `projected_player_season_stats_by_team_w_bye_week_adp`")  # 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 `projected_player_season_stats_by_team_w_bye_week_adp`")  # 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 `projected_player_season_stats_by_team_w_bye_week_adp`")  # 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}/PlayerSeasonProjectionStatsByTeam/{season}/{team}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflProjectionsPlayerSeasonProjection]',  # 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 projected_player_season_stats_w_bye_week_adp(self, format, season, **kwargs):  # noqa: E501
        """Projected Player Season Stats (w/ Bye Week, ADP)  # noqa: E501

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

    def projected_player_season_stats_w_bye_week_adp_with_http_info(self, format, season, **kwargs):  # noqa: E501
        """Projected Player Season Stats (w/ Bye Week, ADP)  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.projected_player_season_stats_w_bye_week_adp_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[NflProjectionsPlayerSeasonProjection]
                 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 projected_player_season_stats_w_bye_week_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 `projected_player_season_stats_w_bye_week_adp`")  # 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 `projected_player_season_stats_w_bye_week_adp`")  # 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}/PlayerSeasonProjectionStats/{season}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflProjectionsPlayerSeasonProjection]',  # 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 upcoming_dfs_slate_ownership_projections(self, format, **kwargs):  # noqa: E501
        """Upcoming DFS Slate Ownership Projections  # noqa: E501

        Grabs DFS Slates which have not yet started for which we have DFS Ownership projections.   # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.upcoming_dfs_slate_ownership_projections(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[NflProjectionsDfsSlateWithOwnershipProjection]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.upcoming_dfs_slate_ownership_projections_with_http_info(format, **kwargs)  # noqa: E501
        else:
            (data) = self.upcoming_dfs_slate_ownership_projections_with_http_info(format, **kwargs)  # noqa: E501
            return data

    def upcoming_dfs_slate_ownership_projections_with_http_info(self, format, **kwargs):  # noqa: E501
        """Upcoming DFS Slate Ownership Projections  # noqa: E501

        Grabs DFS Slates which have not yet started for which we have DFS Ownership projections.   # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.upcoming_dfs_slate_ownership_projections_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[NflProjectionsDfsSlateWithOwnershipProjection]
                 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 upcoming_dfs_slate_ownership_projections" % 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 `upcoming_dfs_slate_ownership_projections`")  # 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}/UpcomingDfsSlateOwnershipProjections', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[NflProjectionsDfsSlateWithOwnershipProjection]',  # 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)
