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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ba2ef6a6a8d06966d736c794476322b088878573154468dc55de61a85704f459
-  data.tar.gz: 8f7fcb77831968e9f6f4f42c58bc2f63892b56bae35902aec892932dc5425acc
+  metadata.gz: 24abfbef9f478a43dce3382a737ceec2ea4310f69454d5d3e8903699f97454a0
+  data.tar.gz: aaede220a86b78362f4dd2a8e51ffdb320ba7352a88b4980dec244e7452662fc
 SHA512:
-  metadata.gz: 8fbe93a49fd3d0063c7d9e392cc1e99180cbdfacb3a1a355c813eaa3df5f476be03e6c44b265871bdea82c646c250b5f486b4446f8c0ce2efbc4481c778d5553
-  data.tar.gz: 2509ae814a1dbb07a2100c24fe0aff90b8c59123f41d8b37a90bce60c9ad33fe1ecd9d57562533e3f7c52f5c051c27120136d1d7f1efe1df4714212281663827
+  metadata.gz: 22de008f6805303b6540c879a35a11366c41e49be7dc7ca76347436afaedf256e5b19d8de9242e0351ab0ba78bb6eebf6ad3a202c105b1523ba414836e3a5c64
+  data.tar.gz: 1eb03da0104dcd61ca5149471ae71f774206f342e01d23e73e71917db7189610346d7432d6f9ef9c0ef5a3f92767ec048905adb2004578d99fc7be82faf6c2b6

data/lib/domainic/type/behavior/date_time_behavior.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+require 'date'
+
+module Domainic
+  module Type
+    module Behavior
+      # A module providing date/time validation constraint methods
+      #
+      # This module extends types with methods for constraining date/time values based on
+      # chronological relationships. It provides a fluent interface for building complex
+      # date/time validation constraints using natural language methods.
+      #
+      # @example Basic date comparisons
+      #   type = DateType.new
+      #     .being_after(Date.new(2024, 1, 1))
+      #     .being_before(Date.new(2024, 12, 31))
+      #
+      # @example Range-based validation
+      #   type = DateType.new
+      #     .being_between(Date.new(2024, 1, 1), Date.new(2024, 12, 31))
+      #
+      # @example Inclusive/exclusive bounds
+      #   type = DateType.new
+      #     .being_on_or_after(Date.new(2024, 1, 1))
+      #     .being_on_or_before(Date.new(2024, 12, 31))
+      #
+      # @author {https://aaronmallen.me Aaron Allen}
+      # @since 0.1.0
+      module DateTimeBehavior
+        TO_DATETIME_COERCER = lambda { |value|
+          if [Date, DateTime, Time].any? { |type| value.is_a?(type) }
+            value
+          else
+            DateTime.parse(value.to_s)
+          end
+        } #: Proc
+
+        class << self
+          private
+
+          # 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 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
+          # @rbs (
+          #   (Date | DateTime | String | Time)? after,
+          #   (Date | DateTime | String | Time)? before,
+          #   Hash[Symbol, (Date | DateTime | String | Time)?] options
+          #   ) -> Array[(Date | DateTime | String | Time)?]
+          def parse_being_between_arguments!(after, before, options)
+            after ||= options[:after]
+            before ||= options[:before]
+            raise_being_between_argument_error!(caller, after, before, options) if after.nil? || before.nil?
+
+            [after, before] #: Array[(Date | DateTime | String | Time)?]
+          end
+
+          # 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 options [Hash] keyword arguments containing after/before values
+          #
+          # @raise [ArgumentError] with appropriate message
+          # @return [void]
+          # @rbs (
+          #   Array[String] original_caller,
+          #   (Date | DateTime | String | Time)? after,
+          #   (Date | DateTime | String | Time)? before,
+          #   Hash[Symbol, (Date | DateTime | String | Time)?] options
+          #   ) -> void
+          def raise_being_between_argument_error!(original_caller, after, before, options)
+            message = if options.empty?
+                        "wrong number of arguments (given #{[after, before].compact.count}, expected 2)"
+                      else
+                        "missing keyword: :#{%i[after before].find { |key| !options.key?(key) }}"
+                      end
+
+            error = ArgumentError.new(message)
+            error.set_backtrace(original_caller)
+            raise error
+          end
+        end
+
+        # Constrain the value to be chronologically after a given date/time
+        #
+        # @param other [Date, DateTime, String, Time] the date/time to compare against
+        # @return [self] self for method chaining
+        # @rbs (Date | DateTime | String | Time other) -> Behavior
+        def being_after(other)
+          # @type self: Object & Behavior
+          constrain :self, :range, { minimum: other },
+                    coerce_with: TO_DATETIME_COERCER, description: 'being', inclusive: false
+        end
+        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
+        # @return [self] self for method chaining
+        # @rbs (Date | DateTime | String | Time other) -> Behavior
+        def being_before(other)
+          # @type self: Object & Behavior
+          constrain :self, :range, { maximum: other },
+                    coerce_with: TO_DATETIME_COERCER, description: 'being', inclusive: false
+        end
+        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 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
+        # @return [self] self for method chaining
+        # @rbs (Date | DateTime | String | Time after, Date | DateTime | String | Time before) -> Behavior
+        def being_between(after = nil, before = nil, **options)
+          # @type self: Object & Behavior
+          after, before =
+            DateTimeBehavior.send(:parse_being_between_arguments!, after, before, options.transform_keys(&:to_sym))
+          constrain :self, :range, { minimum: after, maximum: before },
+                    coerce_with: TO_DATETIME_COERCER, description: 'being', inclusive: false
+        end
+        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
+        # @return [self] self for method chaining
+        # @rbs (Date | DateTime | String | Time other) -> Behavior
+        def being_equal_to(other)
+          # @type self: Object & Behavior
+          constrain :self, :equality, other,
+                    coerce_with: TO_DATETIME_COERCER, description: 'being'
+        end
+        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
+        # @return [self] self for method chaining
+        # @rbs (Date | DateTime | String | Time other) -> Behavior
+        def being_on_or_after(other)
+          # @type self: Object & Behavior
+          constrain :self, :range, { minimum: other },
+                    coerce_with: TO_DATETIME_COERCER, description: 'being'
+        end
+        alias at_or_after being_on_or_after
+        alias being_at_or_after being_on_or_after
+        alias on_or_after being_on_or_after
+
+        # 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
+        # @return [self] self for method chaining
+        # @rbs (Date | DateTime | String | Time other) -> Behavior
+        def being_on_or_before(other)
+          # @type self: Object & Behavior
+          constrain :self, :range, { maximum: other },
+                    coerce_with: TO_DATETIME_COERCER, description: 'being'
+        end
+        alias at_or_before being_on_or_before
+        alias being_at_or_before being_on_or_before
+        alias on_or_before being_on_or_before
+      end
+    end
+  end
+end

data/lib/domainic/type/behavior/sizable_behavior.rb

@@ -75,7 +75,7 @@ module Domainic
           # @raise [ArgumentError] if minimum or maximum value can't be determined
           # @return [Array<Integer>] parsed [minimum, maximum] values
           # @rbs (Integer? minimum, Integer? maximum, Hash[Symbol, Integer?] options) -> Array[Integer]
-          def parse_having_between_arguments(minimum, maximum, options)
+          def parse_having_between_arguments!(minimum, maximum, options)
             min = minimum || options[:min] || options[:minimum]
             max = maximum || options[:max] || options[:maximum]
             raise_having_between_argument_error!(caller, min, max, options) if min.nil? || max.nil?
@@ -231,7 +231,7 @@ module Domainic
         def having_size_between(minimum = nil, maximum = nil, **options)
           # @type self: Object & Behavior
           min, max =
-            SizableBehavior.send(:parse_having_between_arguments, minimum, maximum, options.transform_keys(&:to_sym))
+            SizableBehavior.send(:parse_having_between_arguments!, minimum, maximum, options.transform_keys(&:to_sym))
           constrain :size, :range, { minimum: min, maximum: max },
                     concerning: :size, description: "having #{__callee__.to_s.split('_').[](1)}", inclusive: false
         end

data/lib/domainic/type/config/registry.yml

@@ -81,6 +81,12 @@ types:
   cuid:
     constant: Domainic::Type::CUIDType
     require_path: domainic/type/types/identifier/cuid_type
+  date:
+    constant: Domainic::Type::DateType
+    require_path: domainic/type/types/datetime/date_type
+  date_time:
+    constant: Domainic::Type::DateTimeType
+    require_path: domainic/type/types/datetime/date_time_type
   duck:
     constant: Domainic::Type::DuckType
     require_path: domainic/type/types/specification/duck_type
@@ -111,6 +117,9 @@ types:
   symbol:
     constant: Domainic::Type::SymbolType
     require_path: domainic/type/types/core/symbol_type
+  time:
+    constant: Domainic::Type::TimeType
+    require_path: domainic/type/types/datetime/time_type
   union:
     constant: Domainic::Type::UnionType
     require_path: domainic/type/types/specification/union_type

data/lib/domainic/type/constraint/constraints/range_constraint.rb

@@ -5,36 +5,56 @@ require 'domainic/type/constraint/behavior'
 module Domainic
   module Type
     module Constraint
-      # A constraint for validating that numeric values fall within a specified range.
+      # A constraint for validating that comparable values fall within a specified range.
       #
-      # This constraint allows for validating numeric values against minimum and maximum
-      # boundaries. It supports specifying either or both boundaries, allowing for
-      # open-ended ranges when appropriate.
+      # This constraint allows for validating any values that implement comparison operators
+      # (<, <=, >, >=) against minimum and maximum boundaries. It supports specifying either
+      # or both boundaries, allowing for open-ended ranges when appropriate. This makes it
+      # suitable for numeric ranges, date/time ranges, or any other comparable types.
       #
-      # @example Validating with both minimum and maximum
+      # @example Validating numeric ranges
       #   constraint = RangeConstraint.new(:self, { minimum: 1, maximum: 10 })
       #   constraint.satisfied?(5)  # => true
       #   constraint.satisfied?(15) # => false
       #
-      # @example Validating with only minimum
-      #   constraint = RangeConstraint.new(:self, { minimum: 0 })
-      #   constraint.satisfied?(10)  # => true
-      #   constraint.satisfied?(-1)  # => false
+      # @example Validating date ranges
+      #   constraint = RangeConstraint.new(:self, {
+      #     minimum: Date.new(2024, 1, 1),
+      #     maximum: Date.new(2024, 12, 31)
+      #   })
+      #   constraint.satisfied?(Date.new(2024, 6, 15))  # => true
+      #   constraint.satisfied?(Date.new(2023, 12, 31)) # => false
       #
-      # @example Validating with only maximum
-      #   constraint = RangeConstraint.new(:self, { maximum: 100 })
-      #   constraint.satisfied?(50)   # => true
-      #   constraint.satisfied?(150)  # => false
+      # @example Validating with only minimum
+      #   constraint = RangeConstraint.new(:self, { minimum: Time.now })
+      #   constraint.satisfied?(Time.now + 3600)  # => true
+      #   constraint.satisfied?(Time.now - 3600)  # => false
       #
       # @author {https://aaronmallen.me Aaron Allen}
       # @since 0.1.0
       class RangeConstraint
         # @rbs!
-        #   type expected = { ?minimum: Numeric, ?maximum: Numeric }
+        #   interface _Compatible
+        #     def <: (untyped other) -> bool
+        #
+        #     def <=: (untyped other) -> bool
+        #
+        #     def >: (untyped other) -> bool
+        #
+        #     def >=: (untyped other) -> bool
+        #
+        #     def inspect: () -> untyped
+        #
+        #     def nil?: () -> bool
+        #
+        #     def send: (Symbol method_name, *untyped arguments, **untyped keyword_arguments) -> untyped
+        #   end
+        #
+        #   type expected = { ?minimum: _Compatible, ?maximum: _Compatible}
         #
         #   type options = { ?inclusive: bool }
 
-        include Behavior #[expected, Numeric, options]
+        include Behavior #[expected, _Compatible, options]
 
         # Get a human-readable description of the range constraint.
         #
@@ -55,8 +75,8 @@ module Domainic
         # @rbs override
         def short_description
           min, max = @expected.values_at(:minimum, :maximum)
-          min_description = "greater than or equal to #{min}"
-          max_description = "less than or equal to #{max}"
+          min_description = "greater than#{inclusive? ? ' or equal to' : ''} #{min}"
+          max_description = "less than#{inclusive? ? ' or equal to' : ''} #{max}"
 
           return "#{min_description} and #{max_description}" unless min.nil? || max.nil?
           return min_description unless min.nil?
@@ -91,10 +111,10 @@ module Domainic
         # @rbs override
         def satisfies_constraint?
           min, max = @expected.values_at(:minimum, :maximum)
-          min_comparison, max_comparison = @options.fetch(:inclusive, true) ? %i[>= <=] : %i[> <]
+          min_comparison, max_comparison = inclusive? ? %i[>= <=] : %i[> <]
 
-          @actual.send(min_comparison, (min || -Float::INFINITY)) &&
-            @actual.send(max_comparison, (max || Float::INFINITY))
+          (min.nil? ? true : @actual.send(min_comparison, min)) &&
+            (max.nil? ? true : @actual.send(max_comparison, max))
         end
 
         # Validate that the expected value is a properly formatted range specification.
@@ -112,6 +132,16 @@ module Domainic
           validate_minimum_and_maximum!(expectation)
         end
 
+        private
+
+        # Check if the range constraint is inclusive.
+        #
+        # @return [Boolean] `true` if the range is inclusive, `false` otherwise
+        # @rbs () -> bool
+        def inclusive?
+          @options.fetch(:inclusive, true) #: bool
+        end
+
         # Validate the minimum and maximum values in a range specification.
         #
         # @param expectation [Hash] The range specification to validate
@@ -120,15 +150,28 @@ module Domainic
         # @return [void]
         # @rbs (untyped expectation) -> void
         def validate_minimum_and_maximum!(expectation)
-          expectation.each_pair do |property, value|
-            raise ArgumentError, ":#{property} must be a Numeric" unless value.nil? || value.is_a?(Numeric)
-          end
+          validate_minimum_and_maximum_types!(expectation)
 
           min, max = expectation.values_at(:minimum, :maximum)
           return if min.nil? || max.nil? || min <= max
 
           raise ArgumentError, ':minimum must be less than or equal to :maximum'
         end
+
+        # Validate the minimum and maximum value types are compatible with the constraint.
+        #
+        # @param expectation [Hash] The range specification to validate
+        #
+        # @raise [ArgumentError] if the values are invalid
+        # @return [void]
+        # @rbs (untyped expectation) -> void
+        def validate_minimum_and_maximum_types!(expectation)
+          expectation.each_pair do |property, value|
+            unless value.nil? || (%i[< <= > >=].all? { |m| value.respond_to?(m) })
+              raise ArgumentError, ":#{property}: #{value} is not compatible with RangeConstraint"
+            end
+          end
+        end
       end
     end
   end

data/lib/domainic/type/definitions.rb

@@ -133,6 +133,68 @@ module Domainic
       end
       alias _Cuid? _CUID?
 
+      # Creates a DateType instance.
+      #
+      # DateType restricts values to valid `Date` objects.
+      #
+      # @example
+      #   type = _Date
+      #   type.validate(Date.new(2024, 1, 1)) # => true
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::DateType] the created type
+      # @rbs (**__todo__ options) -> DateType
+      def _Date(**options)
+        require 'domainic/type/types/datetime/date_type'
+        Domainic::Type::DateType.new(**options)
+      end
+
+      # Creates a nilable DateType instance.
+      #
+      # @example
+      #   _Date? === Date.new(2024, 1, 1) # => true
+      #   _Date? === nil                  # => true
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::UnionType] the created type (DateType or NilClass)
+      # @rbs (**__todo__ options) -> UnionType
+      def _Date?(**options)
+        _Nilable(_Date(**options))
+      end
+
+      # Creates a DateTimeType instance.
+      #
+      # DateTimeType restricts values to valid `DateTime` objects.
+      #
+      # @example
+      #   type = _DateTime
+      #   type.validate(DateTime.new(2024, 1, 1, 12, 0, 0)) # => true
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::DateTimeType] the created type
+      # @rbs (**__todo__ options) -> DateTimeType
+      def _DateTime(**options)
+        require 'domainic/type/types/datetime/date_time_type'
+        Domainic::Type::DateTimeType.new(**options)
+      end
+
+      # Creates a nilable DateTimeType instance.
+      #
+      # @example
+      #   _DateTime? === DateTime.new(2024, 1, 1, 12, 0, 0) # => true
+      #   _DateTime? === nil                                # => true
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::UnionType] the created type (DateTimeType or NilClass)
+      # @rbs (**__todo__ options) -> UnionType
+      def _DateTime?(**options)
+        _Nilable(_DateTime(**options))
+      end
+
       # Creates a DuckType instance.
       #
       # DuckType allows specifying behavior based on method availability.
@@ -475,6 +537,73 @@ module Domainic
       end
       alias _Interned? _Symbol?
 
+      # Creates a TimeType instance.
+      #
+      # TimeType restricts values to valid `Time` objects.
+      #
+      # @example
+      #   type = _Time
+      #   type.validate(Time.new(2024, 1, 1, 12, 0, 0)) # => true
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::TimeType] the created type
+      # @rbs (**__todo__ options) -> TimeType
+      def _Time(**options)
+        require 'domainic/type/types/datetime/time_type'
+        Domainic::Type::TimeType.new(**options)
+      end
+
+      # Creates a nilable TimeType instance.
+      #
+      # @example
+      #   _Time? === Time.new(2024, 1, 1, 12, 0, 0) # => true
+      #   _Time? === nil                            # => true
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::UnionType] the created type (TimeType or NilClass)
+      # @rbs (**__todo__ options) -> UnionType
+      def _Time?(**options)
+        _Nilable(_Time(**options))
+      end
+
+      # Creates a URIType instance.
+      #
+      # URIType restricts values to valid URIs.
+      #
+      # @example
+      #   type = _URI.having_scheme('https')
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::URIType] the created type
+      # @rbs (**__todo__ options) -> URIType
+      def _URI(**options)
+        require 'domainic/type/types/network/uri_type'
+        Domainic::Type::URIType.new(**options)
+      end
+      alias _URL _URI
+      alias _Url _URI
+      alias _Uri _URI
+
+      # Creates a nilable URIType instance.
+      #
+      # @example
+      #   _Uri?.validate("https://example.com") # => true
+      #   _Uri?.validate(nil)                   # => true
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::UnionType] the created type (URIType or NilClass)
+      # @rbs (**__todo__ options) -> UnionType
+      def _URI?(**options)
+        _Nilable(_Uri(**options))
+      end
+      alias _URL? _URI?
+      alias _Url? _URI?
+      alias _Uri? _URI?
+
       # Creates a UUIDType instance
       #
       # @example
@@ -523,38 +652,6 @@ module Domainic
       end
       alias _Either _Union
 
-      # Creates a URIType instance.
-      #
-      # URIType restricts values to valid URIs.
-      #
-      # @example
-      #   type = _URI.having_scheme('https')
-      #
-      # @param options [Hash] additional configuration options
-      #
-      # @return [Domainic::Type::URIType] the created type
-      # @rbs (**__todo__ options) -> URIType
-      def _Uri(**options)
-        require 'domainic/type/types/network/uri_type'
-        Domainic::Type::URIType.new(**options)
-      end
-      alias _Url _Uri
-
-      # Creates a nilable URIType instance.
-      #
-      # @example
-      #   _Uri?.validate("https://example.com") # => true
-      #   _Uri?.validate(nil)                   # => true
-      #
-      # @param options [Hash] additional configuration options
-      #
-      # @return [Domainic::Type::UnionType] the created type (URIType or NilClass)
-      # @rbs (**__todo__ options) -> UnionType
-      def _Uri?(**options)
-        _Nilable(_Uri(**options))
-      end
-      alias _Url? _Uri?
-
       # Creates a VoidType instance.
       #
       # Represents an operation that returns no value.

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'date'
+require 'domainic/type/behavior'
+require 'domainic/type/behavior/date_time_behavior'
+
+module Domainic
+  module Type
+    # A type for validating DateTime objects
+    #
+    # This type ensures the value is a `DateTime` object and supports comprehensive
+    # date-time validation through `DateTimeBehavior`. It is ideal for scenarios requiring
+    # precise date-time constraints.
+    #
+    # Key features:
+    # - Ensures the value is a `DateTime` object
+    # - Supports chronological relationship validation (e.g., before, after)
+    # - Provides range and equality checks
+    #
+    # @example Basic usage
+    #   type = DateTimeType.new
+    #   type.validate(DateTime.now)            # => true
+    #   type.validate(Date.today)              # => false
+    #
+    # @example Range validation
+    #   type = DateTimeType.new
+    #     .being_between(DateTime.new(2024, 1, 1, 0, 0, 0), DateTime.new(2024, 12, 31, 23, 59, 59))
+    #   type.validate(DateTime.new(2024, 6, 15, 12, 0, 0))  # => true
+    #
+    # @author {https://aaronmallen.me Aaron Allen}
+    # @since 0.1.0
+    class DateTimeType
+      # @rbs! extend Behavior::ClassMethods
+
+      include Behavior
+      include Behavior::DateTimeBehavior
+
+      intrinsically_constrain :self, :type, DateTime, abort_on_failure: true, description: :not_described
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'date'
+require 'domainic/type/behavior'
+require 'domainic/type/behavior/date_time_behavior'
+
+module Domainic
+  module Type
+    # A type for validating Date objects
+    #
+    # This type provides robust validation for `Date` objects, ensuring values conform
+    # to specified chronological constraints. It supports the full range of date-based
+    # constraints provided by `DateTimeBehavior`.
+    #
+    # Key features:
+    # - Ensures the value is a `Date` object
+    # - Supports validation for chronological relationships (e.g., before, after)
+    # - Full integration with `DateTimeBehavior` for range and equality checks
+    #
+    # @example Basic usage
+    #   type = DateType.new
+    #   type.validate(Date.today)               # => true
+    #   type.validate(DateTime.now)             # => false
+    #
+    # @example With range constraints
+    #   type = DateType.new
+    #     .being_between(Date.new(2024, 1, 1), Date.new(2024, 12, 31))
+    #   type.validate(Date.new(2024, 6, 15))    # => true
+    #   type.validate(Date.new(2023, 12, 31))   # => false
+    #
+    # @author {https://aaronmallen.me Aaron Allen}
+    # @since 0.1.0
+    class DateType
+      # @rbs! extend Behavior::ClassMethods
+
+      include Behavior
+      include Behavior::DateTimeBehavior
+
+      intrinsically_constrain :self, :type, Date, abort_on_failure: true, description: :not_described
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'date'
+require 'domainic/type/behavior'
+require 'domainic/type/behavior/date_time_behavior'
+
+module Domainic
+  module Type
+    # A type for validating Time objects
+    #
+    # This type ensures the value is a `Time` object and integrates with
+    # `DateTimeBehavior` to provide a rich set of time-based validation capabilities.
+    #
+    # Key features:
+    # - Ensures the value is a `Time` object
+    # - Supports chronological relationship constraints (e.g., before, after)
+    # - Provides range and equality checks
+    #
+    # @example Basic usage
+    #   type = TimeType.new
+    #   type.validate(Time.now)                 # => true
+    #   type.validate(Date.today)               # => false
+    #
+    # @example Range validation
+    #   type = TimeType.new
+    #     .being_between(Time.now, Time.now + 3600)
+    #   type.validate(Time.now + 1800)          # => true
+    #   type.validate(Time.now + 7200)          # => false
+    #
+    # @author {https://aaronmallen.me Aaron Allen}
+    # @since 0.1.0
+    class TimeType
+      # @rbs! extend Behavior::ClassMethods
+
+      include Behavior
+      include Behavior::DateTimeBehavior
+
+      intrinsically_constrain :self, :type, Time, abort_on_failure: true, description: :not_described
+    end
+  end
+end

data/lib/domainic/type/types/identifier/cuid_type.rb

@@ -60,7 +60,7 @@ module Domainic
       end
 
       # Core CUID constraints
-      intrinsically_constrain :self, :type, String, description: :not_described
+      intrinsically_constrain :self, :type, String, abort_on_failure: true, description: :not_described
 
       # Accept either v1 or v2 format by default
       intrinsically_constrain :self, :match_pattern, CUID::ALL_REGEXP,

data/lib/domainic/type/types/identifier/uuid_type.rb

@@ -176,7 +176,7 @@ module Domainic
       end
 
       # Core UUID constraints based on RFC 4122
-      intrinsically_constrain :self, :type, String, description: :not_described
+      intrinsically_constrain :self, :type, String, abort_on_failure: true, description: :not_described
 
       # The base UUID type should accept either standard or compact format
       intrinsically_constrain :self, :match_pattern,

data/lib/domainic/type/types/network/email_address_type.rb

@@ -47,7 +47,7 @@ module Domainic
       include Behavior::URIBehavior
 
       # Core email constraints based on RFCs 5321 and 5322
-      intrinsically_constrain :self, :type, String, description: :not_described
+      intrinsically_constrain :self, :type, String, abort_on_failure: true, description: :not_described
       intrinsically_constrain :self, :match_pattern, URI::MailTo::EMAIL_REGEXP, description: :not_described
       intrinsically_constrain :length, :range, { maximum: 254 }, description: :not_described, concerning: :size
       intrinsically_constrain :self, :character_set, :ascii, description: :not_described

data/lib/domainic/type/types/network/hostname_type.rb

@@ -60,7 +60,7 @@ module Domainic
       \z/x #: Regexp
 
       # Core hostname constraints based on RFC standards
-      intrinsically_constrain :self, :type, String, description: :not_described
+      intrinsically_constrain :self, :type, String, abort_on_failure: true, description: :not_described
       intrinsically_constrain :self, :match_pattern, RFC_HOSTNAME_REGEXP, description: :not_described
       intrinsically_constrain :length, :range, { maximum: 253 }, description: :not_described, concerning: :size
       intrinsically_constrain :self, :character_set, :ascii, description: :not_described

data/lib/domainic/type/types/network/uri_type.rb

@@ -52,7 +52,7 @@ module Domainic
       URI_REGEXP = /\A#{URI::DEFAULT_PARSER.make_regexp}\z/ #: Regexp
 
       # Core URI constraints based on RFC standards
-      intrinsically_constrain :self, :type, String, description: :not_described
+      intrinsically_constrain :self, :type, String, abort_on_failure: true, description: :not_described
       intrinsically_constrain :self, :match_pattern, URI_REGEXP, description: :not_described
       intrinsically_constrain :self, :character_set, :ascii, description: :not_described
 

data/lib/domainic/type/types/specialized/instance_type.rb

@@ -66,7 +66,7 @@ module Domainic
       # @return [self] self for method chaining
       # @rbs (Class | Module | Behavior type) -> self
       def of(type)
-        constrain :self, :instance_of, type, description: 'of'
+        constrain :self, :instance_of, type, abort_on_failure: true, description: 'of'
       end
     end
   end

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

@@ -0,0 +1,115 @@
+module Domainic
+  module Type
+    module Behavior
+      # A module providing date/time validation constraint methods
+      #
+      # This module extends types with methods for constraining date/time values based on
+      # chronological relationships. It provides a fluent interface for building complex
+      # date/time validation constraints using natural language methods.
+      #
+      # @example Basic date comparisons
+      #   type = DateType.new
+      #     .being_after(Date.new(2024, 1, 1))
+      #     .being_before(Date.new(2024, 12, 31))
+      #
+      # @example Range-based validation
+      #   type = DateType.new
+      #     .being_between(Date.new(2024, 1, 1), Date.new(2024, 12, 31))
+      #
+      # @example Inclusive/exclusive bounds
+      #   type = DateType.new
+      #     .being_on_or_after(Date.new(2024, 1, 1))
+      #     .being_on_or_before(Date.new(2024, 12, 31))
+      #
+      # @author {https://aaronmallen.me Aaron Allen}
+      # @since 0.1.0
+      module DateTimeBehavior
+        TO_DATETIME_COERCER: Proc
+
+        # 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 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)?]
+
+        # 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 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
+
+        # Constrain the value to be chronologically after a given date/time
+        #
+        # @param other [Date, DateTime, String, Time] the date/time to compare against
+        # @return [self] self for method chaining
+        def being_after: (Date | DateTime | 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
+        # @return [self] self for method chaining
+        def being_before: (Date | DateTime | 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 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
+        # @return [self] self for method chaining
+        def being_between: (Date | DateTime | String | Time after, Date | DateTime | 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
+        # @return [self] self for method chaining
+        def being_equal_to: (Date | DateTime | 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
+        # @return [self] self for method chaining
+        def being_on_or_after: (Date | DateTime | String | Time other) -> Behavior
+
+        alias at_or_after being_on_or_after
+
+        alias being_at_or_after being_on_or_after
+
+        alias on_or_after being_on_or_after
+
+        # 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
+        # @return [self] self for method chaining
+        def being_on_or_before: (Date | DateTime | String | Time other) -> Behavior
+
+        alias at_or_before being_on_or_before
+
+        alias being_at_or_before being_on_or_before
+
+        alias on_or_before being_on_or_before
+      end
+    end
+  end
+end

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

@@ -67,7 +67,7 @@ module Domainic
         #
         # @raise [ArgumentError] if minimum or maximum value can't be determined
         # @return [Array<Integer>] parsed [minimum, maximum] values
-        private def self.parse_having_between_arguments: (Integer? minimum, Integer? maximum, Hash[Symbol, Integer?] options) -> Array[Integer]
+        private def self.parse_having_between_arguments!: (Integer? minimum, Integer? maximum, Hash[Symbol, Integer?] options) -> Array[Integer]
 
         # Raise appropriate ArgumentError for having_size_between
         #

data/sig/domainic/type/constraint/constraints/range_constraint.rbs

@@ -1,35 +1,55 @@
 module Domainic
   module Type
     module Constraint
-      # A constraint for validating that numeric values fall within a specified range.
+      # A constraint for validating that comparable values fall within a specified range.
       #
-      # This constraint allows for validating numeric values against minimum and maximum
-      # boundaries. It supports specifying either or both boundaries, allowing for
-      # open-ended ranges when appropriate.
+      # This constraint allows for validating any values that implement comparison operators
+      # (<, <=, >, >=) against minimum and maximum boundaries. It supports specifying either
+      # or both boundaries, allowing for open-ended ranges when appropriate. This makes it
+      # suitable for numeric ranges, date/time ranges, or any other comparable types.
       #
-      # @example Validating with both minimum and maximum
+      # @example Validating numeric ranges
       #   constraint = RangeConstraint.new(:self, { minimum: 1, maximum: 10 })
       #   constraint.satisfied?(5)  # => true
       #   constraint.satisfied?(15) # => false
       #
-      # @example Validating with only minimum
-      #   constraint = RangeConstraint.new(:self, { minimum: 0 })
-      #   constraint.satisfied?(10)  # => true
-      #   constraint.satisfied?(-1)  # => false
+      # @example Validating date ranges
+      #   constraint = RangeConstraint.new(:self, {
+      #     minimum: Date.new(2024, 1, 1),
+      #     maximum: Date.new(2024, 12, 31)
+      #   })
+      #   constraint.satisfied?(Date.new(2024, 6, 15))  # => true
+      #   constraint.satisfied?(Date.new(2023, 12, 31)) # => false
       #
-      # @example Validating with only maximum
-      #   constraint = RangeConstraint.new(:self, { maximum: 100 })
-      #   constraint.satisfied?(50)   # => true
-      #   constraint.satisfied?(150)  # => false
+      # @example Validating with only minimum
+      #   constraint = RangeConstraint.new(:self, { minimum: Time.now })
+      #   constraint.satisfied?(Time.now + 3600)  # => true
+      #   constraint.satisfied?(Time.now - 3600)  # => false
       #
       # @author {https://aaronmallen.me Aaron Allen}
       # @since 0.1.0
       class RangeConstraint
-        type expected = { ?minimum: Numeric, ?maximum: Numeric }
+        interface _Compatible
+          def <: (untyped other) -> bool
+
+          def <=: (untyped other) -> bool
+
+          def >: (untyped other) -> bool
+
+          def >=: (untyped other) -> bool
+
+          def inspect: () -> untyped
+
+          def nil?: () -> bool
+
+          def send: (Symbol method_name, *untyped arguments, **untyped keyword_arguments) -> untyped
+        end
+
+        type expected = { ?minimum: _Compatible, ?maximum: _Compatible }
 
         type options = { ?inclusive: bool }
 
-        include Behavior[expected, Numeric, options]
+        include Behavior[expected, _Compatible, options]
 
         # Get a human-readable description of the range constraint.
         #
@@ -75,6 +95,13 @@ module Domainic
         # @return [void]
         def validate_expectation!: ...
 
+        private
+
+        # Check if the range constraint is inclusive.
+        #
+        # @return [Boolean] `true` if the range is inclusive, `false` otherwise
+        def inclusive?: () -> bool
+
         # Validate the minimum and maximum values in a range specification.
         #
         # @param expectation [Hash] The range specification to validate
@@ -82,6 +109,14 @@ module Domainic
         # @raise [ArgumentError] if the values are invalid
         # @return [void]
         def validate_minimum_and_maximum!: (untyped expectation) -> void
+
+        # Validate the minimum and maximum value types are compatible with the constraint.
+        #
+        # @param expectation [Hash] The range specification to validate
+        #
+        # @raise [ArgumentError] if the values are invalid
+        # @return [void]
+        def validate_minimum_and_maximum_types!: (untyped expectation) -> void
       end
     end
   end

data/sig/domainic/type/definitions.rbs

@@ -111,6 +111,54 @@ module Domainic
 
       alias _Cuid? _CUID?
 
+      # Creates a DateType instance.
+      #
+      # DateType restricts values to valid `Date` objects.
+      #
+      # @example
+      #   type = _Date
+      #   type.validate(Date.new(2024, 1, 1)) # => true
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::DateType] the created type
+      def _Date: (**__todo__ options) -> DateType
+
+      # Creates a nilable DateType instance.
+      #
+      # @example
+      #   _Date? === Date.new(2024, 1, 1) # => true
+      #   _Date? === nil                  # => true
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::UnionType] the created type (DateType or NilClass)
+      def _Date?: (**__todo__ options) -> UnionType
+
+      # Creates a DateTimeType instance.
+      #
+      # DateTimeType restricts values to valid `DateTime` objects.
+      #
+      # @example
+      #   type = _DateTime
+      #   type.validate(DateTime.new(2024, 1, 1, 12, 0, 0)) # => true
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::DateTimeType] the created type
+      def _DateTime: (**__todo__ options) -> DateTimeType
+
+      # Creates a nilable DateTimeType instance.
+      #
+      # @example
+      #   _DateTime? === DateTime.new(2024, 1, 1, 12, 0, 0) # => true
+      #   _DateTime? === nil                                # => true
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::UnionType] the created type (DateTimeType or NilClass)
+      def _DateTime?: (**__todo__ options) -> UnionType
+
       # Creates a DuckType instance.
       #
       # DuckType allows specifying behavior based on method availability.
@@ -395,6 +443,65 @@ module Domainic
 
       alias _Interned? _Symbol?
 
+      # Creates a TimeType instance.
+      #
+      # TimeType restricts values to valid `Time` objects.
+      #
+      # @example
+      #   type = _Time
+      #   type.validate(Time.new(2024, 1, 1, 12, 0, 0)) # => true
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::TimeType] the created type
+      def _Time: (**__todo__ options) -> TimeType
+
+      # Creates a nilable TimeType instance.
+      #
+      # @example
+      #   _Time? === Time.new(2024, 1, 1, 12, 0, 0) # => true
+      #   _Time? === nil                            # => true
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::UnionType] the created type (TimeType or NilClass)
+      def _Time?: (**__todo__ options) -> UnionType
+
+      # Creates a URIType instance.
+      #
+      # URIType restricts values to valid URIs.
+      #
+      # @example
+      #   type = _URI.having_scheme('https')
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::URIType] the created type
+      def _URI: (**__todo__ options) -> URIType
+
+      alias _URL _URI
+
+      alias _Url _URI
+
+      alias _Uri _URI
+
+      # Creates a nilable URIType instance.
+      #
+      # @example
+      #   _Uri?.validate("https://example.com") # => true
+      #   _Uri?.validate(nil)                   # => true
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::UnionType] the created type (URIType or NilClass)
+      def _URI?: (**__todo__ options) -> UnionType
+
+      alias _URL? _URI?
+
+      alias _Url? _URI?
+
+      alias _Uri? _URI?
+
       # Creates a UUIDType instance
       #
       # @example
@@ -435,33 +542,6 @@ module Domainic
 
       alias _Either _Union
 
-      # Creates a URIType instance.
-      #
-      # URIType restricts values to valid URIs.
-      #
-      # @example
-      #   type = _URI.having_scheme('https')
-      #
-      # @param options [Hash] additional configuration options
-      #
-      # @return [Domainic::Type::URIType] the created type
-      def _Uri: (**__todo__ options) -> URIType
-
-      alias _Url _Uri
-
-      # Creates a nilable URIType instance.
-      #
-      # @example
-      #   _Uri?.validate("https://example.com") # => true
-      #   _Uri?.validate(nil)                   # => true
-      #
-      # @param options [Hash] additional configuration options
-      #
-      # @return [Domainic::Type::UnionType] the created type (URIType or NilClass)
-      def _Uri?: (**__todo__ options) -> UnionType
-
-      alias _Url? _Uri?
-
       # Creates a VoidType instance.
       #
       # Represents an operation that returns no value.

data/sig/domainic/type/types/datetime/date_time_type.rbs

@@ -0,0 +1,34 @@
+module Domainic
+  module Type
+    # A type for validating DateTime objects
+    #
+    # This type ensures the value is a `DateTime` object and supports comprehensive
+    # date-time validation through `DateTimeBehavior`. It is ideal for scenarios requiring
+    # precise date-time constraints.
+    #
+    # Key features:
+    # - Ensures the value is a `DateTime` object
+    # - Supports chronological relationship validation (e.g., before, after)
+    # - Provides range and equality checks
+    #
+    # @example Basic usage
+    #   type = DateTimeType.new
+    #   type.validate(DateTime.now)            # => true
+    #   type.validate(Date.today)              # => false
+    #
+    # @example Range validation
+    #   type = DateTimeType.new
+    #     .being_between(DateTime.new(2024, 1, 1, 0, 0, 0), DateTime.new(2024, 12, 31, 23, 59, 59))
+    #   type.validate(DateTime.new(2024, 6, 15, 12, 0, 0))  # => true
+    #
+    # @author {https://aaronmallen.me Aaron Allen}
+    # @since 0.1.0
+    class DateTimeType
+      extend Behavior::ClassMethods
+
+      include Behavior
+
+      include Behavior::DateTimeBehavior
+    end
+  end
+end

data/sig/domainic/type/types/datetime/date_type.rbs

@@ -0,0 +1,35 @@
+module Domainic
+  module Type
+    # A type for validating Date objects
+    #
+    # This type provides robust validation for `Date` objects, ensuring values conform
+    # to specified chronological constraints. It supports the full range of date-based
+    # constraints provided by `DateTimeBehavior`.
+    #
+    # Key features:
+    # - Ensures the value is a `Date` object
+    # - Supports validation for chronological relationships (e.g., before, after)
+    # - Full integration with `DateTimeBehavior` for range and equality checks
+    #
+    # @example Basic usage
+    #   type = DateType.new
+    #   type.validate(Date.today)               # => true
+    #   type.validate(DateTime.now)             # => false
+    #
+    # @example With range constraints
+    #   type = DateType.new
+    #     .being_between(Date.new(2024, 1, 1), Date.new(2024, 12, 31))
+    #   type.validate(Date.new(2024, 6, 15))    # => true
+    #   type.validate(Date.new(2023, 12, 31))   # => false
+    #
+    # @author {https://aaronmallen.me Aaron Allen}
+    # @since 0.1.0
+    class DateType
+      extend Behavior::ClassMethods
+
+      include Behavior
+
+      include Behavior::DateTimeBehavior
+    end
+  end
+end

data/sig/domainic/type/types/datetime/time_type.rbs

@@ -0,0 +1,34 @@
+module Domainic
+  module Type
+    # A type for validating Time objects
+    #
+    # This type ensures the value is a `Time` object and integrates with
+    # `DateTimeBehavior` to provide a rich set of time-based validation capabilities.
+    #
+    # Key features:
+    # - Ensures the value is a `Time` object
+    # - Supports chronological relationship constraints (e.g., before, after)
+    # - Provides range and equality checks
+    #
+    # @example Basic usage
+    #   type = TimeType.new
+    #   type.validate(Time.now)                 # => true
+    #   type.validate(Date.today)               # => false
+    #
+    # @example Range validation
+    #   type = TimeType.new
+    #     .being_between(Time.now, Time.now + 3600)
+    #   type.validate(Time.now + 1800)          # => true
+    #   type.validate(Time.now + 7200)          # => false
+    #
+    # @author {https://aaronmallen.me Aaron Allen}
+    # @since 0.1.0
+    class TimeType
+      extend Behavior::ClassMethods
+
+      include Behavior
+
+      include Behavior::DateTimeBehavior
+    end
+  end
+end

data/sig/manifest.yaml

@@ -1,2 +1,5 @@
 dependencies:
+  - name: forwardable
+  - name: date
   - name: yaml
+  - name: uri

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: domainic-type
 version: !ruby/object:Gem::Version
-  version: 0.1.0.alpha.3.1.0
+  version: 0.1.0.alpha.3.2.0
 platform: ruby
 authors:
 - Aaron Allen
@@ -28,6 +28,7 @@ files:
 - lib/domainic/type.rb
 - lib/domainic/type/accessors.rb
 - lib/domainic/type/behavior.rb
+- lib/domainic/type/behavior/date_time_behavior.rb
 - lib/domainic/type/behavior/enumerable_behavior.rb
 - lib/domainic/type/behavior/numeric_behavior.rb
 - lib/domainic/type/behavior/sizable_behavior.rb
@@ -69,6 +70,9 @@ files:
 - lib/domainic/type/types/core/integer_type.rb
 - lib/domainic/type/types/core/string_type.rb
 - lib/domainic/type/types/core/symbol_type.rb
+- lib/domainic/type/types/datetime/date_time_type.rb
+- lib/domainic/type/types/datetime/date_type.rb
+- lib/domainic/type/types/datetime/time_type.rb
 - lib/domainic/type/types/identifier/cuid_type.rb
 - lib/domainic/type/types/identifier/uuid_type.rb
 - lib/domainic/type/types/network/email_address_type.rb
@@ -84,6 +88,7 @@ files:
 - sig/domainic/type.rbs
 - sig/domainic/type/accessors.rbs
 - sig/domainic/type/behavior.rbs
+- sig/domainic/type/behavior/date_time_behavior.rbs
 - sig/domainic/type/behavior/enumerable_behavior.rbs
 - sig/domainic/type/behavior/numeric_behavior.rbs
 - sig/domainic/type/behavior/sizable_behavior.rbs
@@ -124,6 +129,9 @@ files:
 - sig/domainic/type/types/core/integer_type.rbs
 - sig/domainic/type/types/core/string_type.rbs
 - sig/domainic/type/types/core/symbol_type.rbs
+- sig/domainic/type/types/datetime/date_time_type.rbs
+- sig/domainic/type/types/datetime/date_type.rbs
+- sig/domainic/type/types/datetime/time_type.rbs
 - sig/domainic/type/types/identifier/cuid_type.rbs
 - sig/domainic/type/types/identifier/uuid_type.rbs
 - sig/domainic/type/types/network/email_address_type.rbs
@@ -136,15 +144,15 @@ files:
 - sig/domainic/type/types/specification/union_type.rbs
 - sig/domainic/type/types/specification/void_type.rbs
 - sig/manifest.yaml
-homepage: https://github.com/domainic/domainic/tree/domainic-type-v0.1.0-alpha.3.1.0/domainic-type
+homepage: https://github.com/domainic/domainic/tree/domainic-type-v0.1.0-alpha.3.2.0/domainic-type
 licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/domainic/domainic/issues
-  changelog_uri: https://github.com/domainic/domainic/releases/tag/domainic-type-v0.1.0-alpha.3.1.0
-  homepage_uri: https://github.com/domainic/domainic/tree/domainic-type-v0.1.0-alpha.3.1.0/domainic-type
+  changelog_uri: https://github.com/domainic/domainic/releases/tag/domainic-type-v0.1.0-alpha.3.2.0
+  homepage_uri: https://github.com/domainic/domainic/tree/domainic-type-v0.1.0-alpha.3.2.0/domainic-type
   rubygems_mfa_required: 'true'
-  source_code_uri: https://github.com/domainic/domainic/tree/domainic-type-v0.1.0-alpha.3.1.0/domainic-type
+  source_code_uri: https://github.com/domainic/domainic/tree/domainic-type-v0.1.0-alpha.3.2.0/domainic-type
 post_install_message:
 rdoc_options: []
 require_paths: