<filename>fastreport_cloud_sdk/api/reports_api.py
# coding: utf-8

"""
    FastReport Cloud

    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)  # noqa: E501

    The version of the OpenAPI document: v1
    Generated by: https://openapi-generator.tech
"""


from __future__ import absolute_import

import re  # noqa: F401

# python 2 and python 3 compatibility library
import six

from fastreport_cloud_sdk.api_client import ApiClient
from fastreport_cloud_sdk.exceptions import (  # noqa: F401
    ApiTypeError,
    ApiValueError
)


class ReportsApi(object):
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

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

    def report_folder_and_file_get_count(self, id, **kwargs):  # noqa: E501
        """Get count of files and folders what contains in a specified folder  # noqa: E501

        User with a Get Count permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folder_and_file_get_count(id, async_req=True)
        >>> result = thread.get()

        :param id: folder id (required)
        :type id: str
        :param search_pattern: string, that must be incuded in file or folder name to be counted <br />              (leave undefined to count all files and folders)
        :type search_pattern: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: CountVM
        """
        kwargs['_return_http_data_only'] = True
        return self.report_folder_and_file_get_count_with_http_info(id, **kwargs)  # noqa: E501

    def report_folder_and_file_get_count_with_http_info(self, id, **kwargs):  # noqa: E501
        """Get count of files and folders what contains in a specified folder  # noqa: E501

        User with a Get Count permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folder_and_file_get_count_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: folder id (required)
        :type id: str
        :param search_pattern: string, that must be incuded in file or folder name to be counted <br />              (leave undefined to count all files and folders)
        :type search_pattern: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(CountVM, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'id',
            'search_pattern'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method report_folder_and_file_get_count" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `report_folder_and_file_get_count`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `report_folder_and_file_get_count`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        if self.api_client.client_side_validation and ('search_pattern' in local_var_params and  # noqa: E501
                                                        len(local_var_params['search_pattern']) > 100):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `search_pattern` when calling `report_folder_and_file_get_count`, length must be less than or equal to `100`")  # noqa: E501
        if self.api_client.client_side_validation and ('search_pattern' in local_var_params and  # noqa: E501
                                                        len(local_var_params['search_pattern']) < 0):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `search_pattern` when calling `report_folder_and_file_get_count`, length must be greater than or equal to `0`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501

        query_params = []
        if 'search_pattern' in local_var_params and local_var_params['search_pattern'] is not None:  # noqa: E501
            query_params.append(('searchPattern', local_var_params['search_pattern']))  # noqa: E501

        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 = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {
            200: "CountVM",
            400: "ProblemDetails",
            403: "ProblemDetails",
            404: "ProblemDetails",
        }

        return self.api_client.call_api(
            '/api/rp/v1/Reports/Folder/{id}/CountFolderAndFiles', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def report_folder_and_file_get_folders_and_files(self, id, **kwargs):  # noqa: E501
        """Get all folders and files from specified folder  # noqa: E501

        User with a Get Entity permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folder_and_file_get_folders_and_files(id, async_req=True)
        >>> result = thread.get()

        :param id: folder id (required)
        :type id: str
        :param skip: number of folder and files, that have to be skipped
        :type skip: int
        :param take: number of folder and files, that have to be returned
        :type take: int
        :param order_by: indicates a field to sort by
        :type order_by: FileSorting
        :param desc: indicates if sorting is descending
        :type desc: bool
        :param search_pattern:
        :type search_pattern: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: FilesVM
        """
        kwargs['_return_http_data_only'] = True
        return self.report_folder_and_file_get_folders_and_files_with_http_info(id, **kwargs)  # noqa: E501

    def report_folder_and_file_get_folders_and_files_with_http_info(self, id, **kwargs):  # noqa: E501
        """Get all folders and files from specified folder  # noqa: E501

        User with a Get Entity permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folder_and_file_get_folders_and_files_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: folder id (required)
        :type id: str
        :param skip: number of folder and files, that have to be skipped
        :type skip: int
        :param take: number of folder and files, that have to be returned
        :type take: int
        :param order_by: indicates a field to sort by
        :type order_by: FileSorting
        :param desc: indicates if sorting is descending
        :type desc: bool
        :param search_pattern:
        :type search_pattern: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(FilesVM, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'id',
            'skip',
            'take',
            'order_by',
            'desc',
            'search_pattern'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method report_folder_and_file_get_folders_and_files" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `report_folder_and_file_get_folders_and_files`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `report_folder_and_file_get_folders_and_files`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        if self.api_client.client_side_validation and 'skip' in local_var_params and local_var_params['skip'] > 2147483647:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `skip` when calling `report_folder_and_file_get_folders_and_files`, must be a value less than or equal to `2147483647`")  # noqa: E501
        if self.api_client.client_side_validation and 'skip' in local_var_params and local_var_params['skip'] < 0:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `skip` when calling `report_folder_and_file_get_folders_and_files`, must be a value greater than or equal to `0`")  # noqa: E501
        if self.api_client.client_side_validation and 'take' in local_var_params and local_var_params['take'] > 120:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `take` when calling `report_folder_and_file_get_folders_and_files`, must be a value less than or equal to `120`")  # noqa: E501
        if self.api_client.client_side_validation and 'take' in local_var_params and local_var_params['take'] < 1:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `take` when calling `report_folder_and_file_get_folders_and_files`, must be a value greater than or equal to `1`")  # noqa: E501
        if self.api_client.client_side_validation and ('search_pattern' in local_var_params and  # noqa: E501
                                                        len(local_var_params['search_pattern']) > 100):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `search_pattern` when calling `report_folder_and_file_get_folders_and_files`, length must be less than or equal to `100`")  # noqa: E501
        if self.api_client.client_side_validation and ('search_pattern' in local_var_params and  # noqa: E501
                                                        len(local_var_params['search_pattern']) < 0):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `search_pattern` when calling `report_folder_and_file_get_folders_and_files`, length must be greater than or equal to `0`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501

        query_params = []
        if 'skip' in local_var_params and local_var_params['skip'] is not None:  # noqa: E501
            query_params.append(('skip', local_var_params['skip']))  # noqa: E501
        if 'take' in local_var_params and local_var_params['take'] is not None:  # noqa: E501
            query_params.append(('take', local_var_params['take']))  # noqa: E501
        if 'order_by' in local_var_params and local_var_params['order_by'] is not None:  # noqa: E501
            query_params.append(('orderBy', local_var_params['order_by']))  # noqa: E501
        if 'desc' in local_var_params and local_var_params['desc'] is not None:  # noqa: E501
            query_params.append(('desc', local_var_params['desc']))  # noqa: E501
        if 'search_pattern' in local_var_params and local_var_params['search_pattern'] is not None:  # noqa: E501
            query_params.append(('searchPattern', local_var_params['search_pattern']))  # noqa: E501

        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 = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {
            200: "FilesVM",
            400: "ProblemDetails",
            403: "ProblemDetails",
            404: "ProblemDetails",
        }

        return self.api_client.call_api(
            '/api/rp/v1/Reports/Folder/{id}/ListFolderAndFiles', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def report_folders_copy_folder(self, id, folder_id, **kwargs):  # noqa: E501
        """Move folder to a specified folder  # noqa: E501

        User with a Update Place permission for a folder and Create Entity  for a Parent Folder can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_copy_folder(id, folder_id, async_req=True)
        >>> result = thread.get()

        :param id: moving folder id (required)
        :type id: str
        :param folder_id: destination folder id (required)
        :type folder_id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: FileVM
        """
        kwargs['_return_http_data_only'] = True
        return self.report_folders_copy_folder_with_http_info(id, folder_id, **kwargs)  # noqa: E501

    def report_folders_copy_folder_with_http_info(self, id, folder_id, **kwargs):  # noqa: E501
        """Move folder to a specified folder  # noqa: E501

        User with a Update Place permission for a folder and Create Entity  for a Parent Folder can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_copy_folder_with_http_info(id, folder_id, async_req=True)
        >>> result = thread.get()

        :param id: moving folder id (required)
        :type id: str
        :param folder_id: destination folder id (required)
        :type folder_id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(FileVM, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'id',
            'folder_id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method report_folders_copy_folder" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `report_folders_copy_folder`")  # noqa: E501
        # verify the required parameter 'folder_id' is set
        if self.api_client.client_side_validation and ('folder_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['folder_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `folder_id` when calling `report_folders_copy_folder`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `report_folders_copy_folder`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        if self.api_client.client_side_validation and 'folder_id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['folder_id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `folder_id` when calling `report_folders_copy_folder`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501
        if 'folder_id' in local_var_params:
            path_params['folderId'] = local_var_params['folder_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 = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {
            200: "FileVM",
            400: "ProblemDetails",
            403: "ProblemDetails",
            402: "ProblemDetails",
            404: "ProblemDetails",
        }

        return self.api_client.call_api(
            '/api/rp/v1/Reports/Folder/{id}/Copy/{folderId}', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def report_folders_delete_folder(self, id, **kwargs):  # noqa: E501
        """Delete specified folder  # noqa: E501

        User with a Delete Entity permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_delete_folder(id, async_req=True)
        >>> result = thread.get()

        :param id: folder id (required)
        :type id: str
        :param recursive: delete all childs
        :type recursive: bool
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """
        kwargs['_return_http_data_only'] = True
        return self.report_folders_delete_folder_with_http_info(id, **kwargs)  # noqa: E501

    def report_folders_delete_folder_with_http_info(self, id, **kwargs):  # noqa: E501
        """Delete specified folder  # noqa: E501

        User with a Delete Entity permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_delete_folder_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: folder id (required)
        :type id: str
        :param recursive: delete all childs
        :type recursive: bool
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """

        local_var_params = locals()

        all_params = [
            'id',
            'recursive'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method report_folders_delete_folder" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `report_folders_delete_folder`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `report_folders_delete_folder`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501

        query_params = []
        if 'recursive' in local_var_params and local_var_params['recursive'] is not None:  # noqa: E501
            query_params.append(('recursive', local_var_params['recursive']))  # noqa: E501

        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 = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {}

        return self.api_client.call_api(
            '/api/rp/v1/Reports/Folder/{id}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def report_folders_get_breadcrumbs(self, id, **kwargs):  # noqa: E501
        """Get specified folder breadcrumbs  # noqa: E501

        User with a Get Entity permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_get_breadcrumbs(id, async_req=True)
        >>> result = thread.get()

        :param id: folder id (required)
        :type id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: BreadcrumbsVM
        """
        kwargs['_return_http_data_only'] = True
        return self.report_folders_get_breadcrumbs_with_http_info(id, **kwargs)  # noqa: E501

    def report_folders_get_breadcrumbs_with_http_info(self, id, **kwargs):  # noqa: E501
        """Get specified folder breadcrumbs  # noqa: E501

        User with a Get Entity permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_get_breadcrumbs_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: folder id (required)
        :type id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(BreadcrumbsVM, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method report_folders_get_breadcrumbs" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `report_folders_get_breadcrumbs`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `report_folders_get_breadcrumbs`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['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 = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {
            200: "BreadcrumbsVM",
            400: "ProblemDetails",
            403: "ProblemDetails",
            404: "ProblemDetails",
        }

        return self.api_client.call_api(
            '/api/rp/v1/Reports/Folder/{id}/Breadcrumbs', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def report_folders_get_folder(self, id, **kwargs):  # noqa: E501
        """Get specified folder  # noqa: E501

        User with a Get Entity permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_get_folder(id, async_req=True)
        >>> result = thread.get()

        :param id: folder id (required)
        :type id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: FileVM
        """
        kwargs['_return_http_data_only'] = True
        return self.report_folders_get_folder_with_http_info(id, **kwargs)  # noqa: E501

    def report_folders_get_folder_with_http_info(self, id, **kwargs):  # noqa: E501
        """Get specified folder  # noqa: E501

        User with a Get Entity permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_get_folder_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: folder id (required)
        :type id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(FileVM, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method report_folders_get_folder" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `report_folders_get_folder`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `report_folders_get_folder`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['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 = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {
            200: "FileVM",
            400: "ProblemDetails",
            403: "ProblemDetails",
            404: "ProblemDetails",
        }

        return self.api_client.call_api(
            '/api/rp/v1/Reports/Folder/{id}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def report_folders_get_folders(self, id, **kwargs):  # noqa: E501
        """Get all folders from specified folder  # noqa: E501

        User with a Get Entity permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_get_folders(id, async_req=True)
        >>> result = thread.get()

        :param id: folder id (required)
        :type id: str
        :param skip: number of files, that have to be skipped
        :type skip: int
        :param take: number of files, that have to be returned
        :type take: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: FilesVM
        """
        kwargs['_return_http_data_only'] = True
        return self.report_folders_get_folders_with_http_info(id, **kwargs)  # noqa: E501

    def report_folders_get_folders_with_http_info(self, id, **kwargs):  # noqa: E501
        """Get all folders from specified folder  # noqa: E501

        User with a Get Entity permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_get_folders_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: folder id (required)
        :type id: str
        :param skip: number of files, that have to be skipped
        :type skip: int
        :param take: number of files, that have to be returned
        :type take: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(FilesVM, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'id',
            'skip',
            'take'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method report_folders_get_folders" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `report_folders_get_folders`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `report_folders_get_folders`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        if self.api_client.client_side_validation and 'skip' in local_var_params and local_var_params['skip'] > 2147483647:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `skip` when calling `report_folders_get_folders`, must be a value less than or equal to `2147483647`")  # noqa: E501
        if self.api_client.client_side_validation and 'skip' in local_var_params and local_var_params['skip'] < 0:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `skip` when calling `report_folders_get_folders`, must be a value greater than or equal to `0`")  # noqa: E501
        if self.api_client.client_side_validation and 'take' in local_var_params and local_var_params['take'] > 120:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `take` when calling `report_folders_get_folders`, must be a value less than or equal to `120`")  # noqa: E501
        if self.api_client.client_side_validation and 'take' in local_var_params and local_var_params['take'] < 1:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `take` when calling `report_folders_get_folders`, must be a value greater than or equal to `1`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501

        query_params = []
        if 'skip' in local_var_params and local_var_params['skip'] is not None:  # noqa: E501
            query_params.append(('skip', local_var_params['skip']))  # noqa: E501
        if 'take' in local_var_params and local_var_params['take'] is not None:  # noqa: E501
            query_params.append(('take', local_var_params['take']))  # noqa: E501

        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 = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {
            200: "FilesVM",
            400: "ProblemDetails",
            403: "ProblemDetails",
            404: "ProblemDetails",
        }

        return self.api_client.call_api(
            '/api/rp/v1/Reports/Folder/{id}/ListFolders', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def report_folders_get_folders_count(self, id, **kwargs):  # noqa: E501
        """Get count of folders what contains in a specified folder  # noqa: E501

        User with a Get Count permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_get_folders_count(id, async_req=True)
        >>> result = thread.get()

        :param id: folder id (required)
        :type id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: CountVM
        """
        kwargs['_return_http_data_only'] = True
        return self.report_folders_get_folders_count_with_http_info(id, **kwargs)  # noqa: E501

    def report_folders_get_folders_count_with_http_info(self, id, **kwargs):  # noqa: E501
        """Get count of folders what contains in a specified folder  # noqa: E501

        User with a Get Count permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_get_folders_count_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: folder id (required)
        :type id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(CountVM, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method report_folders_get_folders_count" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `report_folders_get_folders_count`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `report_folders_get_folders_count`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['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 = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {
            200: "CountVM",
            400: "ProblemDetails",
            403: "ProblemDetails",
            404: "ProblemDetails",
        }

        return self.api_client.call_api(
            '/api/rp/v1/Reports/Folder/{id}/CountFolders', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def report_folders_get_permissions(self, id, **kwargs):  # noqa: E501
        """Get all folder permissions  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_get_permissions(id, async_req=True)
        >>> result = thread.get()

        :param id: (required)
        :type id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: FilePermissionsVM
        """
        kwargs['_return_http_data_only'] = True
        return self.report_folders_get_permissions_with_http_info(id, **kwargs)  # noqa: E501

    def report_folders_get_permissions_with_http_info(self, id, **kwargs):  # noqa: E501
        """Get all folder permissions  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_get_permissions_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: (required)
        :type id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(FilePermissionsVM, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method report_folders_get_permissions" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `report_folders_get_permissions`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `report_folders_get_permissions`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['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 = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {
            200: "FilePermissionsVM",
            400: "ProblemDetails",
            403: "ProblemDetails",
            404: "ProblemDetails",
        }

        return self.api_client.call_api(
            '/api/rp/v1/Reports/Folder/{id}/permissions', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def report_folders_get_root_folder(self, **kwargs):  # noqa: E501
        """Get user's root folder (without parents)  # noqa: E501

        > Breakchange. Now user model doesn't contain a root folders.  This method can return error 400 and 404 when subscription is not found.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_get_root_folder(async_req=True)
        >>> result = thread.get()

        :param subscription_id:
        :type subscription_id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: FileVM
        """
        kwargs['_return_http_data_only'] = True
        return self.report_folders_get_root_folder_with_http_info(**kwargs)  # noqa: E501

    def report_folders_get_root_folder_with_http_info(self, **kwargs):  # noqa: E501
        """Get user's root folder (without parents)  # noqa: E501

        > Breakchange. Now user model doesn't contain a root folders.  This method can return error 400 and 404 when subscription is not found.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_get_root_folder_with_http_info(async_req=True)
        >>> result = thread.get()

        :param subscription_id:
        :type subscription_id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(FileVM, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'subscription_id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method report_folders_get_root_folder" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'subscription_id' in local_var_params and local_var_params['subscription_id'] is not None:  # noqa: E501
            query_params.append(('subscriptionId', local_var_params['subscription_id']))  # noqa: E501

        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 = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {
            200: "FileVM",
            400: None,
            404: None,
            403: None,
        }

        return self.api_client.call_api(
            '/api/rp/v1/Reports/Root', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def report_folders_move_folder(self, id, folder_id, **kwargs):  # noqa: E501
        """Move folder to a specified folder  # noqa: E501

        User with a Update Place permission for a folder and Create Entity  for a Parent Folder can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_move_folder(id, folder_id, async_req=True)
        >>> result = thread.get()

        :param id: moving folder id (required)
        :type id: str
        :param folder_id: destination folder id (required)
        :type folder_id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: FileVM
        """
        kwargs['_return_http_data_only'] = True
        return self.report_folders_move_folder_with_http_info(id, folder_id, **kwargs)  # noqa: E501

    def report_folders_move_folder_with_http_info(self, id, folder_id, **kwargs):  # noqa: E501
        """Move folder to a specified folder  # noqa: E501

        User with a Update Place permission for a folder and Create Entity  for a Parent Folder can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_move_folder_with_http_info(id, folder_id, async_req=True)
        >>> result = thread.get()

        :param id: moving folder id (required)
        :type id: str
        :param folder_id: destination folder id (required)
        :type folder_id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(FileVM, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'id',
            'folder_id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method report_folders_move_folder" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `report_folders_move_folder`")  # noqa: E501
        # verify the required parameter 'folder_id' is set
        if self.api_client.client_side_validation and ('folder_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['folder_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `folder_id` when calling `report_folders_move_folder`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `report_folders_move_folder`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        if self.api_client.client_side_validation and 'folder_id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['folder_id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `folder_id` when calling `report_folders_move_folder`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501
        if 'folder_id' in local_var_params:
            path_params['folderId'] = local_var_params['folder_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 = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {
            200: "FileVM",
            400: "ProblemDetails",
            403: "ProblemDetails",
            402: "ProblemDetails",
            404: "ProblemDetails",
        }

        return self.api_client.call_api(
            '/api/rp/v1/Reports/Folder/{id}/Move/{folderId}', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def report_folders_post_folder(self, id, **kwargs):  # noqa: E501
        """Create folder  # noqa: E501

        User with a Create Entity permisison can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_post_folder(id, async_req=True)
        >>> result = thread.get()

        :param id: Identifier of parent folder id (required)
        :type id: str
        :param report_folder_create_vm: create VM
        :type report_folder_create_vm: ReportFolderCreateVM
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: FileVM
        """
        kwargs['_return_http_data_only'] = True
        return self.report_folders_post_folder_with_http_info(id, **kwargs)  # noqa: E501

    def report_folders_post_folder_with_http_info(self, id, **kwargs):  # noqa: E501
        """Create folder  # noqa: E501

        User with a Create Entity permisison can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_post_folder_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: Identifier of parent folder id (required)
        :type id: str
        :param report_folder_create_vm: create VM
        :type report_folder_create_vm: ReportFolderCreateVM
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(FileVM, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'id',
            'report_folder_create_vm'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method report_folders_post_folder" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `report_folders_post_folder`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `report_folders_post_folder`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'report_folder_create_vm' in local_var_params:
            body_params = local_var_params['report_folder_create_vm']
        # 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', 'text/json', 'application/*+json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {
            200: "FileVM",
            400: "ProblemDetails",
            403: "ProblemDetails",
            402: "ProblemDetails",
            404: "ProblemDetails",
        }

        return self.api_client.call_api(
            '/api/rp/v1/Reports/Folder/{id}/Folder', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def report_folders_rename_folder(self, id, **kwargs):  # noqa: E501
        """Rename a folder  # noqa: E501

        User with a Update Name permision can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_rename_folder(id, async_req=True)
        >>> result = thread.get()

        :param id: (required)
        :type id: str
        :param folder_rename_vm:
        :type folder_rename_vm: FolderRenameVM
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: FileVM
        """
        kwargs['_return_http_data_only'] = True
        return self.report_folders_rename_folder_with_http_info(id, **kwargs)  # noqa: E501

    def report_folders_rename_folder_with_http_info(self, id, **kwargs):  # noqa: E501
        """Rename a folder  # noqa: E501

        User with a Update Name permision can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_rename_folder_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: (required)
        :type id: str
        :param folder_rename_vm:
        :type folder_rename_vm: FolderRenameVM
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(FileVM, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'id',
            'folder_rename_vm'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method report_folders_rename_folder" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `report_folders_rename_folder`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `report_folders_rename_folder`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'folder_rename_vm' in local_var_params:
            body_params = local_var_params['folder_rename_vm']
        # 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', 'text/json', 'application/*+json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {
            200: "FileVM",
            400: "ProblemDetails",
            403: "ProblemDetails",
            402: "ProblemDetails",
            404: "ProblemDetails",
        }

        return self.api_client.call_api(
            '/api/rp/v1/Reports/Folder/{id}/Rename', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def report_folders_update_icon(self, id, **kwargs):  # noqa: E501
        """Update a folder's icon  # noqa: E501

        User with a Update Icon permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_update_icon(id, async_req=True)
        >>> result = thread.get()

        :param id: Identifier of folder (required)
        :type id: str
        :param folder_icon_vm: Update icon model
        :type folder_icon_vm: FolderIconVM
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: FileVM
        """
        kwargs['_return_http_data_only'] = True
        return self.report_folders_update_icon_with_http_info(id, **kwargs)  # noqa: E501

    def report_folders_update_icon_with_http_info(self, id, **kwargs):  # noqa: E501
        """Update a folder's icon  # noqa: E501

        User with a Update Icon permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_update_icon_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: Identifier of folder (required)
        :type id: str
        :param folder_icon_vm: Update icon model
        :type folder_icon_vm: FolderIconVM
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(FileVM, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'id',
            'folder_icon_vm'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method report_folders_update_icon" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `report_folders_update_icon`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `report_folders_update_icon`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'folder_icon_vm' in local_var_params:
            body_params = local_var_params['folder_icon_vm']
        # 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', 'text/json', 'application/*+json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {
            200: "FileVM",
            400: "ProblemDetails",
            403: "ProblemDetails",
            402: "ProblemDetails",
            404: "ProblemDetails",
        }

        return self.api_client.call_api(
            '/api/rp/v1/Reports/Folder/{id}/Icon', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def report_folders_update_permissions(self, id, **kwargs):  # noqa: E501
        """Update permissions  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_update_permissions(id, async_req=True)
        >>> result = thread.get()

        :param id: (required)
        :type id: str
        :param update_file_permissions_vm:
        :type update_file_permissions_vm: UpdateFilePermissionsVM
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """
        kwargs['_return_http_data_only'] = True
        return self.report_folders_update_permissions_with_http_info(id, **kwargs)  # noqa: E501

    def report_folders_update_permissions_with_http_info(self, id, **kwargs):  # noqa: E501
        """Update permissions  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_update_permissions_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: (required)
        :type id: str
        :param update_file_permissions_vm:
        :type update_file_permissions_vm: UpdateFilePermissionsVM
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """

        local_var_params = locals()

        all_params = [
            'id',
            'update_file_permissions_vm'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method report_folders_update_permissions" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `report_folders_update_permissions`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `report_folders_update_permissions`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'update_file_permissions_vm' in local_var_params:
            body_params = local_var_params['update_file_permissions_vm']
        # 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', 'text/json', 'application/*+json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {}

        return self.api_client.call_api(
            '/api/rp/v1/Reports/{id}/permissions', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def report_folders_update_tags(self, id, **kwargs):  # noqa: E501
        """Update tags  # noqa: E501

        User with a Update Tags permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_update_tags(id, async_req=True)
        >>> result = thread.get()

        :param id: (required)
        :type id: str
        :param folder_tags_update_vm:
        :type folder_tags_update_vm: FolderTagsUpdateVM
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: FileVM
        """
        kwargs['_return_http_data_only'] = True
        return self.report_folders_update_tags_with_http_info(id, **kwargs)  # noqa: E501

    def report_folders_update_tags_with_http_info(self, id, **kwargs):  # noqa: E501
        """Update tags  # noqa: E501

        User with a Update Tags permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_update_tags_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: (required)
        :type id: str
        :param folder_tags_update_vm:
        :type folder_tags_update_vm: FolderTagsUpdateVM
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(FileVM, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'id',
            'folder_tags_update_vm'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method report_folders_update_tags" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `report_folders_update_tags`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `report_folders_update_tags`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'folder_tags_update_vm' in local_var_params:
            body_params = local_var_params['folder_tags_update_vm']
        # 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', 'text/json', 'application/*+json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {
            200: "FileVM",
            400: "ProblemDetails",
            403: "ProblemDetails",
            402: "ProblemDetails",
            404: "ProblemDetails",
        }

        return self.api_client.call_api(
            '/api/rp/v1/Reports/Folder/{id}/UpdateTags', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def reports_copy_file(self, id, folder_id, **kwargs):  # noqa: E501
        """Copy file to a specified folder  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.reports_copy_file(id, folder_id, async_req=True)
        >>> result = thread.get()

        :param id: file id (required)
        :type id: str
        :param folder_id: folder id (required)
        :type folder_id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: ReportVM
        """
        kwargs['_return_http_data_only'] = True
        return self.reports_copy_file_with_http_info(id, folder_id, **kwargs)  # noqa: E501

    def reports_copy_file_with_http_info(self, id, folder_id, **kwargs):  # noqa: E501
        """Copy file to a specified folder  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.reports_copy_file_with_http_info(id, folder_id, async_req=True)
        >>> result = thread.get()

        :param id: file id (required)
        :type id: str
        :param folder_id: folder id (required)
        :type folder_id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(ReportVM, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'id',
            'folder_id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method reports_copy_file" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `reports_copy_file`")  # noqa: E501
        # verify the required parameter 'folder_id' is set
        if self.api_client.client_side_validation and ('folder_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['folder_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `folder_id` when calling `reports_copy_file`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `reports_copy_file`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        if self.api_client.client_side_validation and 'folder_id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['folder_id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `folder_id` when calling `reports_copy_file`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501
        if 'folder_id' in local_var_params:
            path_params['folderId'] = local_var_params['folder_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 = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {
            200: "ReportVM",
            400: "ProblemDetails",
            403: "ProblemDetails",
            402: "ProblemDetails",
            404: "ProblemDetails",
            500: None,
        }

        return self.api_client.call_api(
            '/api/rp/v1/Reports/File/{id}/Copy/{folderId}', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def reports_delete_file(self, id, **kwargs):  # noqa: E501
        """Delete specified file  # noqa: E501

        User with Delete permission can access the method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.reports_delete_file(id, async_req=True)
        >>> result = thread.get()

        :param id: file id (required)
        :type id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """
        kwargs['_return_http_data_only'] = True
        return self.reports_delete_file_with_http_info(id, **kwargs)  # noqa: E501

    def reports_delete_file_with_http_info(self, id, **kwargs):  # noqa: E501
        """Delete specified file  # noqa: E501

        User with Delete permission can access the method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.reports_delete_file_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: file id (required)
        :type id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """

        local_var_params = locals()

        all_params = [
            'id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method reports_delete_file" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `reports_delete_file`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `reports_delete_file`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['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 = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {}

        return self.api_client.call_api(
            '/api/rp/v1/Reports/File/{id}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def reports_export(self, id, **kwargs):  # noqa: E501
        """Export specified report to a specified format  # noqa: E501

        User with Execute Export permission on prepared report and  Create Entity on an export folder can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.reports_export(id, async_req=True)
        >>> result = thread.get()

        :param id: report id (required)
        :type id: str
        :param export_report_vm: export parameters
        :type export_report_vm: ExportReportVM
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: ExportVM
        """
        kwargs['_return_http_data_only'] = True
        return self.reports_export_with_http_info(id, **kwargs)  # noqa: E501

    def reports_export_with_http_info(self, id, **kwargs):  # noqa: E501
        """Export specified report to a specified format  # noqa: E501

        User with Execute Export permission on prepared report and  Create Entity on an export folder can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.reports_export_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: report id (required)
        :type id: str
        :param export_report_vm: export parameters
        :type export_report_vm: ExportReportVM
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(ExportVM, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'id',
            'export_report_vm'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method reports_export" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `reports_export`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `reports_export`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'export_report_vm' in local_var_params:
            body_params = local_var_params['export_report_vm']
        # 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', 'text/json', 'application/*+json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {
            200: "ExportVM",
            400: "ProblemDetails",
            403: "ProblemDetails",
            402: "ProblemDetails",
            404: "ProblemDetails",
        }

        return self.api_client.call_api(
            '/api/rp/v1/Reports/File/{id}/Export', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def reports_get_file(self, id, **kwargs):  # noqa: E501
        """Get specified file  # noqa: E501

        User with Get Entity permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.reports_get_file(id, async_req=True)
        >>> result = thread.get()

        :param id: file id (required)
        :type id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: ReportVM
        """
        kwargs['_return_http_data_only'] = True
        return self.reports_get_file_with_http_info(id, **kwargs)  # noqa: E501

    def reports_get_file_with_http_info(self, id, **kwargs):  # noqa: E501
        """Get specified file  # noqa: E501

        User with Get Entity permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.reports_get_file_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: file id (required)
        :type id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(ReportVM, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method reports_get_file" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `reports_get_file`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `reports_get_file`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['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 = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {
            200: "ReportVM",
            400: "ProblemDetails",
            403: "ProblemDetails",
            404: "ProblemDetails",
            500: None,
        }

        return self.api_client.call_api(
            '/api/rp/v1/Reports/File/{id}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def reports_get_files_count(self, id, **kwargs):  # noqa: E501
        """Get count of files what contains in a specified folder  # noqa: E501

        User with Get Count permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.reports_get_files_count(id, async_req=True)
        >>> result = thread.get()

        :param id: folder id (required)
        :type id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: CountVM
        """
        kwargs['_return_http_data_only'] = True
        return self.reports_get_files_count_with_http_info(id, **kwargs)  # noqa: E501

    def reports_get_files_count_with_http_info(self, id, **kwargs):  # noqa: E501
        """Get count of files what contains in a specified folder  # noqa: E501

        User with Get Count permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.reports_get_files_count_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: folder id (required)
        :type id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(CountVM, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method reports_get_files_count" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `reports_get_files_count`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `reports_get_files_count`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['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 = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {
            200: "CountVM",
            400: "ProblemDetails",
            403: "ProblemDetails",
            404: "ProblemDetails",
            500: None,
        }

        return self.api_client.call_api(
            '/api/rp/v1/Reports/Folder/{id}/CountFiles', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def reports_get_files_list(self, id, **kwargs):  # noqa: E501
        """Get all files from specified folder. <br />  User with Get Entity permission can access this method. <br />  The method will returns minimal infomration about the file: <br />  id, name, size, editedTime, createdTime, tags, status, statusReason.  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.reports_get_files_list(id, async_req=True)
        >>> result = thread.get()

        :param id: folder id (required)
        :type id: str
        :param skip: number of files, that have to be skipped
        :type skip: int
        :param take: number of files, that have to be returned
        :type take: int
        :param search_pattern:
        :type search_pattern: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: ReportsVM
        """
        kwargs['_return_http_data_only'] = True
        return self.reports_get_files_list_with_http_info(id, **kwargs)  # noqa: E501

    def reports_get_files_list_with_http_info(self, id, **kwargs):  # noqa: E501
        """Get all files from specified folder. <br />  User with Get Entity permission can access this method. <br />  The method will returns minimal infomration about the file: <br />  id, name, size, editedTime, createdTime, tags, status, statusReason.  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.reports_get_files_list_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: folder id (required)
        :type id: str
        :param skip: number of files, that have to be skipped
        :type skip: int
        :param take: number of files, that have to be returned
        :type take: int
        :param search_pattern:
        :type search_pattern: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(ReportsVM, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'id',
            'skip',
            'take',
            'search_pattern'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method reports_get_files_list" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `reports_get_files_list`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `reports_get_files_list`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        if self.api_client.client_side_validation and 'skip' in local_var_params and local_var_params['skip'] > 2147483647:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `skip` when calling `reports_get_files_list`, must be a value less than or equal to `2147483647`")  # noqa: E501
        if self.api_client.client_side_validation and 'skip' in local_var_params and local_var_params['skip'] < 0:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `skip` when calling `reports_get_files_list`, must be a value greater than or equal to `0`")  # noqa: E501
        if self.api_client.client_side_validation and 'take' in local_var_params and local_var_params['take'] > 120:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `take` when calling `reports_get_files_list`, must be a value less than or equal to `120`")  # noqa: E501
        if self.api_client.client_side_validation and 'take' in local_var_params and local_var_params['take'] < 1:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `take` when calling `reports_get_files_list`, must be a value greater than or equal to `1`")  # noqa: E501
        if self.api_client.client_side_validation and ('search_pattern' in local_var_params and  # noqa: E501
                                                        len(local_var_params['search_pattern']) > 100):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `search_pattern` when calling `reports_get_files_list`, length must be less than or equal to `100`")  # noqa: E501
        if self.api_client.client_side_validation and ('search_pattern' in local_var_params and  # noqa: E501
                                                        len(local_var_params['search_pattern']) < 0):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `search_pattern` when calling `reports_get_files_list`, length must be greater than or equal to `0`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501

        query_params = []
        if 'skip' in local_var_params and local_var_params['skip'] is not None:  # noqa: E501
            query_params.append(('skip', local_var_params['skip']))  # noqa: E501
        if 'take' in local_var_params and local_var_params['take'] is not None:  # noqa: E501
            query_params.append(('take', local_var_params['take']))  # noqa: E501
        if 'search_pattern' in local_var_params and local_var_params['search_pattern'] is not None:  # noqa: E501
            query_params.append(('searchPattern', local_var_params['search_pattern']))  # noqa: E501

        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 = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {
            200: "ReportsVM",
            400: "ProblemDetails",
            403: "ProblemDetails",
            404: "ProblemDetails",
            500: None,
        }

        return self.api_client.call_api(
            '/api/rp/v1/Reports/Folder/{id}/ListFiles', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def reports_get_permissions(self, id, **kwargs):  # noqa: E501
        """Get all file permissions  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.reports_get_permissions(id, async_req=True)
        >>> result = thread.get()

        :param id: (required)
        :type id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: FilePermissionsVM
        """
        kwargs['_return_http_data_only'] = True
        return self.reports_get_permissions_with_http_info(id, **kwargs)  # noqa: E501

    def reports_get_permissions_with_http_info(self, id, **kwargs):  # noqa: E501
        """Get all file permissions  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.reports_get_permissions_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: (required)
        :type id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(FilePermissionsVM, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method reports_get_permissions" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `reports_get_permissions`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `reports_get_permissions`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['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 = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {
            200: "FilePermissionsVM",
            400: "ProblemDetails",
            403: "ProblemDetails",
            404: "ProblemDetails",
        }

        return self.api_client.call_api(
            '/api/rp/v1/Reports/File/{id}/permissions', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def reports_move_file(self, id, folder_id, **kwargs):  # noqa: E501
        """Move file to a specified folder  # noqa: E501

        User with Update Place permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.reports_move_file(id, folder_id, async_req=True)
        >>> result = thread.get()

        :param id: file id (required)
        :type id: str
        :param folder_id: folder id (required)
        :type folder_id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: ReportVM
        """
        kwargs['_return_http_data_only'] = True
        return self.reports_move_file_with_http_info(id, folder_id, **kwargs)  # noqa: E501

    def reports_move_file_with_http_info(self, id, folder_id, **kwargs):  # noqa: E501
        """Move file to a specified folder  # noqa: E501

        User with Update Place permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.reports_move_file_with_http_info(id, folder_id, async_req=True)
        >>> result = thread.get()

        :param id: file id (required)
        :type id: str
        :param folder_id: folder id (required)
        :type folder_id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(ReportVM, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'id',
            'folder_id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method reports_move_file" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `reports_move_file`")  # noqa: E501
        # verify the required parameter 'folder_id' is set
        if self.api_client.client_side_validation and ('folder_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['folder_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `folder_id` when calling `reports_move_file`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `reports_move_file`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        if self.api_client.client_side_validation and 'folder_id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['folder_id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `folder_id` when calling `reports_move_file`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501
        if 'folder_id' in local_var_params:
            path_params['folderId'] = local_var_params['folder_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 = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {
            200: "ReportVM",
            400: "ProblemDetails",
            403: "ProblemDetails",
            402: "ProblemDetails",
            404: "ProblemDetails",
            500: None,
        }

        return self.api_client.call_api(
            '/api/rp/v1/Reports/File/{id}/Move/{folderId}', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def reports_rename_file(self, id, **kwargs):  # noqa: E501
        """Rename a file  # noqa: E501

        User with Update Name permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.reports_rename_file(id, async_req=True)
        >>> result = thread.get()

        :param id: (required)
        :type id: str
        :param file_rename_vm:
        :type file_rename_vm: FileRenameVM
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: ReportVM
        """
        kwargs['_return_http_data_only'] = True
        return self.reports_rename_file_with_http_info(id, **kwargs)  # noqa: E501

    def reports_rename_file_with_http_info(self, id, **kwargs):  # noqa: E501
        """Rename a file  # noqa: E501

        User with Update Name permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.reports_rename_file_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: (required)
        :type id: str
        :param file_rename_vm:
        :type file_rename_vm: FileRenameVM
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(ReportVM, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'id',
            'file_rename_vm'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method reports_rename_file" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `reports_rename_file`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `reports_rename_file`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'file_rename_vm' in local_var_params:
            body_params = local_var_params['file_rename_vm']
        # 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', 'text/json', 'application/*+json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {
            200: "ReportVM",
            400: "ProblemDetails",
            403: "ProblemDetails",
            402: "ProblemDetails",
            404: "ProblemDetails",
            500: None,
        }

        return self.api_client.call_api(
            '/api/rp/v1/Reports/File/{id}/Rename', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def reports_update_icon(self, id, **kwargs):  # noqa: E501
        """Update a files's icon  # noqa: E501

        User with Update Icon permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.reports_update_icon(id, async_req=True)
        >>> result = thread.get()

        :param id: (required)
        :type id: str
        :param file_icon_vm:
        :type file_icon_vm: FileIconVM
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: ReportVM
        """
        kwargs['_return_http_data_only'] = True
        return self.reports_update_icon_with_http_info(id, **kwargs)  # noqa: E501

    def reports_update_icon_with_http_info(self, id, **kwargs):  # noqa: E501
        """Update a files's icon  # noqa: E501

        User with Update Icon permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.reports_update_icon_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: (required)
        :type id: str
        :param file_icon_vm:
        :type file_icon_vm: FileIconVM
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(ReportVM, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'id',
            'file_icon_vm'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method reports_update_icon" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `reports_update_icon`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `reports_update_icon`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'file_icon_vm' in local_var_params:
            body_params = local_var_params['file_icon_vm']
        # 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', 'text/json', 'application/*+json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {
            200: "ReportVM",
            400: "ProblemDetails",
            403: "ProblemDetails",
            402: "ProblemDetails",
            404: "ProblemDetails",
            500: None,
        }

        return self.api_client.call_api(
            '/api/rp/v1/Reports/File/{id}/Icon', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def reports_update_permissions(self, id, **kwargs):  # noqa: E501
        """Update permissions  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.reports_update_permissions(id, async_req=True)
        >>> result = thread.get()

        :param id: (required)
        :type id: str
        :param update_file_permissions_vm:
        :type update_file_permissions_vm: UpdateFilePermissionsVM
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """
        kwargs['_return_http_data_only'] = True
        return self.reports_update_permissions_with_http_info(id, **kwargs)  # noqa: E501

    def reports_update_permissions_with_http_info(self, id, **kwargs):  # noqa: E501
        """Update permissions  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.reports_update_permissions_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: (required)
        :type id: str
        :param update_file_permissions_vm:
        :type update_file_permissions_vm: UpdateFilePermissionsVM
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """

        local_var_params = locals()

        all_params = [
            'id',
            'update_file_permissions_vm'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method reports_update_permissions" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `reports_update_permissions`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `reports_update_permissions`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'update_file_permissions_vm' in local_var_params:
            body_params = local_var_params['update_file_permissions_vm']
        # 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', 'text/json', 'application/*+json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {}

        return self.api_client.call_api(
            '/api/rp/v1/Reports/File/{id}/permissions', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def reports_update_tags(self, id, **kwargs):  # noqa: E501
        """Update tags  # noqa: E501

        User with Update Tags permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.reports_update_tags(id, async_req=True)
        >>> result = thread.get()

        :param id: (required)
        :type id: str
        :param file_tags_update_vm:
        :type file_tags_update_vm: FileTagsUpdateVM
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: ReportVM
        """
        kwargs['_return_http_data_only'] = True
        return self.reports_update_tags_with_http_info(id, **kwargs)  # noqa: E501

    def reports_update_tags_with_http_info(self, id, **kwargs):  # noqa: E501
        """Update tags  # noqa: E501

        User with Update Tags permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.reports_update_tags_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: (required)
        :type id: str
        :param file_tags_update_vm:
        :type file_tags_update_vm: FileTagsUpdateVM
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(ReportVM, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'id',
            'file_tags_update_vm'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method reports_update_tags" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `reports_update_tags`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `reports_update_tags`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'file_tags_update_vm' in local_var_params:
            body_params = local_var_params['file_tags_update_vm']
        # 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', 'text/json', 'application/*+json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {
            200: "ReportVM",
            400: "ProblemDetails",
            403: "ProblemDetails",
            402: "ProblemDetails",
            404: "ProblemDetails",
            500: None,
        }

        return self.api_client.call_api(
            '/api/rp/v1/Reports/File/{id}/UpdateTags', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def reports_upload_file(self, id, **kwargs):  # noqa: E501
        """Upload a file to the specified folder  !  # noqa: E501

        User with Create Entity permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.reports_upload_file(id, async_req=True)
        >>> result = thread.get()

        :param id: Identifier of folder (required)
        :type id: str
        :param report_create_vm: file's view model
        :type report_create_vm: ReportCreateVM
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: ReportVM
        """
        kwargs['_return_http_data_only'] = True
        return self.reports_upload_file_with_http_info(id, **kwargs)  # noqa: E501

    def reports_upload_file_with_http_info(self, id, **kwargs):  # noqa: E501
        """Upload a file to the specified folder  !  # noqa: E501

        User with Create Entity permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.reports_upload_file_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: Identifier of folder (required)
        :type id: str
        :param report_create_vm: file's view model
        :type report_create_vm: ReportCreateVM
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(ReportVM, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'id',
            'report_create_vm'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method reports_upload_file" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `reports_upload_file`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `reports_upload_file`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'report_create_vm' in local_var_params:
            body_params = local_var_params['report_create_vm']
        # 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', 'text/json', 'application/*+json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {
            200: "ReportVM",
            400: "ProblemDetails",
            403: "ProblemDetails",
            402: "ProblemDetails",
            404: "ProblemDetails",
        }

        return self.api_client.call_api(
            '/api/rp/v1/Reports/Folder/{id}/File', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

<filename>fastreport_cloud_sdk/api/reports_api.py
# coding: utf-8

"""
    FastReport Cloud

    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)  # noqa: E501

    The version of the OpenAPI document: v1
    Generated by: https://openapi-generator.tech
"""


from __future__ import absolute_import

import re  # noqa: F401

# python 2 and python 3 compatibility library
import six

from fastreport_cloud_sdk.api_client import ApiClient
from fastreport_cloud_sdk.exceptions import (  # noqa: F401
    ApiTypeError,
    ApiValueError
)


class ReportsApi(object):
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

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

    def report_folder_and_file_get_count(self, id, **kwargs):  # noqa: E501
        """Get count of files and folders what contains in a specified folder  # noqa: E501

        User with a Get Count permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folder_and_file_get_count(id, async_req=True)
        >>> result = thread.get()

        :param id: folder id (required)
        :type id: str
        :param search_pattern: string, that must be incuded in file or folder name to be counted <br />              (leave undefined to count all files and folders)
        :type search_pattern: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: CountVM
        """
        kwargs['_return_http_data_only'] = True
        return self.report_folder_and_file_get_count_with_http_info(id, **kwargs)  # noqa: E501

    def report_folder_and_file_get_count_with_http_info(self, id, **kwargs):  # noqa: E501
        """Get count of files and folders what contains in a specified folder  # noqa: E501

        User with a Get Count permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folder_and_file_get_count_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: folder id (required)
        :type id: str
        :param search_pattern: string, that must be incuded in file or folder name to be counted <br />              (leave undefined to count all files and folders)
        :type search_pattern: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(CountVM, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'id',
            'search_pattern'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method report_folder_and_file_get_count" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `report_folder_and_file_get_count`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `report_folder_and_file_get_count`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        if self.api_client.client_side_validation and ('search_pattern' in local_var_params and  # noqa: E501
                                                        len(local_var_params['search_pattern']) > 100):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `search_pattern` when calling `report_folder_and_file_get_count`, length must be less than or equal to `100`")  # noqa: E501
        if self.api_client.client_side_validation and ('search_pattern' in local_var_params and  # noqa: E501
                                                        len(local_var_params['search_pattern']) < 0):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `search_pattern` when calling `report_folder_and_file_get_count`, length must be greater than or equal to `0`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501

        query_params = []
        if 'search_pattern' in local_var_params and local_var_params['search_pattern'] is not None:  # noqa: E501
            query_params.append(('searchPattern', local_var_params['search_pattern']))  # noqa: E501

        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 = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {
            200: "CountVM",
            400: "ProblemDetails",
            403: "ProblemDetails",
            404: "ProblemDetails",
        }

        return self.api_client.call_api(
            '/api/rp/v1/Reports/Folder/{id}/CountFolderAndFiles', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def report_folder_and_file_get_folders_and_files(self, id, **kwargs):  # noqa: E501
        """Get all folders and files from specified folder  # noqa: E501

        User with a Get Entity permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folder_and_file_get_folders_and_files(id, async_req=True)
        >>> result = thread.get()

        :param id: folder id (required)
        :type id: str
        :param skip: number of folder and files, that have to be skipped
        :type skip: int
        :param take: number of folder and files, that have to be returned
        :type take: int
        :param order_by: indicates a field to sort by
        :type order_by: FileSorting
        :param desc: indicates if sorting is descending
        :type desc: bool
        :param search_pattern:
        :type search_pattern: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: FilesVM
        """
        kwargs['_return_http_data_only'] = True
        return self.report_folder_and_file_get_folders_and_files_with_http_info(id, **kwargs)  # noqa: E501

    def report_folder_and_file_get_folders_and_files_with_http_info(self, id, **kwargs):  # noqa: E501
        """Get all folders and files from specified folder  # noqa: E501

        User with a Get Entity permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folder_and_file_get_folders_and_files_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: folder id (required)
        :type id: str
        :param skip: number of folder and files, that have to be skipped
        :type skip: int
        :param take: number of folder and files, that have to be returned
        :type take: int
        :param order_by: indicates a field to sort by
        :type order_by: FileSorting
        :param desc: indicates if sorting is descending
        :type desc: bool
        :param search_pattern:
        :type search_pattern: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(FilesVM, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'id',
            'skip',
            'take',
            'order_by',
            'desc',
            'search_pattern'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method report_folder_and_file_get_folders_and_files" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `report_folder_and_file_get_folders_and_files`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `report_folder_and_file_get_folders_and_files`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        if self.api_client.client_side_validation and 'skip' in local_var_params and local_var_params['skip'] > 2147483647:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `skip` when calling `report_folder_and_file_get_folders_and_files`, must be a value less than or equal to `2147483647`")  # noqa: E501
        if self.api_client.client_side_validation and 'skip' in local_var_params and local_var_params['skip'] < 0:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `skip` when calling `report_folder_and_file_get_folders_and_files`, must be a value greater than or equal to `0`")  # noqa: E501
        if self.api_client.client_side_validation and 'take' in local_var_params and local_var_params['take'] > 120:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `take` when calling `report_folder_and_file_get_folders_and_files`, must be a value less than or equal to `120`")  # noqa: E501
        if self.api_client.client_side_validation and 'take' in local_var_params and local_var_params['take'] < 1:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `take` when calling `report_folder_and_file_get_folders_and_files`, must be a value greater than or equal to `1`")  # noqa: E501
        if self.api_client.client_side_validation and ('search_pattern' in local_var_params and  # noqa: E501
                                                        len(local_var_params['search_pattern']) > 100):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `search_pattern` when calling `report_folder_and_file_get_folders_and_files`, length must be less than or equal to `100`")  # noqa: E501
        if self.api_client.client_side_validation and ('search_pattern' in local_var_params and  # noqa: E501
                                                        len(local_var_params['search_pattern']) < 0):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `search_pattern` when calling `report_folder_and_file_get_folders_and_files`, length must be greater than or equal to `0`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501

        query_params = []
        if 'skip' in local_var_params and local_var_params['skip'] is not None:  # noqa: E501
            query_params.append(('skip', local_var_params['skip']))  # noqa: E501
        if 'take' in local_var_params and local_var_params['take'] is not None:  # noqa: E501
            query_params.append(('take', local_var_params['take']))  # noqa: E501
        if 'order_by' in local_var_params and local_var_params['order_by'] is not None:  # noqa: E501
            query_params.append(('orderBy', local_var_params['order_by']))  # noqa: E501
        if 'desc' in local_var_params and local_var_params['desc'] is not None:  # noqa: E501
            query_params.append(('desc', local_var_params['desc']))  # noqa: E501
        if 'search_pattern' in local_var_params and local_var_params['search_pattern'] is not None:  # noqa: E501
            query_params.append(('searchPattern', local_var_params['search_pattern']))  # noqa: E501

        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 = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {
            200: "FilesVM",
            400: "ProblemDetails",
            403: "ProblemDetails",
            404: "ProblemDetails",
        }

        return self.api_client.call_api(
            '/api/rp/v1/Reports/Folder/{id}/ListFolderAndFiles', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def report_folders_copy_folder(self, id, folder_id, **kwargs):  # noqa: E501
        """Move folder to a specified folder  # noqa: E501

        User with a Update Place permission for a folder and Create Entity  for a Parent Folder can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_copy_folder(id, folder_id, async_req=True)
        >>> result = thread.get()

        :param id: moving folder id (required)
        :type id: str
        :param folder_id: destination folder id (required)
        :type folder_id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: FileVM
        """
        kwargs['_return_http_data_only'] = True
        return self.report_folders_copy_folder_with_http_info(id, folder_id, **kwargs)  # noqa: E501

    def report_folders_copy_folder_with_http_info(self, id, folder_id, **kwargs):  # noqa: E501
        """Move folder to a specified folder  # noqa: E501

        User with a Update Place permission for a folder and Create Entity  for a Parent Folder can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_copy_folder_with_http_info(id, folder_id, async_req=True)
        >>> result = thread.get()

        :param id: moving folder id (required)
        :type id: str
        :param folder_id: destination folder id (required)
        :type folder_id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(FileVM, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'id',
            'folder_id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method report_folders_copy_folder" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `report_folders_copy_folder`")  # noqa: E501
        # verify the required parameter 'folder_id' is set
        if self.api_client.client_side_validation and ('folder_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['folder_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `folder_id` when calling `report_folders_copy_folder`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `report_folders_copy_folder`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        if self.api_client.client_side_validation and 'folder_id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['folder_id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `folder_id` when calling `report_folders_copy_folder`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501
        if 'folder_id' in local_var_params:
            path_params['folderId'] = local_var_params['folder_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 = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {
            200: "FileVM",
            400: "ProblemDetails",
            403: "ProblemDetails",
            402: "ProblemDetails",
            404: "ProblemDetails",
        }

        return self.api_client.call_api(
            '/api/rp/v1/Reports/Folder/{id}/Copy/{folderId}', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def report_folders_delete_folder(self, id, **kwargs):  # noqa: E501
        """Delete specified folder  # noqa: E501

        User with a Delete Entity permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_delete_folder(id, async_req=True)
        >>> result = thread.get()

        :param id: folder id (required)
        :type id: str
        :param recursive: delete all childs
        :type recursive: bool
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """
        kwargs['_return_http_data_only'] = True
        return self.report_folders_delete_folder_with_http_info(id, **kwargs)  # noqa: E501

    def report_folders_delete_folder_with_http_info(self, id, **kwargs):  # noqa: E501
        """Delete specified folder  # noqa: E501

        User with a Delete Entity permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_delete_folder_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: folder id (required)
        :type id: str
        :param recursive: delete all childs
        :type recursive: bool
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """

        local_var_params = locals()

        all_params = [
            'id',
            'recursive'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method report_folders_delete_folder" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `report_folders_delete_folder`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `report_folders_delete_folder`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501

        query_params = []
        if 'recursive' in local_var_params and local_var_params['recursive'] is not None:  # noqa: E501
            query_params.append(('recursive', local_var_params['recursive']))  # noqa: E501

        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 = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {}

        return self.api_client.call_api(
            '/api/rp/v1/Reports/Folder/{id}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def report_folders_get_breadcrumbs(self, id, **kwargs):  # noqa: E501
        """Get specified folder breadcrumbs  # noqa: E501

        User with a Get Entity permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_get_breadcrumbs(id, async_req=True)
        >>> result = thread.get()

        :param id: folder id (required)
        :type id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: BreadcrumbsVM
        """
        kwargs['_return_http_data_only'] = True
        return self.report_folders_get_breadcrumbs_with_http_info(id, **kwargs)  # noqa: E501

    def report_folders_get_breadcrumbs_with_http_info(self, id, **kwargs):  # noqa: E501
        """Get specified folder breadcrumbs  # noqa: E501

        User with a Get Entity permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_get_breadcrumbs_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: folder id (required)
        :type id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(BreadcrumbsVM, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method report_folders_get_breadcrumbs" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `report_folders_get_breadcrumbs`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `report_folders_get_breadcrumbs`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['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 = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {
            200: "BreadcrumbsVM",
            400: "ProblemDetails",
            403: "ProblemDetails",
            404: "ProblemDetails",
        }

        return self.api_client.call_api(
            '/api/rp/v1/Reports/Folder/{id}/Breadcrumbs', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def report_folders_get_folder(self, id, **kwargs):  # noqa: E501
        """Get specified folder  # noqa: E501

        User with a Get Entity permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_get_folder(id, async_req=True)
        >>> result = thread.get()

        :param id: folder id (required)
        :type id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: FileVM
        """
        kwargs['_return_http_data_only'] = True
        return self.report_folders_get_folder_with_http_info(id, **kwargs)  # noqa: E501

    def report_folders_get_folder_with_http_info(self, id, **kwargs):  # noqa: E501
        """Get specified folder  # noqa: E501

        User with a Get Entity permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_get_folder_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: folder id (required)
        :type id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(FileVM, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method report_folders_get_folder" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `report_folders_get_folder`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `report_folders_get_folder`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['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 = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {
            200: "FileVM",
            400: "ProblemDetails",
            403: "ProblemDetails",
            404: "ProblemDetails",
        }

        return self.api_client.call_api(
            '/api/rp/v1/Reports/Folder/{id}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def report_folders_get_folders(self, id, **kwargs):  # noqa: E501
        """Get all folders from specified folder  # noqa: E501

        User with a Get Entity permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_get_folders(id, async_req=True)
        >>> result = thread.get()

        :param id: folder id (required)
        :type id: str
        :param skip: number of files, that have to be skipped
        :type skip: int
        :param take: number of files, that have to be returned
        :type take: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: FilesVM
        """
        kwargs['_return_http_data_only'] = True
        return self.report_folders_get_folders_with_http_info(id, **kwargs)  # noqa: E501

    def report_folders_get_folders_with_http_info(self, id, **kwargs):  # noqa: E501
        """Get all folders from specified folder  # noqa: E501

        User with a Get Entity permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_get_folders_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: folder id (required)
        :type id: str
        :param skip: number of files, that have to be skipped
        :type skip: int
        :param take: number of files, that have to be returned
        :type take: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(FilesVM, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'id',
            'skip',
            'take'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method report_folders_get_folders" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `report_folders_get_folders`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `report_folders_get_folders`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        if self.api_client.client_side_validation and 'skip' in local_var_params and local_var_params['skip'] > 2147483647:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `skip` when calling `report_folders_get_folders`, must be a value less than or equal to `2147483647`")  # noqa: E501
        if self.api_client.client_side_validation and 'skip' in local_var_params and local_var_params['skip'] < 0:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `skip` when calling `report_folders_get_folders`, must be a value greater than or equal to `0`")  # noqa: E501
        if self.api_client.client_side_validation and 'take' in local_var_params and local_var_params['take'] > 120:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `take` when calling `report_folders_get_folders`, must be a value less than or equal to `120`")  # noqa: E501
        if self.api_client.client_side_validation and 'take' in local_var_params and local_var_params['take'] < 1:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `take` when calling `report_folders_get_folders`, must be a value greater than or equal to `1`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501

        query_params = []
        if 'skip' in local_var_params and local_var_params['skip'] is not None:  # noqa: E501
            query_params.append(('skip', local_var_params['skip']))  # noqa: E501
        if 'take' in local_var_params and local_var_params['take'] is not None:  # noqa: E501
            query_params.append(('take', local_var_params['take']))  # noqa: E501

        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 = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {
            200: "FilesVM",
            400: "ProblemDetails",
            403: "ProblemDetails",
            404: "ProblemDetails",
        }

        return self.api_client.call_api(
            '/api/rp/v1/Reports/Folder/{id}/ListFolders', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def report_folders_get_folders_count(self, id, **kwargs):  # noqa: E501
        """Get count of folders what contains in a specified folder  # noqa: E501

        User with a Get Count permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_get_folders_count(id, async_req=True)
        >>> result = thread.get()

        :param id: folder id (required)
        :type id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: CountVM
        """
        kwargs['_return_http_data_only'] = True
        return self.report_folders_get_folders_count_with_http_info(id, **kwargs)  # noqa: E501

    def report_folders_get_folders_count_with_http_info(self, id, **kwargs):  # noqa: E501
        """Get count of folders what contains in a specified folder  # noqa: E501

        User with a Get Count permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_get_folders_count_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: folder id (required)
        :type id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(CountVM, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method report_folders_get_folders_count" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `report_folders_get_folders_count`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `report_folders_get_folders_count`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['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 = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {
            200: "CountVM",
            400: "ProblemDetails",
            403: "ProblemDetails",
            404: "ProblemDetails",
        }

        return self.api_client.call_api(
            '/api/rp/v1/Reports/Folder/{id}/CountFolders', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def report_folders_get_permissions(self, id, **kwargs):  # noqa: E501
        """Get all folder permissions  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_get_permissions(id, async_req=True)
        >>> result = thread.get()

        :param id: (required)
        :type id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: FilePermissionsVM
        """
        kwargs['_return_http_data_only'] = True
        return self.report_folders_get_permissions_with_http_info(id, **kwargs)  # noqa: E501

    def report_folders_get_permissions_with_http_info(self, id, **kwargs):  # noqa: E501
        """Get all folder permissions  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_get_permissions_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: (required)
        :type id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(FilePermissionsVM, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method report_folders_get_permissions" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `report_folders_get_permissions`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `report_folders_get_permissions`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['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 = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {
            200: "FilePermissionsVM",
            400: "ProblemDetails",
            403: "ProblemDetails",
            404: "ProblemDetails",
        }

        return self.api_client.call_api(
            '/api/rp/v1/Reports/Folder/{id}/permissions', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def report_folders_get_root_folder(self, **kwargs):  # noqa: E501
        """Get user's root folder (without parents)  # noqa: E501

        > Breakchange. Now user model doesn't contain a root folders.  This method can return error 400 and 404 when subscription is not found.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_get_root_folder(async_req=True)
        >>> result = thread.get()

        :param subscription_id:
        :type subscription_id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: FileVM
        """
        kwargs['_return_http_data_only'] = True
        return self.report_folders_get_root_folder_with_http_info(**kwargs)  # noqa: E501

    def report_folders_get_root_folder_with_http_info(self, **kwargs):  # noqa: E501
        """Get user's root folder (without parents)  # noqa: E501

        > Breakchange. Now user model doesn't contain a root folders.  This method can return error 400 and 404 when subscription is not found.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_get_root_folder_with_http_info(async_req=True)
        >>> result = thread.get()

        :param subscription_id:
        :type subscription_id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(FileVM, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'subscription_id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method report_folders_get_root_folder" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'subscription_id' in local_var_params and local_var_params['subscription_id'] is not None:  # noqa: E501
            query_params.append(('subscriptionId', local_var_params['subscription_id']))  # noqa: E501

        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 = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {
            200: "FileVM",
            400: None,
            404: None,
            403: None,
        }

        return self.api_client.call_api(
            '/api/rp/v1/Reports/Root', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def report_folders_move_folder(self, id, folder_id, **kwargs):  # noqa: E501
        """Move folder to a specified folder  # noqa: E501

        User with a Update Place permission for a folder and Create Entity  for a Parent Folder can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_move_folder(id, folder_id, async_req=True)
        >>> result = thread.get()

        :param id: moving folder id (required)
        :type id: str
        :param folder_id: destination folder id (required)
        :type folder_id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: FileVM
        """
        kwargs['_return_http_data_only'] = True
        return self.report_folders_move_folder_with_http_info(id, folder_id, **kwargs)  # noqa: E501

    def report_folders_move_folder_with_http_info(self, id, folder_id, **kwargs):  # noqa: E501
        """Move folder to a specified folder  # noqa: E501

        User with a Update Place permission for a folder and Create Entity  for a Parent Folder can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_move_folder_with_http_info(id, folder_id, async_req=True)
        >>> result = thread.get()

        :param id: moving folder id (required)
        :type id: str
        :param folder_id: destination folder id (required)
        :type folder_id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(FileVM, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'id',
            'folder_id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method report_folders_move_folder" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `report_folders_move_folder`")  # noqa: E501
        # verify the required parameter 'folder_id' is set
        if self.api_client.client_side_validation and ('folder_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['folder_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `folder_id` when calling `report_folders_move_folder`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `report_folders_move_folder`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        if self.api_client.client_side_validation and 'folder_id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['folder_id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `folder_id` when calling `report_folders_move_folder`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501
        if 'folder_id' in local_var_params:
            path_params['folderId'] = local_var_params['folder_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 = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {
            200: "FileVM",
            400: "ProblemDetails",
            403: "ProblemDetails",
            402: "ProblemDetails",
            404: "ProblemDetails",
        }

        return self.api_client.call_api(
            '/api/rp/v1/Reports/Folder/{id}/Move/{folderId}', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def report_folders_post_folder(self, id, **kwargs):  # noqa: E501
        """Create folder  # noqa: E501

        User with a Create Entity permisison can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_post_folder(id, async_req=True)
        >>> result = thread.get()

        :param id: Identifier of parent folder id (required)
        :type id: str
        :param report_folder_create_vm: create VM
        :type report_folder_create_vm: ReportFolderCreateVM
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: FileVM
        """
        kwargs['_return_http_data_only'] = True
        return self.report_folders_post_folder_with_http_info(id, **kwargs)  # noqa: E501

    def report_folders_post_folder_with_http_info(self, id, **kwargs):  # noqa: E501
        """Create folder  # noqa: E501

        User with a Create Entity permisison can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_post_folder_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: Identifier of parent folder id (required)
        :type id: str
        :param report_folder_create_vm: create VM
        :type report_folder_create_vm: ReportFolderCreateVM
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(FileVM, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'id',
            'report_folder_create_vm'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method report_folders_post_folder" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `report_folders_post_folder`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `report_folders_post_folder`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'report_folder_create_vm' in local_var_params:
            body_params = local_var_params['report_folder_create_vm']
        # 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', 'text/json', 'application/*+json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {
            200: "FileVM",
            400: "ProblemDetails",
            403: "ProblemDetails",
            402: "ProblemDetails",
            404: "ProblemDetails",
        }

        return self.api_client.call_api(
            '/api/rp/v1/Reports/Folder/{id}/Folder', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def report_folders_rename_folder(self, id, **kwargs):  # noqa: E501
        """Rename a folder  # noqa: E501

        User with a Update Name permision can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_rename_folder(id, async_req=True)
        >>> result = thread.get()

        :param id: (required)
        :type id: str
        :param folder_rename_vm:
        :type folder_rename_vm: FolderRenameVM
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: FileVM
        """
        kwargs['_return_http_data_only'] = True
        return self.report_folders_rename_folder_with_http_info(id, **kwargs)  # noqa: E501

    def report_folders_rename_folder_with_http_info(self, id, **kwargs):  # noqa: E501
        """Rename a folder  # noqa: E501

        User with a Update Name permision can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_rename_folder_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: (required)
        :type id: str
        :param folder_rename_vm:
        :type folder_rename_vm: FolderRenameVM
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(FileVM, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'id',
            'folder_rename_vm'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method report_folders_rename_folder" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `report_folders_rename_folder`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `report_folders_rename_folder`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'folder_rename_vm' in local_var_params:
            body_params = local_var_params['folder_rename_vm']
        # 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', 'text/json', 'application/*+json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {
            200: "FileVM",
            400: "ProblemDetails",
            403: "ProblemDetails",
            402: "ProblemDetails",
            404: "ProblemDetails",
        }

        return self.api_client.call_api(
            '/api/rp/v1/Reports/Folder/{id}/Rename', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def report_folders_update_icon(self, id, **kwargs):  # noqa: E501
        """Update a folder's icon  # noqa: E501

        User with a Update Icon permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_update_icon(id, async_req=True)
        >>> result = thread.get()

        :param id: Identifier of folder (required)
        :type id: str
        :param folder_icon_vm: Update icon model
        :type folder_icon_vm: FolderIconVM
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: FileVM
        """
        kwargs['_return_http_data_only'] = True
        return self.report_folders_update_icon_with_http_info(id, **kwargs)  # noqa: E501

    def report_folders_update_icon_with_http_info(self, id, **kwargs):  # noqa: E501
        """Update a folder's icon  # noqa: E501

        User with a Update Icon permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_update_icon_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: Identifier of folder (required)
        :type id: str
        :param folder_icon_vm: Update icon model
        :type folder_icon_vm: FolderIconVM
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(FileVM, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'id',
            'folder_icon_vm'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method report_folders_update_icon" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `report_folders_update_icon`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `report_folders_update_icon`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'folder_icon_vm' in local_var_params:
            body_params = local_var_params['folder_icon_vm']
        # 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', 'text/json', 'application/*+json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {
            200: "FileVM",
            400: "ProblemDetails",
            403: "ProblemDetails",
            402: "ProblemDetails",
            404: "ProblemDetails",
        }

        return self.api_client.call_api(
            '/api/rp/v1/Reports/Folder/{id}/Icon', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def report_folders_update_permissions(self, id, **kwargs):  # noqa: E501
        """Update permissions  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_update_permissions(id, async_req=True)
        >>> result = thread.get()

        :param id: (required)
        :type id: str
        :param update_file_permissions_vm:
        :type update_file_permissions_vm: UpdateFilePermissionsVM
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """
        kwargs['_return_http_data_only'] = True
        return self.report_folders_update_permissions_with_http_info(id, **kwargs)  # noqa: E501

    def report_folders_update_permissions_with_http_info(self, id, **kwargs):  # noqa: E501
        """Update permissions  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_update_permissions_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: (required)
        :type id: str
        :param update_file_permissions_vm:
        :type update_file_permissions_vm: UpdateFilePermissionsVM
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """

        local_var_params = locals()

        all_params = [
            'id',
            'update_file_permissions_vm'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method report_folders_update_permissions" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `report_folders_update_permissions`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `report_folders_update_permissions`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'update_file_permissions_vm' in local_var_params:
            body_params = local_var_params['update_file_permissions_vm']
        # 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', 'text/json', 'application/*+json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {}

        return self.api_client.call_api(
            '/api/rp/v1/Reports/{id}/permissions', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def report_folders_update_tags(self, id, **kwargs):  # noqa: E501
        """Update tags  # noqa: E501

        User with a Update Tags permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_update_tags(id, async_req=True)
        >>> result = thread.get()

        :param id: (required)
        :type id: str
        :param folder_tags_update_vm:
        :type folder_tags_update_vm: FolderTagsUpdateVM
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: FileVM
        """
        kwargs['_return_http_data_only'] = True
        return self.report_folders_update_tags_with_http_info(id, **kwargs)  # noqa: E501

    def report_folders_update_tags_with_http_info(self, id, **kwargs):  # noqa: E501
        """Update tags  # noqa: E501

        User with a Update Tags permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_folders_update_tags_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: (required)
        :type id: str
        :param folder_tags_update_vm:
        :type folder_tags_update_vm: FolderTagsUpdateVM
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(FileVM, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'id',
            'folder_tags_update_vm'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method report_folders_update_tags" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `report_folders_update_tags`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `report_folders_update_tags`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'folder_tags_update_vm' in local_var_params:
            body_params = local_var_params['folder_tags_update_vm']
        # 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', 'text/json', 'application/*+json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {
            200: "FileVM",
            400: "ProblemDetails",
            403: "ProblemDetails",
            402: "ProblemDetails",
            404: "ProblemDetails",
        }

        return self.api_client.call_api(
            '/api/rp/v1/Reports/Folder/{id}/UpdateTags', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def reports_copy_file(self, id, folder_id, **kwargs):  # noqa: E501
        """Copy file to a specified folder  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.reports_copy_file(id, folder_id, async_req=True)
        >>> result = thread.get()

        :param id: file id (required)
        :type id: str
        :param folder_id: folder id (required)
        :type folder_id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: ReportVM
        """
        kwargs['_return_http_data_only'] = True
        return self.reports_copy_file_with_http_info(id, folder_id, **kwargs)  # noqa: E501

    def reports_copy_file_with_http_info(self, id, folder_id, **kwargs):  # noqa: E501
        """Copy file to a specified folder  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.reports_copy_file_with_http_info(id, folder_id, async_req=True)
        >>> result = thread.get()

        :param id: file id (required)
        :type id: str
        :param folder_id: folder id (required)
        :type folder_id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(ReportVM, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'id',
            'folder_id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method reports_copy_file" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `reports_copy_file`")  # noqa: E501
        # verify the required parameter 'folder_id' is set
        if self.api_client.client_side_validation and ('folder_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['folder_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `folder_id` when calling `reports_copy_file`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `reports_copy_file`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        if self.api_client.client_side_validation and 'folder_id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['folder_id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `folder_id` when calling `reports_copy_file`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501
        if 'folder_id' in local_var_params:
            path_params['folderId'] = local_var_params['folder_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 = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {
            200: "ReportVM",
            400: "ProblemDetails",
            403: "ProblemDetails",
            402: "ProblemDetails",
            404: "ProblemDetails",
            500: None,
        }

        return self.api_client.call_api(
            '/api/rp/v1/Reports/File/{id}/Copy/{folderId}', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def reports_delete_file(self, id, **kwargs):  # noqa: E501
        """Delete specified file  # noqa: E501

        User with Delete permission can access the method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.reports_delete_file(id, async_req=True)
        >>> result = thread.get()

        :param id: file id (required)
        :type id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """
        kwargs['_return_http_data_only'] = True
        return self.reports_delete_file_with_http_info(id, **kwargs)  # noqa: E501

    def reports_delete_file_with_http_info(self, id, **kwargs):  # noqa: E501
        """Delete specified file  # noqa: E501

        User with Delete permission can access the method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.reports_delete_file_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: file id (required)
        :type id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """

        local_var_params = locals()

        all_params = [
            'id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method reports_delete_file" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `reports_delete_file`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `reports_delete_file`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['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 = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {}

        return self.api_client.call_api(
            '/api/rp/v1/Reports/File/{id}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def reports_export(self, id, **kwargs):  # noqa: E501
        """Export specified report to a specified format  # noqa: E501

        User with Execute Export permission on prepared report and  Create Entity on an export folder can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.reports_export(id, async_req=True)
        >>> result = thread.get()

        :param id: report id (required)
        :type id: str
        :param export_report_vm: export parameters
        :type export_report_vm: ExportReportVM
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: ExportVM
        """
        kwargs['_return_http_data_only'] = True
        return self.reports_export_with_http_info(id, **kwargs)  # noqa: E501

    def reports_export_with_http_info(self, id, **kwargs):  # noqa: E501
        """Export specified report to a specified format  # noqa: E501

        User with Execute Export permission on prepared report and  Create Entity on an export folder can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.reports_export_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: report id (required)
        :type id: str
        :param export_report_vm: export parameters
        :type export_report_vm: ExportReportVM
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(ExportVM, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'id',
            'export_report_vm'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method reports_export" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `reports_export`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `reports_export`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'export_report_vm' in local_var_params:
            body_params = local_var_params['export_report_vm']
        # 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', 'text/json', 'application/*+json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {
            200: "ExportVM",
            400: "ProblemDetails",
            403: "ProblemDetails",
            402: "ProblemDetails",
            404: "ProblemDetails",
        }

        return self.api_client.call_api(
            '/api/rp/v1/Reports/File/{id}/Export', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def reports_get_file(self, id, **kwargs):  # noqa: E501
        """Get specified file  # noqa: E501

        User with Get Entity permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.reports_get_file(id, async_req=True)
        >>> result = thread.get()

        :param id: file id (required)
        :type id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: ReportVM
        """
        kwargs['_return_http_data_only'] = True
        return self.reports_get_file_with_http_info(id, **kwargs)  # noqa: E501

    def reports_get_file_with_http_info(self, id, **kwargs):  # noqa: E501
        """Get specified file  # noqa: E501

        User with Get Entity permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.reports_get_file_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: file id (required)
        :type id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(ReportVM, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method reports_get_file" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `reports_get_file`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `reports_get_file`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['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 = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {
            200: "ReportVM",
            400: "ProblemDetails",
            403: "ProblemDetails",
            404: "ProblemDetails",
            500: None,
        }

        return self.api_client.call_api(
            '/api/rp/v1/Reports/File/{id}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def reports_get_files_count(self, id, **kwargs):  # noqa: E501
        """Get count of files what contains in a specified folder  # noqa: E501

        User with Get Count permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.reports_get_files_count(id, async_req=True)
        >>> result = thread.get()

        :param id: folder id (required)
        :type id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: CountVM
        """
        kwargs['_return_http_data_only'] = True
        return self.reports_get_files_count_with_http_info(id, **kwargs)  # noqa: E501

    def reports_get_files_count_with_http_info(self, id, **kwargs):  # noqa: E501
        """Get count of files what contains in a specified folder  # noqa: E501

        User with Get Count permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.reports_get_files_count_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: folder id (required)
        :type id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(CountVM, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method reports_get_files_count" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `reports_get_files_count`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `reports_get_files_count`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['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 = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {
            200: "CountVM",
            400: "ProblemDetails",
            403: "ProblemDetails",
            404: "ProblemDetails",
            500: None,
        }

        return self.api_client.call_api(
            '/api/rp/v1/Reports/Folder/{id}/CountFiles', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def reports_get_files_list(self, id, **kwargs):  # noqa: E501
        """Get all files from specified folder. <br />  User with Get Entity permission can access this method. <br />  The method will returns minimal infomration about the file: <br />  id, name, size, editedTime, createdTime, tags, status, statusReason.  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.reports_get_files_list(id, async_req=True)
        >>> result = thread.get()

        :param id: folder id (required)
        :type id: str
        :param skip: number of files, that have to be skipped
        :type skip: int
        :param take: number of files, that have to be returned
        :type take: int
        :param search_pattern:
        :type search_pattern: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: ReportsVM
        """
        kwargs['_return_http_data_only'] = True
        return self.reports_get_files_list_with_http_info(id, **kwargs)  # noqa: E501

    def reports_get_files_list_with_http_info(self, id, **kwargs):  # noqa: E501
        """Get all files from specified folder. <br />  User with Get Entity permission can access this method. <br />  The method will returns minimal infomration about the file: <br />  id, name, size, editedTime, createdTime, tags, status, statusReason.  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.reports_get_files_list_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: folder id (required)
        :type id: str
        :param skip: number of files, that have to be skipped
        :type skip: int
        :param take: number of files, that have to be returned
        :type take: int
        :param search_pattern:
        :type search_pattern: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(ReportsVM, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'id',
            'skip',
            'take',
            'search_pattern'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method reports_get_files_list" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `reports_get_files_list`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `reports_get_files_list`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        if self.api_client.client_side_validation and 'skip' in local_var_params and local_var_params['skip'] > 2147483647:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `skip` when calling `reports_get_files_list`, must be a value less than or equal to `2147483647`")  # noqa: E501
        if self.api_client.client_side_validation and 'skip' in local_var_params and local_var_params['skip'] < 0:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `skip` when calling `reports_get_files_list`, must be a value greater than or equal to `0`")  # noqa: E501
        if self.api_client.client_side_validation and 'take' in local_var_params and local_var_params['take'] > 120:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `take` when calling `reports_get_files_list`, must be a value less than or equal to `120`")  # noqa: E501
        if self.api_client.client_side_validation and 'take' in local_var_params and local_var_params['take'] < 1:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `take` when calling `reports_get_files_list`, must be a value greater than or equal to `1`")  # noqa: E501
        if self.api_client.client_side_validation and ('search_pattern' in local_var_params and  # noqa: E501
                                                        len(local_var_params['search_pattern']) > 100):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `search_pattern` when calling `reports_get_files_list`, length must be less than or equal to `100`")  # noqa: E501
        if self.api_client.client_side_validation and ('search_pattern' in local_var_params and  # noqa: E501
                                                        len(local_var_params['search_pattern']) < 0):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `search_pattern` when calling `reports_get_files_list`, length must be greater than or equal to `0`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501

        query_params = []
        if 'skip' in local_var_params and local_var_params['skip'] is not None:  # noqa: E501
            query_params.append(('skip', local_var_params['skip']))  # noqa: E501
        if 'take' in local_var_params and local_var_params['take'] is not None:  # noqa: E501
            query_params.append(('take', local_var_params['take']))  # noqa: E501
        if 'search_pattern' in local_var_params and local_var_params['search_pattern'] is not None:  # noqa: E501
            query_params.append(('searchPattern', local_var_params['search_pattern']))  # noqa: E501

        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 = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {
            200: "ReportsVM",
            400: "ProblemDetails",
            403: "ProblemDetails",
            404: "ProblemDetails",
            500: None,
        }

        return self.api_client.call_api(
            '/api/rp/v1/Reports/Folder/{id}/ListFiles', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def reports_get_permissions(self, id, **kwargs):  # noqa: E501
        """Get all file permissions  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.reports_get_permissions(id, async_req=True)
        >>> result = thread.get()

        :param id: (required)
        :type id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: FilePermissionsVM
        """
        kwargs['_return_http_data_only'] = True
        return self.reports_get_permissions_with_http_info(id, **kwargs)  # noqa: E501

    def reports_get_permissions_with_http_info(self, id, **kwargs):  # noqa: E501
        """Get all file permissions  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.reports_get_permissions_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: (required)
        :type id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(FilePermissionsVM, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method reports_get_permissions" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `reports_get_permissions`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `reports_get_permissions`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['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 = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {
            200: "FilePermissionsVM",
            400: "ProblemDetails",
            403: "ProblemDetails",
            404: "ProblemDetails",
        }

        return self.api_client.call_api(
            '/api/rp/v1/Reports/File/{id}/permissions', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def reports_move_file(self, id, folder_id, **kwargs):  # noqa: E501
        """Move file to a specified folder  # noqa: E501

        User with Update Place permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.reports_move_file(id, folder_id, async_req=True)
        >>> result = thread.get()

        :param id: file id (required)
        :type id: str
        :param folder_id: folder id (required)
        :type folder_id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: ReportVM
        """
        kwargs['_return_http_data_only'] = True
        return self.reports_move_file_with_http_info(id, folder_id, **kwargs)  # noqa: E501

    def reports_move_file_with_http_info(self, id, folder_id, **kwargs):  # noqa: E501
        """Move file to a specified folder  # noqa: E501

        User with Update Place permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.reports_move_file_with_http_info(id, folder_id, async_req=True)
        >>> result = thread.get()

        :param id: file id (required)
        :type id: str
        :param folder_id: folder id (required)
        :type folder_id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(ReportVM, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'id',
            'folder_id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method reports_move_file" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `reports_move_file`")  # noqa: E501
        # verify the required parameter 'folder_id' is set
        if self.api_client.client_side_validation and ('folder_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['folder_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `folder_id` when calling `reports_move_file`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `reports_move_file`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        if self.api_client.client_side_validation and 'folder_id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['folder_id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `folder_id` when calling `reports_move_file`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501
        if 'folder_id' in local_var_params:
            path_params['folderId'] = local_var_params['folder_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 = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {
            200: "ReportVM",
            400: "ProblemDetails",
            403: "ProblemDetails",
            402: "ProblemDetails",
            404: "ProblemDetails",
            500: None,
        }

        return self.api_client.call_api(
            '/api/rp/v1/Reports/File/{id}/Move/{folderId}', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def reports_rename_file(self, id, **kwargs):  # noqa: E501
        """Rename a file  # noqa: E501

        User with Update Name permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.reports_rename_file(id, async_req=True)
        >>> result = thread.get()

        :param id: (required)
        :type id: str
        :param file_rename_vm:
        :type file_rename_vm: FileRenameVM
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: ReportVM
        """
        kwargs['_return_http_data_only'] = True
        return self.reports_rename_file_with_http_info(id, **kwargs)  # noqa: E501

    def reports_rename_file_with_http_info(self, id, **kwargs):  # noqa: E501
        """Rename a file  # noqa: E501

        User with Update Name permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.reports_rename_file_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: (required)
        :type id: str
        :param file_rename_vm:
        :type file_rename_vm: FileRenameVM
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(ReportVM, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'id',
            'file_rename_vm'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method reports_rename_file" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `reports_rename_file`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `reports_rename_file`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'file_rename_vm' in local_var_params:
            body_params = local_var_params['file_rename_vm']
        # 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', 'text/json', 'application/*+json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {
            200: "ReportVM",
            400: "ProblemDetails",
            403: "ProblemDetails",
            402: "ProblemDetails",
            404: "ProblemDetails",
            500: None,
        }

        return self.api_client.call_api(
            '/api/rp/v1/Reports/File/{id}/Rename', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def reports_update_icon(self, id, **kwargs):  # noqa: E501
        """Update a files's icon  # noqa: E501

        User with Update Icon permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.reports_update_icon(id, async_req=True)
        >>> result = thread.get()

        :param id: (required)
        :type id: str
        :param file_icon_vm:
        :type file_icon_vm: FileIconVM
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: ReportVM
        """
        kwargs['_return_http_data_only'] = True
        return self.reports_update_icon_with_http_info(id, **kwargs)  # noqa: E501

    def reports_update_icon_with_http_info(self, id, **kwargs):  # noqa: E501
        """Update a files's icon  # noqa: E501

        User with Update Icon permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.reports_update_icon_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: (required)
        :type id: str
        :param file_icon_vm:
        :type file_icon_vm: FileIconVM
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(ReportVM, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'id',
            'file_icon_vm'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method reports_update_icon" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `reports_update_icon`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `reports_update_icon`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'file_icon_vm' in local_var_params:
            body_params = local_var_params['file_icon_vm']
        # 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', 'text/json', 'application/*+json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {
            200: "ReportVM",
            400: "ProblemDetails",
            403: "ProblemDetails",
            402: "ProblemDetails",
            404: "ProblemDetails",
            500: None,
        }

        return self.api_client.call_api(
            '/api/rp/v1/Reports/File/{id}/Icon', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def reports_update_permissions(self, id, **kwargs):  # noqa: E501
        """Update permissions  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.reports_update_permissions(id, async_req=True)
        >>> result = thread.get()

        :param id: (required)
        :type id: str
        :param update_file_permissions_vm:
        :type update_file_permissions_vm: UpdateFilePermissionsVM
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """
        kwargs['_return_http_data_only'] = True
        return self.reports_update_permissions_with_http_info(id, **kwargs)  # noqa: E501

    def reports_update_permissions_with_http_info(self, id, **kwargs):  # noqa: E501
        """Update permissions  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.reports_update_permissions_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: (required)
        :type id: str
        :param update_file_permissions_vm:
        :type update_file_permissions_vm: UpdateFilePermissionsVM
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """

        local_var_params = locals()

        all_params = [
            'id',
            'update_file_permissions_vm'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method reports_update_permissions" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `reports_update_permissions`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `reports_update_permissions`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'update_file_permissions_vm' in local_var_params:
            body_params = local_var_params['update_file_permissions_vm']
        # 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', 'text/json', 'application/*+json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {}

        return self.api_client.call_api(
            '/api/rp/v1/Reports/File/{id}/permissions', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def reports_update_tags(self, id, **kwargs):  # noqa: E501
        """Update tags  # noqa: E501

        User with Update Tags permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.reports_update_tags(id, async_req=True)
        >>> result = thread.get()

        :param id: (required)
        :type id: str
        :param file_tags_update_vm:
        :type file_tags_update_vm: FileTagsUpdateVM
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: ReportVM
        """
        kwargs['_return_http_data_only'] = True
        return self.reports_update_tags_with_http_info(id, **kwargs)  # noqa: E501

    def reports_update_tags_with_http_info(self, id, **kwargs):  # noqa: E501
        """Update tags  # noqa: E501

        User with Update Tags permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.reports_update_tags_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: (required)
        :type id: str
        :param file_tags_update_vm:
        :type file_tags_update_vm: FileTagsUpdateVM
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(ReportVM, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'id',
            'file_tags_update_vm'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method reports_update_tags" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `reports_update_tags`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `reports_update_tags`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'file_tags_update_vm' in local_var_params:
            body_params = local_var_params['file_tags_update_vm']
        # 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', 'text/json', 'application/*+json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {
            200: "ReportVM",
            400: "ProblemDetails",
            403: "ProblemDetails",
            402: "ProblemDetails",
            404: "ProblemDetails",
            500: None,
        }

        return self.api_client.call_api(
            '/api/rp/v1/Reports/File/{id}/UpdateTags', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def reports_upload_file(self, id, **kwargs):  # noqa: E501
        """Upload a file to the specified folder  !  # noqa: E501

        User with Create Entity permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.reports_upload_file(id, async_req=True)
        >>> result = thread.get()

        :param id: Identifier of folder (required)
        :type id: str
        :param report_create_vm: file's view model
        :type report_create_vm: ReportCreateVM
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: ReportVM
        """
        kwargs['_return_http_data_only'] = True
        return self.reports_upload_file_with_http_info(id, **kwargs)  # noqa: E501

    def reports_upload_file_with_http_info(self, id, **kwargs):  # noqa: E501
        """Upload a file to the specified folder  !  # noqa: E501

        User with Create Entity permission can access this method.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.reports_upload_file_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: Identifier of folder (required)
        :type id: str
        :param report_create_vm: file's view model
        :type report_create_vm: ReportCreateVM
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(ReportVM, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'id',
            'report_create_vm'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method reports_upload_file" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `reports_upload_file`")  # noqa: E501

        if self.api_client.client_side_validation and 'id' in local_var_params and not re.search(r'^[A-Fa-f0-9]{24}$', local_var_params['id']):  # noqa: E501
            raise ApiValueError("Invalid value for parameter `id` when calling `reports_upload_file`, must conform to the pattern `/^[A-Fa-f0-9]{24}$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'report_create_vm' in local_var_params:
            body_params = local_var_params['report_create_vm']
        # 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', 'text/json', 'application/*+json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['ApiKey', 'JWT']  # noqa: E501
        
        response_types_map = {
            200: "ReportVM",
            400: "ProblemDetails",
            403: "ProblemDetails",
            402: "ProblemDetails",
            404: "ProblemDetails",
        }

        return self.api_client.call_api(
            '/api/rp/v1/Reports/Folder/{id}/File', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_types_map=response_types_map,
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

# coding: utf-8 FastReport Cloud      No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)  # noqa: E501      The version of the OpenAPI document: v1     Generated by: https://openapi-generator.tech # noqa: F401 # python 2 and python 3 compatibility library # noqa: F401 NOTE: This class is auto generated by OpenAPI Generator     Ref: https://openapi-generator.tech      Do not edit the class manually. # noqa: E501 Get count of files and folders what contains in a specified folder  # noqa: E501          User with a Get Count permission can access this method.  # noqa: E501         This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.report_folder_and_file_get_count(id, async_req=True)         >>> result = thread.get()          :param id: folder id (required)         :type id: str         :param search_pattern: string, that must be incuded in file or folder name to be counted <br />              (leave undefined to count all files and folders)         :type search_pattern: str         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: CountVM # noqa: E501 # noqa: E501 Get count of files and folders what contains in a specified folder  # noqa: E501          User with a Get Count permission can access this method.  # noqa: E501         This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.report_folder_and_file_get_count_with_http_info(id, async_req=True)         >>> result = thread.get()          :param id: folder id (required)         :type id: str         :param search_pattern: string, that must be incuded in file or folder name to be counted <br />              (leave undefined to count all files and folders)         :type search_pattern: str         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _return_http_data_only: response data without head status code                                        and headers         :type _return_http_data_only: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :param _request_auth: set to override the auth_settings for an a single                               request; this effectively ignores the authentication                               in the spec for a single request.         :type _request_auth: dict, optional         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: tuple(CountVM, status_code(int), headers(HTTPHeaderDict)) # verify the required parameter 'id' is set # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # HTTP header `Accept` # noqa: E501 # Authentication setting # noqa: E501 # noqa: E501 # noqa: E501 Get all folders and files from specified folder  # noqa: E501          User with a Get Entity permission can access this method.  # noqa: E501         This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.report_folder_and_file_get_folders_and_files(id, async_req=True)         >>> result = thread.get()          :param id: folder id (required)         :type id: str         :param skip: number of folder and files, that have to be skipped         :type skip: int         :param take: number of folder and files, that have to be returned         :type take: int         :param order_by: indicates a field to sort by         :type order_by: FileSorting         :param desc: indicates if sorting is descending         :type desc: bool         :param search_pattern:         :type search_pattern: str         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: FilesVM # noqa: E501 # noqa: E501 Get all folders and files from specified folder  # noqa: E501          User with a Get Entity permission can access this method.  # noqa: E501         This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.report_folder_and_file_get_folders_and_files_with_http_info(id, async_req=True)         >>> result = thread.get()          :param id: folder id (required)         :type id: str         :param skip: number of folder and files, that have to be skipped         :type skip: int         :param take: number of folder and files, that have to be returned         :type take: int         :param order_by: indicates a field to sort by         :type order_by: FileSorting         :param desc: indicates if sorting is descending         :type desc: bool         :param search_pattern:         :type search_pattern: str         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _return_http_data_only: response data without head status code                                        and headers         :type _return_http_data_only: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :param _request_auth: set to override the auth_settings for an a single                               request; this effectively ignores the authentication                               in the spec for a single request.         :type _request_auth: dict, optional         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: tuple(FilesVM, status_code(int), headers(HTTPHeaderDict)) # verify the required parameter 'id' is set # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # HTTP header `Accept` # noqa: E501 # Authentication setting # noqa: E501 # noqa: E501 # noqa: E501 Move folder to a specified folder  # noqa: E501          User with a Update Place permission for a folder and Create Entity  for a Parent Folder can access this method.  # noqa: E501         This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.report_folders_copy_folder(id, folder_id, async_req=True)         >>> result = thread.get()          :param id: moving folder id (required)         :type id: str         :param folder_id: destination folder id (required)         :type folder_id: str         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: FileVM # noqa: E501 # noqa: E501 Move folder to a specified folder  # noqa: E501          User with a Update Place permission for a folder and Create Entity  for a Parent Folder can access this method.  # noqa: E501         This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.report_folders_copy_folder_with_http_info(id, folder_id, async_req=True)         >>> result = thread.get()          :param id: moving folder id (required)         :type id: str         :param folder_id: destination folder id (required)         :type folder_id: str         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _return_http_data_only: response data without head status code                                        and headers         :type _return_http_data_only: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :param _request_auth: set to override the auth_settings for an a single                               request; this effectively ignores the authentication                               in the spec for a single request.         :type _request_auth: dict, optional         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: tuple(FileVM, status_code(int), headers(HTTPHeaderDict)) # verify the required parameter 'id' is set # noqa: E501 # noqa: E501 # noqa: E501 # verify the required parameter 'folder_id' is set # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # HTTP header `Accept` # noqa: E501 # Authentication setting # noqa: E501 # noqa: E501 # noqa: E501 Delete specified folder  # noqa: E501          User with a Delete Entity permission can access this method.  # noqa: E501         This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.report_folders_delete_folder(id, async_req=True)         >>> result = thread.get()          :param id: folder id (required)         :type id: str         :param recursive: delete all childs         :type recursive: bool         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: None # noqa: E501 # noqa: E501 Delete specified folder  # noqa: E501          User with a Delete Entity permission can access this method.  # noqa: E501         This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.report_folders_delete_folder_with_http_info(id, async_req=True)         >>> result = thread.get()          :param id: folder id (required)         :type id: str         :param recursive: delete all childs         :type recursive: bool         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _return_http_data_only: response data without head status code                                        and headers         :type _return_http_data_only: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :param _request_auth: set to override the auth_settings for an a single                               request; this effectively ignores the authentication                               in the spec for a single request.         :type _request_auth: dict, optional         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: None # verify the required parameter 'id' is set # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # HTTP header `Accept` # noqa: E501 # Authentication setting # noqa: E501 # noqa: E501 # noqa: E501 Get specified folder breadcrumbs  # noqa: E501          User with a Get Entity permission can access this method.  # noqa: E501         This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.report_folders_get_breadcrumbs(id, async_req=True)         >>> result = thread.get()          :param id: folder id (required)         :type id: str         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: BreadcrumbsVM # noqa: E501 # noqa: E501 Get specified folder breadcrumbs  # noqa: E501          User with a Get Entity permission can access this method.  # noqa: E501         This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.report_folders_get_breadcrumbs_with_http_info(id, async_req=True)         >>> result = thread.get()          :param id: folder id (required)         :type id: str         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _return_http_data_only: response data without head status code                                        and headers         :type _return_http_data_only: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :param _request_auth: set to override the auth_settings for an a single                               request; this effectively ignores the authentication                               in the spec for a single request.         :type _request_auth: dict, optional         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: tuple(BreadcrumbsVM, status_code(int), headers(HTTPHeaderDict)) # verify the required parameter 'id' is set # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # HTTP header `Accept` # noqa: E501 # Authentication setting # noqa: E501 # noqa: E501 # noqa: E501 Get specified folder  # noqa: E501          User with a Get Entity permission can access this method.  # noqa: E501         This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.report_folders_get_folder(id, async_req=True)         >>> result = thread.get()          :param id: folder id (required)         :type id: str         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: FileVM # noqa: E501 # noqa: E501 Get specified folder  # noqa: E501          User with a Get Entity permission can access this method.  # noqa: E501         This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.report_folders_get_folder_with_http_info(id, async_req=True)         >>> result = thread.get()          :param id: folder id (required)         :type id: str         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _return_http_data_only: response data without head status code                                        and headers         :type _return_http_data_only: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :param _request_auth: set to override the auth_settings for an a single                               request; this effectively ignores the authentication                               in the spec for a single request.         :type _request_auth: dict, optional         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: tuple(FileVM, status_code(int), headers(HTTPHeaderDict)) # verify the required parameter 'id' is set # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # HTTP header `Accept` # noqa: E501 # Authentication setting # noqa: E501 # noqa: E501 # noqa: E501 Get all folders from specified folder  # noqa: E501          User with a Get Entity permission can access this method.  # noqa: E501         This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.report_folders_get_folders(id, async_req=True)         >>> result = thread.get()          :param id: folder id (required)         :type id: str         :param skip: number of files, that have to be skipped         :type skip: int         :param take: number of files, that have to be returned         :type take: int         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: FilesVM # noqa: E501 # noqa: E501 Get all folders from specified folder  # noqa: E501          User with a Get Entity permission can access this method.  # noqa: E501         This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.report_folders_get_folders_with_http_info(id, async_req=True)         >>> result = thread.get()          :param id: folder id (required)         :type id: str         :param skip: number of files, that have to be skipped         :type skip: int         :param take: number of files, that have to be returned         :type take: int         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _return_http_data_only: response data without head status code                                        and headers         :type _return_http_data_only: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :param _request_auth: set to override the auth_settings for an a single                               request; this effectively ignores the authentication                               in the spec for a single request.         :type _request_auth: dict, optional         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: tuple(FilesVM, status_code(int), headers(HTTPHeaderDict)) # verify the required parameter 'id' is set # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # HTTP header `Accept` # noqa: E501 # Authentication setting # noqa: E501 # noqa: E501 # noqa: E501 Get count of folders what contains in a specified folder  # noqa: E501          User with a Get Count permission can access this method.  # noqa: E501         This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.report_folders_get_folders_count(id, async_req=True)         >>> result = thread.get()          :param id: folder id (required)         :type id: str         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: CountVM # noqa: E501 # noqa: E501 Get count of folders what contains in a specified folder  # noqa: E501          User with a Get Count permission can access this method.  # noqa: E501         This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.report_folders_get_folders_count_with_http_info(id, async_req=True)         >>> result = thread.get()          :param id: folder id (required)         :type id: str         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _return_http_data_only: response data without head status code                                        and headers         :type _return_http_data_only: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :param _request_auth: set to override the auth_settings for an a single                               request; this effectively ignores the authentication                               in the spec for a single request.         :type _request_auth: dict, optional         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: tuple(CountVM, status_code(int), headers(HTTPHeaderDict)) # verify the required parameter 'id' is set # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # HTTP header `Accept` # noqa: E501 # Authentication setting # noqa: E501 # noqa: E501 # noqa: E501 Get all folder permissions  # noqa: E501          This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.report_folders_get_permissions(id, async_req=True)         >>> result = thread.get()          :param id: (required)         :type id: str         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: FilePermissionsVM # noqa: E501 # noqa: E501 Get all folder permissions  # noqa: E501          This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.report_folders_get_permissions_with_http_info(id, async_req=True)         >>> result = thread.get()          :param id: (required)         :type id: str         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _return_http_data_only: response data without head status code                                        and headers         :type _return_http_data_only: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :param _request_auth: set to override the auth_settings for an a single                               request; this effectively ignores the authentication                               in the spec for a single request.         :type _request_auth: dict, optional         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: tuple(FilePermissionsVM, status_code(int), headers(HTTPHeaderDict)) # verify the required parameter 'id' is set # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # HTTP header `Accept` # noqa: E501 # Authentication setting # noqa: E501 # noqa: E501 # noqa: E501 Get user's root folder (without parents)  # noqa: E501          > Breakchange. Now user model doesn't contain a root folders.  This method can return error 400 and 404 when subscription is not found.  # noqa: E501         This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.report_folders_get_root_folder(async_req=True)         >>> result = thread.get()          :param subscription_id:         :type subscription_id: str         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: FileVM # noqa: E501 # noqa: E501 Get user's root folder (without parents)  # noqa: E501          > Breakchange. Now user model doesn't contain a root folders.  This method can return error 400 and 404 when subscription is not found.  # noqa: E501         This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.report_folders_get_root_folder_with_http_info(async_req=True)         >>> result = thread.get()          :param subscription_id:         :type subscription_id: str         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _return_http_data_only: response data without head status code                                        and headers         :type _return_http_data_only: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :param _request_auth: set to override the auth_settings for an a single                               request; this effectively ignores the authentication                               in the spec for a single request.         :type _request_auth: dict, optional         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: tuple(FileVM, status_code(int), headers(HTTPHeaderDict)) # noqa: E501 # noqa: E501 # HTTP header `Accept` # noqa: E501 # Authentication setting # noqa: E501 # noqa: E501 # noqa: E501 Move folder to a specified folder  # noqa: E501          User with a Update Place permission for a folder and Create Entity  for a Parent Folder can access this method.  # noqa: E501         This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.report_folders_move_folder(id, folder_id, async_req=True)         >>> result = thread.get()          :param id: moving folder id (required)         :type id: str         :param folder_id: destination folder id (required)         :type folder_id: str         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: FileVM # noqa: E501 # noqa: E501 Move folder to a specified folder  # noqa: E501          User with a Update Place permission for a folder and Create Entity  for a Parent Folder can access this method.  # noqa: E501         This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.report_folders_move_folder_with_http_info(id, folder_id, async_req=True)         >>> result = thread.get()          :param id: moving folder id (required)         :type id: str         :param folder_id: destination folder id (required)         :type folder_id: str         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _return_http_data_only: response data without head status code                                        and headers         :type _return_http_data_only: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :param _request_auth: set to override the auth_settings for an a single                               request; this effectively ignores the authentication                               in the spec for a single request.         :type _request_auth: dict, optional         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: tuple(FileVM, status_code(int), headers(HTTPHeaderDict)) # verify the required parameter 'id' is set # noqa: E501 # noqa: E501 # noqa: E501 # verify the required parameter 'folder_id' is set # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # HTTP header `Accept` # noqa: E501 # Authentication setting # noqa: E501 # noqa: E501 # noqa: E501 Create folder  # noqa: E501          User with a Create Entity permisison can access this method.  # noqa: E501         This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.report_folders_post_folder(id, async_req=True)         >>> result = thread.get()          :param id: Identifier of parent folder id (required)         :type id: str         :param report_folder_create_vm: create VM         :type report_folder_create_vm: ReportFolderCreateVM         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: FileVM # noqa: E501 # noqa: E501 Create folder  # noqa: E501          User with a Create Entity permisison can access this method.  # noqa: E501         This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.report_folders_post_folder_with_http_info(id, async_req=True)         >>> result = thread.get()          :param id: Identifier of parent folder id (required)         :type id: str         :param report_folder_create_vm: create VM         :type report_folder_create_vm: ReportFolderCreateVM         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _return_http_data_only: response data without head status code                                        and headers         :type _return_http_data_only: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :param _request_auth: set to override the auth_settings for an a single                               request; this effectively ignores the authentication                               in the spec for a single request.         :type _request_auth: dict, optional         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: tuple(FileVM, status_code(int), headers(HTTPHeaderDict)) # verify the required parameter 'id' is set # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # HTTP header `Accept` # noqa: E501 # HTTP header `Content-Type` # noqa: E501 # noqa: E501 # Authentication setting # noqa: E501 # noqa: E501 # noqa: E501 Rename a folder  # noqa: E501          User with a Update Name permision can access this method.  # noqa: E501         This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.report_folders_rename_folder(id, async_req=True)         >>> result = thread.get()          :param id: (required)         :type id: str         :param folder_rename_vm:         :type folder_rename_vm: FolderRenameVM         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: FileVM # noqa: E501 # noqa: E501 Rename a folder  # noqa: E501          User with a Update Name permision can access this method.  # noqa: E501         This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.report_folders_rename_folder_with_http_info(id, async_req=True)         >>> result = thread.get()          :param id: (required)         :type id: str         :param folder_rename_vm:         :type folder_rename_vm: FolderRenameVM         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _return_http_data_only: response data without head status code                                        and headers         :type _return_http_data_only: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :param _request_auth: set to override the auth_settings for an a single                               request; this effectively ignores the authentication                               in the spec for a single request.         :type _request_auth: dict, optional         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: tuple(FileVM, status_code(int), headers(HTTPHeaderDict)) # verify the required parameter 'id' is set # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # HTTP header `Accept` # noqa: E501 # HTTP header `Content-Type` # noqa: E501 # noqa: E501 # Authentication setting # noqa: E501 # noqa: E501 # noqa: E501 Update a folder's icon  # noqa: E501          User with a Update Icon permission can access this method.  # noqa: E501         This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.report_folders_update_icon(id, async_req=True)         >>> result = thread.get()          :param id: Identifier of folder (required)         :type id: str         :param folder_icon_vm: Update icon model         :type folder_icon_vm: FolderIconVM         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: FileVM # noqa: E501 # noqa: E501 Update a folder's icon  # noqa: E501          User with a Update Icon permission can access this method.  # noqa: E501         This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.report_folders_update_icon_with_http_info(id, async_req=True)         >>> result = thread.get()          :param id: Identifier of folder (required)         :type id: str         :param folder_icon_vm: Update icon model         :type folder_icon_vm: FolderIconVM         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _return_http_data_only: response data without head status code                                        and headers         :type _return_http_data_only: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :param _request_auth: set to override the auth_settings for an a single                               request; this effectively ignores the authentication                               in the spec for a single request.         :type _request_auth: dict, optional         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: tuple(FileVM, status_code(int), headers(HTTPHeaderDict)) # verify the required parameter 'id' is set # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # HTTP header `Accept` # noqa: E501 # HTTP header `Content-Type` # noqa: E501 # noqa: E501 # Authentication setting # noqa: E501 # noqa: E501 # noqa: E501 Update permissions  # noqa: E501          This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.report_folders_update_permissions(id, async_req=True)         >>> result = thread.get()          :param id: (required)         :type id: str         :param update_file_permissions_vm:         :type update_file_permissions_vm: UpdateFilePermissionsVM         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: None # noqa: E501 # noqa: E501 Update permissions  # noqa: E501          This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.report_folders_update_permissions_with_http_info(id, async_req=True)         >>> result = thread.get()          :param id: (required)         :type id: str         :param update_file_permissions_vm:         :type update_file_permissions_vm: UpdateFilePermissionsVM         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _return_http_data_only: response data without head status code                                        and headers         :type _return_http_data_only: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :param _request_auth: set to override the auth_settings for an a single                               request; this effectively ignores the authentication                               in the spec for a single request.         :type _request_auth: dict, optional         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: None # verify the required parameter 'id' is set # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # HTTP header `Accept` # noqa: E501 # HTTP header `Content-Type` # noqa: E501 # noqa: E501 # Authentication setting # noqa: E501 # noqa: E501 # noqa: E501 Update tags  # noqa: E501          User with a Update Tags permission can access this method.  # noqa: E501         This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.report_folders_update_tags(id, async_req=True)         >>> result = thread.get()          :param id: (required)         :type id: str         :param folder_tags_update_vm:         :type folder_tags_update_vm: FolderTagsUpdateVM         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: FileVM # noqa: E501 # noqa: E501 Update tags  # noqa: E501          User with a Update Tags permission can access this method.  # noqa: E501         This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.report_folders_update_tags_with_http_info(id, async_req=True)         >>> result = thread.get()          :param id: (required)         :type id: str         :param folder_tags_update_vm:         :type folder_tags_update_vm: FolderTagsUpdateVM         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _return_http_data_only: response data without head status code                                        and headers         :type _return_http_data_only: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :param _request_auth: set to override the auth_settings for an a single                               request; this effectively ignores the authentication                               in the spec for a single request.         :type _request_auth: dict, optional         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: tuple(FileVM, status_code(int), headers(HTTPHeaderDict)) # verify the required parameter 'id' is set # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # HTTP header `Accept` # noqa: E501 # HTTP header `Content-Type` # noqa: E501 # noqa: E501 # Authentication setting # noqa: E501 # noqa: E501 # noqa: E501 Copy file to a specified folder  # noqa: E501          This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.reports_copy_file(id, folder_id, async_req=True)         >>> result = thread.get()          :param id: file id (required)         :type id: str         :param folder_id: folder id (required)         :type folder_id: str         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: ReportVM # noqa: E501 # noqa: E501 Copy file to a specified folder  # noqa: E501          This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.reports_copy_file_with_http_info(id, folder_id, async_req=True)         >>> result = thread.get()          :param id: file id (required)         :type id: str         :param folder_id: folder id (required)         :type folder_id: str         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _return_http_data_only: response data without head status code                                        and headers         :type _return_http_data_only: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :param _request_auth: set to override the auth_settings for an a single                               request; this effectively ignores the authentication                               in the spec for a single request.         :type _request_auth: dict, optional         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: tuple(ReportVM, status_code(int), headers(HTTPHeaderDict)) # verify the required parameter 'id' is set # noqa: E501 # noqa: E501 # noqa: E501 # verify the required parameter 'folder_id' is set # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # HTTP header `Accept` # noqa: E501 # Authentication setting # noqa: E501 # noqa: E501 # noqa: E501 Delete specified file  # noqa: E501          User with Delete permission can access the method.  # noqa: E501         This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.reports_delete_file(id, async_req=True)         >>> result = thread.get()          :param id: file id (required)         :type id: str         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: None # noqa: E501 # noqa: E501 Delete specified file  # noqa: E501          User with Delete permission can access the method.  # noqa: E501         This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.reports_delete_file_with_http_info(id, async_req=True)         >>> result = thread.get()          :param id: file id (required)         :type id: str         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _return_http_data_only: response data without head status code                                        and headers         :type _return_http_data_only: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :param _request_auth: set to override the auth_settings for an a single                               request; this effectively ignores the authentication                               in the spec for a single request.         :type _request_auth: dict, optional         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: None # verify the required parameter 'id' is set # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # HTTP header `Accept` # noqa: E501 # Authentication setting # noqa: E501 # noqa: E501 # noqa: E501 Export specified report to a specified format  # noqa: E501          User with Execute Export permission on prepared report and  Create Entity on an export folder can access this method.  # noqa: E501         This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.reports_export(id, async_req=True)         >>> result = thread.get()          :param id: report id (required)         :type id: str         :param export_report_vm: export parameters         :type export_report_vm: ExportReportVM         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: ExportVM # noqa: E501 # noqa: E501 Export specified report to a specified format  # noqa: E501          User with Execute Export permission on prepared report and  Create Entity on an export folder can access this method.  # noqa: E501         This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.reports_export_with_http_info(id, async_req=True)         >>> result = thread.get()          :param id: report id (required)         :type id: str         :param export_report_vm: export parameters         :type export_report_vm: ExportReportVM         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _return_http_data_only: response data without head status code                                        and headers         :type _return_http_data_only: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :param _request_auth: set to override the auth_settings for an a single                               request; this effectively ignores the authentication                               in the spec for a single request.         :type _request_auth: dict, optional         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: tuple(ExportVM, status_code(int), headers(HTTPHeaderDict)) # verify the required parameter 'id' is set # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # HTTP header `Accept` # noqa: E501 # HTTP header `Content-Type` # noqa: E501 # noqa: E501 # Authentication setting # noqa: E501 # noqa: E501 # noqa: E501 Get specified file  # noqa: E501          User with Get Entity permission can access this method.  # noqa: E501         This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.reports_get_file(id, async_req=True)         >>> result = thread.get()          :param id: file id (required)         :type id: str         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: ReportVM # noqa: E501 # noqa: E501 Get specified file  # noqa: E501          User with Get Entity permission can access this method.  # noqa: E501         This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.reports_get_file_with_http_info(id, async_req=True)         >>> result = thread.get()          :param id: file id (required)         :type id: str         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _return_http_data_only: response data without head status code                                        and headers         :type _return_http_data_only: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :param _request_auth: set to override the auth_settings for an a single                               request; this effectively ignores the authentication                               in the spec for a single request.         :type _request_auth: dict, optional         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: tuple(ReportVM, status_code(int), headers(HTTPHeaderDict)) # verify the required parameter 'id' is set # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # HTTP header `Accept` # noqa: E501 # Authentication setting # noqa: E501 # noqa: E501 # noqa: E501 Get count of files what contains in a specified folder  # noqa: E501          User with Get Count permission can access this method.  # noqa: E501         This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.reports_get_files_count(id, async_req=True)         >>> result = thread.get()          :param id: folder id (required)         :type id: str         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: CountVM # noqa: E501 # noqa: E501 Get count of files what contains in a specified folder  # noqa: E501          User with Get Count permission can access this method.  # noqa: E501         This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.reports_get_files_count_with_http_info(id, async_req=True)         >>> result = thread.get()          :param id: folder id (required)         :type id: str         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _return_http_data_only: response data without head status code                                        and headers         :type _return_http_data_only: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :param _request_auth: set to override the auth_settings for an a single                               request; this effectively ignores the authentication                               in the spec for a single request.         :type _request_auth: dict, optional         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: tuple(CountVM, status_code(int), headers(HTTPHeaderDict)) # verify the required parameter 'id' is set # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # HTTP header `Accept` # noqa: E501 # Authentication setting # noqa: E501 # noqa: E501 # noqa: E501 Get all files from specified folder. <br />  User with Get Entity permission can access this method. <br />  The method will returns minimal infomration about the file: <br />  id, name, size, editedTime, createdTime, tags, status, statusReason.  # noqa: E501          This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.reports_get_files_list(id, async_req=True)         >>> result = thread.get()          :param id: folder id (required)         :type id: str         :param skip: number of files, that have to be skipped         :type skip: int         :param take: number of files, that have to be returned         :type take: int         :param search_pattern:         :type search_pattern: str         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: ReportsVM # noqa: E501 # noqa: E501 Get all files from specified folder. <br />  User with Get Entity permission can access this method. <br />  The method will returns minimal infomration about the file: <br />  id, name, size, editedTime, createdTime, tags, status, statusReason.  # noqa: E501          This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.reports_get_files_list_with_http_info(id, async_req=True)         >>> result = thread.get()          :param id: folder id (required)         :type id: str         :param skip: number of files, that have to be skipped         :type skip: int         :param take: number of files, that have to be returned         :type take: int         :param search_pattern:         :type search_pattern: str         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _return_http_data_only: response data without head status code                                        and headers         :type _return_http_data_only: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :param _request_auth: set to override the auth_settings for an a single                               request; this effectively ignores the authentication                               in the spec for a single request.         :type _request_auth: dict, optional         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: tuple(ReportsVM, status_code(int), headers(HTTPHeaderDict)) # verify the required parameter 'id' is set # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # HTTP header `Accept` # noqa: E501 # Authentication setting # noqa: E501 # noqa: E501 # noqa: E501 Get all file permissions  # noqa: E501          This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.reports_get_permissions(id, async_req=True)         >>> result = thread.get()          :param id: (required)         :type id: str         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: FilePermissionsVM # noqa: E501 # noqa: E501 Get all file permissions  # noqa: E501          This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.reports_get_permissions_with_http_info(id, async_req=True)         >>> result = thread.get()          :param id: (required)         :type id: str         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _return_http_data_only: response data without head status code                                        and headers         :type _return_http_data_only: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :param _request_auth: set to override the auth_settings for an a single                               request; this effectively ignores the authentication                               in the spec for a single request.         :type _request_auth: dict, optional         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: tuple(FilePermissionsVM, status_code(int), headers(HTTPHeaderDict)) # verify the required parameter 'id' is set # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # HTTP header `Accept` # noqa: E501 # Authentication setting # noqa: E501 # noqa: E501 # noqa: E501 Move file to a specified folder  # noqa: E501          User with Update Place permission can access this method.  # noqa: E501         This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.reports_move_file(id, folder_id, async_req=True)         >>> result = thread.get()          :param id: file id (required)         :type id: str         :param folder_id: folder id (required)         :type folder_id: str         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: ReportVM # noqa: E501 # noqa: E501 Move file to a specified folder  # noqa: E501          User with Update Place permission can access this method.  # noqa: E501         This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.reports_move_file_with_http_info(id, folder_id, async_req=True)         >>> result = thread.get()          :param id: file id (required)         :type id: str         :param folder_id: folder id (required)         :type folder_id: str         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _return_http_data_only: response data without head status code                                        and headers         :type _return_http_data_only: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :param _request_auth: set to override the auth_settings for an a single                               request; this effectively ignores the authentication                               in the spec for a single request.         :type _request_auth: dict, optional         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: tuple(ReportVM, status_code(int), headers(HTTPHeaderDict)) # verify the required parameter 'id' is set # noqa: E501 # noqa: E501 # noqa: E501 # verify the required parameter 'folder_id' is set # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # HTTP header `Accept` # noqa: E501 # Authentication setting # noqa: E501 # noqa: E501 # noqa: E501 Rename a file  # noqa: E501          User with Update Name permission can access this method.  # noqa: E501         This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.reports_rename_file(id, async_req=True)         >>> result = thread.get()          :param id: (required)         :type id: str         :param file_rename_vm:         :type file_rename_vm: FileRenameVM         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: ReportVM # noqa: E501 # noqa: E501 Rename a file  # noqa: E501          User with Update Name permission can access this method.  # noqa: E501         This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.reports_rename_file_with_http_info(id, async_req=True)         >>> result = thread.get()          :param id: (required)         :type id: str         :param file_rename_vm:         :type file_rename_vm: FileRenameVM         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _return_http_data_only: response data without head status code                                        and headers         :type _return_http_data_only: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :param _request_auth: set to override the auth_settings for an a single                               request; this effectively ignores the authentication                               in the spec for a single request.         :type _request_auth: dict, optional         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: tuple(ReportVM, status_code(int), headers(HTTPHeaderDict)) # verify the required parameter 'id' is set # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # HTTP header `Accept` # noqa: E501 # HTTP header `Content-Type` # noqa: E501 # noqa: E501 # Authentication setting # noqa: E501 # noqa: E501 # noqa: E501 Update a files's icon  # noqa: E501          User with Update Icon permission can access this method.  # noqa: E501         This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.reports_update_icon(id, async_req=True)         >>> result = thread.get()          :param id: (required)         :type id: str         :param file_icon_vm:         :type file_icon_vm: FileIconVM         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: ReportVM # noqa: E501 # noqa: E501 Update a files's icon  # noqa: E501          User with Update Icon permission can access this method.  # noqa: E501         This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.reports_update_icon_with_http_info(id, async_req=True)         >>> result = thread.get()          :param id: (required)         :type id: str         :param file_icon_vm:         :type file_icon_vm: FileIconVM         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _return_http_data_only: response data without head status code                                        and headers         :type _return_http_data_only: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :param _request_auth: set to override the auth_settings for an a single                               request; this effectively ignores the authentication                               in the spec for a single request.         :type _request_auth: dict, optional         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: tuple(ReportVM, status_code(int), headers(HTTPHeaderDict)) # verify the required parameter 'id' is set # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # HTTP header `Accept` # noqa: E501 # HTTP header `Content-Type` # noqa: E501 # noqa: E501 # Authentication setting # noqa: E501 # noqa: E501 # noqa: E501 Update permissions  # noqa: E501          This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.reports_update_permissions(id, async_req=True)         >>> result = thread.get()          :param id: (required)         :type id: str         :param update_file_permissions_vm:         :type update_file_permissions_vm: UpdateFilePermissionsVM         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: None # noqa: E501 # noqa: E501 Update permissions  # noqa: E501          This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.reports_update_permissions_with_http_info(id, async_req=True)         >>> result = thread.get()          :param id: (required)         :type id: str         :param update_file_permissions_vm:         :type update_file_permissions_vm: UpdateFilePermissionsVM         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _return_http_data_only: response data without head status code                                        and headers         :type _return_http_data_only: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :param _request_auth: set to override the auth_settings for an a single                               request; this effectively ignores the authentication                               in the spec for a single request.         :type _request_auth: dict, optional         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: None # verify the required parameter 'id' is set # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # HTTP header `Accept` # noqa: E501 # HTTP header `Content-Type` # noqa: E501 # noqa: E501 # Authentication setting # noqa: E501 # noqa: E501 # noqa: E501 Update tags  # noqa: E501          User with Update Tags permission can access this method.  # noqa: E501         This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.reports_update_tags(id, async_req=True)         >>> result = thread.get()          :param id: (required)         :type id: str         :param file_tags_update_vm:         :type file_tags_update_vm: FileTagsUpdateVM         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: ReportVM # noqa: E501 # noqa: E501 Update tags  # noqa: E501          User with Update Tags permission can access this method.  # noqa: E501         This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.reports_update_tags_with_http_info(id, async_req=True)         >>> result = thread.get()          :param id: (required)         :type id: str         :param file_tags_update_vm:         :type file_tags_update_vm: FileTagsUpdateVM         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _return_http_data_only: response data without head status code                                        and headers         :type _return_http_data_only: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :param _request_auth: set to override the auth_settings for an a single                               request; this effectively ignores the authentication                               in the spec for a single request.         :type _request_auth: dict, optional         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: tuple(ReportVM, status_code(int), headers(HTTPHeaderDict)) # verify the required parameter 'id' is set # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # HTTP header `Accept` # noqa: E501 # HTTP header `Content-Type` # noqa: E501 # noqa: E501 # Authentication setting # noqa: E501 # noqa: E501 # noqa: E501 Upload a file to the specified folder  !  # noqa: E501          User with Create Entity permission can access this method.  # noqa: E501         This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.reports_upload_file(id, async_req=True)         >>> result = thread.get()          :param id: Identifier of folder (required)         :type id: str         :param report_create_vm: file's view model         :type report_create_vm: ReportCreateVM         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: ReportVM # noqa: E501 # noqa: E501 Upload a file to the specified folder  !  # noqa: E501          User with Create Entity permission can access this method.  # noqa: E501         This method makes a synchronous HTTP request by default. To make an         asynchronous HTTP request, please pass async_req=True          >>> thread = api.reports_upload_file_with_http_info(id, async_req=True)         >>> result = thread.get()          :param id: Identifier of folder (required)         :type id: str         :param report_create_vm: file's view model         :type report_create_vm: ReportCreateVM         :param async_req: Whether to execute the request asynchronously.         :type async_req: bool, optional         :param _return_http_data_only: response data without head status code                                        and headers         :type _return_http_data_only: bool, optional         :param _preload_content: if False, the urllib3.HTTPResponse object will                                  be returned without reading/decoding response                                  data. Default is True.         :type _preload_content: bool, optional         :param _request_timeout: timeout setting for this request. If one                                  number provided, it will be total request                                  timeout. It can also be a pair (tuple) of                                  (connection, read) timeouts.         :param _request_auth: set to override the auth_settings for an a single                               request; this effectively ignores the authentication                               in the spec for a single request.         :type _request_auth: dict, optional         :return: Returns the result object.                  If the method is called asynchronously,                  returns the request thread.         :rtype: tuple(ReportVM, status_code(int), headers(HTTPHeaderDict)) # verify the required parameter 'id' is set # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # noqa: E501 # HTTP header `Accept` # noqa: E501 # HTTP header `Content-Type` # noqa: E501 # noqa: E501 # Authentication setting # noqa: E501 # noqa: E501