                  (fnil inc 0))
       update-progress))
 
-(defmulti process-record
+(defmulti import-record
   (fn [_ record]
     (-> record meta :record-type)))
 
-(defmethod process-record :declaration
+(defmethod import-record :declaration
   [context {:keys [record-type record-count]}]
   (-> context
       (assoc-in [:progress record-type :total] record-count)
       update-progress))
 
-(defmethod process-record :account
+(defmethod import-record :account
   [context account]
   (import-account context account))
 
-(defmethod process-record :transaction
+(defmethod import-record :transaction
   [context transaction]
   (import-transaction context transaction))
 
-(defmethod process-record :budget
+(defmethod import-record :budget
   [context budget]
   (import-budget context budget))
 
-(defmethod process-record :price
+(defmethod import-record :price
   [context price]
   (import-price context price))
 
-(defmethod process-record :commodity
+(defmethod import-record :commodity
   [context commodity]
   (import-commodity context commodity))
 

          [input source-type] (prepare-input s (:image-id impt))]
      (transactions/with-delayed-balancing s (-> @context :entity :id)
        (doseq [record (read-source source-type input)]
          (process-callback context record)))
      (:entity @context))))

  (let [{:keys [record-type ignore?]} (meta record)]
    (swap! context #(cond-> %
                      (not ignore?)
                      (import-record record)

                      (report-progress? record-type)
                      (inc-and-update-progress record-type)))))
