domainic-type 0.1.0.alpha.3.2.0 → 0.1.0.alpha.3.3.0

data/lib/domainic/type/types/core/complex_type.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require 'domainic/type/behavior'
+require 'domainic/type/behavior/numeric_behavior'
+
+module Domainic
+  module Type
+    # A type for validating and constraining `Complex` numbers.
+    #
+    # This type extends `NumericBehavior` to provide a fluent interface for numeric-specific validations such as
+    # polarity and divisibility checks.
+    #
+    # @example Validating a `Complex` value
+    #   type = Domainic::Type::ComplexType.new
+    #   type.validate!(Complex(3, 4)) # => true
+    #
+    # @example Enforcing constraints
+    #   type = Domainic::Type::ComplexType.new
+    #   type.being_positive.validate!(Complex(42, 0)) # => raises TypeError
+    #
+    # @author {https://aaronmallen.me Aaron Allen}
+    # @since 0.1.0
+    class ComplexType
+      # @rbs! extend Behavior::ClassMethods
+
+      include Behavior
+      include Behavior::NumericBehavior
+
+      intrinsically_constrain :self, :type, Complex, abort_on_failure: true, description: :not_described
+
+      # Constrain the Complex real to be divisible by a given divisor.
+      #
+      # @param arguments [Array<Numeric>] a list of arguments, typically one divisor
+      # @param options [Hash] additional options such as tolerance for floating-point checks
+      # @option options [Numeric] :divisor the divisor to check for divisibility
+      # @option options [Numeric] :tolerance the tolerance for floating-point checks
+      #
+      # @return [self] the current instance for chaining
+      # @rbs (*Numeric arguments, ?divisor: Numeric, ?tolerance: Numeric) -> Behavior
+      def being_divisible_by(*arguments, **options)
+        if arguments.size > 1 || (arguments.empty? && !options.key?(:divisor))
+          raise ArgumentError, "wrong number of arguments (given #{arguments.size}, expected 1)"
+        end
+
+        divisor = arguments.first || options[:divisor]
+        constrain :real, :divisibility, divisor, description: 'being', **options.except(:divisor)
+      end
+      alias being_multiple_of being_divisible_by
+      alias divisible_by being_divisible_by
+      alias multiple_of being_divisible_by
+
+      # Constrain the Complex real to be even.
+      #
+      # @return [self] the current instance for chaining
+      # @rbs () -> Behavior
+      def being_even
+        # @type self: Object & Behavior
+        constrain :real, :parity, :even, description: 'being'
+      end
+      alias even being_even
+      alias not_being_odd being_even
+
+      # Constrain the Complex real to be negative.
+      #
+      # @return [self] the current instance for chaining
+      # @rbs () -> Behavior
+      def being_negative
+        # @type self: Object & Behavior
+        constrain :real, :polarity, :negative, description: 'being'
+      end
+      alias negative being_negative
+      alias not_being_positive being_negative
+
+      # Constrain the Complex real value to be odd.
+      #
+      # @return [self] the current instance for chaining
+      # @rbs () -> Behavior
+      def being_odd
+        # @type self: Object & Behavior
+        constrain :real, :parity, :odd, description: 'being'
+      end
+      alias odd being_odd
+      alias not_being_even being_odd
+
+      # Constrain the Complex real to be positive.
+      #
+      # @return [self] the current instance for chaining
+      # @rbs () -> Behavior
+      def being_positive
+        # @type self: Object & Behavior
+        constrain :real, :polarity, :positive, description: 'being'
+      end
+      alias positive being_positive
+      alias not_being_negative being_positive
+
+      # Constrain the Complex real to not be divisible by a specific divisor.
+      #
+      # @note the divisor MUST be provided as an argument or in the options Hash.
+      #
+      # @param arguments [Array<Numeric>] a list of arguments, typically one divisor
+      # @param options [Hash] additional options such as tolerance for floating-point checks
+      # @option options [Numeric] :divisor the divisor to check for divisibility
+      # @option options [Numeric] :tolerance the tolerance for floating-point checks
+      #
+      # @return [self] the current instance for chaining
+      # @rbs (*Numeric arguments, ?divisor: Numeric, ?tolerance: Numeric) -> Behavior
+      def not_being_divisible_by(*arguments, **options)
+        if arguments.size > 1 || (arguments.empty? && !options.key?(:divisor))
+          raise ArgumentError, "wrong number of arguments (given #{arguments.size}, expected 1)"
+        end
+
+        # @type self: Object & Behavior
+        divisor = arguments.first || options[:divisor]
+        divisible_by = @constraints.prepare :self, :divisibility, divisor, **options.except(:divisor)
+        constrain :real, :not, divisible_by, concerning: :divisibility, description: 'being'
+      end
+      alias not_being_multiple_of not_being_divisible_by
+      alias not_divisible_by not_being_divisible_by
+      alias not_multiple_of not_being_divisible_by
+    end
+  end
+end

data/lib/domainic/type/types/core/range_type.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'domainic/type/behavior'
+require 'domainic/type/behavior/enumerable_behavior'
+
+module Domainic
+  module Type
+    # A type for validating `Range` objects with comprehensive constraints.
+    #
+    # This class allows flexible validation of ranges, supporting type checks,
+    # inclusion/exclusion of values, and range-specific behaviors such as bounds validation.
+    # It integrates with `EnumerableBehavior` for enumerable-style validations
+    # (e.g., size constraints, element presence).
+    #
+    # Key features:
+    # - Ensures the value is a `Range`.
+    # - Supports constraints for range boundaries (`begin` and `end`).
+    # - Provides validations for inclusion and exclusion of values.
+    # - Leverages `EnumerableBehavior` for size and collection-style constraints.
+    #
+    # @example Basic usage
+    #   type = RangeType.new
+    #   type.having_bounds(1, 10)         # Validates range bounds (inclusive or exclusive).
+    #   type.containing(5)               # Ensures value is within the range.
+    #   type.not_containing(15)          # Ensures value is not within the range.
+    #
+    # @example Integration with EnumerableBehavior
+    #   type = RangeType.new
+    #   type.having_size(10)             # Validates size (total elements in the range).
+    #   type.containing_exactly(3, 7)    # Validates specific values within the range.
+    #
+    # @example Flexible boundaries
+    #   type = RangeType.new
+    #   type.having_bounds(1, 10, exclusive: true)  # Upper and lower bounds are exclusive.
+    #
+    # @author {https://aaronmallen.me Aaron Allen}
+    # @since 0.1.0
+    class RangeType
+      # @rbs! extend Behavior::ClassMethods
+
+      include Behavior
+      include Behavior::EnumerableBehavior
+
+      intrinsically_constrain :self, :type, Range, abort_on_failure: true, description: :not_described
+    end
+  end
+end

data/lib/domainic/type/types/core/rational_type.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'domainic/type/behavior'
+require 'domainic/type/behavior/numeric_behavior'
+
+module Domainic
+  module Type
+    # A type for validating Rational numbers.
+    #
+    # This type ensures values are of type `Rational` and supports a range of
+    # constraints for numerical validation, such as positivity, negativity,
+    # and divisibility. It integrates with `NumericBehavior` to provide a
+    # consistent and fluent interface for numeric constraints.
+    #
+    # @example Validating a positive Rational number
+    #   type = Domainic::Type::RationalType.new
+    #   type.being_positive.validate!(Rational(3, 4)) # => true
+    #
+    # @example Validating divisibility
+    #   type = Domainic::Type::RationalType.new
+    #   type.being_divisible_by(1).validate!(Rational(3, 1)) # => true
+    #
+    # @example Using constraints with chaining
+    #   type = Domainic::Type::RationalType.new
+    #   type.being_greater_than(0).being_less_than(1).validate!(Rational(1, 2)) # => true
+    #
+    # @author {https://aaronmallen.me Aaron Allen}
+    # @since 0.1.0
+    class RationalType
+      # @rbs! extend Behavior::ClassMethods
+
+      include Behavior
+      include Behavior::NumericBehavior
+
+      intrinsically_constrain :self, :type, Rational, abort_on_failure: true, description: :not_described
+    end
+  end
+end

data/lib/domainic/type/types/core_extended/big_decimal_type.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'bigdecimal'
+require 'domainic/type/behavior'
+require 'domainic/type/behavior/numeric_behavior'
+
+module Domainic
+  module Type
+    # A type for validating and constraining `BigDecimal` objects.
+    #
+    # This type extends `NumericBehavior` to provide a fluent interface for numeric-specific validations such as being
+    # positive, being within a range, or satisfying divisibility rules.
+    #
+    # @example Validating a `BigDecimal` value
+    #   type = Domainic::Type::BigDecimalType.new
+    #   type.validate!(BigDecimal('3.14')) # => true
+    #
+    # @example Enforcing constraints
+    #   type = Domainic::Type::BigDecimalType.new
+    #   type.being_positive.validate!(BigDecimal('42')) # => true
+    #   type.being_positive.validate!(BigDecimal('-42')) # raises TypeError
+    #
+    # @author {https://aaronmallen.me Aaron Allen}
+    # @since 0.1.0
+    class BigDecimalType
+      # @rbs! extend Behavior::ClassMethods
+
+      include Behavior
+      include Behavior::NumericBehavior
+
+      intrinsically_constrain :self, :type, BigDecimal, abort_on_failure: true, description: :not_described
+    end
+  end
+end

data/lib/domainic/type/types/core_extended/set_type.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'domainic/type/behavior'
+require 'domainic/type/behavior/enumerable_behavior'
+require 'set'
+
+module Domainic
+  module Type
+    # A type for validating and constraining `Set` objects.
+    #
+    # This type extends `EnumerableBehavior` to support validations and constraints
+    # such as being empty, containing specific elements, or having a minimum or maximum count.
+    #
+    # @example Validating a `Set` object
+    #   type = Domainic::Type::SetType.new
+    #   type.validate!(Set.new([1, 2, 3])) # => true
+    #
+    # @example Enforcing constraints
+    #   type = Domainic::Type::SetType.new
+    #   type.being_empty.validate!(Set.new) # => true
+    #   type.being_empty.validate!(Set.new([1])) # raises TypeError
+    #
+    # @author {https://aaronmallen.me Aaron Allen}
+    # @since 0.1.0
+    class SetType
+      # @rbs! extend Behavior::ClassMethods
+
+      include Behavior
+      include Behavior::EnumerableBehavior
+
+      intrinsically_constrain :self, :type, Set, abort_on_failure: true, description: :not_described
+    end
+  end
+end

data/lib/domainic/type/types/datetime/date_time_string_type.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require 'domainic/type/behavior'
+require 'domainic/type/behavior/date_time_behavior'
+
+module Domainic
+  module Type
+    # A type for validating and constraining strings to match various datetime formats.
+    #
+    # This class includes behaviors for handling datetime constraints and ensures that
+    # a string matches one of the predefined datetime formats (e.g., ISO 8601, RFC2822).
+    #
+    # @example Validating American format
+    #   type = Domainic::Type::DateTimeStringType.new
+    #   type.having_american_format.validate!("01/31/2024")
+    #
+    # @example Validating ISO 8601 format
+    #   type = Domainic::Type::DateTimeStringType.new
+    #   type.having_iso8601_format.validate!("2024-01-01T12:00:00Z")
+    #
+    # @example Validating RFC2822 format
+    #   type = Domainic::Type::DateTimeStringType.new
+    #   type.having_rfc2822_format.validate!("Thu, 31 Jan 2024 13:30:00 +0000")
+    #
+    # @author {https://aaronmallen.me Aaron Allen}
+    # @since 0.1.0
+    class DateTimeStringType
+      # @rbs! extend Behavior::ClassMethods
+
+      include Behavior
+      include Behavior::DateTimeBehavior
+
+      # The `Format` module provides a set of regular expressions for validating
+      # various datetime formats, including ISO 8601, RFC2822, American, European,
+      # full month names, abbreviated month names, and 12-hour clock formats.
+      #
+      # @author {https://aaronmallen.me Aaron Allen}
+      # @since 0.1.0
+      module Format
+        # Matches ISO 8601 datetime formats, including:
+        # - `2024-01-01T12:00:00.000+00:00`
+        # - `2024-01-01T12:00:00+00:00`
+        # - `2024-01-01T12:00:00.000`
+        # - `2024-01-01T12:00:00`
+        # - `20240101T120000+0000` (basic format)
+        # @return [Regexp]
+        ISO8601 = /\A\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[-+]\d{2}:?\d{2})?)?\z/ #: Regexp
+
+        # Matches RFC2822 datetime formats, including:
+        # - `Thu, 31 Jan 2024 13:30:00 +0000`
+        # - `31 Jan 2024 13:30:00 +0000`
+        # @return [Regexp]
+        RFC2822 = /\A
+          (?:                                                                     # Optional day of the week
+            (?:Mon|Tue|Wed|Thu|Fri|Sat|Sun),\s+
+          )?
+          \d{1,2}\s+                                                              # Day of the month
+          (?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s+                  # Month
+          \d{2,4}\s+                                                              # Year
+          \d{2}:\d{2}                                                             # Time in HH:MM
+          (?::\d{2})?                                                             # Optional seconds
+          \s+                                                                     # Space
+          (?:                                                                     # Time zone
+            [+-]\d{4} |                                                           # Offset (e.g., +0000)
+            GMT | UTC                                                             # Literal GMT or UTC
+          )
+        \z/x #: Regexp
+
+        # Matches American-style dates with optional time in 12-hour or 24-hour formats, including:
+        # - `01/31/2024`
+        # - `01/31/2024 12:30:00`
+        # - `01/31/2024 12:30 PM`
+        # @return [Regexp]
+        AMERICAN = %r{\A\d{1,2}/\d{1,2}/\d{2,4}(?: \d{1,2}:\d{1,2}(?::\d{1,2})?(?:\s*[AaPp][Mm])?)?\z} #: Regexp
+
+        # Matches European-style dates with optional time in 24-hour format, including:
+        # - `31.01.2024`
+        # - `31.01.2024 12:30:00`
+        # @return [Regexp]
+        EUROPEAN = /\A\d{1,2}\.\d{1,2}\.\d{2,4}(?: \d{1,2}:\d{2}(?::\d{2})?)?\z/ #: Regexp
+
+        # Matches datetime formats with full month names, including:
+        # - `January 31, 2024 12:00:00`
+        # - `January 31, 2024 12:00`
+        # @return [Regexp]
+        FULL_MONTH_NAME = /\A
+          (?:                                                                      # Full month name
+            (?:January|February|March|April|May|June|July|August|September|October|November|December)
+          )\s+\d{1,2},\s+\d{4}(?:\s+\d{1,2}:\d{2}(?::\d{2})?)?
+        \z/x #: Regexp
+
+        # Matches datetime formats with abbreviated month names, including:
+        # - `Jan 31, 2024 12:00:00`
+        # - `Jan 31, 2024 12:00`
+        # @return [Regexp]
+        ABBREVIATED_MONTH_NAME = /\A
+          \d{1,2}\s+(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec),\s+\d{4}(?:\s+\d{1,2}:\d{2}(?::\d{2})?)?
+        \z/x #: Regexp
+
+        # Matches datetime formats using a 12-hour clock with AM/PM, including:
+        # - `2024-01-01 01:30:00 PM`
+        # - `2024-01-01 01:30 PM`
+        # @return [Regexp]
+        TWELVE_HOUR_FORMAT = /\A\d{4}-\d{2}-\d{2}\s+\d{1,2}:\d{2}(?::\d{2})?\s+[APap][Mm]\z/x #: Regexp
+      end
+      private_constant :Format
+
+      intrinsically_constrain :self, :type, String, abort_on_failure: true, description: :not_described
+      intrinsically_constrain :self, :match_pattern,
+                              Regexp.union(Format.constants.map { |name| Format.const_get(name) }),
+                              abort_on_failure: true, concerning: :format, description: :not_described
+
+      # Constrain the type to match American-style datetime formats.
+      #
+      # @return [self] self for method chaining
+      # @rbs () -> self
+      def having_american_format
+        constrain :self, :match_pattern, Format::AMERICAN, concerning: :format
+      end
+      alias american having_american_format
+      alias having_us_format having_american_format
+      alias us_format having_american_format
+
+      # Constrain the type to match European-style datetime formats.
+      #
+      # @return [self] self for method chaining
+      # @rbs () -> self
+      def having_european_format
+        constrain :self, :match_pattern, Format::EUROPEAN, concerning: :format
+      end
+      alias european having_european_format
+      alias having_eu_format having_european_format
+      alias eu_format having_european_format
+
+      # Constrain the type to match ISO 8601 datetime formats.
+      #
+      # @return [self] self for method chaining
+      # @rbs () -> self
+      def having_iso8601_format
+        constrain :self, :match_pattern, Format::ISO8601, concerning: :format
+      end
+      alias iso8601 having_iso8601_format
+      alias iso8601_format having_iso8601_format
+
+      # Constrain the type to match RFC2822 datetime formats.
+      #
+      # @return [self] self for method chaining
+      # @rbs () -> self
+      def having_rfc2822_format
+        constrain :self, :match_pattern, Format::RFC2822, concerning: :format
+      end
+      alias rfc2822 having_rfc2822_format
+      alias rfc2822_format having_rfc2822_format
+    end
+  end
+end

data/lib/domainic/type/types/datetime/timestamp_type.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'domainic/type/behavior'
+require 'domainic/type/behavior/date_time_behavior'
+
+module Domainic
+  module Type
+    # A type for validating Unix timestamps (seconds since the Unix epoch).
+    #
+    # This type ensures the value is an `Integer` representing a valid Unix
+    # timestamp. It integrates with `DateTimeBehavior` to provide a rich set of
+    # validation capabilities, including chronological constraints and range checks.
+    #
+    # Key features:
+    # - Ensures the value is an `Integer` representing a Unix timestamp.
+    # - Supports chronological relationship constraints (e.g., before, after).
+    # - Provides range, equality, and nilable checks.
+    #
+    # @example Basic usage
+    #   type = TimestampType.new
+    #   type.validate(Time.now.to_i)             # => true
+    #   type.validate(Date.today.to_time.to_i)   # => true
+    #   type.validate('invalid')                 # => false
+    #
+    # @example Range validation
+    #   type = TimestampType.new
+    #     .being_between(Time.now.to_i, (Time.now + 3600).to_i)
+    #   type.validate((Time.now + 1800).to_i)    # => true
+    #   type.validate((Time.now + 7200).to_i)    # => false
+    #
+    # @example Historical timestamps
+    #   type = TimestampType.new
+    #   type.validate(-1234567890)               # => true (date before 1970-01-01)
+    #
+    # @example Nilable timestamp
+    #   nilable_type = _Nilable(TimestampType.new)
+    #   nilable_type.validate(nil)               # => true
+    #
+    # @author {https://aaronmallen.me Aaron Allen}
+    # @since 0.1.0
+    class TimestampType
+      # @rbs! extend Behavior::ClassMethods
+
+      include Behavior
+      include Behavior::DateTimeBehavior
+
+      intrinsically_constrain :self, :type, Integer, abort_on_failure: true, description: :not_described
+    end
+  end
+end

data/sig/domainic/type/accessors.rbs

@@ -1,11 +1,11 @@
 module Domainic
   module Type
-    type accessor = :abs | :begin | :chars | :class | :count | :end | :entries | :first | :keys | :last | :length | :self | :size | :values
+    type accessor = :abs | :begin | :chars | :class | :count | :end | :entries | :first | :keys | :last | :length | :real | :self | :size | :values
 
     # A list of valid access methods that can be used to retrieve values for constraint validation.
     # These methods represent common Ruby interfaces for accessing collection sizes, ranges, and values.
     #
-    # - :abs                       - For absolute values
+    # - :abs, :real                - For absolute values
     # - :begin, :end               - For Range-like objects
     # - :class                     - For type checking
     # - :count, :length, :size     - For measuring collections

data/sig/domainic/type/behavior/date_time_behavior.rbs

@@ -24,73 +24,85 @@ module Domainic
       # @author {https://aaronmallen.me Aaron Allen}
       # @since 0.1.0
       module DateTimeBehavior
-        TO_DATETIME_COERCER: Proc
+        # The supported date/time patterns for parsing date/time strings
+        #
+        # @note This list is ordered from most specific to least specific to ensure that the most specific patterns are
+        #  tried first. This is important because some patterns are more lenient than others and may match a wider range
+        #  of input strings.
+        #
+        # @return [Array<String>] the supported date/time patterns
+        DATETIME_PATTERNS: Array[String]
+
+        # Coerce a value to a Date, DateTime, or Time object
+        #
+        # @return [Proc] a lambda that coerces a value to a Date, DateTime, or Time object
+        TO_DATETIME_COERCER: ^(Date | DateTime | Integer | String | Time value) -> (Date | DateTime | Time)
 
         # Parse arguments for being_between
         #
         # @note this in my opinion is better than polluting the namespace of the including class even with a private
         #   method. This way, the method is only available within the module itself. See {#being_between}.
         #
-        # @param after [Date, DateTime, String, Time, nil] minimum size value from positional args
-        # @param before [Date, DateTime, String, Time, nil] maximum size value from positional args
+        # @param after [Date, DateTime, Integer, String, Time, nil] minimum size value from positional args
+        # @param before [Date, DateTime, Integer, String, Time, nil] maximum size value from positional args
         # @param options [Hash] keyword arguments containing after/before values
         #
         # @raise [ArgumentError] if minimum or maximum value can't be determined
-        # @return [Array<Date, DateTime, String, Time, nil>] parsed [after, before] values
-        private def self.parse_being_between_arguments!: ((Date | DateTime | String | Time)? after, (Date | DateTime | String | Time)? before, Hash[Symbol, (Date | DateTime | String | Time)?] options) -> Array[(Date | DateTime | String | Time)?]
+        # @return [Array<Date, DateTime, Integer, String, Time, nil>] parsed [after, before] values
+        private def self.parse_being_between_arguments!: ((Date | DateTime | Integer | String | Time)? after, (Date | DateTime | Integer | String | Time)? before, Hash[Symbol, (Date | DateTime | Integer | String | Time)?] options) -> Array[(Date | DateTime | Integer | String | Time)?]
 
         # Raise appropriate ArgumentError for being_between
         #
         # @param original_caller [Array<String>] caller stack for error
-        # @param after [Date, DateTime, String, Time, nil] after value from positional args
-        # @param before [Date, DateTime, String, Time, nil] before value from positional args
+        # @param after [Date, DateTime, Integer, String, Time, nil] after value from positional args
+        # @param before [Date, DateTime, Integer, String, Time, nil] before value from positional args
         # @param options [Hash] keyword arguments containing after/before values
         #
         # @raise [ArgumentError] with appropriate message
         # @return [void]
-        private def self.raise_being_between_argument_error!: (Array[String] original_caller, (Date | DateTime | String | Time)? after, (Date | DateTime | String | Time)? before, Hash[Symbol, (Date | DateTime | String | Time)?] options) -> void
+        private def self.raise_being_between_argument_error!: (Array[String] original_caller, (Date | DateTime | Integer | String | Time)? after, (Date | DateTime | Integer | String | Time)? before, Hash[Symbol, (Date | DateTime | Integer | String | Time)?] options) -> void
 
         # Constrain the value to be chronologically after a given date/time
         #
-        # @param other [Date, DateTime, String, Time] the date/time to compare against
+        # @param other [Date, DateTime, Integer, String, Time] the date/time to compare against
         # @return [self] self for method chaining
-        def being_after: (Date | DateTime | String | Time other) -> Behavior
+        def being_after: (Date | DateTime | Integer | String | Time other) -> Behavior
 
         alias after being_after
 
         # Constrain the value to be chronologically before a given date/time
         #
-        # @param other [Date, DateTime, String, Time] the date/time to compare against
+        # @param other [Date, DateTime, Integer, String, Time] the date/time to compare against
         # @return [self] self for method chaining
-        def being_before: (Date | DateTime | String | Time other) -> Behavior
+        def being_before: (Date | DateTime | Integer | String | Time other) -> Behavior
 
         alias before being_before
 
         # Constrain the value to be chronologically between two date/times
         #
-        # @param after [Date, DateTime, String, Time] the earliest allowed date/time
-        # @param before [Date, DateTime, String, Time] the latest allowed date/time
+        # @param after [Date, DateTime, Integer, String, Time] the earliest allowed date/time
+        # @param before [Date, DateTime, Integer, String, Time] the latest allowed date/time
         # @param options [Hash] alternative way to specify after/before via keywords
-        # @option options [Date, DateTime, String, Time] :after earliest allowed date/time
-        # @option options [Date, DateTime, String, Time] :before latest allowed date/time
+        # @option options [Date, DateTime, Integer, String, Time] :after earliest allowed date/time
+        # @option options [Date, DateTime, Integer, String, Time] :before latest allowed date/time
         # @return [self] self for method chaining
-        def being_between: (Date | DateTime | String | Time after, Date | DateTime | String | Time before) -> Behavior
+        def being_between: (Date | DateTime | Integer | String | Time after, Date | DateTime | Integer | String | Time before) -> Behavior
 
         alias between being_between
 
         # Constrain the value to be exactly equal to a given date/time
         #
-        # @param other [Date, DateTime, String, Time] the date/time to compare against
+        # @param other [Date, DateTime, Integer, String, Time] the date/time to compare against
         # @return [self] self for method chaining
-        def being_equal_to: (Date | DateTime | String | Time other) -> Behavior
+        def being_equal_to: (Date | DateTime | Integer | String | Time other) -> Behavior
 
         alias at being_equal_to
 
         # Constrain the value to be chronologically on or after a given date/time
         #
-        # @param other [Date, DateTime, String, Time] the date/time to compare against
+        # @param other [Date, DateTime, Integer, String, Time] the date/time to compare against
         # @return [self] self for method chaining
-        def being_on_or_after: (Date | DateTime | String | Time other) -> Behavior
+        def being_on_or_after: (Date | DateTime | Integer | String | Time other) -> Behavior
 
         alias at_or_after being_on_or_after
 
@@ -100,9 +112,9 @@ module Domainic
 
         # Constrain the value to be chronologically on or before a given date/time
         #
-        # @param other [Date, DateTime, String, Time] the date/time to compare against
+        # @param other [Date, DateTime, Integer, String, Time] the date/time to compare against
         # @return [self] self for method chaining
-        def being_on_or_before: (Date | DateTime | String | Time other) -> Behavior
+        def being_on_or_before: (Date | DateTime | Integer | String | Time other) -> Behavior
 
         alias at_or_before being_on_or_before