   (rejected-unexpected-fields #{:properties :additionalProperties :required :oneOf :anyOf} schema-type)
   (if-let [one-of (:oneOf schema-type)]
     (object-one-of->generator schema type-name schema-type)
-
     ;; else
     (if-let [any-of (:anyOf schema-type)]
       (->> any-of

      (throw (Exception. (format "The fields [%s] are not supported by generators with schema type [%s]"
                                 (pr-str unexpected-fields) (pr-str schema-type)))))))

(defn- object-like-schema-type->generator
  "Takes an object-like schema type and generates a generator. By \"object-like\" it means a map
  with keys properties, required, and additionalProperties. This is used to handle a normal object

        ;; Figure out which properties are required and which are optional
        required-properties (set (map keyword (:required schema-type)))
        optional-properties (vec (set/difference (set (keys properties)) required-properties))]
    (non-empty-obj-gen
     (chgen/for [;; Determine which properties to generate in this instance of the object
                 num-optional-fields (gen/choose 0 (count optional-properties))
                 :let [selected-properties (concat required-properties
                                                   (subvec optional-properties
                                                           0 num-optional-fields))
                       ;; Create a map of property names to generators
                       selected-prop-gens (select-keys prop-gens selected-properties)]
                 ;; Generate a hash map containing the properties
                 prop-map (apply gen/hash-map (flatten (seq selected-prop-gens)))]
       ;; Construct a record from the hash map
       (constructor-fn prop-map)))))

(defn- assert-field-not-present-with-one-of
  [schema-type k]
