             {:doc "A unique identifier for this window."
              :type :keyword
              :optional? false
-             :restrictions ["Must be unique across all Window entries."]}
+             :restrictions ["Must be unique across all Window entries."]
+             :added "0.8.0"}
 
             :window/task
             {:doc "The task that this window will be applied to."
              :type :keyword
              :optional? false
-             :restrictions ["Must name a task in the workflow."]}
+             :restrictions ["Must name a task in the workflow."]
+             :added "0.8.0"}
 
             :window/type
             {:doc "The type of Window to use. See the User Guide for what each type means."
              :type :keyword
              :choices [:fixed :sliding :global :session]
-             :optional? false}
+             :optional? false
+             :added "0.8.0"}
 
             :window/aggregation
             {:doc "If this value is a keyword, it is a fully qualified, namespaced keyword pointing to a symbol on the classpath at runtime. This symbol must be a map with keys as further specified by the information model. Onyx comes with a handful of aggregations built in, such as `:onyx.windowing.aggregation/min`. See the User Guide for the full list. Users can also implement their own aggregations.
 
                   If this value is a vector, it contain two values: a keyword as described above, and another keyword which represents the key to aggregate over."
              :type [:keyword [:keyword]]
-             :optional? false}
+             :optional? false
+             :added "0.8.0"}
 
             :window/window-key
             {:doc "The key of the incoming segments to window over. This key can represent any totally ordered domain, for example `:event-time`."
              :type :any
              :required-when ["`:window/type` is set to `:fixed`"
                              "`:window/type` is set to `:sliding`"
-                             "`:window/type` is set to `:session`"]}
+                             "`:window/type` is set to `:session`"]
+             :added "0.8.0"}
 
             :window/min-key
             {:doc "A globally minimum value that values of `:window/window-key` will never be less than. This is used for calculating materialized aggregates for windows in a space efficient manner."
              :type :integer
              :optional? true
-             :default 0}
+             :default 0
+             :added "0.8.0"}
 
             :window/session-key
             {:doc "The key of the incoming segments to calculate a session window over. This key can represent any totally ordered domain, e.g. `:event-time`"
              :type :any
-             :optional? true}
+             :optional? true
+             :added "0.8.0"}
 
             :window/range
             {:doc "The span of time, or other totally ordered domain, that this window will capture data within."
              :type [:unit]
              :optional? false
-             :required-when ["The `:window/type` is `:fixed` or `:sliding`."]}
+             :required-when ["The `:window/type` is `:fixed` or `:sliding`."]
+             :added "0.8.0"}
 
             :window/slide
             {:doc "To offset of time, or other totally ordered domain, to wait before starting a new window after the previous window."
              :type [:unit]
-             :required-when ["The `:window/type` is `:sliding`."]}
+             :required-when ["The `:window/type` is `:sliding`."]
+             :added "0.8.0"}
 
             :window/init
             {:doc "The initial value to be used for the aggregate, if required. Some aggregates require this, such as the Minimum aggregate. Others, such as the Conj aggregate, do not, as empty vector makes a suitable initial value."
              :type :any
-             :required-when ["The `:window/aggregation` has no predefined initial value."]}
+             :required-when ["The `:window/aggregation` has no predefined initial value."]
+             :added "0.8.0"}
 
             :window/timeout-gap
             {:doc "The duration of dormant activity that constitutes a session window being closed."
              :type :unit
-             :required-when ["The `window/type` is `:session`."]}
+             :required-when ["The `window/type` is `:session`."]
+             :added "0.8.0"}
 
             :window/doc
             {:doc "A docstring for this window."
              :type :string
-             :optional? true}}}
+             :optional? true
+             :added "0.8.0"}}}
 
    :state-aggregation
    {:summary "Onyx provides the ability to perform stateful updates for segments calculated over windows. For example, a grouping task may accumulate incoming values for a number of keys over windows of 5 minutes."
     :link nil
     :model {:aggregation/init {:doc "Fn (window) to initialise the state."
                                :type :function
-                               :optional? true}
+                               :optional? true
+                               :added "0.8.0"}
             :aggregation/fn {:doc "Fn (state, window, segment) to generate a serializable state machine update."
                              :type :function
-                             :optional? false}
+                             :optional? false
+                             :added "0.8.0"}
             :aggregation/apply-state-update {:doc "Fn (state, entry) to apply state machine update entry to a state."
                                              :type :function
-                                             :optional? false}
+                                             :optional? false
+                                             :added "0.8.0"}
             :aggregation/super-aggregation-fn {:doc "Fn (state-1, state-2, window) to combine two states in the case of two windows being merged, e.g. session windows."
                                                :type :function
-                                               :optional? true}}}
+                                               :optional? true
+                                               :added "0.8.0"}}}
    :trigger-entry
    {:summary "Triggers are a feature that interact with Windows. Windows capture and bucket data over time. Triggers let you release the captured data over a variety stimuli."
     :link nil

             :restrictions ["Must be unique across all catalog entries."
                            "Value cannot be `:none`."
                            "Value cannot be `:all`."]
             :optional? false}

            :onyx/type
            {:doc "The role that this task performs. `:input` reads data. `:function` applies a transformation. `:output` writes data."
             :type :keyword
             :tags [:task]
             :choices [:input :function :output]
             :optional? false}

            :onyx/batch-size
            {:doc "The number of segments a peer will wait to read before processing them all in a batch for this task. Segments will be processed when either `:onyx/batch-size` segments have been received at this peer, or `:onyx/batch-timeout` milliseconds have passed - whichever comes first. This is a knob that is used to tune throughput and latency, and it goes hand-in-hand with `:onyx/batch-timeout`."
             :type :integer
             :tags [:latency :throughput]
             :restrictions ["Value must be greater than 0."]
             :optional? false}

            :onyx/batch-timeout
            {:doc "The number of milliseconds a peer will wait to read more segments before processing them all in a batch for this task. Segments will be processe when either `:onyx/batch-timeout` milliseconds passed, or `:onyx/batch-size` segments have been read - whichever comes first. This is a knob that is used to tune throughput and latency, and it goes hand-in-hand with `:onyx/batch-size`."

             :choices [:retry]
             :optional? true
             :default nil
             :restrictions ["Any flow condition clauses with `:flow/action` set to `:retry` must also have `:flow/short-circuit?` set to `true`, and `:flow/to` set to `:none`."]
             :added "0.8.0"}

            :flow/doc
            {:doc "A docstring for this flow condition."
             :type :string
             :optional? true
             :added "0.8.0"}}}

   :window-entry
   {:summary "Windows allow you to group and accrue data into possibly overlapping buckets. Windows are intimately related to the Triggers feature."
