          (for [[a-name [a-type a-value]] attrs]
            (prepare-message-attrs a-name a-type a-value)))))
 
-(let [target->elem
-      {:create-queue  [:one :queue-url]
-       :get-queue-url [:one :queue-url]
-       :list-queues   [:many :queue-url]
-       :list-dead-letter-source-queues [:many :queue-url]}]
-  (defn extract-response-value [target resp]
-    (if-let [[tag elem] (target->elem target)]
-      (case tag
-        :one  (x/child-content resp elem)
-        :many (map x/content (x/children resp elem)))
-      resp)))
-
 (defmulti  restructure-response (fn [target body] target))
 (defmethod restructure-response :default [_ body] body)
 

      (assoc req :body
             (as-> body %
               (q/expand-sequences  % (target->seq-spec target))
               (q/translate-enums   % enum-keys-out)
               (prepare-body target %)))))

  (transform-request [_ body]

(defmethod restructure-response :send-message [_ body]
  (x/child-content->map body {:message-id :id :md-5-of-message-body :md5}))

(defn message-attr->kv [attr]
  (let [a-name (x/child-content attr :name)
        {[type value] :value} (x/child attr :value)
        type (keyword (x/child-content type :data-type))
        in-type ({:Binary :binary
                  :String :string
                  :Number :number} type type)]
    [(keyword a-name) [in-type (x/content value)]]))

(defn message-attrs->map [message]
  (into {}
    (for [attr (x/children message :message-attribute)]
      (message-attr->kv attr))))

(defn restructure-message [message]
  (-> message
