openhab-scripting 5.36.2 → 5.38.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9dca6625d5d2a4ac13a8012df40e3d0a0ebdefced290c5cff076465c6f759757
-  data.tar.gz: 25f336aa6c3cd7c7a0e47f5e237fd19ac73f6f1ea989ff18d911e2a66a22048b
+  metadata.gz: dcf7591d994378fb216137014e04dae3321ba891e11f201336e1afc6f1b7226b
+  data.tar.gz: d9917f8c8f5ead81623e39b3c606ab0f4efe7da519f654b081498bd743ebc721
 SHA512:
-  metadata.gz: 2df6953fce517e82fda1fc8e3a5098c63af45333c1637639f6488597230d2634c18a666eb4bc3ae1302abb0d19fdd64eb9c256b7bb263b6f7d6852b9bead6600
-  data.tar.gz: bfb62aca10a6a2b3bff00adf94f39d1b30f806fc55cc34f503102d6c2c349ad938c1a8f5c71f17d60164eaeb810141f38ca0120a5357feec9f69af7aa71866e2
+  metadata.gz: 78aa38c7c90b81ead46d438543077abb55bf06db1476f6e73cf36577f4df10c3b305e5169de2df2580f7d1d963fd8e5a998521764d9377305f87717ff216fff5
+  data.tar.gz: 9a410509dc518a5019c3885d5123c8a1840a0a70c6abb99df85cdbc11897eb7d5367d6014c71ff16759baebe03083a409f8f254606f0fab22a51ef50f2cdcdc6

data/lib/openhab/core/events/item_state_changed_event.rb

@@ -13,6 +13,14 @@ module OpenHAB
       class ItemStateChangedEvent < ItemEvent
         include ItemState
 
+        # @!attribute [r] last_state_update
+        #   @return [ZonedDateTime] the time the previous state update occurred
+        #   @since openHAB 5.0
+
+        # @!attribute [r] last_state_change
+        #   @return [ZonedDateTime] the time the previous state change occurred
+        #   @since openHAB 5.0
+
         # @!method was_undef?
         #   Check if {#was} is {UNDEF}
         #   @return [true, false]
@@ -74,6 +82,9 @@ module OpenHAB
         def inspect
           s = "#<OpenHAB::Core::Events::ItemStateChangedEvent item=#{item_name} " \
               "state=#{item_state.inspect} was=#{old_item_state.inspect}"
+          # @deprecated OH4.3 remove respond_to? checks in the next two lines when dropping OH 4.3
+          s += " last_state_update=#{last_state_update}" if respond_to?(:last_state_update) && last_state_update
+          s += " last_state_change=#{last_state_change}" if respond_to?(:last_state_change) && last_state_change
           s += " source=#{source.inspect}" if source
           "#{s}>"
         end

data/lib/openhab/core/events/item_state_updated_event.rb

@@ -14,6 +14,19 @@ module OpenHAB
       #
       class ItemStateUpdatedEvent < ItemEvent
         include ItemState
+
+        # @!attribute [r] last_state_update
+        #   @return [ZonedDateTime] the time the previous state update occurred
+        #   @since openHAB 5.0
+
+        # @return [String]
+        def inspect
+          s = "#<OpenHAB::Core::Events::ItemStateUpdatedEvent item=#{item_name} state=#{item_state.inspect}"
+          # @deprecated OH4.3 remove respond_to? check when dropping OH 4.3
+          s += " last_state_update=#{last_state_update}" if respond_to?(:last_state_update) && last_state_update
+          s += " source=#{source.inspect}" if source
+          "#{s}>"
+        end
       end
     end
   end

data/lib/openhab/core/items/call_item.rb

@@ -13,6 +13,10 @@ module OpenHAB
       # @!attribute [r] state
       #   @return [StringListType, nil]
       #
+      # @!attribute [r] was
+      #   @return [StringListType, nil]
+      #   @since openHAB 5.0
+      #
       class CallItem < GenericItem
         # @!visibility private
         def format_type(command)

data/lib/openhab/core/items/color_item.rb

@@ -35,6 +35,10 @@ module OpenHAB
       # @!attribute [r] state
       #   @return [HSBType, nil]
       #
+      # @!attribute [r] was
+      #   @return [HSBType, nil]
+      #   @since openHAB 5.0
+      #
       class ColorItem < DimmerItem
         # Make sure to do the String => HSBType conversion in Ruby,
         # where we add support for hex

data/lib/openhab/core/items/contact_item.rb

@@ -8,7 +8,7 @@ module OpenHAB
       java_import org.openhab.core.library.items.ContactItem
 
       #
-      #  A {ContactItem} can be used for sensors that return an "open" or
+      # A {ContactItem} can be used for sensors that return an "open" or
       # "closed" as a state.
       #
       # This is useful for doors, windows, etc.
@@ -16,6 +16,10 @@ module OpenHAB
       # @!attribute [r] state
       #   @return [OpenClosedType, nil]
       #
+      # @!attribute [r] was
+      #   @return [OpenClosedType, nil]
+      #   @since openHAB 5.0
+      #
       # @example
       #   rule 'Log state of all doors on system startup' do
       #     on_load
@@ -30,20 +34,29 @@ module OpenHAB
       #     end
       #   end
       #
+      # @!method open?
+      #   Check if the item state == {OPEN}
+      #   @return [true,false]
+      #
+      #   @example Log open contacts
+      #     Contacts.select(&:open?).each { |contact| logger.info("Contact #{contact.name} is open")}
+      #
+      # @!method closed?
+      #   Check if the item state == {CLOSED}
+      #   @return [true,false]
+      #
+      #   @example Log closed contacts
+      #     Contacts.select(&:closed?).each { |contact| logger.info("Contact #{contact.name} is closed")}
+      #
+      # @!method was_open?
+      #   Check if {#was} is {OPEN}
+      #   @return [true, false]
+      #
+      # @!method was_closed?
+      #   Check if {#was} is {CLOSED}
+      #   @return [true, false]
+      #
       class ContactItem < GenericItem
-        # @!method open?
-        #   Check if the item state == {OPEN}
-        #   @return [true,false]
-        #
-        # @example Log open contacts
-        #   Contacts.select(&:open?).each { |contact| logger.info("Contact #{contact.name} is open")}
-
-        # @!method closed?
-        #   Check if the item state == {CLOSED}
-        #   @return [true,false]
-        #
-        # @example Log closed contacts
-        #   Contacts.select(&:closed?).each { |contact| logger.info("Contact #{contact.name} is closed")}
       end
     end
   end

data/lib/openhab/core/items/date_time_item.rb

@@ -13,6 +13,10 @@ module OpenHAB
       # @!attribute [r] state
       #   @return [DateTimeType, nil]
       #
+      # @!attribute [r] was
+      #   @return [DateTimeType, nil]
+      #   @since openHAB 5.0
+      #
       # @example DateTime items can be updated and commanded with Ruby Time objects or Java ZonedDateTime objects
       #   Example_DateTimeItem << Time.now
       #   Example_DateTimeItem << ZonedDateTime.now

data/lib/openhab/core/items/dimmer_item.rb

@@ -15,6 +15,10 @@ module OpenHAB
       # @!attribute [r] state
       #   @return [PercentType, nil]
       #
+      # @!attribute [r] was
+      #   @return [PercentType, nil]
+      #   @since openHAB 5.0
+      #
       # @example
       #   DimmerOne << DimmerOne.state - 5
       #   DimmerOne << 100 - DimmerOne.state

data/lib/openhab/core/items/generic_item.rb

@@ -79,10 +79,45 @@ module OpenHAB
         #   [Ruby safe navigation operator `&.`](https://docs.ruby-lang.org/en/master/syntax/calling_methods_rdoc.html#label-Safe+Navigation+Operator)
         #   Use {#undef?} or {#null?} to check for those states.
         #
+        # @see was
+        #
         def state
           raw_state if state?
         end
 
+        # @!method was_undef?
+        #   Check if {#was} is {UNDEF}
+        #   @return [true, false]
+
+        # @!method was_null?
+        #   Check if {#was} is {NULL}
+        #   @return [true, false]
+
+        #
+        # Check if the item's previous state was not `nil`, {UNDEF} or {NULL}
+        #
+        # @return [true, false]
+        #
+        # @since openHAB 5.0
+        #
+        def was?
+          !last_state.nil? && !last_state.is_a?(Types::UnDefType)
+        end
+
+        #
+        # @!attribute [r] was
+        #
+        # @return [State] The previous state of the item. nil if the item was never updated, or
+        #   if the item was updated to {NULL} or {UNDEF}.
+        # @since openHAB 5.0
+        #
+        # @see state
+        # @see Item#last_state
+        #
+        def was
+          last_state if was?
+        end
+
         # @!method null?
         #   Check if the item state == {NULL}
         #   @return [true,false]

data/lib/openhab/core/items/image_item.rb

@@ -18,7 +18,11 @@ module OpenHAB
       # @!attribute [r] state
       #   @return [RawType, nil]
       #
-      # @example Update from a base 64 encode image string
+      # @!attribute [r] was
+      #   @return [RawType, nil]
+      #   @since openHAB 5.0
+      #
+      # @example Update from a base 64 encoded image string
       #   Image.update("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABAQMAAAAl21bKAAAAA1BMVEUAAACnej3aAAAAAXRSTlMAQObYZgAAAApJREFUCNdjYAAAAAIAAeIhvDMAAAAASUVORK5CYII=")
       #
       # @example Update from image bytes and mime type

data/lib/openhab/core/items/item.rb

@@ -70,6 +70,18 @@ module OpenHAB
         # @!attribute [r] command_description
         #   @return [Types::CommandDescription, nil]
 
+        # @!attribute [r] last_state
+        #   @return [State] The previous state of the item.
+        #   @since openHAB 5.0
+
+        # @!attribute [r] last_state_change
+        #   @return [ZonedDateTime] The time of the last state change.
+        #   @since openHAB 5.0
+
+        # @!attribute [r] last_state_update
+        #   @return [ZonedDateTime] The time of the last state update.
+        #   @since openHAB 5.0
+
         #
         # The item's {GenericItem#label label} if one is defined, otherwise its {#name}.
         #
@@ -550,6 +562,12 @@ module OpenHAB
         # @return [String]
         def inspect
           s = "#<OpenHAB::Core::Items::#{type}Item#{type_details} #{name} #{label.inspect} state=#{raw_state.inspect}"
+          # @deprecated OH 4.3 Remove if guard when dropping support for OH 4.3
+          if respond_to?(:last_state)
+            s += " last_state=#{last_state.inspect}" if last_state
+            s += " last_state_update=#{last_state_update}" if last_state_update
+            s += " last_state_change=#{last_state_change}" if last_state_change
+          end
           s += " category=#{category.inspect}" if category
           s += " tags=#{tags.to_a.inspect}" unless tags.empty?
           s += " groups=#{group_names}" unless group_names.empty?

data/lib/openhab/core/items/location_item.rb

@@ -16,6 +16,10 @@ module OpenHAB
       # @!attribute [r] state
       #   @return [PointType, nil]
       #
+      # @!attribute [r] was
+      #   @return [PointType, nil]
+      #   @since openHAB 5.0
+      #
       # @example Send point commands
       #   Location << '30,20'   # latitude of 30, longitude of 20
       #   Location << '30,20,80' # latitude of 30, longitude of 20, altitude of 80

data/lib/openhab/core/items/number_item.rb

@@ -25,6 +25,9 @@ module OpenHAB
       #   @return [javax.measure.Unit, nil]
       # @!attribute [r] state
       #   @return [DecimalType, QuantityType, nil]
+      # @!attribute [r] was
+      #   @return [DecimalType, QuantityType, nil]
+      #   @since openHAB 5.0
       #
       # @example Number Items can be selected in an enumerable with grep.
       #   # Get all NumberItems

data/lib/openhab/core/items/persistence.rb

@@ -111,28 +111,37 @@ module OpenHAB
         # @deprecated Use {PersistedState} instead
         HistoricState = PersistedState
 
-        # @!method average_since(timestamp, service = nil)
+        # @!method average_since(timestamp, service = nil, riemann_type: nil)
         #   Returns the average value of the item's state since the given time
         #   @param [#to_zoned_date_time] timestamp The point in time from which to search
         #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
+        #   @param [:left, :midpoint, :right, :trapezoidal] riemann_type An optional approximation type for Riemann sum.
+        #     If nil, :left is used.
         #   @return [DecimalType, QuantityType, nil] The average value since `timestamp`,
         #     or nil if no previous states could be found.
+        #   @since openHAB 5.0 riemann_type parameter added
 
-        # @!method average_until(timestamp, service = nil)
+        # @!method average_until(timestamp, service = nil, riemann_type: nil)
         #   Returns the average value of the item's state between now until the given time
         #   @param [#to_zoned_date_time] timestamp The point in time until which to search
         #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
+        #   @param [:left, :midpoint, :right, :trapezoidal] riemann_type An optional approximation type for Riemann sum.
+        #     If nil, :left is used.
         #   @return [DecimalType, QuantityType, nil] The average value until `timestamp`,
         #     or nil if no future states could be found.
         #   @since openHAB 4.2
+        #   @since openHAB 5.0 riemann_type parameter added
 
-        # @!method average_between(start, finish, service = nil)
+        # @!method average_between(start, finish, service = nil, riemann_type: nil)
         #   Returns the average value of the item's state between two points in time
         #   @param [#to_zoned_date_time] start The point in time from which to search
         #   @param [#to_zoned_date_time] finish The point in time to which to search
         #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
+        #   @param [:left, :midpoint, :right, :trapezoidal] riemann_type An optional approximation type for Riemann sum.
+        #     If nil, :left is used.
         #   @return [DecimalType, QuantityType, nil] The average value between `start` and `finish`,
         #     or nil if no states could be found.
+        #   @since openHAB 5.0 riemann_type parameter added
 
         # @!method delta_since(timestamp, service = nil)
         #   Returns the difference value of the item's state since the given time
@@ -157,28 +166,37 @@ module OpenHAB
         #   @return [DecimalType, QuantityType, nil] The difference value between `start` and `finish`,
         #     or nil if no states could be found.
 
-        # @!method deviation_since(timestamp, service = nil)
+        # @!method deviation_since(timestamp, service = nil, riemann_type: nil)
         #   Returns the standard deviation of the item's state since the given time
         #   @param [#to_zoned_date_time] timestamp The point in time from which to search
         #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
+        #   @param [:left, :midpoint, :right, :trapezoidal] riemann_type An optional approximation type for Riemann sum.
+        #     If nil, :left is used.
         #   @return [DecimalType, QuantityType, nil] The standard deviation since `timestamp`,
         #     or nil if no previous states could be found.
+        #   @since openHAB 5.0 riemann_type parameter added
 
-        # @!method deviation_until(timestamp, service = nil)
+        # @!method deviation_until(timestamp, service = nil, riemann_type: nil)
         #   Returns the standard deviation of the item's state beetween now until the given time
         #   @param [#to_zoned_date_time] timestamp The point in time until which to search
         #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
+        #   @param [:left, :midpoint, :right, :trapezoidal] riemann_type An optional approximation type for Riemann sum.
+        #     If nil, :left is used.
         #   @return [DecimalType, QuantityType, nil] The standard deviation until `timestamp`,
         #     or nil if no future states could be found.
         #   @since openHAB 4.2
+        #   @since openHAB 5.0 riemann_type parameter added
 
-        # @!method deviation_between(start, finish, service = nil)
+        # @!method deviation_between(start, finish, service = nil, riemann_type: nil)
         #   Returns the standard deviation of the item's state between two points in time
         #   @param [#to_zoned_date_time] start The point in time from which to search
         #   @param [#to_zoned_date_time] finish The point in time to which to search
         #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
+        #   @param [:left, :midpoint, :right, :trapezoidal] riemann_type An optional approximation type for Riemann sum.
+        #     If nil, :left is used.
         #   @return [DecimalType, QuantityType, nil] The standard deviation between `start` and `finish`,
         #     or nil if no states could be found.
+        #   @since openHAB 5.0 riemann_type parameter added
 
         # @!method median_since(timestamp, service = nil)
         #   Returns the median of the item's state since the given time
@@ -228,28 +246,37 @@ module OpenHAB
         #   @return [DecimalType, QuantityType, nil] The sum between `start` and `finish`,
         #     or nil if no states could be found.
 
-        # @!method variance_since(timestamp, service = nil)
+        # @!method variance_since(timestamp, service = nil, riemann_type: nil)
         #   Returns the variance of the item's state since the given time
         #   @param [#to_zoned_date_time] timestamp The point in time from which to search
         #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
+        #   @param [:left, :midpoint, :right, :trapezoidal] riemann_type An optional approximation type for Riemann sum.
+        #     If nil, :left is used.
         #   @return [DecimalType, QuantityType, nil] The variance since `timestamp`,
         #     or nil if no previous states could be found.
+        #   @since openHAB 5.0 riemann_type parameter added
 
-        # @!method variance_until(timestamp, service = nil)
+        # @!method variance_until(timestamp, service = nil, riemann_type: nil)
         #   Returns the variance of the item's state between now until the given time
         #   @param [#to_zoned_date_time] timestamp The point in time until which to search
         #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
+        #   @param [:left, :midpoint, :right, :trapezoidal] riemann_type An optional approximation type for Riemann sum.
+        #     If nil, :left is used.
         #   @return [DecimalType, QuantityType, nil] The variance until `timestamp`,
         #     or nil if no future states could be found.
         #   @since openHAB 4.2
+        #   @since openHAB 5.0 riemann_type parameter added
 
-        # @!method variance_between(start, finish, service = nil)
+        # @!method variance_between(start, finish, service = nil, riemann_type: nil)
         #   Returns the variance of the item's state between two points in time
         #   @param [#to_zoned_date_time] start The point in time from which to search
         #   @param [#to_zoned_date_time] finish The point in time to which to search
         #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
+        #   @param [:left, :midpoint, :right, :trapezoidal] riemann_type An optional approximation type for Riemann sum.
+        #     If nil, :left is used.
         #   @return [DecimalType, QuantityType, nil] The variance between `start` and `finish`,
         #     or nil if no states could be found.
+        #   @since openHAB 5.0 riemann_type parameter added
 
         # @!method changed_since?(timestamp, service = nil)
         #   Whether the item's state has changed since the given time
@@ -461,6 +488,37 @@ module OpenHAB
         #   @return [Array<PersistedState>] An array of {PersistedState} persisted for this item.
         #   @since openHAB 4.0
 
+        # @!method riemann_sum_since(timestamp, service = nil, riemann_type: nil)
+        #   Returns the Riemann sum of the states since a certain point in time.
+        #   @param [#to_zoned_date_time] timestamp The point in time from which to search
+        #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
+        #   @param [:left, :midpoint, :right, :trapezoidal] riemann_type An optional approximation type for Riemann sum.
+        #     If nil, :left is used.
+        #   @return [DecimalType, QuantityType, nil] The riemann sum since `timestamp`,
+        #     or nil if no previous states could be found.
+        #   @since openHAB 5.0
+
+        # @!method riemann_sum_until(timestamp, service = nil, riemann_type: nil)
+        #   Returns the Riemann sum of the states between now until a certain point in time.
+        #   @param [#to_zoned_date_time] timestamp The point in time until which to search
+        #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
+        #   @param [:left, :midpoint, :right, :trapezoidal] riemann_type An optional approximation type for Riemann sum.
+        #     If nil, :left is used.
+        #   @return [DecimalType, QuantityType, nil] The riemann sum until `timestamp`,
+        #     or nil if no previous states could be found.
+        #   @since openHAB 5.0
+
+        # @!method riemann_sum_between(start, finish, service = nil, riemann_type: nil)
+        #   Returns the Riemann sum of the states between two points in time.
+        #   @param [#to_zoned_date_time] start The point in time from which to search
+        #   @param [#to_zoned_date_time] finish The point in time to which to search
+        #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
+        #   @param [:left, :midpoint, :right, :trapezoidal] riemann_type An optional approximation type for Riemann sum.
+        #     If nil, :left is used.
+        #   @return [DecimalType, QuantityType, nil] The riemann sum between `start` and `finish`,
+        #     or nil if no previous states could be found.
+        #   @since openHAB 5.0
+
         # @!method remove_all_states_since(timestamp, service = nil)
         #   Removes persisted data points since a certain point in time.
         #   @param [#to_zoned_date_time] timestamp The point in time from which to remove
@@ -565,6 +623,7 @@ module OpenHAB
         #   Returns the time the item was last updated.
         #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
         #   @return [ZonedDateTime, nil] The timestamp of the last update
+        #   @see Item#last_state_update
 
         # @!method next_update(service = nil)
         #   Returns the first future update time of the item.
@@ -578,6 +637,7 @@ module OpenHAB
         #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
         #   @return [ZonedDateTime, nil] The timestamp of the last update
         #   @since openHAB 4.2
+        #   @see Item#last_state_change
 
         # @!method next_change(service = nil)
         #   Returns the first future change time of the item.
@@ -612,6 +672,8 @@ module OpenHAB
         #   @return [PersistedState, nil] the previous state or nil if no previous state could be found,
         #           or if the default persistence service is not configured or
         #           does not refer to a valid service
+        #
+        #   @see Item#last_state
 
         # @!method next_state(service = nil, skip_equal: false)
         #   Return the next state of the item
@@ -645,76 +707,103 @@ module OpenHAB
 
         class << self
           # @!visibility private
-          def def_persistence_method(method, quantify: false)
+          def def_persistence_method(method, quantify: false, riemann_param: nil)
             method = method.to_s.dup
             suffix = method.delete_suffix!("?") && "?"
+            riemann_arg = nil
+
+            if riemann_param
+              riemann_param = ", riemann_type: nil"
+              # @deprecated OH4.3 remove if guard when dropping OH 4.3
+              if Actions::PersistenceExtensions.const_defined?(:RiemannType)
+                riemann_arg = "to_riemann_type(riemann_type),"
+              end
+            end
 
             class_eval <<~RUBY, __FILE__, __LINE__ + 1
-              def #{method}#{suffix}(timestamp, service = nil)        # def changed_since?(timestamp, service = nil)
-                service ||= persistence_service                       #   service ||= persistence_service
-                result = Actions::PersistenceExtensions.#{method}(    #   result = Actions::PersistenceExtensions.changed_since(
-                  self,                                               #     self,
-                  timestamp.to_zoned_date_time,                       #     timestamp.to_zoned_date_time,
-                  service&.to_s                                       #     service&.to_s
-                )                                                     #   )
-                wrap_result(result, quantify: #{quantify})            #   wrap_result(result, quantify: false)
-              end                                                     # end
+              def #{method}#{suffix}(timestamp, service = nil#{riemann_param}) # def changed_since?(timestamp, service = nil, riemann_type: nil)
+                service ||= persistence_service                                #   service ||= persistence_service
+                result = Actions::PersistenceExtensions.#{method}(             #   result = Actions::PersistenceExtensions.average_since(
+                  self,                                                        #     self,
+                  timestamp.to_zoned_date_time,                                #     timestamp.to_zoned_date_time,
+                  #{riemann_arg}                                               #     to_riemann_type(riemann_type),
+                  service&.to_s                                                #     service&.to_s
+                )                                                              #   )
+                wrap_result(result, quantify: #{quantify})                     #   wrap_result(result, quantify: false)
+              end                                                              # end
             RUBY
           end
 
           # @!visibility private
-          def def_persistence_methods(method, quantify: false)
+          def def_persistence_methods(method, quantify: false, riemann_param: nil)
             method = method.to_s.dup
             suffix = method.delete_suffix!("?") && "?"
+            riemann_arg = nil
 
-            def_persistence_method("#{method}_since#{suffix}", quantify:)
+            def_persistence_method("#{method}_since#{suffix}", quantify:, riemann_param:)
             # @deprecated OH 4.1 remove if guard, keeping the content, when dropping OH 4.1
             if OpenHAB::Core.version >= OpenHAB::Core::V4_2
-              def_persistence_method("#{method}_until#{suffix}", quantify:)
+              def_persistence_method("#{method}_until#{suffix}", quantify:, riemann_param:)
+            end
+
+            if riemann_param
+              riemann_param = ", riemann_type: nil"
+              # @deprecated OH4.3 remove if guard when dropping OH 4.3
+              if Actions::PersistenceExtensions.const_defined?(:RiemannType)
+                riemann_arg = "to_riemann_type(riemann_type),"
+              end
             end
 
             method = "#{method}_between"
             class_eval <<~RUBY, __FILE__, __LINE__ + 1
-              def #{method}#{suffix}(start, finish, service = nil)    # def changed_between?(start, finish, service = nil)
-                service ||= persistence_service                       #   service ||= persistence_service
-                result = Actions::PersistenceExtensions.#{method}(    #   result = Actions::PersistenceExtensions.changed_between?(
-                  self,                                               #     self,
-                  start.to_zoned_date_time,                           #     start.to_zoned_date_time,
-                  finish.to_zoned_date_time,                          #     finish.to_zoned_date_time,
-                  service&.to_s                                       #     service&.to_s
-                )                                                     #   )
-                wrap_result(result, quantify: #{quantify})            #   wrap_result(result, quantify: false)
-              end                                                     # end
+              def #{method}#{suffix}(start, finish, service = nil#{riemann_param}) # def changed_between?(start, finish, service = nil, riemann_type: nil)
+                service ||= persistence_service                                    #   service ||= persistence_service
+                result = Actions::PersistenceExtensions.#{method}(                 #   result = Actions::PersistenceExtensions.average_between(
+                  self,                                                            #     self,
+                  start.to_zoned_date_time,                                        #     start.to_zoned_date_time,
+                  finish.to_zoned_date_time,                                       #     finish.to_zoned_date_time,
+                  #{riemann_arg}                                                   #     to_riemann_type(riemann_type),
+                  service&.to_s                                                    #     service&.to_s
+                )                                                                  #   )
+                wrap_result(result, quantify: #{quantify})                         #   wrap_result(result, quantify: false)
+              end                                                                  # end
             RUBY
           end
         end
 
-        def_persistence_methods(:average, quantify: true)
-        def_persistence_methods(:median, quantify: true) if OpenHAB::Core.version >= OpenHAB::Core::V4_3
-        def_persistence_methods(:delta, quantify: true)
-        def_persistence_methods(:deviation, quantify: true)
-        def_persistence_methods(:sum, quantify: true)
-        def_persistence_methods(:variance, quantify: true)
-
+        # arranged in alphabetical order
+        def_persistence_methods(:average, quantify: true, riemann_param: true)
         def_persistence_methods(:changed?)
         def_persistence_methods(:count)
+
         def_persistence_methods(:count_state_changes)
         alias_method :state_changes_since, :count_state_changes_since
         alias_method :state_changes_until, :count_state_changes_until if OpenHAB::Core.version >= OpenHAB::Core::V4_2
         alias_method :state_changes_between, :count_state_changes_between
 
+        def_persistence_methods(:delta, quantify: true)
+        def_persistence_methods(:deviation, quantify: true, riemann_param: true)
+
         # @deprecated OH 4.2 - this still exists in OH 4.2 but logs a deprecation warning
         def_persistence_method(:historic_state, quantify: true)
 
-        def_persistence_methods(:maximum, quantify: true)
-        def_persistence_methods(:minimum, quantify: true)
-        def_persistence_methods(:updated?)
-
         def_persistence_methods(:get_all_states, quantify: true)
         alias_method :all_states_since, :get_all_states_since
         alias_method :all_states_until, :get_all_states_until if OpenHAB::Core.version >= OpenHAB::Core::V4_2
         alias_method :all_states_between, :get_all_states_between
 
+        def_persistence_methods(:maximum, quantify: true)
+        def_persistence_methods(:minimum, quantify: true)
+        def_persistence_methods(:median, quantify: true) if OpenHAB::Core.version >= OpenHAB::Core::V4_3
+        # @deprecated OH4.3 remove if guard when dropping OH 4.3
+        if Actions::PersistenceExtensions.const_defined?(:RiemannType)
+          # riemann_sum methods were added in OH 5.0 which already quantifies the result in core
+          def_persistence_methods(:riemann_sum, riemann_param: true)
+        end
+        def_persistence_methods(:sum, quantify: true)
+        def_persistence_methods(:updated?)
+        def_persistence_methods(:variance, quantify: true, riemann_param: true)
+
         if OpenHAB::Core.version >= OpenHAB::Core::V4_2
           def_persistence_method(:persisted_state) # already quantified in core
 
@@ -805,6 +894,15 @@ module OpenHAB
         def persistence_service
           Thread.current[:openhab_persistence_service]
         end
+
+        #
+        # Convert a symbol to a RiemannType enum value
+        # @param [Symbol] sym the symbol to convert
+        # @return [RiemannType] the RiemannType enum value, or nil if sym is nil
+        #
+        def to_riemann_type(sym)
+          Actions::PersistenceExtensions::RiemannType.value_of(sym.to_s.upcase) if sym
+        end
       end
     end
   end