class Onfido::DefaultApi

Attributes

api_client[RW]

Public Class Methods

new(api_client = ApiClient.default) click to toggle source
# File lib/onfido/api/default_api.rb, line 19
def initialize(api_client = ApiClient.default)
  @api_client = api_client
end

Public Instance Methods

cancel_report(report_id, opts = {}) click to toggle source

Cancel report Cancels single paused reports. @param report_id [String] @param [Hash] opts the optional parameters @return [nil]

# File lib/onfido/api/default_api.rb, line 27
def cancel_report(report_id, opts = {})
  cancel_report_with_http_info(report_id, opts)
  nil
end
cancel_report_with_http_info(report_id, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 37
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']) unless header_params['Accept']

  # 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(workflow_run_id, task_id, complete_task_builder, opts = {}) click to toggle source

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]

# File lib/onfido/api/default_api.rb, line 92
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_with_http_info(workflow_run_id, task_id, complete_task_builder, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 104
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']) unless header_params['Accept']
  # 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(applicant_builder, opts = {}) click to toggle source

Create Applicant Creates a single applicant. Returns an applicant object. @param applicant_builder [ApplicantBuilder] @param [Hash] opts the optional parameters @return [Applicant]

# File lib/onfido/api/default_api.rb, line 170
def create_applicant(applicant_builder, opts = {})
  data, _status_code, _headers = create_applicant_with_http_info(applicant_builder, opts)
  data
end
create_applicant_with_http_info(applicant_builder, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 180
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']) unless header_params['Accept']
  # 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_check(check_builder, opts = {}) click to toggle source

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]

# File lib/onfido/api/default_api.rb, line 238
def create_check(check_builder, opts = {})
  data, _status_code, _headers = create_check_with_http_info(check_builder, opts)
  data
end
create_check_with_http_info(check_builder, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 248
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']) unless header_params['Accept']
  # 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(workflow_run_id, opts = {}) click to toggle source

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]

# File lib/onfido/api/default_api.rb, line 306
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_with_http_info(workflow_run_id, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 316
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']) unless header_params['Accept']

  # 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_watchlist_monitor(watchlist_monitor_builder, opts = {}) click to toggle source

Create monitor Creates a new monitor for the applicant @param watchlist_monitor_builder [WatchlistMonitorBuilder] @param [Hash] opts the optional parameters @return [WatchlistMonitor]

# File lib/onfido/api/default_api.rb, line 369
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_watchlist_monitor_with_http_info(watchlist_monitor_builder, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 379
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']) unless header_params['Accept']
  # 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
create_webhook(webhook_builder, opts = {}) click to toggle source

Register webhook Registers a webhook. Returns a webhook object. @param webhook_builder [WebhookBuilder] @param [Hash] opts the optional parameters @return [Webhook]

# File lib/onfido/api/default_api.rb, line 437
def create_webhook(webhook_builder, opts = {})
  data, _status_code, _headers = create_webhook_with_http_info(webhook_builder, opts)
  data
end
create_webhook_with_http_info(webhook_builder, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 447
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']) unless header_params['Accept']
  # 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_workflow_run(workflow_run_builder, opts = {}) click to toggle source

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]

# File lib/onfido/api/default_api.rb, line 505
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_workflow_run_with_http_info(workflow_run_builder, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 515
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']) unless header_params['Accept']
  # 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(applicant_id, opts = {}) click to toggle source

Delete Applicant Deletes a single applicant. @param applicant_id [String] @param [Hash] opts the optional parameters @return [nil]

# File lib/onfido/api/default_api.rb, line 573
def delete_applicant(applicant_id, opts = {})
  delete_applicant_with_http_info(applicant_id, opts)
  nil
end
delete_applicant_with_http_info(applicant_id, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 583
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']) unless header_params['Accept']

  # 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_watchlist_monitor(monitor_id, opts = {}) click to toggle source

Delete monitor Deactivates the given monitor @param monitor_id [String] @param [Hash] opts the optional parameters @return [nil]

# File lib/onfido/api/default_api.rb, line 636
def delete_watchlist_monitor(monitor_id, opts = {})
  delete_watchlist_monitor_with_http_info(monitor_id, opts)
  nil
end
delete_watchlist_monitor_with_http_info(monitor_id, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 646
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']) unless header_params['Accept']

  # 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_webhook(webhook_id, opts = {}) click to toggle source

Delete a webhook Deletes a webhook. @param webhook_id [String] @param [Hash] opts the optional parameters @return [nil]

# File lib/onfido/api/default_api.rb, line 699
def delete_webhook(webhook_id, opts = {})
  delete_webhook_with_http_info(webhook_id, opts)
  nil
end
delete_webhook_with_http_info(webhook_id, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 709
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']) unless header_params['Accept']

  # 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(check_id, opts = {}) click to toggle source

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]

# File lib/onfido/api/default_api.rb, line 762
def download_check(check_id, opts = {})
  data, _status_code, _headers = download_check_with_http_info(check_id, opts)
  data
end
download_check_with_http_info(check_id, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 772
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']) unless header_params['Accept']

  # 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(document_id, opts = {}) click to toggle source

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]

# File lib/onfido/api/default_api.rb, line 825
def download_document(document_id, opts = {})
  data, _status_code, _headers = download_document_with_http_info(document_id, opts)
  data
end
download_document_video(document_id, opts = {}) click to toggle source

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]

# File lib/onfido/api/default_api.rb, line 888
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_with_http_info(document_id, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 898
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']) unless header_params['Accept']

  # 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_document_with_http_info(document_id, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 835
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']) unless header_params['Accept']

  # 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_id_photo(id_photo_id, opts = {}) click to toggle source

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]

# File lib/onfido/api/default_api.rb, line 951
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_with_http_info(id_photo_id, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 961
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']) unless header_params['Accept']

  # 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_photo_id, opts = {}) click to toggle source

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]

# File lib/onfido/api/default_api.rb, line 1014
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_with_http_info(live_photo_id, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 1024
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']) unless header_params['Accept']

  # 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_video_id, opts = {}) click to toggle source

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]

# File lib/onfido/api/default_api.rb, line 1077
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_frame(live_video_id, opts = {}) click to toggle source

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]

# File lib/onfido/api/default_api.rb, line 1140
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_with_http_info(live_video_id, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 1150
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']) unless header_params['Accept']

  # 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_live_video_with_http_info(live_video_id, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 1087
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']) unless header_params['Accept']

  # 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_motion_capture(motion_capture_id, opts = {}) click to toggle source

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]

# File lib/onfido/api/default_api.rb, line 1203
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_frame(motion_capture_id, opts = {}) click to toggle source

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]

# File lib/onfido/api/default_api.rb, line 1266
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_with_http_info(motion_capture_id, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 1276
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']) unless header_params['Accept']

  # 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
download_motion_capture_with_http_info(motion_capture_id, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 1213
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']) unless header_params['Accept']

  # 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_qes_document(workflow_run_id, file_id, opts = {}) click to toggle source

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]

# File lib/onfido/api/default_api.rb, line 1330
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
download_qes_document_with_http_info(workflow_run_id, file_id, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 1341
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']) unless header_params['Accept']

  # 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
download_signed_evidence_file(workflow_run_id, opts = {}) click to toggle source

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]

# File lib/onfido/api/default_api.rb, line 1400
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
download_signed_evidence_file_with_http_info(workflow_run_id, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 1410
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']) unless header_params['Accept']

  # 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
extract(extract_request, opts = {}) click to toggle source

Autofill Extract information from a document @param extract_request [ExtractRequest] @param [Hash] opts the optional parameters @return [Extraction]

# File lib/onfido/api/default_api.rb, line 1463
def extract(extract_request, opts = {})
  data, _status_code, _headers = extract_with_http_info(extract_request, opts)
  data
end
extract_with_http_info(extract_request, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 1473
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']) unless header_params['Accept']
  # 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
find_addresses(postcode, opts = {}) click to toggle source

Address Picker Search for addresses by postcode @param postcode [String] @param [Hash] opts the optional parameters @return [AddressesList]

# File lib/onfido/api/default_api.rb, line 1531
def find_addresses(postcode, opts = {})
  data, _status_code, _headers = find_addresses_with_http_info(postcode, opts)
  data
end
find_addresses_with_http_info(postcode, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 1541
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']) unless header_params['Accept']

  # 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
find_applicant(applicant_id, opts = {}) click to toggle source

Retrieve Applicant Retrieves a single applicant. Returns an applicant object. @param applicant_id [String] @param [Hash] opts the optional parameters @return [Applicant]

# File lib/onfido/api/default_api.rb, line 1595
def find_applicant(applicant_id, opts = {})
  data, _status_code, _headers = find_applicant_with_http_info(applicant_id, opts)
  data
end
find_applicant_with_http_info(applicant_id, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 1605
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']) unless header_params['Accept']

  # 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
find_check(check_id, opts = {}) click to toggle source

Retrieve a Check Retrieves a single check. Returns a check object. @param check_id [String] @param [Hash] opts the optional parameters @return [Check]

# File lib/onfido/api/default_api.rb, line 1658
def find_check(check_id, opts = {})
  data, _status_code, _headers = find_check_with_http_info(check_id, opts)
  data
end
find_check_with_http_info(check_id, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 1668
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']) unless header_params['Accept']

  # 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
find_document(document_id, opts = {}) click to toggle source

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]

# File lib/onfido/api/default_api.rb, line 1721
def find_document(document_id, opts = {})
  data, _status_code, _headers = find_document_with_http_info(document_id, opts)
  data
end
find_document_with_http_info(document_id, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 1731
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']) unless header_params['Accept']

  # 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
find_id_photo(id_photo_id, opts = {}) click to toggle source

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]

# File lib/onfido/api/default_api.rb, line 1784
def find_id_photo(id_photo_id, opts = {})
  data, _status_code, _headers = find_id_photo_with_http_info(id_photo_id, opts)
  data
end
find_id_photo_with_http_info(id_photo_id, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 1794
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']) unless header_params['Accept']

  # 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
find_live_photo(live_photo_id, opts = {}) click to toggle source

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]

# File lib/onfido/api/default_api.rb, line 1847
def find_live_photo(live_photo_id, opts = {})
  data, _status_code, _headers = find_live_photo_with_http_info(live_photo_id, opts)
  data
end
find_live_photo_with_http_info(live_photo_id, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 1857
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']) unless header_params['Accept']

  # 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
find_live_video(live_video_id, opts = {}) click to toggle source

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]

# File lib/onfido/api/default_api.rb, line 1910
def find_live_video(live_video_id, opts = {})
  data, _status_code, _headers = find_live_video_with_http_info(live_video_id, opts)
  data
end
find_live_video_with_http_info(live_video_id, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 1920
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']) unless header_params['Accept']

  # 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
find_motion_capture(motion_capture_id, opts = {}) click to toggle source

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]

# File lib/onfido/api/default_api.rb, line 1973
def find_motion_capture(motion_capture_id, opts = {})
  data, _status_code, _headers = find_motion_capture_with_http_info(motion_capture_id, opts)
  data
end
find_motion_capture_with_http_info(motion_capture_id, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 1983
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']) unless header_params['Accept']

  # 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
find_report(report_id, opts = {}) click to toggle source

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]

# File lib/onfido/api/default_api.rb, line 2036
def find_report(report_id, opts = {})
  data, _status_code, _headers = find_report_with_http_info(report_id, opts)
  data
end
find_report_with_http_info(report_id, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 2046
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']) unless header_params['Accept']

  # 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
find_task(workflow_run_id, task_id, opts = {}) click to toggle source

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]

# File lib/onfido/api/default_api.rb, line 2100
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
find_task_with_http_info(workflow_run_id, task_id, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 2111
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']) unless header_params['Accept']

  # 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
find_timeline_file(workflow_run_id, timeline_file_id, opts = {}) click to toggle source

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]

# File lib/onfido/api/default_api.rb, line 2169
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
find_timeline_file_with_http_info(workflow_run_id, timeline_file_id, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 2180
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']) unless header_params['Accept']

  # 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
find_watchlist_monitor(monitor_id, opts = {}) click to toggle source

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]

# File lib/onfido/api/default_api.rb, line 2237
def find_watchlist_monitor(monitor_id, opts = {})
  data, _status_code, _headers = find_watchlist_monitor_with_http_info(monitor_id, opts)
  data
end
find_watchlist_monitor_with_http_info(monitor_id, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 2247
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']) unless header_params['Accept']

  # 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
find_webhook(webhook_id, opts = {}) click to toggle source

Retrieve a Webhook Retrieves a single webhook. Returns a webhook object. @param webhook_id [String] @param [Hash] opts the optional parameters @return [Webhook]

# File lib/onfido/api/default_api.rb, line 2300
def find_webhook(webhook_id, opts = {})
  data, _status_code, _headers = find_webhook_with_http_info(webhook_id, opts)
  data
end
find_webhook_with_http_info(webhook_id, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 2310
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']) unless header_params['Accept']

  # 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
find_workflow_run(workflow_run_id, opts = {}) click to toggle source

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]

# File lib/onfido/api/default_api.rb, line 2363
def find_workflow_run(workflow_run_id, opts = {})
  data, _status_code, _headers = find_workflow_run_with_http_info(workflow_run_id, opts)
  data
end
find_workflow_run_with_http_info(workflow_run_id, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 2373
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']) unless header_params['Accept']

  # 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_report_creation_from_watchlist_monitor(monitor_id, opts = {}) click to toggle source

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]

# File lib/onfido/api/default_api.rb, line 2426
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_report_creation_from_watchlist_monitor_with_http_info(monitor_id, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 2436
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']) unless header_params['Accept']

  # 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_sdk_token(sdk_token_builder, opts = {}) click to toggle source

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]

# File lib/onfido/api/default_api.rb, line 2489
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_sdk_token_with_http_info(sdk_token_builder, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 2499
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']) unless header_params['Accept']
  # 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(opts = {}) click to toggle source

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]

# File lib/onfido/api/default_api.rb, line 2559
def list_applicants(opts = {})
  data, _status_code, _headers = list_applicants_with_http_info(opts)
  data
end
list_applicants_with_http_info(opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 2571
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']) unless header_params['Accept']

  # 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
list_checks(applicant_id, opts = {}) click to toggle source

Retrieve Checks Retrieves a single check. Returns a check object. @param applicant_id [String] @param [Hash] opts the optional parameters @return [ChecksList]

# File lib/onfido/api/default_api.rb, line 2623
def list_checks(applicant_id, opts = {})
  data, _status_code, _headers = list_checks_with_http_info(applicant_id, opts)
  data
end
list_checks_with_http_info(applicant_id, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 2633
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']) unless header_params['Accept']

  # 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(applicant_id, opts = {}) click to toggle source

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]

# File lib/onfido/api/default_api.rb, line 2687
def list_documents(applicant_id, opts = {})
  data, _status_code, _headers = list_documents_with_http_info(applicant_id, opts)
  data
end
list_documents_with_http_info(applicant_id, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 2697
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']) unless header_params['Accept']

  # 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(applicant_id, opts = {}) click to toggle source

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]

# File lib/onfido/api/default_api.rb, line 2751
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_with_http_info(applicant_id, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 2761
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']) unless header_params['Accept']

  # 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(applicant_id, opts = {}) click to toggle source

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]

# File lib/onfido/api/default_api.rb, line 2815
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_with_http_info(applicant_id, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 2825
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']) unless header_params['Accept']

  # 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(applicant_id, opts = {}) click to toggle source

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]

# File lib/onfido/api/default_api.rb, line 2879
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_with_http_info(applicant_id, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 2889
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']) unless header_params['Accept']

  # 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(applicant_id, opts = {}) click to toggle source

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]

# File lib/onfido/api/default_api.rb, line 2943
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_with_http_info(applicant_id, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 2953
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']) unless header_params['Accept']

  # 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
list_repeat_attempts(report_id, opts = {}) click to toggle source

Retrieve repeat attempts Returns all repeat attempts for a given Document report @param report_id [String] @param [Hash] opts the optional parameters @return [RepeatAttemptsList]

# File lib/onfido/api/default_api.rb, line 3007
def list_repeat_attempts(report_id, opts = {})
  data, _status_code, _headers = list_repeat_attempts_with_http_info(report_id, opts)
  data
end
list_repeat_attempts_with_http_info(report_id, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 3017
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']) unless header_params['Accept']

  # 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(check_id, opts = {}) click to toggle source

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]

# File lib/onfido/api/default_api.rb, line 3070
def list_reports(check_id, opts = {})
  data, _status_code, _headers = list_reports_with_http_info(check_id, opts)
  data
end
list_reports_with_http_info(check_id, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 3080
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']) unless header_params['Accept']

  # 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(workflow_run_id, opts = {}) click to toggle source

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>]

# File lib/onfido/api/default_api.rb, line 3134
def list_tasks(workflow_run_id, opts = {})
  data, _status_code, _headers = list_tasks_with_http_info(workflow_run_id, opts)
  data
end
list_tasks_with_http_info(workflow_run_id, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 3144
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']) unless header_params['Accept']

  # 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_watchlist_monitor_matches(monitor_id, opts = {}) click to toggle source

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]

# File lib/onfido/api/default_api.rb, line 3197
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_watchlist_monitor_matches_with_http_info(monitor_id, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 3207
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']) unless header_params['Accept']

  # 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_watchlist_monitors(applicant_id, opts = {}) click to toggle source

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]

# File lib/onfido/api/default_api.rb, line 3261
def list_watchlist_monitors(applicant_id, opts = {})
  data, _status_code, _headers = list_watchlist_monitors_with_http_info(applicant_id, opts)
  data
end
list_watchlist_monitors_with_http_info(applicant_id, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 3272
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']) unless header_params['Accept']

  # 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(opts = {}) click to toggle source

List webhooks Lists all webhooks you’ve created. @param [Hash] opts the optional parameters @return [WebhooksList]

# File lib/onfido/api/default_api.rb, line 3326
def list_webhooks(opts = {})
  data, _status_code, _headers = list_webhooks_with_http_info(opts)
  data
end
list_webhooks_with_http_info(opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 3335
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']) unless header_params['Accept']

  # 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(opts = {}) click to toggle source

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>]

# File lib/onfido/api/default_api.rb, line 3388
def list_workflow_runs(opts = {})
  data, _status_code, _headers = list_workflow_runs_with_http_info(opts)
  data
end
list_workflow_runs_with_http_info(opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 3402
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']) unless header_params['Accept']

  # 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(opts = {}) click to toggle source

Ping Run a health check on the Onfido API @param [Hash] opts the optional parameters @return [String]

# File lib/onfido/api/default_api.rb, line 3459
def ping(opts = {})
  data, _status_code, _headers = ping_with_http_info(opts)
  data
end
ping_with_http_info(opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 3468
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']) unless header_params['Accept']

  # 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
post_results_feedback(results_feedback, opts = {}) click to toggle source

Fraud reporting (ALPHA) Create Feedback on checks and reports @param results_feedback [ResultsFeedback] @param [Hash] opts the optional parameters @return [ResultsFeedback]

# File lib/onfido/api/default_api.rb, line 3517
def post_results_feedback(results_feedback, opts = {})
  data, _status_code, _headers = post_results_feedback_with_http_info(results_feedback, opts)
  data
end
post_results_feedback_with_http_info(results_feedback, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 3527
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']) unless header_params['Accept']
  # 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
resend_webhooks(webhook_resend, opts = {}) click to toggle source

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]

# File lib/onfido/api/default_api.rb, line 3585
def resend_webhooks(webhook_resend, opts = {})
  resend_webhooks_with_http_info(webhook_resend, opts)
  nil
end
resend_webhooks_with_http_info(webhook_resend, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 3595
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']) unless header_params['Accept']
  # 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(applicant_id, opts = {}) click to toggle source

Restore Applicant Restores a single applicant scheduled for deletion. @param applicant_id [String] @param [Hash] opts the optional parameters @return [nil]

# File lib/onfido/api/default_api.rb, line 3653
def restore_applicant(applicant_id, opts = {})
  restore_applicant_with_http_info(applicant_id, opts)
  nil
end
restore_applicant_with_http_info(applicant_id, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 3663
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']) unless header_params['Accept']

  # 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_check(check_id, opts = {}) click to toggle source

Resume a Check Resumes a paused check. @param check_id [String] @param [Hash] opts the optional parameters @return [nil]

# File lib/onfido/api/default_api.rb, line 3716
def resume_check(check_id, opts = {})
  resume_check_with_http_info(check_id, opts)
  nil
end
resume_check_with_http_info(check_id, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 3726
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']) unless header_params['Accept']

  # 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(report_id, opts = {}) click to toggle source

Resume report Resumes a single paused report. @param report_id [String] @param [Hash] opts the optional parameters @return [nil]

# File lib/onfido/api/default_api.rb, line 3779
def resume_report(report_id, opts = {})
  resume_report_with_http_info(report_id, opts)
  nil
end
resume_report_with_http_info(report_id, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 3789
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']) unless header_params['Accept']

  # 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(applicant_id, applicant_updater, opts = {}) click to toggle source

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]

# File lib/onfido/api/default_api.rb, line 3843
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_with_http_info(applicant_id, applicant_updater, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 3854
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']) unless header_params['Accept']
  # 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
update_watchlist_monitor_match(monitor_id, watchlist_monitor_matches_updater, opts = {}) click to toggle source

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]

# File lib/onfido/api/default_api.rb, line 3917
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
update_watchlist_monitor_match_with_http_info(monitor_id, watchlist_monitor_matches_updater, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 3928
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']) unless header_params['Accept']
  # 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
update_webhook(webhook_id, webhook_updater, opts = {}) click to toggle source

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]

# File lib/onfido/api/default_api.rb, line 3991
def update_webhook(webhook_id, webhook_updater, opts = {})
  data, _status_code, _headers = update_webhook_with_http_info(webhook_id, webhook_updater, opts)
  data
end
update_webhook_with_http_info(webhook_id, webhook_updater, opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 4002
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']) unless header_params['Accept']
  # 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_document(type, applicant_id, file, opts = {}) click to toggle source

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 [DocumentTypes] 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]

# File lib/onfido/api/default_api.rb, line 4071
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_document_with_http_info(type, applicant_id, file, opts = {}) click to toggle source

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 [DocumentTypes] 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

# File lib/onfido/api/default_api.rb, line 4088
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']) unless header_params['Accept']
  # 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(opts = {}) click to toggle source

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]

# File lib/onfido/api/default_api.rb, line 4171
def upload_id_photo(opts = {})
  data, _status_code, _headers = upload_id_photo_with_http_info(opts)
  data
end
upload_id_photo_with_http_info(opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 4182
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']) unless header_params['Accept']
  # 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(opts = {}) click to toggle source

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]

# File lib/onfido/api/default_api.rb, line 4240
def upload_live_photo(opts = {})
  data, _status_code, _headers = upload_live_photo_with_http_info(opts)
  data
end
upload_live_photo_with_http_info(opts = {}) click to toggle source

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

# File lib/onfido/api/default_api.rb, line 4252
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']) unless header_params['Accept']
  # 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