# coding: utf-8

"""
    Street Manager Data Export API

    See API specification Resource Guide > Data Export API for more information on endpoints NOTE: Swagger Editor/UI does not display all description text for enumerations and child elements, check swagger.json for full description text  # noqa: E501

    OpenAPI spec version: 1.0.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 ..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 generate_comments_csv(self, **kwargs):  # noqa: E501
        """generate_comments_csv  # noqa: E501

        See API specification Resource Guide > Data Export API > Generate Comments CSV for more information Authenticated user must have one of the following roles: Planner, Contractor, HighwayAuthority  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generate_comments_csv(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CommentCSVExportRequest body:
        :return: CSVExportResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.generate_comments_csv_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.generate_comments_csv_with_http_info(**kwargs)  # noqa: E501
            return data

    def generate_comments_csv_with_http_info(self, **kwargs):  # noqa: E501
        """generate_comments_csv  # noqa: E501

        See API specification Resource Guide > Data Export API > Generate Comments CSV for more information Authenticated user must have one of the following roles: Planner, Contractor, HighwayAuthority  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generate_comments_csv_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CommentCSVExportRequest body:
        :return: CSVExportResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body']  # 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 generate_comments_csv" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['token']  # noqa: E501

        return self.api_client.call_api(
            '/comments/csv', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CSVExportResponse',  # 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 generate_expiring_interim_reinstatements_csv(self, **kwargs):  # noqa: E501
        """generate_expiring_interim_reinstatements_csv  # noqa: E501

        See API specification Resource Guide > Data Export API > Generate Expiring Interim Reinstatements CSV for more information Authenticated user must have one of the following roles: Planner, Contractor, HighwayAuthority  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generate_expiring_interim_reinstatements_csv(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ExpiringInterimReinstatementCSVExportRequest body:
        :return: CSVExportResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.generate_expiring_interim_reinstatements_csv_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.generate_expiring_interim_reinstatements_csv_with_http_info(**kwargs)  # noqa: E501
            return data

    def generate_expiring_interim_reinstatements_csv_with_http_info(self, **kwargs):  # noqa: E501
        """generate_expiring_interim_reinstatements_csv  # noqa: E501

        See API specification Resource Guide > Data Export API > Generate Expiring Interim Reinstatements CSV for more information Authenticated user must have one of the following roles: Planner, Contractor, HighwayAuthority  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generate_expiring_interim_reinstatements_csv_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ExpiringInterimReinstatementCSVExportRequest body:
        :return: CSVExportResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body']  # 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 generate_expiring_interim_reinstatements_csv" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['token']  # noqa: E501

        return self.api_client.call_api(
            '/reinstatements/expiring-interims/csv', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CSVExportResponse',  # 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 generate_fees_csv(self, **kwargs):  # noqa: E501
        """generate_fees_csv  # noqa: E501

        See API specification Resource Guide > Data Export API > Generate Fees CSV for more information Authenticated user must have one of the following roles: Planner, Contractor, HighwayAuthority  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generate_fees_csv(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param FeesCSVExportRequest body:
        :return: CSVExportResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.generate_fees_csv_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.generate_fees_csv_with_http_info(**kwargs)  # noqa: E501
            return data

    def generate_fees_csv_with_http_info(self, **kwargs):  # noqa: E501
        """generate_fees_csv  # noqa: E501

        See API specification Resource Guide > Data Export API > Generate Fees CSV for more information Authenticated user must have one of the following roles: Planner, Contractor, HighwayAuthority  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generate_fees_csv_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param FeesCSVExportRequest body:
        :return: CSVExportResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body']  # 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 generate_fees_csv" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['token']  # noqa: E501

        return self.api_client.call_api(
            '/fees/csv', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CSVExportResponse',  # 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 generate_forward_plans_csv(self, **kwargs):  # noqa: E501
        """generate_forward_plans_csv  # noqa: E501

        See API specification Resource Guide > Data Export API > Generate Forward plans CSV for more information Authenticated user must have one of the following roles: Planner, Contractor, HighwayAuthority  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generate_forward_plans_csv(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ForwardPlanCSVExportRequest body:
        :return: CSVExportResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.generate_forward_plans_csv_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.generate_forward_plans_csv_with_http_info(**kwargs)  # noqa: E501
            return data

    def generate_forward_plans_csv_with_http_info(self, **kwargs):  # noqa: E501
        """generate_forward_plans_csv  # noqa: E501

        See API specification Resource Guide > Data Export API > Generate Forward plans CSV for more information Authenticated user must have one of the following roles: Planner, Contractor, HighwayAuthority  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generate_forward_plans_csv_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ForwardPlanCSVExportRequest body:
        :return: CSVExportResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body']  # 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 generate_forward_plans_csv" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['token']  # noqa: E501

        return self.api_client.call_api(
            '/forward-plans/csv', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CSVExportResponse',  # 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 generate_fpns_csv(self, **kwargs):  # noqa: E501
        """generate_fpns_csv  # noqa: E501

        See API specification Resource Guide > Data Export API > Generate FPNs CSV for more information Authenticated user must have one of the following roles: Planner, Contractor, HighwayAuthority  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generate_fpns_csv(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param FPNCSVExportRequest body:
        :return: CSVExportResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.generate_fpns_csv_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.generate_fpns_csv_with_http_info(**kwargs)  # noqa: E501
            return data

    def generate_fpns_csv_with_http_info(self, **kwargs):  # noqa: E501
        """generate_fpns_csv  # noqa: E501

        See API specification Resource Guide > Data Export API > Generate FPNs CSV for more information Authenticated user must have one of the following roles: Planner, Contractor, HighwayAuthority  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generate_fpns_csv_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param FPNCSVExportRequest body:
        :return: CSVExportResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body']  # 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 generate_fpns_csv" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['token']  # noqa: E501

        return self.api_client.call_api(
            '/fixed-penalty-notices/csv', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CSVExportResponse',  # 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 generate_inspection_csv(self, **kwargs):  # noqa: E501
        """generate_inspection_csv  # noqa: E501

        See API specification Resource Guide > Data Export API > Generate Inspections CSV for more information Authenticated user must have one of the following roles: Planner, Contractor, HighwayAuthority  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generate_inspection_csv(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param InspectionCSVExportRequest body:
        :return: CSVExportResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.generate_inspection_csv_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.generate_inspection_csv_with_http_info(**kwargs)  # noqa: E501
            return data

    def generate_inspection_csv_with_http_info(self, **kwargs):  # noqa: E501
        """generate_inspection_csv  # noqa: E501

        See API specification Resource Guide > Data Export API > Generate Inspections CSV for more information Authenticated user must have one of the following roles: Planner, Contractor, HighwayAuthority  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generate_inspection_csv_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param InspectionCSVExportRequest body:
        :return: CSVExportResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body']  # 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 generate_inspection_csv" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['token']  # noqa: E501

        return self.api_client.call_api(
            '/inspections/csv', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CSVExportResponse',  # 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 generate_interested_party_permits(self, **kwargs):  # noqa: E501
        """generate_interested_party_permits  # noqa: E501

        See API specification Resource Guide > Data Export API > Generate Interested party permits CSV for more information Authenticated user must have one of the following roles: HighwayAuthority  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generate_interested_party_permits(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param InterestedPartyPermitsCSVExportRequest body:
        :return: CSVExportResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.generate_interested_party_permits_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.generate_interested_party_permits_with_http_info(**kwargs)  # noqa: E501
            return data

    def generate_interested_party_permits_with_http_info(self, **kwargs):  # noqa: E501
        """generate_interested_party_permits  # noqa: E501

        See API specification Resource Guide > Data Export API > Generate Interested party permits CSV for more information Authenticated user must have one of the following roles: HighwayAuthority  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generate_interested_party_permits_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param InterestedPartyPermitsCSVExportRequest body:
        :return: CSVExportResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body']  # 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 generate_interested_party_permits" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['token']  # noqa: E501

        return self.api_client.call_api(
            '/interested-party-permits/csv', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CSVExportResponse',  # 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 generate_material_classification_csv(self, **kwargs):  # noqa: E501
        """generate_material_classification_csv  # noqa: E501

        See API specification Resource Guide > Data Export API > Generate Material Classification CSV for more information Authenticated user must have one of the following roles: Planner, Contractor, HighwayAuthority  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generate_material_classification_csv(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param MaterialClassificationCSVExportRequest body:
        :return: CSVExportResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.generate_material_classification_csv_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.generate_material_classification_csv_with_http_info(**kwargs)  # noqa: E501
            return data

    def generate_material_classification_csv_with_http_info(self, **kwargs):  # noqa: E501
        """generate_material_classification_csv  # noqa: E501

        See API specification Resource Guide > Data Export API > Generate Material Classification CSV for more information Authenticated user must have one of the following roles: Planner, Contractor, HighwayAuthority  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generate_material_classification_csv_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param MaterialClassificationCSVExportRequest body:
        :return: CSVExportResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body']  # 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 generate_material_classification_csv" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['token']  # noqa: E501

        return self.api_client.call_api(
            '/material-classifications/csv', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CSVExportResponse',  # 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 generate_non_compliances_csv(self, **kwargs):  # noqa: E501
        """generate_non_compliances_csv  # noqa: E501

        See API specification Resource Guide > Data Export API > Generate Non Compliances CSV for more information Authenticated user must have one of the following roles: Planner, Contractor, HighwayAuthority  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generate_non_compliances_csv(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param NonComplianceCSVExportRequest body:
        :return: CSVExportResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.generate_non_compliances_csv_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.generate_non_compliances_csv_with_http_info(**kwargs)  # noqa: E501
            return data

    def generate_non_compliances_csv_with_http_info(self, **kwargs):  # noqa: E501
        """generate_non_compliances_csv  # noqa: E501

        See API specification Resource Guide > Data Export API > Generate Non Compliances CSV for more information Authenticated user must have one of the following roles: Planner, Contractor, HighwayAuthority  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generate_non_compliances_csv_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param NonComplianceCSVExportRequest body:
        :return: CSVExportResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body']  # 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 generate_non_compliances_csv" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['token']  # noqa: E501

        return self.api_client.call_api(
            '/non-compliances/csv', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CSVExportResponse',  # 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 generate_pbi_sample_inspection_targets_csv(self, **kwargs):  # noqa: E501
        """generate_pbi_sample_inspection_targets_csv  # noqa: E501

        See API specification Resource Guide > Data Export API > Generate PBI sample inspection targets CSV for more information Authenticated user must have one of the following roles: Admin or StreetWorksAdmin  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generate_pbi_sample_inspection_targets_csv(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param PbiSampleInspectionTargetCSVExportRequest body:
        :return: CSVExportResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.generate_pbi_sample_inspection_targets_csv_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.generate_pbi_sample_inspection_targets_csv_with_http_info(**kwargs)  # noqa: E501
            return data

    def generate_pbi_sample_inspection_targets_csv_with_http_info(self, **kwargs):  # noqa: E501
        """generate_pbi_sample_inspection_targets_csv  # noqa: E501

        See API specification Resource Guide > Data Export API > Generate PBI sample inspection targets CSV for more information Authenticated user must have one of the following roles: Admin or StreetWorksAdmin  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generate_pbi_sample_inspection_targets_csv_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param PbiSampleInspectionTargetCSVExportRequest body:
        :return: CSVExportResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body']  # 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 generate_pbi_sample_inspection_targets_csv" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['token']  # noqa: E501

        return self.api_client.call_api(
            '/pbi-sample-inspection-targets/csv', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CSVExportResponse',  # 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 generate_pbi_sample_inspections_due_csv(self, **kwargs):  # noqa: E501
        """generate_pbi_sample_inspections_due_csv  # noqa: E501

        See API specification Resource Guide > Data Export API > Generate PBI Sample Inspections Due CSV for more information Authenticated user must have one of the following roles: HighwayAuthority  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generate_pbi_sample_inspections_due_csv(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param PbiSampleInspectionsDueCSVExportRequest body:
        :return: CSVExportResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.generate_pbi_sample_inspections_due_csv_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.generate_pbi_sample_inspections_due_csv_with_http_info(**kwargs)  # noqa: E501
            return data

    def generate_pbi_sample_inspections_due_csv_with_http_info(self, **kwargs):  # noqa: E501
        """generate_pbi_sample_inspections_due_csv  # noqa: E501

        See API specification Resource Guide > Data Export API > Generate PBI Sample Inspections Due CSV for more information Authenticated user must have one of the following roles: HighwayAuthority  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generate_pbi_sample_inspections_due_csv_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param PbiSampleInspectionsDueCSVExportRequest body:
        :return: CSVExportResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body']  # 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 generate_pbi_sample_inspections_due_csv" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['token']  # noqa: E501

        return self.api_client.call_api(
            '/pbi-sample-inspections-due/csv', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CSVExportResponse',  # 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 generate_permit_alterations_csv(self, **kwargs):  # noqa: E501
        """generate_permit_alterations_csv  # noqa: E501

        See API specification Resource Guide > Data Export API > Generate Permit alterations CSV for more information Authenticated user must have one of the following roles: Planner, Contractor, HighwayAuthority  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generate_permit_alterations_csv(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param PermitAlterationCSVExportRequest body:
        :return: CSVExportResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.generate_permit_alterations_csv_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.generate_permit_alterations_csv_with_http_info(**kwargs)  # noqa: E501
            return data

    def generate_permit_alterations_csv_with_http_info(self, **kwargs):  # noqa: E501
        """generate_permit_alterations_csv  # noqa: E501

        See API specification Resource Guide > Data Export API > Generate Permit alterations CSV for more information Authenticated user must have one of the following roles: Planner, Contractor, HighwayAuthority  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generate_permit_alterations_csv_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param PermitAlterationCSVExportRequest body:
        :return: CSVExportResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body']  # 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 generate_permit_alterations_csv" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['token']  # noqa: E501

        return self.api_client.call_api(
            '/alterations/csv', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CSVExportResponse',  # 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 generate_permits_csv(self, **kwargs):  # noqa: E501
        """generate_permits_csv  # noqa: E501

        See API specification Resource Guide > Data Export API > Generate Permits CSV for more information Authenticated user must have one of the following roles: Planner, Contractor, HighwayAuthority  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generate_permits_csv(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param PermitCSVExportRequest body:
        :return: CSVExportResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.generate_permits_csv_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.generate_permits_csv_with_http_info(**kwargs)  # noqa: E501
            return data

    def generate_permits_csv_with_http_info(self, **kwargs):  # noqa: E501
        """generate_permits_csv  # noqa: E501

        See API specification Resource Guide > Data Export API > Generate Permits CSV for more information Authenticated user must have one of the following roles: Planner, Contractor, HighwayAuthority  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generate_permits_csv_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param PermitCSVExportRequest body:
        :return: CSVExportResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body']  # 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 generate_permits_csv" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['token']  # noqa: E501

        return self.api_client.call_api(
            '/permits/csv', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CSVExportResponse',  # 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 generate_private_street_notices_csv(self, **kwargs):  # noqa: E501
        """generate_private_street_notices_csv  # noqa: E501

        See API specification Resource Guide > Data Export API > Generate Private Street Notices CSV for more information Authenticated user must have one of the following roles: Planner, Contractor, HighwayAuthority  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generate_private_street_notices_csv(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param PrivateStreetCSVExportRequest body:
        :return: CSVExportResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.generate_private_street_notices_csv_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.generate_private_street_notices_csv_with_http_info(**kwargs)  # noqa: E501
            return data

    def generate_private_street_notices_csv_with_http_info(self, **kwargs):  # noqa: E501
        """generate_private_street_notices_csv  # noqa: E501

        See API specification Resource Guide > Data Export API > Generate Private Street Notices CSV for more information Authenticated user must have one of the following roles: Planner, Contractor, HighwayAuthority  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generate_private_street_notices_csv_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param PrivateStreetCSVExportRequest body:
        :return: CSVExportResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body']  # 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 generate_private_street_notices_csv" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['token']  # noqa: E501

        return self.api_client.call_api(
            '/private-street-notices/csv', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CSVExportResponse',  # 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 generate_reinspection_csv(self, **kwargs):  # noqa: E501
        """generate_reinspection_csv  # noqa: E501

        See API specification Resource Guide > Data Export API > Generate Inspections CSV for more information Authenticated user must have one of the following roles: Planner, Contractor, HighwayAuthority  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generate_reinspection_csv(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ReinspectionCSVExportRequest body:
        :return: CSVExportResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.generate_reinspection_csv_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.generate_reinspection_csv_with_http_info(**kwargs)  # noqa: E501
            return data

    def generate_reinspection_csv_with_http_info(self, **kwargs):  # noqa: E501
        """generate_reinspection_csv  # noqa: E501

        See API specification Resource Guide > Data Export API > Generate Inspections CSV for more information Authenticated user must have one of the following roles: Planner, Contractor, HighwayAuthority  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generate_reinspection_csv_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ReinspectionCSVExportRequest body:
        :return: CSVExportResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body']  # 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 generate_reinspection_csv" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['token']  # noqa: E501

        return self.api_client.call_api(
            '/reinspections/csv', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CSVExportResponse',  # 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 generate_reinstatements_csv(self, **kwargs):  # noqa: E501
        """generate_reinstatements_csv  # noqa: E501

        See API specification Resource Guide > Data Export API > Generate Reinstatements CSV for more information Authenticated user must have one of the following roles: Planner, Contractor, HighwayAuthority  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generate_reinstatements_csv(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ReinstatementCSVExportRequest body:
        :return: CSVExportResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.generate_reinstatements_csv_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.generate_reinstatements_csv_with_http_info(**kwargs)  # noqa: E501
            return data

    def generate_reinstatements_csv_with_http_info(self, **kwargs):  # noqa: E501
        """generate_reinstatements_csv  # noqa: E501

        See API specification Resource Guide > Data Export API > Generate Reinstatements CSV for more information Authenticated user must have one of the following roles: Planner, Contractor, HighwayAuthority  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generate_reinstatements_csv_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ReinstatementCSVExportRequest body:
        :return: CSVExportResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body']  # 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 generate_reinstatements_csv" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['token']  # noqa: E501

        return self.api_client.call_api(
            '/reinstatements/csv', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CSVExportResponse',  # 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 generate_reinstatements_due_csv(self, **kwargs):  # noqa: E501
        """generate_reinstatements_due_csv  # noqa: E501

        See API specification Resource Guide > Data Export API > Generate Reinstatements due CSV for more information Authenticated user must have one of the following roles: Planner, Contractor, HighwayAuthority  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generate_reinstatements_due_csv(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ReinstatementsDueCSVExportRequest body:
        :return: CSVExportResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.generate_reinstatements_due_csv_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.generate_reinstatements_due_csv_with_http_info(**kwargs)  # noqa: E501
            return data

    def generate_reinstatements_due_csv_with_http_info(self, **kwargs):  # noqa: E501
        """generate_reinstatements_due_csv  # noqa: E501

        See API specification Resource Guide > Data Export API > Generate Reinstatements due CSV for more information Authenticated user must have one of the following roles: Planner, Contractor, HighwayAuthority  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generate_reinstatements_due_csv_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ReinstatementsDueCSVExportRequest body:
        :return: CSVExportResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body']  # 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 generate_reinstatements_due_csv" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['token']  # noqa: E501

        return self.api_client.call_api(
            '/permits/reinstatements-due/csv', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CSVExportResponse',  # 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 generate_section58_csv(self, **kwargs):  # noqa: E501
        """generate_section58_csv  # noqa: E501

        See API specification Resource Guide > Data Export API > Generate Section 58s CSV for more information Authenticated user must have one of the following roles: Planner, Contractor, HighwayAuthority  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generate_section58_csv(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param Section58CSVExportRequest body:
        :return: CSVExportResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.generate_section58_csv_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.generate_section58_csv_with_http_info(**kwargs)  # noqa: E501
            return data

    def generate_section58_csv_with_http_info(self, **kwargs):  # noqa: E501
        """generate_section58_csv  # noqa: E501

        See API specification Resource Guide > Data Export API > Generate Section 58s CSV for more information Authenticated user must have one of the following roles: Planner, Contractor, HighwayAuthority  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generate_section58_csv_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param Section58CSVExportRequest body:
        :return: CSVExportResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body']  # 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 generate_section58_csv" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['token']  # noqa: E501

        return self.api_client.call_api(
            '/section-58s/csv', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CSVExportResponse',  # 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 generate_section74_csv(self, **kwargs):  # noqa: E501
        """generate_section74_csv  # noqa: E501

        See API specification Resource Guide > Data Export API > Generate Section 74s CSV for more information Authenticated user must have one of the following roles: Planner, Contractor, HighwayAuthority  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generate_section74_csv(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param Section74CSVExportRequest body:
        :return: CSVExportResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.generate_section74_csv_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.generate_section74_csv_with_http_info(**kwargs)  # noqa: E501
            return data

    def generate_section74_csv_with_http_info(self, **kwargs):  # noqa: E501
        """generate_section74_csv  # noqa: E501

        See API specification Resource Guide > Data Export API > Generate Section 74s CSV for more information Authenticated user must have one of the following roles: Planner, Contractor, HighwayAuthority  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generate_section74_csv_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param Section74CSVExportRequest body:
        :return: CSVExportResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body']  # 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 generate_section74_csv" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['token']  # noqa: E501

        return self.api_client.call_api(
            '/section-74s/csv', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CSVExportResponse',  # 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 generate_section81_csv(self, **kwargs):  # noqa: E501
        """generate_section81_csv  # noqa: E501

        See API specification Resource Guide > Data Export API > Generate Section 81s CSV for more information Authenticated user must have one of the following roles: Planner, Contractor, HighwayAuthority  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generate_section81_csv(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param Section81CSVExportRequest body:
        :return: CSVExportResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.generate_section81_csv_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.generate_section81_csv_with_http_info(**kwargs)  # noqa: E501
            return data

    def generate_section81_csv_with_http_info(self, **kwargs):  # noqa: E501
        """generate_section81_csv  # noqa: E501

        See API specification Resource Guide > Data Export API > Generate Section 81s CSV for more information Authenticated user must have one of the following roles: Planner, Contractor, HighwayAuthority  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generate_section81_csv_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param Section81CSVExportRequest body:
        :return: CSVExportResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body']  # 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 generate_section81_csv" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['token']  # noqa: E501

        return self.api_client.call_api(
            '/section-81s/csv', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CSVExportResponse',  # 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 get_csv(self, csv_id, **kwargs):  # noqa: E501
        """get_csv  # noqa: E501

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

        :param async_req bool
        :param float csv_id: (required)
        :return: str
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_csv_with_http_info(csv_id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_csv_with_http_info(csv_id, **kwargs)  # noqa: E501
            return data

    def get_csv_with_http_info(self, csv_id, **kwargs):  # noqa: E501
        """get_csv  # noqa: E501

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

        :param async_req bool
        :param float csv_id: (required)
        :return: str
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['csv_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 get_csv" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'csv_id' is set
        if ('csv_id' not in params or
                params['csv_id'] is None):
            raise ValueError("Missing the required parameter `csv_id` when calling `get_csv`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'csv_id' in params:
            path_params['csvId'] = params['csv_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(
            ['text/csv'])  # noqa: E501

        # Authentication setting
        auth_settings = ['token']  # noqa: E501

        return self.api_client.call_api(
            '/csv/{csvId}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='str',  # 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)
