=begin
#Onfido API v3.6

#The Onfido API (v3.6)

The version of the OpenAPI document: v3.6

Generated by: https://openapi-generator.tech
Generator version: 7.6.0

=end

require 'cgi'

module Onfido
  class DefaultApi
    attr_accessor :api_client

    def initialize(api_client = ApiClient.default)
      @api_client = api_client
    end
    # Cancel report
    # Cancels single paused reports. 
    # @param report_id [String] 
    # @param [Hash] opts the optional parameters
    # @return [nil]
    def cancel_report(report_id, opts = {})
      cancel_report_with_http_info(report_id, opts)
      nil
    end

    # Cancel report
    # Cancels single paused reports. 
    # @param report_id [String] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(nil, Integer, Hash)>] nil, response status code and response headers
    def cancel_report_with_http_info(report_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.cancel_report ...'
      end
      # verify the required parameter 'report_id' is set
      if @api_client.config.client_side_validation && report_id.nil?
        fail ArgumentError, "Missing the required parameter 'report_id' when calling DefaultApi.cancel_report"
      end
      # resource path
      local_var_path = '/reports/{report_id}/cancel'.sub('{' + 'report_id' + '}', CGI.escape(report_id.to_s))

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body]

      # return_type
      return_type = opts[:debug_return_type]

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.cancel_report",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#cancel_report\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Complete Task
    # Completes a Send / Receive Data Task. 
    # @param workflow_run_id [String] The unique identifier of the Workflow Run to which the Task belongs.
    # @param task_id [String] The identifier of the Task you want to complete.
    # @param complete_task_builder [CompleteTaskBuilder] 
    # @param [Hash] opts the optional parameters
    # @return [nil]
    def complete_task(workflow_run_id, task_id, complete_task_builder, opts = {})
      complete_task_with_http_info(workflow_run_id, task_id, complete_task_builder, opts)
      nil
    end

    # Complete Task
    # Completes a Send / Receive Data Task. 
    # @param workflow_run_id [String] The unique identifier of the Workflow Run to which the Task belongs.
    # @param task_id [String] The identifier of the Task you want to complete.
    # @param complete_task_builder [CompleteTaskBuilder] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(nil, Integer, Hash)>] nil, response status code and response headers
    def complete_task_with_http_info(workflow_run_id, task_id, complete_task_builder, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.complete_task ...'
      end
      # verify the required parameter 'workflow_run_id' is set
      if @api_client.config.client_side_validation && workflow_run_id.nil?
        fail ArgumentError, "Missing the required parameter 'workflow_run_id' when calling DefaultApi.complete_task"
      end
      # verify the required parameter 'task_id' is set
      if @api_client.config.client_side_validation && task_id.nil?
        fail ArgumentError, "Missing the required parameter 'task_id' when calling DefaultApi.complete_task"
      end
      # verify the required parameter 'complete_task_builder' is set
      if @api_client.config.client_side_validation && complete_task_builder.nil?
        fail ArgumentError, "Missing the required parameter 'complete_task_builder' when calling DefaultApi.complete_task"
      end
      # resource path
      local_var_path = '/workflow_runs/{workflow_run_id}/tasks/{task_id}/complete'.sub('{' + 'workflow_run_id' + '}', CGI.escape(workflow_run_id.to_s)).sub('{' + 'task_id' + '}', CGI.escape(task_id.to_s))

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      content_type = @api_client.select_header_content_type(['application/json'])
      if !content_type.nil?
          header_params['Content-Type'] = content_type
      end

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(complete_task_builder)

      # return_type
      return_type = opts[:debug_return_type]

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.complete_task",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#complete_task\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Create Applicant
    # Creates a single applicant. Returns an applicant object. 
    # @param applicant_builder [ApplicantBuilder] 
    # @param [Hash] opts the optional parameters
    # @return [Applicant]
    def create_applicant(applicant_builder, opts = {})
      data, _status_code, _headers = create_applicant_with_http_info(applicant_builder, opts)
      data
    end

    # Create Applicant
    # Creates a single applicant. Returns an applicant object. 
    # @param applicant_builder [ApplicantBuilder] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(Applicant, Integer, Hash)>] Applicant data, response status code and response headers
    def create_applicant_with_http_info(applicant_builder, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.create_applicant ...'
      end
      # verify the required parameter 'applicant_builder' is set
      if @api_client.config.client_side_validation && applicant_builder.nil?
        fail ArgumentError, "Missing the required parameter 'applicant_builder' when calling DefaultApi.create_applicant"
      end
      # resource path
      local_var_path = '/applicants'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      content_type = @api_client.select_header_content_type(['application/json'])
      if !content_type.nil?
          header_params['Content-Type'] = content_type
      end

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(applicant_builder)

      # return_type
      return_type = opts[:debug_return_type] || 'Applicant'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.create_applicant",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#create_applicant\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Create a check
    # Initiates a check for an applicant, which can contain one or more reports. Returns a check object. 
    # @param check_builder [CheckBuilder] 
    # @param [Hash] opts the optional parameters
    # @return [Check]
    def create_check(check_builder, opts = {})
      data, _status_code, _headers = create_check_with_http_info(check_builder, opts)
      data
    end

    # Create a check
    # Initiates a check for an applicant, which can contain one or more reports. Returns a check object. 
    # @param check_builder [CheckBuilder] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(Check, Integer, Hash)>] Check data, response status code and response headers
    def create_check_with_http_info(check_builder, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.create_check ...'
      end
      # verify the required parameter 'check_builder' is set
      if @api_client.config.client_side_validation && check_builder.nil?
        fail ArgumentError, "Missing the required parameter 'check_builder' when calling DefaultApi.create_check"
      end
      # resource path
      local_var_path = '/checks'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      content_type = @api_client.select_header_content_type(['application/json'])
      if !content_type.nil?
          header_params['Content-Type'] = content_type
      end

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(check_builder)

      # return_type
      return_type = opts[:debug_return_type] || 'Check'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.create_check",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#create_check\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Create Timeline File for Workflow Run
    # Triggers the generation of the Timeline File for the designated Workflow Run. 
    # @param workflow_run_id [String] The unique identifier of the Workflow Run.
    # @param [Hash] opts the optional parameters
    # @return [TimelineFileReference]
    def create_timeline_file(workflow_run_id, opts = {})
      data, _status_code, _headers = create_timeline_file_with_http_info(workflow_run_id, opts)
      data
    end

    # Create Timeline File for Workflow Run
    # Triggers the generation of the Timeline File for the designated Workflow Run. 
    # @param workflow_run_id [String] The unique identifier of the Workflow Run.
    # @param [Hash] opts the optional parameters
    # @return [Array<(TimelineFileReference, Integer, Hash)>] TimelineFileReference data, response status code and response headers
    def create_timeline_file_with_http_info(workflow_run_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.create_timeline_file ...'
      end
      # verify the required parameter 'workflow_run_id' is set
      if @api_client.config.client_side_validation && workflow_run_id.nil?
        fail ArgumentError, "Missing the required parameter 'workflow_run_id' when calling DefaultApi.create_timeline_file"
      end
      # resource path
      local_var_path = '/workflow_runs/{workflow_run_id}/timeline_file'.sub('{' + 'workflow_run_id' + '}', CGI.escape(workflow_run_id.to_s))

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body]

      # return_type
      return_type = opts[:debug_return_type] || 'TimelineFileReference'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.create_timeline_file",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#create_timeline_file\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Create monitor
    # Creates a new monitor for the applicant 
    # @param watchlist_monitor_builder [WatchlistMonitorBuilder] 
    # @param [Hash] opts the optional parameters
    # @return [WatchlistMonitor]
    def create_watchlist_monitor(watchlist_monitor_builder, opts = {})
      data, _status_code, _headers = create_watchlist_monitor_with_http_info(watchlist_monitor_builder, opts)
      data
    end

    # Create monitor
    # Creates a new monitor for the applicant 
    # @param watchlist_monitor_builder [WatchlistMonitorBuilder] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(WatchlistMonitor, Integer, Hash)>] WatchlistMonitor data, response status code and response headers
    def create_watchlist_monitor_with_http_info(watchlist_monitor_builder, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.create_watchlist_monitor ...'
      end
      # verify the required parameter 'watchlist_monitor_builder' is set
      if @api_client.config.client_side_validation && watchlist_monitor_builder.nil?
        fail ArgumentError, "Missing the required parameter 'watchlist_monitor_builder' when calling DefaultApi.create_watchlist_monitor"
      end
      # resource path
      local_var_path = '/watchlist_monitors'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      content_type = @api_client.select_header_content_type(['application/json'])
      if !content_type.nil?
          header_params['Content-Type'] = content_type
      end

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(watchlist_monitor_builder)

      # return_type
      return_type = opts[:debug_return_type] || 'WatchlistMonitor'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.create_watchlist_monitor",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#create_watchlist_monitor\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Register webhook
    # Registers a webhook. Returns a webhook object. 
    # @param webhook_builder [WebhookBuilder] 
    # @param [Hash] opts the optional parameters
    # @return [Webhook]
    def create_webhook(webhook_builder, opts = {})
      data, _status_code, _headers = create_webhook_with_http_info(webhook_builder, opts)
      data
    end

    # Register webhook
    # Registers a webhook. Returns a webhook object. 
    # @param webhook_builder [WebhookBuilder] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(Webhook, Integer, Hash)>] Webhook data, response status code and response headers
    def create_webhook_with_http_info(webhook_builder, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.create_webhook ...'
      end
      # verify the required parameter 'webhook_builder' is set
      if @api_client.config.client_side_validation && webhook_builder.nil?
        fail ArgumentError, "Missing the required parameter 'webhook_builder' when calling DefaultApi.create_webhook"
      end
      # resource path
      local_var_path = '/webhooks'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      content_type = @api_client.select_header_content_type(['application/json'])
      if !content_type.nil?
          header_params['Content-Type'] = content_type
      end

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(webhook_builder)

      # return_type
      return_type = opts[:debug_return_type] || 'Webhook'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.create_webhook",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#create_webhook\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Create a Workflow Run
    # Creates and starts a Workflow Run. Returns a Workflow Run object. 
    # @param workflow_run_builder [WorkflowRunBuilder] 
    # @param [Hash] opts the optional parameters
    # @return [WorkflowRun]
    def create_workflow_run(workflow_run_builder, opts = {})
      data, _status_code, _headers = create_workflow_run_with_http_info(workflow_run_builder, opts)
      data
    end

    # Create a Workflow Run
    # Creates and starts a Workflow Run. Returns a Workflow Run object. 
    # @param workflow_run_builder [WorkflowRunBuilder] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(WorkflowRun, Integer, Hash)>] WorkflowRun data, response status code and response headers
    def create_workflow_run_with_http_info(workflow_run_builder, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.create_workflow_run ...'
      end
      # verify the required parameter 'workflow_run_builder' is set
      if @api_client.config.client_side_validation && workflow_run_builder.nil?
        fail ArgumentError, "Missing the required parameter 'workflow_run_builder' when calling DefaultApi.create_workflow_run"
      end
      # resource path
      local_var_path = '/workflow_runs'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      content_type = @api_client.select_header_content_type(['application/json'])
      if !content_type.nil?
          header_params['Content-Type'] = content_type
      end

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(workflow_run_builder)

      # return_type
      return_type = opts[:debug_return_type] || 'WorkflowRun'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.create_workflow_run",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#create_workflow_run\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Delete Applicant
    # Deletes a single applicant. 
    # @param applicant_id [String] 
    # @param [Hash] opts the optional parameters
    # @return [nil]
    def delete_applicant(applicant_id, opts = {})
      delete_applicant_with_http_info(applicant_id, opts)
      nil
    end

    # Delete Applicant
    # Deletes a single applicant. 
    # @param applicant_id [String] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(nil, Integer, Hash)>] nil, response status code and response headers
    def delete_applicant_with_http_info(applicant_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.delete_applicant ...'
      end
      # verify the required parameter 'applicant_id' is set
      if @api_client.config.client_side_validation && applicant_id.nil?
        fail ArgumentError, "Missing the required parameter 'applicant_id' when calling DefaultApi.delete_applicant"
      end
      # resource path
      local_var_path = '/applicants/{applicant_id}'.sub('{' + 'applicant_id' + '}', CGI.escape(applicant_id.to_s))

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body]

      # return_type
      return_type = opts[:debug_return_type]

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.delete_applicant",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:DELETE, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#delete_applicant\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Delete monitor
    # Deactivates the given monitor 
    # @param monitor_id [String] 
    # @param [Hash] opts the optional parameters
    # @return [nil]
    def delete_watchlist_monitor(monitor_id, opts = {})
      delete_watchlist_monitor_with_http_info(monitor_id, opts)
      nil
    end

    # Delete monitor
    # Deactivates the given monitor 
    # @param monitor_id [String] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(nil, Integer, Hash)>] nil, response status code and response headers
    def delete_watchlist_monitor_with_http_info(monitor_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.delete_watchlist_monitor ...'
      end
      # verify the required parameter 'monitor_id' is set
      if @api_client.config.client_side_validation && monitor_id.nil?
        fail ArgumentError, "Missing the required parameter 'monitor_id' when calling DefaultApi.delete_watchlist_monitor"
      end
      # resource path
      local_var_path = '/watchlist_monitors/{monitor_id}'.sub('{' + 'monitor_id' + '}', CGI.escape(monitor_id.to_s))

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body]

      # return_type
      return_type = opts[:debug_return_type]

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.delete_watchlist_monitor",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:DELETE, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#delete_watchlist_monitor\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Delete a webhook
    # Deletes a webhook. 
    # @param webhook_id [String] 
    # @param [Hash] opts the optional parameters
    # @return [nil]
    def delete_webhook(webhook_id, opts = {})
      delete_webhook_with_http_info(webhook_id, opts)
      nil
    end

    # Delete a webhook
    # Deletes a webhook. 
    # @param webhook_id [String] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(nil, Integer, Hash)>] nil, response status code and response headers
    def delete_webhook_with_http_info(webhook_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.delete_webhook ...'
      end
      # verify the required parameter 'webhook_id' is set
      if @api_client.config.client_side_validation && webhook_id.nil?
        fail ArgumentError, "Missing the required parameter 'webhook_id' when calling DefaultApi.delete_webhook"
      end
      # resource path
      local_var_path = '/webhooks/{webhook_id}'.sub('{' + 'webhook_id' + '}', CGI.escape(webhook_id.to_s))

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body]

      # return_type
      return_type = opts[:debug_return_type]

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.delete_webhook",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:DELETE, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#delete_webhook\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Download check
    # Downloads a PDF of a check with a given check ID. Returns the binary data representing the PDF. 
    # @param check_id [String] 
    # @param [Hash] opts the optional parameters
    # @return [File]
    def download_check(check_id, opts = {})
      data, _status_code, _headers = download_check_with_http_info(check_id, opts)
      data
    end

    # Download check
    # Downloads a PDF of a check with a given check ID. Returns the binary data representing the PDF. 
    # @param check_id [String] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(File, Integer, Hash)>] File data, response status code and response headers
    def download_check_with_http_info(check_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.download_check ...'
      end
      # verify the required parameter 'check_id' is set
      if @api_client.config.client_side_validation && check_id.nil?
        fail ArgumentError, "Missing the required parameter 'check_id' when calling DefaultApi.download_check"
      end
      # resource path
      local_var_path = '/checks/{check_id}/download'.sub('{' + 'check_id' + '}', CGI.escape(check_id.to_s))

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/pdf', 'application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body]

      # return_type
      return_type = opts[:debug_return_type] || 'File'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.download_check",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#download_check\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Download document
    # Downloads specific documents belonging to an applicant. If successful, the response will be the binary data representing the image. 
    # @param document_id [String] 
    # @param [Hash] opts the optional parameters
    # @return [File]
    def download_document(document_id, opts = {})
      data, _status_code, _headers = download_document_with_http_info(document_id, opts)
      data
    end

    # Download document
    # Downloads specific documents belonging to an applicant. If successful, the response will be the binary data representing the image. 
    # @param document_id [String] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(File, Integer, Hash)>] File data, response status code and response headers
    def download_document_with_http_info(document_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.download_document ...'
      end
      # verify the required parameter 'document_id' is set
      if @api_client.config.client_side_validation && document_id.nil?
        fail ArgumentError, "Missing the required parameter 'document_id' when calling DefaultApi.download_document"
      end
      # resource path
      local_var_path = '/documents/{document_id}/download'.sub('{' + 'document_id' + '}', CGI.escape(document_id.to_s))

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['*/*', 'application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body]

      # return_type
      return_type = opts[:debug_return_type] || 'File'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.download_document",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#download_document\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Download document video
    # Downloads a document video. If successful, the response will be the binary data representing the video. 
    # @param document_id [String] 
    # @param [Hash] opts the optional parameters
    # @return [File]
    def download_document_video(document_id, opts = {})
      data, _status_code, _headers = download_document_video_with_http_info(document_id, opts)
      data
    end

    # Download document video
    # Downloads a document video. If successful, the response will be the binary data representing the video. 
    # @param document_id [String] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(File, Integer, Hash)>] File data, response status code and response headers
    def download_document_video_with_http_info(document_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.download_document_video ...'
      end
      # verify the required parameter 'document_id' is set
      if @api_client.config.client_side_validation && document_id.nil?
        fail ArgumentError, "Missing the required parameter 'document_id' when calling DefaultApi.download_document_video"
      end
      # resource path
      local_var_path = '/documents/{document_id}/video/download'.sub('{' + 'document_id' + '}', CGI.escape(document_id.to_s))

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['*/*', 'application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body]

      # return_type
      return_type = opts[:debug_return_type] || 'File'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.download_document_video",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#download_document_video\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Download ID photo
    # ID photos are downloaded using this endpoint.
    # @param id_photo_id [String] The ID photo&#39;s unique identifier.
    # @param [Hash] opts the optional parameters
    # @return [File]
    def download_id_photo(id_photo_id, opts = {})
      data, _status_code, _headers = download_id_photo_with_http_info(id_photo_id, opts)
      data
    end

    # Download ID photo
    # ID photos are downloaded using this endpoint.
    # @param id_photo_id [String] The ID photo&#39;s unique identifier.
    # @param [Hash] opts the optional parameters
    # @return [Array<(File, Integer, Hash)>] File data, response status code and response headers
    def download_id_photo_with_http_info(id_photo_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.download_id_photo ...'
      end
      # verify the required parameter 'id_photo_id' is set
      if @api_client.config.client_side_validation && id_photo_id.nil?
        fail ArgumentError, "Missing the required parameter 'id_photo_id' when calling DefaultApi.download_id_photo"
      end
      # resource path
      local_var_path = '/id_photos/{id_photo_id}/download'.sub('{' + 'id_photo_id' + '}', CGI.escape(id_photo_id.to_s))

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['*/*', 'application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body]

      # return_type
      return_type = opts[:debug_return_type] || 'File'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.download_id_photo",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#download_id_photo\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Download live photo
    # Live photos are downloaded using this endpoint.
    # @param live_photo_id [String] The live photo&#39;s unique identifier.
    # @param [Hash] opts the optional parameters
    # @return [File]
    def download_live_photo(live_photo_id, opts = {})
      data, _status_code, _headers = download_live_photo_with_http_info(live_photo_id, opts)
      data
    end

    # Download live photo
    # Live photos are downloaded using this endpoint.
    # @param live_photo_id [String] The live photo&#39;s unique identifier.
    # @param [Hash] opts the optional parameters
    # @return [Array<(File, Integer, Hash)>] File data, response status code and response headers
    def download_live_photo_with_http_info(live_photo_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.download_live_photo ...'
      end
      # verify the required parameter 'live_photo_id' is set
      if @api_client.config.client_side_validation && live_photo_id.nil?
        fail ArgumentError, "Missing the required parameter 'live_photo_id' when calling DefaultApi.download_live_photo"
      end
      # resource path
      local_var_path = '/live_photos/{live_photo_id}/download'.sub('{' + 'live_photo_id' + '}', CGI.escape(live_photo_id.to_s))

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['*/*', 'application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body]

      # return_type
      return_type = opts[:debug_return_type] || 'File'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.download_live_photo",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#download_live_photo\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Download live video
    # Live videos are downloaded using this endpoint.
    # @param live_video_id [String] The live video&#39;s unique identifier.
    # @param [Hash] opts the optional parameters
    # @return [File]
    def download_live_video(live_video_id, opts = {})
      data, _status_code, _headers = download_live_video_with_http_info(live_video_id, opts)
      data
    end

    # Download live video
    # Live videos are downloaded using this endpoint.
    # @param live_video_id [String] The live video&#39;s unique identifier.
    # @param [Hash] opts the optional parameters
    # @return [Array<(File, Integer, Hash)>] File data, response status code and response headers
    def download_live_video_with_http_info(live_video_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.download_live_video ...'
      end
      # verify the required parameter 'live_video_id' is set
      if @api_client.config.client_side_validation && live_video_id.nil?
        fail ArgumentError, "Missing the required parameter 'live_video_id' when calling DefaultApi.download_live_video"
      end
      # resource path
      local_var_path = '/live_videos/{live_video_id}/download'.sub('{' + 'live_video_id' + '}', CGI.escape(live_video_id.to_s))

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['*/*', 'application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body]

      # return_type
      return_type = opts[:debug_return_type] || 'File'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.download_live_video",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#download_live_video\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Download live video frame
    # Returns the binary data representing a single frame from a live video.
    # @param live_video_id [String] The live video&#39;s unique identifier.
    # @param [Hash] opts the optional parameters
    # @return [File]
    def download_live_video_frame(live_video_id, opts = {})
      data, _status_code, _headers = download_live_video_frame_with_http_info(live_video_id, opts)
      data
    end

    # Download live video frame
    # Returns the binary data representing a single frame from a live video.
    # @param live_video_id [String] The live video&#39;s unique identifier.
    # @param [Hash] opts the optional parameters
    # @return [Array<(File, Integer, Hash)>] File data, response status code and response headers
    def download_live_video_frame_with_http_info(live_video_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.download_live_video_frame ...'
      end
      # verify the required parameter 'live_video_id' is set
      if @api_client.config.client_side_validation && live_video_id.nil?
        fail ArgumentError, "Missing the required parameter 'live_video_id' when calling DefaultApi.download_live_video_frame"
      end
      # resource path
      local_var_path = '/live_videos/{live_video_id}/frame'.sub('{' + 'live_video_id' + '}', CGI.escape(live_video_id.to_s))

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['*/*', 'application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body]

      # return_type
      return_type = opts[:debug_return_type] || 'File'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.download_live_video_frame",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#download_live_video_frame\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Download motion capture
    # Motion captures are downloaded using this endpoint.
    # @param motion_capture_id [String] The motion capture&#39;s unique identifier.
    # @param [Hash] opts the optional parameters
    # @return [File]
    def download_motion_capture(motion_capture_id, opts = {})
      data, _status_code, _headers = download_motion_capture_with_http_info(motion_capture_id, opts)
      data
    end

    # Download motion capture
    # Motion captures are downloaded using this endpoint.
    # @param motion_capture_id [String] The motion capture&#39;s unique identifier.
    # @param [Hash] opts the optional parameters
    # @return [Array<(File, Integer, Hash)>] File data, response status code and response headers
    def download_motion_capture_with_http_info(motion_capture_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.download_motion_capture ...'
      end
      # verify the required parameter 'motion_capture_id' is set
      if @api_client.config.client_side_validation && motion_capture_id.nil?
        fail ArgumentError, "Missing the required parameter 'motion_capture_id' when calling DefaultApi.download_motion_capture"
      end
      # resource path
      local_var_path = '/motion_captures/{motion_capture_id}/download'.sub('{' + 'motion_capture_id' + '}', CGI.escape(motion_capture_id.to_s))

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['*/*', 'application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body]

      # return_type
      return_type = opts[:debug_return_type] || 'File'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.download_motion_capture",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#download_motion_capture\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Download motion capture frame
    # Instead of the whole capture binary, a single frame can be downloaded using this endpoint. Returns the binary data representing the frame.
    # @param motion_capture_id [String] The motion capture&#39;s unique identifier.
    # @param [Hash] opts the optional parameters
    # @return [File]
    def download_motion_capture_frame(motion_capture_id, opts = {})
      data, _status_code, _headers = download_motion_capture_frame_with_http_info(motion_capture_id, opts)
      data
    end

    # Download motion capture frame
    # Instead of the whole capture binary, a single frame can be downloaded using this endpoint. Returns the binary data representing the frame.
    # @param motion_capture_id [String] The motion capture&#39;s unique identifier.
    # @param [Hash] opts the optional parameters
    # @return [Array<(File, Integer, Hash)>] File data, response status code and response headers
    def download_motion_capture_frame_with_http_info(motion_capture_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.download_motion_capture_frame ...'
      end
      # verify the required parameter 'motion_capture_id' is set
      if @api_client.config.client_side_validation && motion_capture_id.nil?
        fail ArgumentError, "Missing the required parameter 'motion_capture_id' when calling DefaultApi.download_motion_capture_frame"
      end
      # resource path
      local_var_path = '/motion_captures/{motion_capture_id}/frame'.sub('{' + 'motion_capture_id' + '}', CGI.escape(motion_capture_id.to_s))

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['*/*', 'application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body]

      # return_type
      return_type = opts[:debug_return_type] || 'File'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.download_motion_capture_frame",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#download_motion_capture_frame\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Retrieves the signed document or application form
    # Retrieves the signed document or application form depending on the file_id provided. 
    # @param workflow_run_id [String] The unique identifier of the Workflow Run for which you want to retrieve the signed document.
    # @param file_id [String] The unique identifier of the file which you want to retrieve.
    # @param [Hash] opts the optional parameters
    # @return [File]
    def download_qes_document(workflow_run_id, file_id, opts = {})
      data, _status_code, _headers = download_qes_document_with_http_info(workflow_run_id, file_id, opts)
      data
    end

    # Retrieves the signed document or application form
    # Retrieves the signed document or application form depending on the file_id provided. 
    # @param workflow_run_id [String] The unique identifier of the Workflow Run for which you want to retrieve the signed document.
    # @param file_id [String] The unique identifier of the file which you want to retrieve.
    # @param [Hash] opts the optional parameters
    # @return [Array<(File, Integer, Hash)>] File data, response status code and response headers
    def download_qes_document_with_http_info(workflow_run_id, file_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.download_qes_document ...'
      end
      # verify the required parameter 'workflow_run_id' is set
      if @api_client.config.client_side_validation && workflow_run_id.nil?
        fail ArgumentError, "Missing the required parameter 'workflow_run_id' when calling DefaultApi.download_qes_document"
      end
      # verify the required parameter 'file_id' is set
      if @api_client.config.client_side_validation && file_id.nil?
        fail ArgumentError, "Missing the required parameter 'file_id' when calling DefaultApi.download_qes_document"
      end
      # resource path
      local_var_path = '/qualified_electronic_signature/documents'

      # query parameters
      query_params = opts[:query_params] || {}
      query_params[:'workflow_run_id'] = workflow_run_id
      query_params[:'file_id'] = file_id

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/pdf', 'application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body]

      # return_type
      return_type = opts[:debug_return_type] || 'File'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.download_qes_document",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#download_qes_document\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Retrieve Workflow Run Evidence Summary File
    # Retrieves the signed evidence file for the designated Workflow Run 
    # @param workflow_run_id [String] Workflow Run ID
    # @param [Hash] opts the optional parameters
    # @return [File]
    def download_signed_evidence_file(workflow_run_id, opts = {})
      data, _status_code, _headers = download_signed_evidence_file_with_http_info(workflow_run_id, opts)
      data
    end

    # Retrieve Workflow Run Evidence Summary File
    # Retrieves the signed evidence file for the designated Workflow Run 
    # @param workflow_run_id [String] Workflow Run ID
    # @param [Hash] opts the optional parameters
    # @return [Array<(File, Integer, Hash)>] File data, response status code and response headers
    def download_signed_evidence_file_with_http_info(workflow_run_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.download_signed_evidence_file ...'
      end
      # verify the required parameter 'workflow_run_id' is set
      if @api_client.config.client_side_validation && workflow_run_id.nil?
        fail ArgumentError, "Missing the required parameter 'workflow_run_id' when calling DefaultApi.download_signed_evidence_file"
      end
      # resource path
      local_var_path = '/workflow_runs/{workflow_run_id}/signed_evidence_file'.sub('{' + 'workflow_run_id' + '}', CGI.escape(workflow_run_id.to_s))

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/pdf', 'application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body]

      # return_type
      return_type = opts[:debug_return_type] || 'File'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.download_signed_evidence_file",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#download_signed_evidence_file\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Autofill
    # Extract information from a document 
    # @param extract_request [ExtractRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Extraction]
    def extract(extract_request, opts = {})
      data, _status_code, _headers = extract_with_http_info(extract_request, opts)
      data
    end

    # Autofill
    # Extract information from a document 
    # @param extract_request [ExtractRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(Extraction, Integer, Hash)>] Extraction data, response status code and response headers
    def extract_with_http_info(extract_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.extract ...'
      end
      # verify the required parameter 'extract_request' is set
      if @api_client.config.client_side_validation && extract_request.nil?
        fail ArgumentError, "Missing the required parameter 'extract_request' when calling DefaultApi.extract"
      end
      # resource path
      local_var_path = '/extractions'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      content_type = @api_client.select_header_content_type(['application/json'])
      if !content_type.nil?
          header_params['Content-Type'] = content_type
      end

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(extract_request)

      # return_type
      return_type = opts[:debug_return_type] || 'Extraction'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.extract",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#extract\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Address Picker
    # Search for addresses by postcode 
    # @param postcode [String] 
    # @param [Hash] opts the optional parameters
    # @return [AddressesList]
    def find_addresses(postcode, opts = {})
      data, _status_code, _headers = find_addresses_with_http_info(postcode, opts)
      data
    end

    # Address Picker
    # Search for addresses by postcode 
    # @param postcode [String] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(AddressesList, Integer, Hash)>] AddressesList data, response status code and response headers
    def find_addresses_with_http_info(postcode, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.find_addresses ...'
      end
      # verify the required parameter 'postcode' is set
      if @api_client.config.client_side_validation && postcode.nil?
        fail ArgumentError, "Missing the required parameter 'postcode' when calling DefaultApi.find_addresses"
      end
      # resource path
      local_var_path = '/addresses/pick'

      # query parameters
      query_params = opts[:query_params] || {}
      query_params[:'postcode'] = postcode

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body]

      # return_type
      return_type = opts[:debug_return_type] || 'AddressesList'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.find_addresses",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#find_addresses\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Retrieve Applicant
    # Retrieves a single applicant. Returns an applicant object. 
    # @param applicant_id [String] 
    # @param [Hash] opts the optional parameters
    # @return [Applicant]
    def find_applicant(applicant_id, opts = {})
      data, _status_code, _headers = find_applicant_with_http_info(applicant_id, opts)
      data
    end

    # Retrieve Applicant
    # Retrieves a single applicant. Returns an applicant object. 
    # @param applicant_id [String] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(Applicant, Integer, Hash)>] Applicant data, response status code and response headers
    def find_applicant_with_http_info(applicant_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.find_applicant ...'
      end
      # verify the required parameter 'applicant_id' is set
      if @api_client.config.client_side_validation && applicant_id.nil?
        fail ArgumentError, "Missing the required parameter 'applicant_id' when calling DefaultApi.find_applicant"
      end
      # resource path
      local_var_path = '/applicants/{applicant_id}'.sub('{' + 'applicant_id' + '}', CGI.escape(applicant_id.to_s))

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body]

      # return_type
      return_type = opts[:debug_return_type] || 'Applicant'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.find_applicant",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#find_applicant\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Retrieve a Check
    # Retrieves a single check. Returns a check object. 
    # @param check_id [String] 
    # @param [Hash] opts the optional parameters
    # @return [Check]
    def find_check(check_id, opts = {})
      data, _status_code, _headers = find_check_with_http_info(check_id, opts)
      data
    end

    # Retrieve a Check
    # Retrieves a single check. Returns a check object. 
    # @param check_id [String] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(Check, Integer, Hash)>] Check data, response status code and response headers
    def find_check_with_http_info(check_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.find_check ...'
      end
      # verify the required parameter 'check_id' is set
      if @api_client.config.client_side_validation && check_id.nil?
        fail ArgumentError, "Missing the required parameter 'check_id' when calling DefaultApi.find_check"
      end
      # resource path
      local_var_path = '/checks/{check_id}'.sub('{' + 'check_id' + '}', CGI.escape(check_id.to_s))

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body]

      # return_type
      return_type = opts[:debug_return_type] || 'Check'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.find_check",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#find_check\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Retrieve document
    # A single document can be retrieved by calling this endpoint with the document's unique identifier. 
    # @param document_id [String] 
    # @param [Hash] opts the optional parameters
    # @return [Document]
    def find_document(document_id, opts = {})
      data, _status_code, _headers = find_document_with_http_info(document_id, opts)
      data
    end

    # Retrieve document
    # A single document can be retrieved by calling this endpoint with the document&#39;s unique identifier. 
    # @param document_id [String] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(Document, Integer, Hash)>] Document data, response status code and response headers
    def find_document_with_http_info(document_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.find_document ...'
      end
      # verify the required parameter 'document_id' is set
      if @api_client.config.client_side_validation && document_id.nil?
        fail ArgumentError, "Missing the required parameter 'document_id' when calling DefaultApi.find_document"
      end
      # resource path
      local_var_path = '/documents/{document_id}'.sub('{' + 'document_id' + '}', CGI.escape(document_id.to_s))

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body]

      # return_type
      return_type = opts[:debug_return_type] || 'Document'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.find_document",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#find_document\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Retrieve ID photo
    # Retrieves a single ID photo. Returns a ID photo object. 
    # @param id_photo_id [String] The ID photo&#39;s unique identifier.
    # @param [Hash] opts the optional parameters
    # @return [IdPhoto]
    def find_id_photo(id_photo_id, opts = {})
      data, _status_code, _headers = find_id_photo_with_http_info(id_photo_id, opts)
      data
    end

    # Retrieve ID photo
    # Retrieves a single ID photo. Returns a ID photo object. 
    # @param id_photo_id [String] The ID photo&#39;s unique identifier.
    # @param [Hash] opts the optional parameters
    # @return [Array<(IdPhoto, Integer, Hash)>] IdPhoto data, response status code and response headers
    def find_id_photo_with_http_info(id_photo_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.find_id_photo ...'
      end
      # verify the required parameter 'id_photo_id' is set
      if @api_client.config.client_side_validation && id_photo_id.nil?
        fail ArgumentError, "Missing the required parameter 'id_photo_id' when calling DefaultApi.find_id_photo"
      end
      # resource path
      local_var_path = '/id_photos/{id_photo_id}'.sub('{' + 'id_photo_id' + '}', CGI.escape(id_photo_id.to_s))

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body]

      # return_type
      return_type = opts[:debug_return_type] || 'IdPhoto'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.find_id_photo",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#find_id_photo\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Retrieve live photo
    # Retrieves a single live photo. Returns a live photo object. 
    # @param live_photo_id [String] The live photo&#39;s unique identifier.
    # @param [Hash] opts the optional parameters
    # @return [LivePhoto]
    def find_live_photo(live_photo_id, opts = {})
      data, _status_code, _headers = find_live_photo_with_http_info(live_photo_id, opts)
      data
    end

    # Retrieve live photo
    # Retrieves a single live photo. Returns a live photo object. 
    # @param live_photo_id [String] The live photo&#39;s unique identifier.
    # @param [Hash] opts the optional parameters
    # @return [Array<(LivePhoto, Integer, Hash)>] LivePhoto data, response status code and response headers
    def find_live_photo_with_http_info(live_photo_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.find_live_photo ...'
      end
      # verify the required parameter 'live_photo_id' is set
      if @api_client.config.client_side_validation && live_photo_id.nil?
        fail ArgumentError, "Missing the required parameter 'live_photo_id' when calling DefaultApi.find_live_photo"
      end
      # resource path
      local_var_path = '/live_photos/{live_photo_id}'.sub('{' + 'live_photo_id' + '}', CGI.escape(live_photo_id.to_s))

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body]

      # return_type
      return_type = opts[:debug_return_type] || 'LivePhoto'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.find_live_photo",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#find_live_photo\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Retrieve live video
    # Retrieves a single live video. Returns the corresponding live video object. 
    # @param live_video_id [String] The live video&#39;s unique identifier.
    # @param [Hash] opts the optional parameters
    # @return [LiveVideo]
    def find_live_video(live_video_id, opts = {})
      data, _status_code, _headers = find_live_video_with_http_info(live_video_id, opts)
      data
    end

    # Retrieve live video
    # Retrieves a single live video. Returns the corresponding live video object. 
    # @param live_video_id [String] The live video&#39;s unique identifier.
    # @param [Hash] opts the optional parameters
    # @return [Array<(LiveVideo, Integer, Hash)>] LiveVideo data, response status code and response headers
    def find_live_video_with_http_info(live_video_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.find_live_video ...'
      end
      # verify the required parameter 'live_video_id' is set
      if @api_client.config.client_side_validation && live_video_id.nil?
        fail ArgumentError, "Missing the required parameter 'live_video_id' when calling DefaultApi.find_live_video"
      end
      # resource path
      local_var_path = '/live_videos/{live_video_id}'.sub('{' + 'live_video_id' + '}', CGI.escape(live_video_id.to_s))

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body]

      # return_type
      return_type = opts[:debug_return_type] || 'LiveVideo'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.find_live_video",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#find_live_video\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Retrieve motion capture
    # Retrieves a single motion capture. Returns the corresponding motion capture object. 
    # @param motion_capture_id [String] The motion capture&#39;s unique identifier.
    # @param [Hash] opts the optional parameters
    # @return [MotionCapture]
    def find_motion_capture(motion_capture_id, opts = {})
      data, _status_code, _headers = find_motion_capture_with_http_info(motion_capture_id, opts)
      data
    end

    # Retrieve motion capture
    # Retrieves a single motion capture. Returns the corresponding motion capture object. 
    # @param motion_capture_id [String] The motion capture&#39;s unique identifier.
    # @param [Hash] opts the optional parameters
    # @return [Array<(MotionCapture, Integer, Hash)>] MotionCapture data, response status code and response headers
    def find_motion_capture_with_http_info(motion_capture_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.find_motion_capture ...'
      end
      # verify the required parameter 'motion_capture_id' is set
      if @api_client.config.client_side_validation && motion_capture_id.nil?
        fail ArgumentError, "Missing the required parameter 'motion_capture_id' when calling DefaultApi.find_motion_capture"
      end
      # resource path
      local_var_path = '/motion_captures/{motion_capture_id}'.sub('{' + 'motion_capture_id' + '}', CGI.escape(motion_capture_id.to_s))

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body]

      # return_type
      return_type = opts[:debug_return_type] || 'MotionCapture'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.find_motion_capture",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#find_motion_capture\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Retrieve report
    # A single report can be retrieved using this endpoint with the corresponding unique identifier. 
    # @param report_id [String] 
    # @param [Hash] opts the optional parameters
    # @return [Report]
    def find_report(report_id, opts = {})
      data, _status_code, _headers = find_report_with_http_info(report_id, opts)
      data
    end

    # Retrieve report
    # A single report can be retrieved using this endpoint with the corresponding unique identifier. 
    # @param report_id [String] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(Report, Integer, Hash)>] Report data, response status code and response headers
    def find_report_with_http_info(report_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.find_report ...'
      end
      # verify the required parameter 'report_id' is set
      if @api_client.config.client_side_validation && report_id.nil?
        fail ArgumentError, "Missing the required parameter 'report_id' when calling DefaultApi.find_report"
      end
      # resource path
      local_var_path = '/reports/{report_id}'.sub('{' + 'report_id' + '}', CGI.escape(report_id.to_s))

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body]

      # return_type
      return_type = opts[:debug_return_type] || 'Report'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.find_report",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#find_report\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Retrieve Task
    # A single task can be retrieved by calling this endpoint with the unique identifier of the Task and Workflow Run. 
    # @param workflow_run_id [String] The unique identifier of the Workflow Run to which the Task belongs.
    # @param task_id [String] The identifier of the Task you want to retrieve.
    # @param [Hash] opts the optional parameters
    # @return [Task]
    def find_task(workflow_run_id, task_id, opts = {})
      data, _status_code, _headers = find_task_with_http_info(workflow_run_id, task_id, opts)
      data
    end

    # Retrieve Task
    # A single task can be retrieved by calling this endpoint with the unique identifier of the Task and Workflow Run. 
    # @param workflow_run_id [String] The unique identifier of the Workflow Run to which the Task belongs.
    # @param task_id [String] The identifier of the Task you want to retrieve.
    # @param [Hash] opts the optional parameters
    # @return [Array<(Task, Integer, Hash)>] Task data, response status code and response headers
    def find_task_with_http_info(workflow_run_id, task_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.find_task ...'
      end
      # verify the required parameter 'workflow_run_id' is set
      if @api_client.config.client_side_validation && workflow_run_id.nil?
        fail ArgumentError, "Missing the required parameter 'workflow_run_id' when calling DefaultApi.find_task"
      end
      # verify the required parameter 'task_id' is set
      if @api_client.config.client_side_validation && task_id.nil?
        fail ArgumentError, "Missing the required parameter 'task_id' when calling DefaultApi.find_task"
      end
      # resource path
      local_var_path = '/workflow_runs/{workflow_run_id}/tasks/{task_id}'.sub('{' + 'workflow_run_id' + '}', CGI.escape(workflow_run_id.to_s)).sub('{' + 'task_id' + '}', CGI.escape(task_id.to_s))

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body]

      # return_type
      return_type = opts[:debug_return_type] || 'Task'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.find_task",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#find_task\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Retrieve Timeline File for Workflow Run
    # Retrieves the Timeline File for the designated Workflow Run. 
    # @param workflow_run_id [String] The unique identifier of the Workflow Run.
    # @param timeline_file_id [String] The unique identifier for the Timefile File.
    # @param [Hash] opts the optional parameters
    # @return [File]
    def find_timeline_file(workflow_run_id, timeline_file_id, opts = {})
      data, _status_code, _headers = find_timeline_file_with_http_info(workflow_run_id, timeline_file_id, opts)
      data
    end

    # Retrieve Timeline File for Workflow Run
    # Retrieves the Timeline File for the designated Workflow Run. 
    # @param workflow_run_id [String] The unique identifier of the Workflow Run.
    # @param timeline_file_id [String] The unique identifier for the Timefile File.
    # @param [Hash] opts the optional parameters
    # @return [Array<(File, Integer, Hash)>] File data, response status code and response headers
    def find_timeline_file_with_http_info(workflow_run_id, timeline_file_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.find_timeline_file ...'
      end
      # verify the required parameter 'workflow_run_id' is set
      if @api_client.config.client_side_validation && workflow_run_id.nil?
        fail ArgumentError, "Missing the required parameter 'workflow_run_id' when calling DefaultApi.find_timeline_file"
      end
      # verify the required parameter 'timeline_file_id' is set
      if @api_client.config.client_side_validation && timeline_file_id.nil?
        fail ArgumentError, "Missing the required parameter 'timeline_file_id' when calling DefaultApi.find_timeline_file"
      end
      # resource path
      local_var_path = '/workflow_runs/{workflow_run_id}/timeline_file/{timeline_file_id}'.sub('{' + 'workflow_run_id' + '}', CGI.escape(workflow_run_id.to_s)).sub('{' + 'timeline_file_id' + '}', CGI.escape(timeline_file_id.to_s))

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/pdf', 'application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body]

      # return_type
      return_type = opts[:debug_return_type] || 'File'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.find_timeline_file",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#find_timeline_file\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Retrieve monitor
    # Retrieves a single monitor 
    # @param monitor_id [String] The watchlist monitor&#39;s unique identifier.
    # @param [Hash] opts the optional parameters
    # @return [WatchlistMonitor]
    def find_watchlist_monitor(monitor_id, opts = {})
      data, _status_code, _headers = find_watchlist_monitor_with_http_info(monitor_id, opts)
      data
    end

    # Retrieve monitor
    # Retrieves a single monitor 
    # @param monitor_id [String] The watchlist monitor&#39;s unique identifier.
    # @param [Hash] opts the optional parameters
    # @return [Array<(WatchlistMonitor, Integer, Hash)>] WatchlistMonitor data, response status code and response headers
    def find_watchlist_monitor_with_http_info(monitor_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.find_watchlist_monitor ...'
      end
      # verify the required parameter 'monitor_id' is set
      if @api_client.config.client_side_validation && monitor_id.nil?
        fail ArgumentError, "Missing the required parameter 'monitor_id' when calling DefaultApi.find_watchlist_monitor"
      end
      # resource path
      local_var_path = '/watchlist_monitors/{monitor_id}'.sub('{' + 'monitor_id' + '}', CGI.escape(monitor_id.to_s))

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body]

      # return_type
      return_type = opts[:debug_return_type] || 'WatchlistMonitor'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.find_watchlist_monitor",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#find_watchlist_monitor\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Retrieve a Webhook
    # Retrieves a single webhook. Returns a webhook object. 
    # @param webhook_id [String] 
    # @param [Hash] opts the optional parameters
    # @return [Webhook]
    def find_webhook(webhook_id, opts = {})
      data, _status_code, _headers = find_webhook_with_http_info(webhook_id, opts)
      data
    end

    # Retrieve a Webhook
    # Retrieves a single webhook. Returns a webhook object. 
    # @param webhook_id [String] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(Webhook, Integer, Hash)>] Webhook data, response status code and response headers
    def find_webhook_with_http_info(webhook_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.find_webhook ...'
      end
      # verify the required parameter 'webhook_id' is set
      if @api_client.config.client_side_validation && webhook_id.nil?
        fail ArgumentError, "Missing the required parameter 'webhook_id' when calling DefaultApi.find_webhook"
      end
      # resource path
      local_var_path = '/webhooks/{webhook_id}'.sub('{' + 'webhook_id' + '}', CGI.escape(webhook_id.to_s))

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body]

      # return_type
      return_type = opts[:debug_return_type] || 'Webhook'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.find_webhook",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#find_webhook\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Retrieve Workflow Run
    # A single workflow run can be retrieved by calling this endpoint with the unique identifier of the Workflow Run. 
    # @param workflow_run_id [String] The unique identifier of the Workflow Run.
    # @param [Hash] opts the optional parameters
    # @return [WorkflowRun]
    def find_workflow_run(workflow_run_id, opts = {})
      data, _status_code, _headers = find_workflow_run_with_http_info(workflow_run_id, opts)
      data
    end

    # Retrieve Workflow Run
    # A single workflow run can be retrieved by calling this endpoint with the unique identifier of the Workflow Run. 
    # @param workflow_run_id [String] The unique identifier of the Workflow Run.
    # @param [Hash] opts the optional parameters
    # @return [Array<(WorkflowRun, Integer, Hash)>] WorkflowRun data, response status code and response headers
    def find_workflow_run_with_http_info(workflow_run_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.find_workflow_run ...'
      end
      # verify the required parameter 'workflow_run_id' is set
      if @api_client.config.client_side_validation && workflow_run_id.nil?
        fail ArgumentError, "Missing the required parameter 'workflow_run_id' when calling DefaultApi.find_workflow_run"
      end
      # resource path
      local_var_path = '/workflow_runs/{workflow_run_id}'.sub('{' + 'workflow_run_id' + '}', CGI.escape(workflow_run_id.to_s))

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body]

      # return_type
      return_type = opts[:debug_return_type] || 'WorkflowRun'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.find_workflow_run",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#find_workflow_run\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Force new report creation (BETA)
    # Triggers a new check with an updated report to be generated by the monitor, as if the monitor had received an update. 
    # @param monitor_id [String] 
    # @param [Hash] opts the optional parameters
    # @return [nil]
    def force_report_creation_from_watchlist_monitor(monitor_id, opts = {})
      force_report_creation_from_watchlist_monitor_with_http_info(monitor_id, opts)
      nil
    end

    # Force new report creation (BETA)
    # Triggers a new check with an updated report to be generated by the monitor, as if the monitor had received an update. 
    # @param monitor_id [String] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(nil, Integer, Hash)>] nil, response status code and response headers
    def force_report_creation_from_watchlist_monitor_with_http_info(monitor_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.force_report_creation_from_watchlist_monitor ...'
      end
      # verify the required parameter 'monitor_id' is set
      if @api_client.config.client_side_validation && monitor_id.nil?
        fail ArgumentError, "Missing the required parameter 'monitor_id' when calling DefaultApi.force_report_creation_from_watchlist_monitor"
      end
      # resource path
      local_var_path = '/watchlist_monitors/{monitor_id}/new_report'.sub('{' + 'monitor_id' + '}', CGI.escape(monitor_id.to_s))

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body]

      # return_type
      return_type = opts[:debug_return_type]

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.force_report_creation_from_watchlist_monitor",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#force_report_creation_from_watchlist_monitor\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Generate a SDK token
    # Generates an SDK token. Returns a token object containing the SDK token. 
    # @param sdk_token_builder [SdkTokenBuilder] 
    # @param [Hash] opts the optional parameters
    # @return [SdkToken]
    def generate_sdk_token(sdk_token_builder, opts = {})
      data, _status_code, _headers = generate_sdk_token_with_http_info(sdk_token_builder, opts)
      data
    end

    # Generate a SDK token
    # Generates an SDK token. Returns a token object containing the SDK token. 
    # @param sdk_token_builder [SdkTokenBuilder] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(SdkToken, Integer, Hash)>] SdkToken data, response status code and response headers
    def generate_sdk_token_with_http_info(sdk_token_builder, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.generate_sdk_token ...'
      end
      # verify the required parameter 'sdk_token_builder' is set
      if @api_client.config.client_side_validation && sdk_token_builder.nil?
        fail ArgumentError, "Missing the required parameter 'sdk_token_builder' when calling DefaultApi.generate_sdk_token"
      end
      # resource path
      local_var_path = '/sdk_token'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      content_type = @api_client.select_header_content_type(['application/json'])
      if !content_type.nil?
          header_params['Content-Type'] = content_type
      end

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(sdk_token_builder)

      # return_type
      return_type = opts[:debug_return_type] || 'SdkToken'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.generate_sdk_token",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#generate_sdk_token\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # List Applicants
    # Lists all applicants you've created, sorted by creation date in descending order. 
    # @param [Hash] opts the optional parameters
    # @option opts [Integer] :page The page to return. The first page is &#x60;page&#x3D;1&#x60; (default to 1)
    # @option opts [Integer] :per_page The number of objects per page. (default to 20)
    # @option opts [Boolean] :include_deleted Whether to also include applicants scheduled for deletion. (default to false)
    # @return [ApplicantsList]
    def list_applicants(opts = {})
      data, _status_code, _headers = list_applicants_with_http_info(opts)
      data
    end

    # List Applicants
    # Lists all applicants you&#39;ve created, sorted by creation date in descending order. 
    # @param [Hash] opts the optional parameters
    # @option opts [Integer] :page The page to return. The first page is &#x60;page&#x3D;1&#x60; (default to 1)
    # @option opts [Integer] :per_page The number of objects per page. (default to 20)
    # @option opts [Boolean] :include_deleted Whether to also include applicants scheduled for deletion. (default to false)
    # @return [Array<(ApplicantsList, Integer, Hash)>] ApplicantsList data, response status code and response headers
    def list_applicants_with_http_info(opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.list_applicants ...'
      end
      # resource path
      local_var_path = '/applicants'

      # query parameters
      query_params = opts[:query_params] || {}
      query_params[:'page'] = opts[:'page'] if !opts[:'page'].nil?
      query_params[:'per_page'] = opts[:'per_page'] if !opts[:'per_page'].nil?
      query_params[:'include_deleted'] = opts[:'include_deleted'] if !opts[:'include_deleted'].nil?

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body]

      # return_type
      return_type = opts[:debug_return_type] || 'ApplicantsList'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.list_applicants",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#list_applicants\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Retrieve Checks
    # Retrieves a single check. Returns a check object. 
    # @param applicant_id [String] 
    # @param [Hash] opts the optional parameters
    # @return [ChecksList]
    def list_checks(applicant_id, opts = {})
      data, _status_code, _headers = list_checks_with_http_info(applicant_id, opts)
      data
    end

    # Retrieve Checks
    # Retrieves a single check. Returns a check object. 
    # @param applicant_id [String] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(ChecksList, Integer, Hash)>] ChecksList data, response status code and response headers
    def list_checks_with_http_info(applicant_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.list_checks ...'
      end
      # verify the required parameter 'applicant_id' is set
      if @api_client.config.client_side_validation && applicant_id.nil?
        fail ArgumentError, "Missing the required parameter 'applicant_id' when calling DefaultApi.list_checks"
      end
      # resource path
      local_var_path = '/checks'

      # query parameters
      query_params = opts[:query_params] || {}
      query_params[:'applicant_id'] = applicant_id

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body]

      # return_type
      return_type = opts[:debug_return_type] || 'ChecksList'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.list_checks",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#list_checks\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # List documents
    # All documents belonging to an applicant can be listed from this endpoint
    # @param applicant_id [String] 
    # @param [Hash] opts the optional parameters
    # @return [DocumentsList]
    def list_documents(applicant_id, opts = {})
      data, _status_code, _headers = list_documents_with_http_info(applicant_id, opts)
      data
    end

    # List documents
    # All documents belonging to an applicant can be listed from this endpoint
    # @param applicant_id [String] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(DocumentsList, Integer, Hash)>] DocumentsList data, response status code and response headers
    def list_documents_with_http_info(applicant_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.list_documents ...'
      end
      # verify the required parameter 'applicant_id' is set
      if @api_client.config.client_side_validation && applicant_id.nil?
        fail ArgumentError, "Missing the required parameter 'applicant_id' when calling DefaultApi.list_documents"
      end
      # resource path
      local_var_path = '/documents'

      # query parameters
      query_params = opts[:query_params] || {}
      query_params[:'applicant_id'] = applicant_id

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body]

      # return_type
      return_type = opts[:debug_return_type] || 'DocumentsList'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.list_documents",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#list_documents\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # List ID photos
    # Lists the ID photos that belong to an applicant. 
    # @param applicant_id [String] The id of the applicant the ID photos belong to.
    # @param [Hash] opts the optional parameters
    # @return [IdPhotosList]
    def list_id_photos(applicant_id, opts = {})
      data, _status_code, _headers = list_id_photos_with_http_info(applicant_id, opts)
      data
    end

    # List ID photos
    # Lists the ID photos that belong to an applicant. 
    # @param applicant_id [String] The id of the applicant the ID photos belong to.
    # @param [Hash] opts the optional parameters
    # @return [Array<(IdPhotosList, Integer, Hash)>] IdPhotosList data, response status code and response headers
    def list_id_photos_with_http_info(applicant_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.list_id_photos ...'
      end
      # verify the required parameter 'applicant_id' is set
      if @api_client.config.client_side_validation && applicant_id.nil?
        fail ArgumentError, "Missing the required parameter 'applicant_id' when calling DefaultApi.list_id_photos"
      end
      # resource path
      local_var_path = '/id_photos'

      # query parameters
      query_params = opts[:query_params] || {}
      query_params[:'applicant_id'] = applicant_id

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body]

      # return_type
      return_type = opts[:debug_return_type] || 'IdPhotosList'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.list_id_photos",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#list_id_photos\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # List live photos
    # Lists the live photos that belong to an applicant. 
    # @param applicant_id [String] The id of the applicant the live photos belong to.
    # @param [Hash] opts the optional parameters
    # @return [LivePhotosList]
    def list_live_photos(applicant_id, opts = {})
      data, _status_code, _headers = list_live_photos_with_http_info(applicant_id, opts)
      data
    end

    # List live photos
    # Lists the live photos that belong to an applicant. 
    # @param applicant_id [String] The id of the applicant the live photos belong to.
    # @param [Hash] opts the optional parameters
    # @return [Array<(LivePhotosList, Integer, Hash)>] LivePhotosList data, response status code and response headers
    def list_live_photos_with_http_info(applicant_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.list_live_photos ...'
      end
      # verify the required parameter 'applicant_id' is set
      if @api_client.config.client_side_validation && applicant_id.nil?
        fail ArgumentError, "Missing the required parameter 'applicant_id' when calling DefaultApi.list_live_photos"
      end
      # resource path
      local_var_path = '/live_photos'

      # query parameters
      query_params = opts[:query_params] || {}
      query_params[:'applicant_id'] = applicant_id

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body]

      # return_type
      return_type = opts[:debug_return_type] || 'LivePhotosList'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.list_live_photos",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#list_live_photos\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # List live videos
    # Lists all the live videos that belong to an applicant. 
    # @param applicant_id [String] The id of the applicant the live videos belong to.
    # @param [Hash] opts the optional parameters
    # @return [LiveVideosList]
    def list_live_videos(applicant_id, opts = {})
      data, _status_code, _headers = list_live_videos_with_http_info(applicant_id, opts)
      data
    end

    # List live videos
    # Lists all the live videos that belong to an applicant. 
    # @param applicant_id [String] The id of the applicant the live videos belong to.
    # @param [Hash] opts the optional parameters
    # @return [Array<(LiveVideosList, Integer, Hash)>] LiveVideosList data, response status code and response headers
    def list_live_videos_with_http_info(applicant_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.list_live_videos ...'
      end
      # verify the required parameter 'applicant_id' is set
      if @api_client.config.client_side_validation && applicant_id.nil?
        fail ArgumentError, "Missing the required parameter 'applicant_id' when calling DefaultApi.list_live_videos"
      end
      # resource path
      local_var_path = '/live_videos'

      # query parameters
      query_params = opts[:query_params] || {}
      query_params[:'applicant_id'] = applicant_id

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body]

      # return_type
      return_type = opts[:debug_return_type] || 'LiveVideosList'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.list_live_videos",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#list_live_videos\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # List motion captures
    # Lists all the motion captures that belong to an applicant. 
    # @param applicant_id [String] The id of the applicant the motion captures belong to.
    # @param [Hash] opts the optional parameters
    # @return [MotionCapturesList]
    def list_motion_captures(applicant_id, opts = {})
      data, _status_code, _headers = list_motion_captures_with_http_info(applicant_id, opts)
      data
    end

    # List motion captures
    # Lists all the motion captures that belong to an applicant. 
    # @param applicant_id [String] The id of the applicant the motion captures belong to.
    # @param [Hash] opts the optional parameters
    # @return [Array<(MotionCapturesList, Integer, Hash)>] MotionCapturesList data, response status code and response headers
    def list_motion_captures_with_http_info(applicant_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.list_motion_captures ...'
      end
      # verify the required parameter 'applicant_id' is set
      if @api_client.config.client_side_validation && applicant_id.nil?
        fail ArgumentError, "Missing the required parameter 'applicant_id' when calling DefaultApi.list_motion_captures"
      end
      # resource path
      local_var_path = '/motion_captures'

      # query parameters
      query_params = opts[:query_params] || {}
      query_params[:'applicant_id'] = applicant_id

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body]

      # return_type
      return_type = opts[:debug_return_type] || 'MotionCapturesList'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.list_motion_captures",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#list_motion_captures\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Retrieve repeat attempts
    # Returns all repeat attempts for a given Document report 
    # @param report_id [String] 
    # @param [Hash] opts the optional parameters
    # @return [RepeatAttemptsList]
    def list_repeat_attempts(report_id, opts = {})
      data, _status_code, _headers = list_repeat_attempts_with_http_info(report_id, opts)
      data
    end

    # Retrieve repeat attempts
    # Returns all repeat attempts for a given Document report 
    # @param report_id [String] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(RepeatAttemptsList, Integer, Hash)>] RepeatAttemptsList data, response status code and response headers
    def list_repeat_attempts_with_http_info(report_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.list_repeat_attempts ...'
      end
      # verify the required parameter 'report_id' is set
      if @api_client.config.client_side_validation && report_id.nil?
        fail ArgumentError, "Missing the required parameter 'report_id' when calling DefaultApi.list_repeat_attempts"
      end
      # resource path
      local_var_path = '/repeat_attempts/{report_id}'.sub('{' + 'report_id' + '}', CGI.escape(report_id.to_s))

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body]

      # return_type
      return_type = opts[:debug_return_type] || 'RepeatAttemptsList'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.list_repeat_attempts",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#list_repeat_attempts\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # List reports
    # All the reports belonging to a particular check can be listed from this endpoint. 
    # @param check_id [String] 
    # @param [Hash] opts the optional parameters
    # @return [ReportsList]
    def list_reports(check_id, opts = {})
      data, _status_code, _headers = list_reports_with_http_info(check_id, opts)
      data
    end

    # List reports
    # All the reports belonging to a particular check can be listed from this endpoint. 
    # @param check_id [String] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(ReportsList, Integer, Hash)>] ReportsList data, response status code and response headers
    def list_reports_with_http_info(check_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.list_reports ...'
      end
      # verify the required parameter 'check_id' is set
      if @api_client.config.client_side_validation && check_id.nil?
        fail ArgumentError, "Missing the required parameter 'check_id' when calling DefaultApi.list_reports"
      end
      # resource path
      local_var_path = '/reports'

      # query parameters
      query_params = opts[:query_params] || {}
      query_params[:'check_id'] = check_id

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body]

      # return_type
      return_type = opts[:debug_return_type] || 'ReportsList'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.list_reports",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#list_reports\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # List Tasks
    # The tasks of a Workflow can be retrieved by calling this endpoint with the unique identifier of the Workflow Run. 
    # @param workflow_run_id [String] The unique identifier of the Workflow Run to which the Tasks belong.
    # @param [Hash] opts the optional parameters
    # @return [Array<TaskItem>]
    def list_tasks(workflow_run_id, opts = {})
      data, _status_code, _headers = list_tasks_with_http_info(workflow_run_id, opts)
      data
    end

    # List Tasks
    # The tasks of a Workflow can be retrieved by calling this endpoint with the unique identifier of the Workflow Run. 
    # @param workflow_run_id [String] The unique identifier of the Workflow Run to which the Tasks belong.
    # @param [Hash] opts the optional parameters
    # @return [Array<(Array<TaskItem>, Integer, Hash)>] Array<TaskItem> data, response status code and response headers
    def list_tasks_with_http_info(workflow_run_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.list_tasks ...'
      end
      # verify the required parameter 'workflow_run_id' is set
      if @api_client.config.client_side_validation && workflow_run_id.nil?
        fail ArgumentError, "Missing the required parameter 'workflow_run_id' when calling DefaultApi.list_tasks"
      end
      # resource path
      local_var_path = '/workflow_runs/{workflow_run_id}/tasks'.sub('{' + 'workflow_run_id' + '}', CGI.escape(workflow_run_id.to_s))

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body]

      # return_type
      return_type = opts[:debug_return_type] || 'Array<TaskItem>'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.list_tasks",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#list_tasks\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # List matches (BETA)
    # List match IDs on this monitor, as well as their enabled/disabled status 
    # @param monitor_id [String] 
    # @param [Hash] opts the optional parameters
    # @return [WatchlistMonitorMatchesList]
    def list_watchlist_monitor_matches(monitor_id, opts = {})
      data, _status_code, _headers = list_watchlist_monitor_matches_with_http_info(monitor_id, opts)
      data
    end

    # List matches (BETA)
    # List match IDs on this monitor, as well as their enabled/disabled status 
    # @param monitor_id [String] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(WatchlistMonitorMatchesList, Integer, Hash)>] WatchlistMonitorMatchesList data, response status code and response headers
    def list_watchlist_monitor_matches_with_http_info(monitor_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.list_watchlist_monitor_matches ...'
      end
      # verify the required parameter 'monitor_id' is set
      if @api_client.config.client_side_validation && monitor_id.nil?
        fail ArgumentError, "Missing the required parameter 'monitor_id' when calling DefaultApi.list_watchlist_monitor_matches"
      end
      # resource path
      local_var_path = '/watchlist_monitors/{monitor_id}/matches'.sub('{' + 'monitor_id' + '}', CGI.escape(monitor_id.to_s))

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body]

      # return_type
      return_type = opts[:debug_return_type] || 'WatchlistMonitorMatchesList'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.list_watchlist_monitor_matches",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#list_watchlist_monitor_matches\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # List monitors
    # List all available monitors for an applicant 
    # @param applicant_id [String] The id of the applicant the watchlist monitors belong to. If omitted, all monitors for the account will be listed.
    # @param [Hash] opts the optional parameters
    # @option opts [Boolean] :include_deleted Whether to also include deleted (inactive) monitors. (default to false)
    # @return [WatchlistMonitorsList]
    def list_watchlist_monitors(applicant_id, opts = {})
      data, _status_code, _headers = list_watchlist_monitors_with_http_info(applicant_id, opts)
      data
    end

    # List monitors
    # List all available monitors for an applicant 
    # @param applicant_id [String] The id of the applicant the watchlist monitors belong to. If omitted, all monitors for the account will be listed.
    # @param [Hash] opts the optional parameters
    # @option opts [Boolean] :include_deleted Whether to also include deleted (inactive) monitors. (default to false)
    # @return [Array<(WatchlistMonitorsList, Integer, Hash)>] WatchlistMonitorsList data, response status code and response headers
    def list_watchlist_monitors_with_http_info(applicant_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.list_watchlist_monitors ...'
      end
      # verify the required parameter 'applicant_id' is set
      if @api_client.config.client_side_validation && applicant_id.nil?
        fail ArgumentError, "Missing the required parameter 'applicant_id' when calling DefaultApi.list_watchlist_monitors"
      end
      # resource path
      local_var_path = '/watchlist_monitors'

      # query parameters
      query_params = opts[:query_params] || {}
      query_params[:'applicant_id'] = applicant_id
      query_params[:'include_deleted'] = opts[:'include_deleted'] if !opts[:'include_deleted'].nil?

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body]

      # return_type
      return_type = opts[:debug_return_type] || 'WatchlistMonitorsList'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.list_watchlist_monitors",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#list_watchlist_monitors\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # List webhooks
    # Lists all webhooks you've created. 
    # @param [Hash] opts the optional parameters
    # @return [WebhooksList]
    def list_webhooks(opts = {})
      data, _status_code, _headers = list_webhooks_with_http_info(opts)
      data
    end

    # List webhooks
    # Lists all webhooks you&#39;ve created. 
    # @param [Hash] opts the optional parameters
    # @return [Array<(WebhooksList, Integer, Hash)>] WebhooksList data, response status code and response headers
    def list_webhooks_with_http_info(opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.list_webhooks ...'
      end
      # resource path
      local_var_path = '/webhooks'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body]

      # return_type
      return_type = opts[:debug_return_type] || 'WebhooksList'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.list_webhooks",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#list_webhooks\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # List Workflow Runs
    # Retrieves the Workflow Runs of the client. Returns a list of Workflow Run objects. 
    # @param [Hash] opts the optional parameters
    # @option opts [Integer] :page The number of the page to be retrieved. If not specified, defaults to 1. (default to 1)
    # @option opts [String] :status A list of comma separated status values to filter the results. Possible values are &#39;processing&#39;, &#39;awaiting_input&#39;, &#39;approved&#39;, &#39;declined&#39;, &#39;review&#39;, &#39;abandoned&#39; and &#39;error&#39;.
    # @option opts [Time] :created_at_gt A ISO-8601 date to filter results with a created date greater than (after) the one provided.
    # @option opts [Time] :created_at_lt A ISO-8601 date to filter results with a created date less than (before) the one provided.
    # @option opts [String] :sort A string with the value &#39;desc&#39; or &#39;asc&#39; that allows to sort the returned list by the completed datetime either descending or ascending, respectively. If not specified, defaults to &#39;desc&#39;. (default to 'desc')
    # @return [Array<WorkflowRun>]
    def list_workflow_runs(opts = {})
      data, _status_code, _headers = list_workflow_runs_with_http_info(opts)
      data
    end

    # List Workflow Runs
    # Retrieves the Workflow Runs of the client. Returns a list of Workflow Run objects. 
    # @param [Hash] opts the optional parameters
    # @option opts [Integer] :page The number of the page to be retrieved. If not specified, defaults to 1. (default to 1)
    # @option opts [String] :status A list of comma separated status values to filter the results. Possible values are &#39;processing&#39;, &#39;awaiting_input&#39;, &#39;approved&#39;, &#39;declined&#39;, &#39;review&#39;, &#39;abandoned&#39; and &#39;error&#39;.
    # @option opts [Time] :created_at_gt A ISO-8601 date to filter results with a created date greater than (after) the one provided.
    # @option opts [Time] :created_at_lt A ISO-8601 date to filter results with a created date less than (before) the one provided.
    # @option opts [String] :sort A string with the value &#39;desc&#39; or &#39;asc&#39; that allows to sort the returned list by the completed datetime either descending or ascending, respectively. If not specified, defaults to &#39;desc&#39;. (default to 'desc')
    # @return [Array<(Array<WorkflowRun>, Integer, Hash)>] Array<WorkflowRun> data, response status code and response headers
    def list_workflow_runs_with_http_info(opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.list_workflow_runs ...'
      end
      allowable_values = ["desc", "asc", "unknown_default_open_api"]
      if @api_client.config.client_side_validation && opts[:'sort'] && !allowable_values.include?(opts[:'sort'])
        fail ArgumentError, "invalid value for \"sort\", must be one of #{allowable_values}"
      end
      # resource path
      local_var_path = '/workflow_runs'

      # query parameters
      query_params = opts[:query_params] || {}
      query_params[:'page'] = opts[:'page'] if !opts[:'page'].nil?
      query_params[:'status'] = opts[:'status'] if !opts[:'status'].nil?
      query_params[:'created_at_gt'] = opts[:'created_at_gt'] if !opts[:'created_at_gt'].nil?
      query_params[:'created_at_lt'] = opts[:'created_at_lt'] if !opts[:'created_at_lt'].nil?
      query_params[:'sort'] = opts[:'sort'] if !opts[:'sort'].nil?

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body]

      # return_type
      return_type = opts[:debug_return_type] || 'Array<WorkflowRun>'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.list_workflow_runs",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#list_workflow_runs\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Ping
    # Run a health check on the Onfido API 
    # @param [Hash] opts the optional parameters
    # @return [String]
    def ping(opts = {})
      data, _status_code, _headers = ping_with_http_info(opts)
      data
    end

    # Ping
    # Run a health check on the Onfido API 
    # @param [Hash] opts the optional parameters
    # @return [Array<(String, Integer, Hash)>] String data, response status code and response headers
    def ping_with_http_info(opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.ping ...'
      end
      # resource path
      local_var_path = '/ping'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['text/plain', 'application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body]

      # return_type
      return_type = opts[:debug_return_type] || 'String'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.ping",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#ping\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Fraud reporting (ALPHA)
    # Create Feedback on checks and reports 
    # @param results_feedback [ResultsFeedback] 
    # @param [Hash] opts the optional parameters
    # @return [ResultsFeedback]
    def post_results_feedback(results_feedback, opts = {})
      data, _status_code, _headers = post_results_feedback_with_http_info(results_feedback, opts)
      data
    end

    # Fraud reporting (ALPHA)
    # Create Feedback on checks and reports 
    # @param results_feedback [ResultsFeedback] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(ResultsFeedback, Integer, Hash)>] ResultsFeedback data, response status code and response headers
    def post_results_feedback_with_http_info(results_feedback, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.post_results_feedback ...'
      end
      # verify the required parameter 'results_feedback' is set
      if @api_client.config.client_side_validation && results_feedback.nil?
        fail ArgumentError, "Missing the required parameter 'results_feedback' when calling DefaultApi.post_results_feedback"
      end
      # resource path
      local_var_path = '/results_feedback'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      content_type = @api_client.select_header_content_type(['application/json'])
      if !content_type.nil?
          header_params['Content-Type'] = content_type
      end

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(results_feedback)

      # return_type
      return_type = opts[:debug_return_type] || 'ResultsFeedback'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.post_results_feedback",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#post_results_feedback\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Resends webhooks
    # Resends events to all webhooks registered with a matching environment in your account. 
    # @param webhook_resend [WebhookResend] 
    # @param [Hash] opts the optional parameters
    # @return [nil]
    def resend_webhooks(webhook_resend, opts = {})
      resend_webhooks_with_http_info(webhook_resend, opts)
      nil
    end

    # Resends webhooks
    # Resends events to all webhooks registered with a matching environment in your account. 
    # @param webhook_resend [WebhookResend] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(nil, Integer, Hash)>] nil, response status code and response headers
    def resend_webhooks_with_http_info(webhook_resend, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.resend_webhooks ...'
      end
      # verify the required parameter 'webhook_resend' is set
      if @api_client.config.client_side_validation && webhook_resend.nil?
        fail ArgumentError, "Missing the required parameter 'webhook_resend' when calling DefaultApi.resend_webhooks"
      end
      # resource path
      local_var_path = '/webhooks/resend'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      content_type = @api_client.select_header_content_type(['application/json'])
      if !content_type.nil?
          header_params['Content-Type'] = content_type
      end

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(webhook_resend)

      # return_type
      return_type = opts[:debug_return_type]

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.resend_webhooks",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#resend_webhooks\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Restore Applicant
    # Restores a single applicant scheduled for deletion. 
    # @param applicant_id [String] 
    # @param [Hash] opts the optional parameters
    # @return [nil]
    def restore_applicant(applicant_id, opts = {})
      restore_applicant_with_http_info(applicant_id, opts)
      nil
    end

    # Restore Applicant
    # Restores a single applicant scheduled for deletion. 
    # @param applicant_id [String] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(nil, Integer, Hash)>] nil, response status code and response headers
    def restore_applicant_with_http_info(applicant_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.restore_applicant ...'
      end
      # verify the required parameter 'applicant_id' is set
      if @api_client.config.client_side_validation && applicant_id.nil?
        fail ArgumentError, "Missing the required parameter 'applicant_id' when calling DefaultApi.restore_applicant"
      end
      # resource path
      local_var_path = '/applicants/{applicant_id}/restore'.sub('{' + 'applicant_id' + '}', CGI.escape(applicant_id.to_s))

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body]

      # return_type
      return_type = opts[:debug_return_type]

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.restore_applicant",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#restore_applicant\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Resume a Check
    # Resumes a paused check. 
    # @param check_id [String] 
    # @param [Hash] opts the optional parameters
    # @return [nil]
    def resume_check(check_id, opts = {})
      resume_check_with_http_info(check_id, opts)
      nil
    end

    # Resume a Check
    # Resumes a paused check. 
    # @param check_id [String] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(nil, Integer, Hash)>] nil, response status code and response headers
    def resume_check_with_http_info(check_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.resume_check ...'
      end
      # verify the required parameter 'check_id' is set
      if @api_client.config.client_side_validation && check_id.nil?
        fail ArgumentError, "Missing the required parameter 'check_id' when calling DefaultApi.resume_check"
      end
      # resource path
      local_var_path = '/checks/{check_id}/resume'.sub('{' + 'check_id' + '}', CGI.escape(check_id.to_s))

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body]

      # return_type
      return_type = opts[:debug_return_type]

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.resume_check",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#resume_check\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Resume report
    # Resumes a single paused report. 
    # @param report_id [String] 
    # @param [Hash] opts the optional parameters
    # @return [nil]
    def resume_report(report_id, opts = {})
      resume_report_with_http_info(report_id, opts)
      nil
    end

    # Resume report
    # Resumes a single paused report. 
    # @param report_id [String] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(nil, Integer, Hash)>] nil, response status code and response headers
    def resume_report_with_http_info(report_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.resume_report ...'
      end
      # verify the required parameter 'report_id' is set
      if @api_client.config.client_side_validation && report_id.nil?
        fail ArgumentError, "Missing the required parameter 'report_id' when calling DefaultApi.resume_report"
      end
      # resource path
      local_var_path = '/reports/{report_id}/resume'.sub('{' + 'report_id' + '}', CGI.escape(report_id.to_s))

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body]

      # return_type
      return_type = opts[:debug_return_type]

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.resume_report",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#resume_report\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Update Applicant
    # Allows updating applicant's information before any checks is created. - Partial updates - Addresses and ID numbers present will replace existing ones - Same applicant validations to create applicant 
    # @param applicant_id [String] 
    # @param applicant_updater [ApplicantUpdater] 
    # @param [Hash] opts the optional parameters
    # @return [Applicant]
    def update_applicant(applicant_id, applicant_updater, opts = {})
      data, _status_code, _headers = update_applicant_with_http_info(applicant_id, applicant_updater, opts)
      data
    end

    # Update Applicant
    # Allows updating applicant&#39;s information before any checks is created. - Partial updates - Addresses and ID numbers present will replace existing ones - Same applicant validations to create applicant 
    # @param applicant_id [String] 
    # @param applicant_updater [ApplicantUpdater] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(Applicant, Integer, Hash)>] Applicant data, response status code and response headers
    def update_applicant_with_http_info(applicant_id, applicant_updater, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.update_applicant ...'
      end
      # verify the required parameter 'applicant_id' is set
      if @api_client.config.client_side_validation && applicant_id.nil?
        fail ArgumentError, "Missing the required parameter 'applicant_id' when calling DefaultApi.update_applicant"
      end
      # verify the required parameter 'applicant_updater' is set
      if @api_client.config.client_side_validation && applicant_updater.nil?
        fail ArgumentError, "Missing the required parameter 'applicant_updater' when calling DefaultApi.update_applicant"
      end
      # resource path
      local_var_path = '/applicants/{applicant_id}'.sub('{' + 'applicant_id' + '}', CGI.escape(applicant_id.to_s))

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      content_type = @api_client.select_header_content_type(['application/json'])
      if !content_type.nil?
          header_params['Content-Type'] = content_type
      end

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(applicant_updater)

      # return_type
      return_type = opts[:debug_return_type] || 'Applicant'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.update_applicant",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:PUT, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#update_applicant\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Set match status (BETA)
    # Update the status of the given matches 
    # @param monitor_id [String] 
    # @param watchlist_monitor_matches_updater [WatchlistMonitorMatchesUpdater] 
    # @param [Hash] opts the optional parameters
    # @return [WatchlistMonitorMatchesList]
    def update_watchlist_monitor_match(monitor_id, watchlist_monitor_matches_updater, opts = {})
      data, _status_code, _headers = update_watchlist_monitor_match_with_http_info(monitor_id, watchlist_monitor_matches_updater, opts)
      data
    end

    # Set match status (BETA)
    # Update the status of the given matches 
    # @param monitor_id [String] 
    # @param watchlist_monitor_matches_updater [WatchlistMonitorMatchesUpdater] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(WatchlistMonitorMatchesList, Integer, Hash)>] WatchlistMonitorMatchesList data, response status code and response headers
    def update_watchlist_monitor_match_with_http_info(monitor_id, watchlist_monitor_matches_updater, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.update_watchlist_monitor_match ...'
      end
      # verify the required parameter 'monitor_id' is set
      if @api_client.config.client_side_validation && monitor_id.nil?
        fail ArgumentError, "Missing the required parameter 'monitor_id' when calling DefaultApi.update_watchlist_monitor_match"
      end
      # verify the required parameter 'watchlist_monitor_matches_updater' is set
      if @api_client.config.client_side_validation && watchlist_monitor_matches_updater.nil?
        fail ArgumentError, "Missing the required parameter 'watchlist_monitor_matches_updater' when calling DefaultApi.update_watchlist_monitor_match"
      end
      # resource path
      local_var_path = '/watchlist_monitors/{monitor_id}/matches'.sub('{' + 'monitor_id' + '}', CGI.escape(monitor_id.to_s))

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      content_type = @api_client.select_header_content_type(['application/json'])
      if !content_type.nil?
          header_params['Content-Type'] = content_type
      end

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(watchlist_monitor_matches_updater)

      # return_type
      return_type = opts[:debug_return_type] || 'WatchlistMonitorMatchesList'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.update_watchlist_monitor_match",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:PATCH, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#update_watchlist_monitor_match\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Edit a webhook
    # Edits a webhook. Returns the updated webhook object. 
    # @param webhook_id [String] 
    # @param webhook_updater [WebhookUpdater] 
    # @param [Hash] opts the optional parameters
    # @return [Webhook]
    def update_webhook(webhook_id, webhook_updater, opts = {})
      data, _status_code, _headers = update_webhook_with_http_info(webhook_id, webhook_updater, opts)
      data
    end

    # Edit a webhook
    # Edits a webhook. Returns the updated webhook object. 
    # @param webhook_id [String] 
    # @param webhook_updater [WebhookUpdater] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(Webhook, Integer, Hash)>] Webhook data, response status code and response headers
    def update_webhook_with_http_info(webhook_id, webhook_updater, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.update_webhook ...'
      end
      # verify the required parameter 'webhook_id' is set
      if @api_client.config.client_side_validation && webhook_id.nil?
        fail ArgumentError, "Missing the required parameter 'webhook_id' when calling DefaultApi.update_webhook"
      end
      # verify the required parameter 'webhook_updater' is set
      if @api_client.config.client_side_validation && webhook_updater.nil?
        fail ArgumentError, "Missing the required parameter 'webhook_updater' when calling DefaultApi.update_webhook"
      end
      # resource path
      local_var_path = '/webhooks/{webhook_id}'.sub('{' + 'webhook_id' + '}', CGI.escape(webhook_id.to_s))

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      content_type = @api_client.select_header_content_type(['application/json'])
      if !content_type.nil?
          header_params['Content-Type'] = content_type
      end

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(webhook_updater)

      # return_type
      return_type = opts[:debug_return_type] || 'Webhook'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.update_webhook",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:PUT, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#update_webhook\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Upload a document
    # Documents are uploaded using this endpoint. Along with the file upload the relevant document type must be specified. Documents must be uploaded as a multipart form. The valid file types are: jpg, png and pdf. The file size must be between 2KB and 3MB. 
    # @param type [String] The type of document
    # @param applicant_id [String] The ID of the applicant whose document is being uploaded.
    # @param file [File] The file to be uploaded.
    # @param [Hash] opts the optional parameters
    # @option opts [String] :file_type The file type of the uploaded file
    # @option opts [String] :side The side of the document, if applicable. The possible values are front and back
    # @option opts [CountryCodes] :issuing_country The issuing country of the document, a 3-letter ISO code.
    # @option opts [Boolean] :validate_image_quality Defaults to false. When true the submitted image will undergo an image quality validation which may take up to 5 seconds.
    # @option opts [LocationBuilder] :location 
    # @return [Document]
    def upload_document(type, applicant_id, file, opts = {})
      data, _status_code, _headers = upload_document_with_http_info(type, applicant_id, file, opts)
      data
    end

    # Upload a document
    # Documents are uploaded using this endpoint. Along with the file upload the relevant document type must be specified. Documents must be uploaded as a multipart form. The valid file types are: jpg, png and pdf. The file size must be between 2KB and 3MB. 
    # @param type [String] The type of document
    # @param applicant_id [String] The ID of the applicant whose document is being uploaded.
    # @param file [File] The file to be uploaded.
    # @param [Hash] opts the optional parameters
    # @option opts [String] :file_type The file type of the uploaded file
    # @option opts [String] :side The side of the document, if applicable. The possible values are front and back
    # @option opts [CountryCodes] :issuing_country The issuing country of the document, a 3-letter ISO code.
    # @option opts [Boolean] :validate_image_quality Defaults to false. When true the submitted image will undergo an image quality validation which may take up to 5 seconds.
    # @option opts [LocationBuilder] :location 
    # @return [Array<(Document, Integer, Hash)>] Document data, response status code and response headers
    def upload_document_with_http_info(type, applicant_id, file, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.upload_document ...'
      end
      # verify the required parameter 'type' is set
      if @api_client.config.client_side_validation && type.nil?
        fail ArgumentError, "Missing the required parameter 'type' when calling DefaultApi.upload_document"
      end
      # verify the required parameter 'applicant_id' is set
      if @api_client.config.client_side_validation && applicant_id.nil?
        fail ArgumentError, "Missing the required parameter 'applicant_id' when calling DefaultApi.upload_document"
      end
      # verify the required parameter 'file' is set
      if @api_client.config.client_side_validation && file.nil?
        fail ArgumentError, "Missing the required parameter 'file' when calling DefaultApi.upload_document"
      end
      allowable_values = ["jpg", "jpeg", "png", "pdf", "unknown_default_open_api"]
      if @api_client.config.client_side_validation && opts[:'file_type'] && !allowable_values.include?(opts[:'file_type'])
        fail ArgumentError, "invalid value for \"file_type\", must be one of #{allowable_values}"
      end
      allowable_values = ["front", "back", "unknown_default_open_api"]
      if @api_client.config.client_side_validation && opts[:'side'] && !allowable_values.include?(opts[:'side'])
        fail ArgumentError, "invalid value for \"side\", must be one of #{allowable_values}"
      end
      # resource path
      local_var_path = '/documents'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      content_type = @api_client.select_header_content_type(['multipart/form-data'])
      if !content_type.nil?
          header_params['Content-Type'] = content_type
      end

      # form parameters
      form_params = opts[:form_params] || {}
      form_params['type'] = type
      form_params['applicant_id'] = applicant_id
      form_params['file'] = file
      form_params['file_type'] = opts[:'file_type'] if !opts[:'file_type'].nil?
      form_params['side'] = opts[:'side'] if !opts[:'side'].nil?
      form_params['issuing_country'] = opts[:'issuing_country'] if !opts[:'issuing_country'].nil?
      form_params['validate_image_quality'] = opts[:'validate_image_quality'] if !opts[:'validate_image_quality'].nil?
      form_params['location'] = opts[:'location'] if !opts[:'location'].nil?

      # http body (model)
      post_body = opts[:debug_body]

      # return_type
      return_type = opts[:debug_return_type] || 'Document'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.upload_document",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#upload_document\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Upload ID photo
    # You can upload ID photos to this endpoint. Like document upload, files must be uploaded as a multipart form. Valid file types are jpg, png and pdf. The file size must be between 32KB and 10MB. 
    # @param [Hash] opts the optional parameters
    # @option opts [String] :applicant_id The ID of the applicant whose ID photo is being uploaded.
    # @option opts [File] :file The file to be uploaded.
    # @return [IdPhoto]
    def upload_id_photo(opts = {})
      data, _status_code, _headers = upload_id_photo_with_http_info(opts)
      data
    end

    # Upload ID photo
    # You can upload ID photos to this endpoint. Like document upload, files must be uploaded as a multipart form. Valid file types are jpg, png and pdf. The file size must be between 32KB and 10MB. 
    # @param [Hash] opts the optional parameters
    # @option opts [String] :applicant_id The ID of the applicant whose ID photo is being uploaded.
    # @option opts [File] :file The file to be uploaded.
    # @return [Array<(IdPhoto, Integer, Hash)>] IdPhoto data, response status code and response headers
    def upload_id_photo_with_http_info(opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.upload_id_photo ...'
      end
      # resource path
      local_var_path = '/id_photos'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      content_type = @api_client.select_header_content_type(['multipart/form-data'])
      if !content_type.nil?
          header_params['Content-Type'] = content_type
      end

      # form parameters
      form_params = opts[:form_params] || {}
      form_params['applicant_id'] = opts[:'applicant_id'] if !opts[:'applicant_id'].nil?
      form_params['file'] = opts[:'file'] if !opts[:'file'].nil?

      # http body (model)
      post_body = opts[:debug_body]

      # return_type
      return_type = opts[:debug_return_type] || 'IdPhoto'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.upload_id_photo",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#upload_id_photo\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Upload live photo
    # You can upload live photos to this endpoint. Like document upload, files must be uploaded as a multipart form. Valid file types are jpg, png and pdf. The file size must be between 32KB and 10MB. Live photos are validated at the point of upload to check that they contain exactly one face. This validation can be disabled by setting the advanced_validation argument to false. 
    # @param [Hash] opts the optional parameters
    # @option opts [String] :applicant_id The ID of the applicant whose live photo is being uploaded.
    # @option opts [File] :file The file to be uploaded.
    # @option opts [Boolean] :advanced_validation Validates that the live photo contains exactly one face. (default to true)
    # @return [LivePhoto]
    def upload_live_photo(opts = {})
      data, _status_code, _headers = upload_live_photo_with_http_info(opts)
      data
    end

    # Upload live photo
    # You can upload live photos to this endpoint. Like document upload, files must be uploaded as a multipart form. Valid file types are jpg, png and pdf. The file size must be between 32KB and 10MB. Live photos are validated at the point of upload to check that they contain exactly one face. This validation can be disabled by setting the advanced_validation argument to false. 
    # @param [Hash] opts the optional parameters
    # @option opts [String] :applicant_id The ID of the applicant whose live photo is being uploaded.
    # @option opts [File] :file The file to be uploaded.
    # @option opts [Boolean] :advanced_validation Validates that the live photo contains exactly one face. (default to true)
    # @return [Array<(LivePhoto, Integer, Hash)>] LivePhoto data, response status code and response headers
    def upload_live_photo_with_http_info(opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: DefaultApi.upload_live_photo ...'
      end
      # resource path
      local_var_path = '/live_photos'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      content_type = @api_client.select_header_content_type(['multipart/form-data'])
      if !content_type.nil?
          header_params['Content-Type'] = content_type
      end

      # form parameters
      form_params = opts[:form_params] || {}
      form_params['applicant_id'] = opts[:'applicant_id'] if !opts[:'applicant_id'].nil?
      form_params['file'] = opts[:'file'] if !opts[:'file'].nil?
      form_params['advanced_validation'] = opts[:'advanced_validation'] if !opts[:'advanced_validation'].nil?

      # http body (model)
      post_body = opts[:debug_body]

      # return_type
      return_type = opts[:debug_return_type] || 'LivePhoto'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['Token']

      new_options = opts.merge(
        :operation => :"DefaultApi.upload_live_photo",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: DefaultApi#upload_live_photo\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end
  end
end