                                            (update $ :description (fnil identity ""))
                                            (if (:schema $)
                                              (-> $
-                                                 (update :schema compile)
+                                                 (update :schema compile options)
                                                  (update :schema swagger/transform {:type :schema}))
                                              $))]))}))
            (throw
              (ex-info
                (str "Can't produce Schema apidocs for " specification)
                {:type specification, :coercion :schema}))))
-       (-compile-model [_ model _] (compile model))
+       (-compile-model [_ model _] (compile model options))
        (-open-model [_ schema] schema)
        (-encode-error [_ error]
          (cond-> error

                                     (update :errors (partial map #(update % :schema edn/write-string opts))))
                 (seq error-keys) (select-keys error-keys)))
       (-request-coercer [_ type schema]
         (-coercer (compile schema) type transformers :decode nil options))
       (-response-coercer [_ schema]
         (let [schema (compile schema)
               encoder (-coercer schema :body transformers :encode nil options)]
           (-coercer schema :response transformers :encode encoder options)))))))


                      (if parameters
                        {:parameters
                         (->> (for [[in schema] parameters
                                    parameter (extract-parameter in (compile schema options))]
                                parameter)
                              (into []))})
                      (if responses
