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

data/sig/domainic/type/definitions.rbs

@@ -64,6 +64,29 @@ module Domainic
 
       alias _List? _Array?
 
+      # Creates a BigDecimalType instance.
+      #
+      # @example
+      #   type = _BigDecimal
+      #   type.validate(BigDecimal('123.45')) # => true
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::BigDecimalType] the created type
+      def _BigDecimal: (**__todo__ options) -> BigDecimalType
+
+      # Creates a nilable BigDecimalType instance.
+      #
+      # @example
+      #   type = _BigDecimal?
+      #   type.validate(BigDecimal('123.45')) # => true
+      #   type.validate(nil)                  # => true
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::UnionType] the created type (BigDecimal or NilClass)
+      def _BigDecimal?: (**__todo__ options) -> UnionType
+
       # Creates a Boolean type.
       #
       # Represents a union of TrueClass and FalseClass.
@@ -111,6 +134,28 @@ module Domainic
 
       alias _Cuid? _CUID?
 
+      # Creates a ComplexType instance.
+      #
+      # @example
+      #   type = _Complex
+      #   type.validate(Complex(1, 2)) # => true
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::ComplexType] the created type
+      def _Complex: (**__todo__ options) -> ComplexType
+
+      # Creates a nilable ComplexType instance.
+      #
+      # @example
+      #   type = _Complex?
+      #   type.validate(Complex(1, 2)) # => true
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::UnionType] the created type (Complex or NilClass)
+      def _Complex?: (**__todo__ options) -> UnionType
+
       # Creates a DateType instance.
       #
       # DateType restricts values to valid `Date` objects.
@@ -159,6 +204,34 @@ module Domainic
       # @return [Domainic::Type::UnionType] the created type (DateTimeType or NilClass)
       def _DateTime?: (**__todo__ options) -> UnionType
 
+      # Creates a DateTimeStringType instance.
+      #
+      # DateTimeStringType restricts values to valid date-time strings.
+      #
+      # @example
+      #   type = _DateTimeString
+      #   type.validate('2024-01-01T12:00:00Z') # => true
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::DateTimeStringType] the created type
+      def _DateTimeString: (**__todo__ options) -> DateTimeStringType
+
+      alias _DateString _DateTimeString
+
+      # Creates a nilable DateTimeStringType instance.
+      #
+      # @example
+      #   _DateTimeString? === '2024-01-01T12:00:00Z' # => true
+      #   _DateTimeString? === nil                    # => true
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::UnionType] the created type (DateTimeStringType or NilClass)
+      def _DateTimeString?: (**__todo__ options) -> UnionType
+
+      alias _DateString? _DateTimeString?
+
       # Creates a DuckType instance.
       #
       # DuckType allows specifying behavior based on method availability.
@@ -395,6 +468,74 @@ module Domainic
 
       alias _Nullable _Nilable
 
+      # Creates a RangeType instance.
+      #
+      # @example
+      #   type = _Range
+      #   type.validate(1..10) # => true
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::RangeType] the created type
+      def _Range: (**__todo__ options) -> RangeType
+
+      # Creates a nilable RangeType instance.
+      #
+      # @example
+      #   type = _Range?
+      #   type.validate(1..10) # => true
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::UnionType] the created type (Range or NilClass)
+      def _Range?: (**__todo__ options) -> UnionType
+
+      # Creates a RationalType instance.
+      #
+      # @example
+      #   type = _Rational
+      #   type.validate(Rational(1, 2)) # => true
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::RationalType] the created type
+      def _Rational: (**__todo__ options) -> RationalType
+
+      # Creates a nilable RationalType instance.
+      #
+      # @example
+      #   type = _Rational?
+      #   type.validate(Rational(1, 2)) # => true
+      #   type.validate(nil)            # => true
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::UnionType] the created type (Rational or NilClass)
+      def _Rational?: (**__todo__ options) -> UnionType
+
+      # Creates a SetType instance.
+      #
+      # @example
+      #   type = _Set
+      #   type.validate(Set[1, 2, 3]) # => true
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::SetType] the created type
+      def _Set: (**__todo__ options) -> SetType
+
+      # Creates a nilable SetType instance.
+      #
+      # @example
+      #   type = _Set?
+      #   type.validate(Set[1, 2, 3]) # => true
+      #   type.validate(nil)          # => true
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::UnionType] the created type (Set or NilClass)
+      def _Set?: (**__todo__ options) -> UnionType
+
       # Creates a StringType instance.
       #
       # @example
@@ -467,6 +608,30 @@ module Domainic
       # @return [Domainic::Type::UnionType] the created type (TimeType or NilClass)
       def _Time?: (**__todo__ options) -> UnionType
 
+      # Creates a TimestampType instance.
+      #
+      # TimestampType restricts values to valid timestamps.
+      #
+      # @example
+      #   type = _Timestamp
+      #   type.validate(1640995200) # => true
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::TimestampType] the created type
+      def _Timestamp: (**__todo__ options) -> TimestampType
+
+      # Creates a nilable TimestampType instance.
+      #
+      # @example
+      #   _Timestamp? === 1640995200 # => true
+      #   _Timestamp? === nil        # => true
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::UnionType] the created type (TimestampType or NilClass)
+      def _Timestamp?: (**__todo__ options) -> UnionType
+
       # Creates a URIType instance.
       #
       # URIType restricts values to valid URIs.

data/sig/domainic/type/types/core/complex_type.rbs

@@ -0,0 +1,96 @@
+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
+      extend Behavior::ClassMethods
+
+      include Behavior
+
+      include Behavior::NumericBehavior
+
+      # 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
+      def being_divisible_by: (*Numeric arguments, ?divisor: Numeric, ?tolerance: Numeric) -> Behavior
+
+      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
+      def being_even: () -> Behavior
+
+      alias even being_even
+
+      alias not_being_odd being_even
+
+      # Constrain the Complex real to be negative.
+      #
+      # @return [self] the current instance for chaining
+      def being_negative: () -> Behavior
+
+      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
+      def being_odd: () -> Behavior
+
+      alias odd being_odd
+
+      alias not_being_even being_odd
+
+      # Constrain the Complex real to be positive.
+      #
+      # @return [self] the current instance for chaining
+      def being_positive: () -> Behavior
+
+      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
+      def not_being_divisible_by: (*Numeric arguments, ?divisor: Numeric, ?tolerance: Numeric) -> Behavior
+
+      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/sig/domainic/type/types/core/range_type.rbs

@@ -0,0 +1,41 @@
+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
+      extend Behavior::ClassMethods
+
+      include Behavior
+
+      include Behavior::EnumerableBehavior
+    end
+  end
+end

data/sig/domainic/type/types/core/rational_type.rbs

@@ -0,0 +1,32 @@
+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
+      extend Behavior::ClassMethods
+
+      include Behavior
+
+      include Behavior::NumericBehavior
+    end
+  end
+end

data/sig/domainic/type/types/core_extended/big_decimal_type.rbs

@@ -0,0 +1,27 @@
+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
+      extend Behavior::ClassMethods
+
+      include Behavior
+
+      include Behavior::NumericBehavior
+    end
+  end
+end

data/sig/domainic/type/types/core_extended/set_type.rbs

@@ -0,0 +1,27 @@
+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
+      extend Behavior::ClassMethods
+
+      include Behavior
+
+      include Behavior::EnumerableBehavior
+    end
+  end
+end

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

@@ -0,0 +1,124 @@
+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
+      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: Regexp
+
+        # Matches RFC2822 datetime formats, including:
+        # - `Thu, 31 Jan 2024 13:30:00 +0000`
+        # - `31 Jan 2024 13:30:00 +0000`
+        # @return [Regexp]
+        RFC2822: 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: 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: 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: 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: 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: Regexp
+      end
+
+      # Constrain the type to match American-style datetime formats.
+      #
+      # @return [self] self for method chaining
+      def having_american_format: () -> self
+
+      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
+      def having_european_format: () -> self
+
+      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
+      def having_iso8601_format: () -> self
+
+      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
+      def having_rfc2822_format: () -> self
+
+      alias rfc2822 having_rfc2822_format
+
+      alias rfc2822_format having_rfc2822_format
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+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
+      extend Behavior::ClassMethods
+
+      include Behavior
+
+      include Behavior::DateTimeBehavior
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: domainic-type
 version: !ruby/object:Gem::Version
-  version: 0.1.0.alpha.3.2.0
+  version: 0.1.0.alpha.3.3.0
 platform: ruby
 authors:
 - Aaron Allen
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-12-26 00:00:00.000000000 Z
+date: 2024-12-27 00:00:00.000000000 Z
 dependencies: []
 description: Stop wrestling with complex type validations and unclear error messages.
   Domainic::Type brings type validation to Ruby that is both powerful and delightful
@@ -24,6 +24,7 @@ files:
 - CHANGELOG.md
 - LICENSE
 - README.md
+- docs/USAGE.md
 - lib/domainic-type.rb
 - lib/domainic/type.rb
 - lib/domainic/type/accessors.rb
@@ -65,14 +66,21 @@ files:
 - lib/domainic/type/constraint/set.rb
 - lib/domainic/type/definitions.rb
 - lib/domainic/type/types/core/array_type.rb
+- lib/domainic/type/types/core/complex_type.rb
 - lib/domainic/type/types/core/float_type.rb
 - lib/domainic/type/types/core/hash_type.rb
 - lib/domainic/type/types/core/integer_type.rb
+- lib/domainic/type/types/core/range_type.rb
+- lib/domainic/type/types/core/rational_type.rb
 - lib/domainic/type/types/core/string_type.rb
 - lib/domainic/type/types/core/symbol_type.rb
+- lib/domainic/type/types/core_extended/big_decimal_type.rb
+- lib/domainic/type/types/core_extended/set_type.rb
+- lib/domainic/type/types/datetime/date_time_string_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/datetime/timestamp_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
@@ -124,14 +132,21 @@ files:
 - sig/domainic/type/constraint/set.rbs
 - sig/domainic/type/definitions.rbs
 - sig/domainic/type/types/core/array_type.rbs
+- sig/domainic/type/types/core/complex_type.rbs
 - sig/domainic/type/types/core/float_type.rbs
 - sig/domainic/type/types/core/hash_type.rbs
 - sig/domainic/type/types/core/integer_type.rbs
+- sig/domainic/type/types/core/range_type.rbs
+- sig/domainic/type/types/core/rational_type.rbs
 - sig/domainic/type/types/core/string_type.rbs
 - sig/domainic/type/types/core/symbol_type.rbs
+- sig/domainic/type/types/core_extended/big_decimal_type.rbs
+- sig/domainic/type/types/core_extended/set_type.rbs
+- sig/domainic/type/types/datetime/date_time_string_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/datetime/timestamp_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
@@ -144,15 +159,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.2.0/domainic-type
+homepage: https://github.com/domainic/domainic/tree/domainic-type-v0.1.0-alpha.3.3.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.2.0
-  homepage_uri: https://github.com/domainic/domainic/tree/domainic-type-v0.1.0-alpha.3.2.0/domainic-type
+  changelog_uri: https://github.com/domainic/domainic/releases/tag/domainic-type-v0.1.0-alpha.3.3.0
+  homepage_uri: https://github.com/domainic/domainic/tree/domainic-type-v0.1.0-alpha.3.3.0/domainic-type
   rubygems_mfa_required: 'true'
-  source_code_uri: https://github.com/domainic/domainic/tree/domainic-type-v0.1.0-alpha.3.2.0/domainic-type
+  source_code_uri: https://github.com/domainic/domainic/tree/domainic-type-v0.1.0-alpha.3.3.0/domainic-type
 post_install_message:
 rdoc_options: []
 require_paths: