class Lithic::Resources::Disputes

def create(params)

Other tags:
    See: Lithic::Models::DisputeCreateParams -

Returns:
  • (Lithic::Dispute) -

Parameters:
  • request_options (Lithic::RequestOptions, Hash{Symbol=>Object}, nil) --
  • customer_note (String) -- Customer description of dispute
  • customer_filed_date (Time) -- Date the customer filed the dispute
  • transaction_token (String) -- Transaction to dispute
  • reason (Symbol, Lithic::DisputeCreateParams::Reason) -- Reason for dispute
  • amount (Integer) -- Amount to dispute

Overloads:
  • create(amount:, reason:, transaction_token:, customer_filed_date: nil, customer_note: nil, request_options: {}) 
def create(params)
  parsed, options = Lithic::DisputeCreateParams.dump_request(params)
  @client.request(
    method: :post,
    path: "v1/disputes",
    body: parsed,
    model: Lithic::Dispute,
    options: options
  )
end

def delete(dispute_token, params = {})

Other tags:
    See: Lithic::Models::DisputeDeleteParams -

Returns:
  • (Lithic::Dispute) -

Parameters:
  • request_options (Lithic::RequestOptions, Hash{Symbol=>Object}, nil) --
  • dispute_token (String) --

Overloads:
  • delete(dispute_token, request_options: {}) 
def delete(dispute_token, params = {})
  @client.request(
    method: :delete,
    path: ["v1/disputes/%1$s", dispute_token],
    model: Lithic::Dispute,
    options: params[:request_options]
  )
end

def delete_evidence(evidence_token, params)

Other tags:
    See: Lithic::Models::DisputeDeleteEvidenceParams -

Returns:
  • (Lithic::DisputeEvidence) -

Parameters:
  • request_options (Lithic::RequestOptions, Hash{Symbol=>Object}, nil) --
  • dispute_token (String) --
  • evidence_token (String) --

Overloads:
  • delete_evidence(evidence_token, dispute_token:, request_options: {}) 
def delete_evidence(evidence_token, params)
  parsed, options = Lithic::DisputeDeleteEvidenceParams.dump_request(params)
  dispute_token =
    parsed.delete(:dispute_token) do
      raise ArgumentError.new("missing required path argument #{_1}")
    end
  @client.request(
    method: :delete,
    path: ["v1/disputes/%1$s/evidences/%2$s", dispute_token, evidence_token],
    model: Lithic::DisputeEvidence,
    options: options
  )
end

def initialize(client:)

Parameters:
  • client (Lithic::Client) --

Other tags:
    Api: - private 
def initialize(client:)
  @client = client
end

def initiate_evidence_upload(dispute_token, params = {})

Other tags:
    See: Lithic::Models::DisputeInitiateEvidenceUploadParams -

Returns:
  • (Lithic::DisputeEvidence) -

Parameters:
  • request_options (Lithic::RequestOptions, Hash{Symbol=>Object}, nil) --
  • filename (String) -- Filename of the evidence.
  • dispute_token (String) --

Overloads:
  • initiate_evidence_upload(dispute_token, filename: nil, request_options: {}) 
def initiate_evidence_upload(dispute_token, params = {})
  parsed, options = Lithic::DisputeInitiateEvidenceUploadParams.dump_request(params)
  @client.request(
    method: :post,
    path: ["v1/disputes/%1$s/evidences", dispute_token],
    body: parsed,
    model: Lithic::DisputeEvidence,
    options: options
  )
end

def list(params = {})

Other tags:
    See: Lithic::Models::DisputeListParams -

Returns:
  • (Lithic::Internal::CursorPage) -

Parameters:
  • request_options (Lithic::RequestOptions, Hash{Symbol=>Object}, nil) --
  • transaction_tokens (Array) -- Transaction tokens to filter by.
  • status (Symbol, Lithic::DisputeListParams::Status) -- List disputes of a specific status.
  • starting_after (String) -- A cursor representing an item's token after which a page of results should begin
  • page_size (Integer) -- Page size (for pagination).
  • ending_before (String) -- A cursor representing an item's token before which a page of results should end.
  • end_ (Time) -- Date string in RFC 3339 format. Only entries created before the specified time w
  • begin_ (Time) -- Date string in RFC 3339 format. Only entries created after the specified time wi

Overloads:
  • list(begin_: nil, end_: nil, ending_before: nil, page_size: nil, starting_after: nil, status: nil, transaction_tokens: nil, request_options: {}) 
def list(params = {})
  parsed, options = Lithic::DisputeListParams.dump_request(params)
  @client.request(
    method: :get,
    path: "v1/disputes",
    query: parsed.transform_keys(begin_: "begin", end_: "end"),
    page: Lithic::Internal::CursorPage,
    model: Lithic::Dispute,
    options: options
  )
end

def list_evidences(dispute_token, params = {})

Other tags:
    See: Lithic::Models::DisputeListEvidencesParams -

Returns:
  • (Lithic::Internal::CursorPage) -

Parameters:
  • request_options (Lithic::RequestOptions, Hash{Symbol=>Object}, nil) --
  • starting_after (String) -- A cursor representing an item's token after which a page of results should begin
  • page_size (Integer) -- Page size (for pagination).
  • ending_before (String) -- A cursor representing an item's token before which a page of results should end.
  • end_ (Time) -- Date string in RFC 3339 format. Only entries created before the specified time w
  • begin_ (Time) -- Date string in RFC 3339 format. Only entries created after the specified time wi
  • dispute_token (String) --

Overloads:
  • list_evidences(dispute_token, begin_: nil, end_: nil, ending_before: nil, page_size: nil, starting_after: nil, request_options: {}) 
def list_evidences(dispute_token, params = {})
  parsed, options = Lithic::DisputeListEvidencesParams.dump_request(params)
  @client.request(
    method: :get,
    path: ["v1/disputes/%1$s/evidences", dispute_token],
    query: parsed.transform_keys(begin_: "begin", end_: "end"),
    page: Lithic::Internal::CursorPage,
    model: Lithic::DisputeEvidence,
    options: options
  )
end

def retrieve(dispute_token, params = {})

Other tags:
    See: Lithic::Models::DisputeRetrieveParams -

Returns:
  • (Lithic::Dispute) -

Parameters:
  • request_options (Lithic::RequestOptions, Hash{Symbol=>Object}, nil) --
  • dispute_token (String) --

Overloads:
  • retrieve(dispute_token, request_options: {}) 
def retrieve(dispute_token, params = {})
  @client.request(
    method: :get,
    path: ["v1/disputes/%1$s", dispute_token],
    model: Lithic::Dispute,
    options: params[:request_options]
  )
end

def retrieve_evidence(evidence_token, params)

Other tags:
    See: Lithic::Models::DisputeRetrieveEvidenceParams -

Returns:
  • (Lithic::DisputeEvidence) -

Parameters:
  • request_options (Lithic::RequestOptions, Hash{Symbol=>Object}, nil) --
  • dispute_token (String) --
  • evidence_token (String) --

Overloads:
  • retrieve_evidence(evidence_token, dispute_token:, request_options: {}) 
def retrieve_evidence(evidence_token, params)
  parsed, options = Lithic::DisputeRetrieveEvidenceParams.dump_request(params)
  dispute_token =
    parsed.delete(:dispute_token) do
      raise ArgumentError.new("missing required path argument #{_1}")
    end
  @client.request(
    method: :get,
    path: ["v1/disputes/%1$s/evidences/%2$s", dispute_token, evidence_token],
    model: Lithic::DisputeEvidence,
    options: options
  )
end

def update(dispute_token, params = {})

Other tags:
    See: Lithic::Models::DisputeUpdateParams -

Returns:
  • (Lithic::Dispute) -

Parameters:
  • request_options (Lithic::RequestOptions, Hash{Symbol=>Object}, nil) --
  • reason (Symbol, Lithic::DisputeUpdateParams::Reason) -- Reason for dispute
  • customer_note (String) -- Customer description of dispute
  • customer_filed_date (Time) -- Date the customer filed the dispute
  • amount (Integer) -- Amount to dispute
  • dispute_token (String) --

Overloads:
  • update(dispute_token, amount: nil, customer_filed_date: nil, customer_note: nil, reason: nil, request_options: {}) 
def update(dispute_token, params = {})
  parsed, options = Lithic::DisputeUpdateParams.dump_request(params)
  @client.request(
    method: :patch,
    path: ["v1/disputes/%1$s", dispute_token],
    body: parsed,
    model: Lithic::Dispute,
    options: options
  )
end