text: # 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'))
  