domainic-attributer 0.1.0

data/sig/domainic/attributer/attribute_set.rbs

@@ -0,0 +1,134 @@
+module Domainic
+  module Attributer
+    # A class representing an ordered collection of attributes.
+    #
+    # This class manages a set of attributes for a given class or module. It maintains
+    # attributes in a specific order determined by their type (argument vs option),
+    # default values, and position. The collection supports standard operations like
+    # adding, selecting, and merging attributes while maintaining proper ownership
+    # relationships with their base class.
+    #
+    # @author {https://aaronmallen.me Aaron Allen}
+    # @since 0.1.0
+    class AttributeSet
+      extend Forwardable
+
+      @base: __todo__
+
+      @lookup: Hash[Symbol, Attribute]
+
+      # Initialize a new AttributeSet.
+      #
+      # @param base [Class, Module] the class or module this set belongs to
+      # @param attributes [Array<Attribute>] initial attributes to add
+      #
+      # @return [void]
+      def initialize: (__todo__ base, ?Array[Attribute] attributes) -> void
+
+      # Get an attribute by name.
+      #
+      # @param attribute_name [String, Symbol] the name of the attribute
+      #
+      # @return [Attribute, nil] the attribute if found
+      def []: (String | Symbol attribute_name) -> Attribute?
+
+      # Add an attribute to the set.
+      #
+      # If an attribute with the same name exists, the attributes are merged.
+      # If the attribute belongs to a different base class, it is duplicated
+      # with the correct base. After adding, attributes are sorted by type
+      # and position.
+      #
+      # @param attribute [Attribute] the attribute to add
+      #
+      # @raise [ArgumentError] if attribute is invalid
+      # @return [void]
+      def add: (Attribute attribute) -> void
+
+      # Check if an attribute exists in the set.
+      #
+      # @param attribute_name [String, Symbol] the name to check
+      #
+      # @return [Boolean] true if the attribute exists
+      def attribute?: (untyped attribute_name) -> untyped
+
+      # Get all attribute names.
+      #
+      # @return [Array<Symbol>] the attribute names
+      def attribute_names: () -> Array[Symbol]
+
+      # Get all attributes.
+      #
+      # @return [Array<Attribute>] the attributes
+      def attributes: () -> Array[Attribute]
+
+      def count: () ?{ (Symbol, Attribute) -> boolish } -> Integer
+
+      # Create a duplicate set for a new base class.
+      #
+      # @param new_base [Class, Module] the new base class
+      #
+      # @return [AttributeSet] the duplicated set
+      def dup_with_base: (__todo__ base) -> AttributeSet
+
+      # Iterate over attribute name/value pairs.
+      #
+      # @yield [name, attribute] each name/attribute pair
+      # @yieldparam name [Symbol] the attribute name
+      # @yieldparam attribute [Attribute] the attribute
+      #
+      # @return [self]
+      def each: () { ([ Symbol, Attribute ]) -> untyped } -> self
+
+      alias each_pair each
+
+      def empty?: () -> bool
+
+      # Create a new set excluding specified attributes.
+      #
+      # @param attribute_names [Array<String, Symbol>] names to exclude
+      #
+      # @return [AttributeSet] new set without specified attributes
+      def except: (*String | Symbol attribute_names) -> AttributeSet
+
+      def length: () -> Integer
+
+      # Merge another set into this one.
+      #
+      # @param other [AttributeSet] the set to merge
+      #
+      # @return [AttributeSet] new set with merged attributes
+      def merge: (AttributeSet other) -> AttributeSet
+
+      # Create a new set with rejected attributes.
+      #
+      # @yield [name, attribute] each name/attribute pair
+      # @yieldparam name [Symbol] the attribute name
+      # @yieldparam attribute [Attribute] the attribute
+      #
+      # @return [AttributeSet] new set without rejected attributes
+      def reject: () { (Symbol, Attribute) -> boolish } -> AttributeSet
+
+      # Create a new set with selected attributes.
+      #
+      # @yield [name, attribute] each name/attribute pair
+      # @yieldparam name [Symbol] the attribute name
+      # @yieldparam attribute [Attribute] the attribute
+      #
+      # @return [AttributeSet] new set with selected attributes
+      def select: () { (Symbol, Attribute) -> boolish } -> AttributeSet
+
+      def size: () -> Integer
+
+      private
+
+      # Sort attributes by type and position.
+      #
+      # Attributes are sorted first by type (required arguments, defaulted arguments,
+      # then options), and then by their position within those groups.
+      #
+      # @return [void]
+      def sort_lookup: () -> void
+    end
+  end
+end

data/sig/domainic/attributer/class_methods.rbs

@@ -0,0 +1,151 @@
+module Domainic
+  module Attributer
+    # A module providing class-level methods for attribute definition.
+    #
+    # This module extends classes that include Domainic::Attributer with methods for
+    # defining and managing attributes. It supports two types of attributes:
+    # 1. Arguments - Positional parameters that must be provided in a specific order
+    # 2. Options - Named parameters that can be provided in any order
+    #
+    # @example Defining arguments and options
+    #   class Person
+    #     include Domainic::Attributer
+    #
+    #     argument :name, ->(value) { value.is_a?(String) }
+    #     argument :age do |value|
+    #       value.is_a?(Integer) && value >= 0
+    #     end
+    #
+    #     option :email, ->(value) { value.is_a?(String) }, default: nil
+    #     option :role do |value|
+    #       %w[admin user guest].include?(value)
+    #     end
+    #   end
+    #
+    # @author {https://aaronmallen.me Aaron Allen}
+    # @since 0.1.0
+    module ClassMethods
+      @__attributes__: AttributeSet
+
+      # Define a positional argument attribute.
+      #
+      # Arguments are required by default and must be provided in the order they are defined.
+      # They can be type-validated and configured with additional options like defaults
+      # and visibility.
+      #
+      # @param attribute_name [String, Symbol] the name of the attribute
+      # @param type_validator [Proc, Object, nil] optional validation handler for type checking
+      # @param options [Hash] additional configuration options
+      #
+      # @option options [Array<Proc>, Proc] :callbacks handlers for attribute change events (priority over :callback,
+      #   :on_change)
+      # @option options [Array<Proc>, Proc] :callback alias for :callbacks
+      # @option options [Array<Proc, Symbol>, Proc, Symbol] :coerce handlers for value coercion (priority over
+      #   :coercers, :coerce_with)
+      # @option options [Array<Proc, Symbol>, Proc, Symbol] :coercers alias for :coerce
+      # @option options [Array<Proc, Symbol>, Proc, Symbol] :coerce_with alias for :coerce
+      # @option options [Object] :default the default value (priority over :default_generator, :default_value)
+      # @option options [Object] :default_generator alias for :default
+      # @option options [Object] :default_value alias for :default
+      # @option options [String] :desc short description (overridden by :description)
+      # @option options [String] :description description text
+      # @option options [Boolean] :non_nil require non-nil values (priority over :non_null, :non_nullable, :not_nil,
+      #   :not_nilable, :not_null, :not_nullable)
+      # @option options [Boolean] :non_null alias for :non_nil
+      # @option options [Boolean] :non_nullable alias for :non_nil
+      # @option options [Boolean] :not_nil alias for :non_nil
+      # @option options [Boolean] :not_nilable alias for :non_nil
+      # @option options [Boolean] :not_null alias for :non_nil
+      # @option options [Boolean] :not_nullable alias for :non_nil
+      # @option options [Boolean] :null inverse of :non_nil
+      # @option options [Array<Proc>, Proc] :on_change alias for :callbacks
+      # @option options [Boolean] :optional whether attribute is optional (overridden by :required)
+      # @option options [Integer] :position specify order position
+      # @option options [Symbol] :read read visibility (:public, :protected, :private) (priority over :read_access,
+      #   :reader)
+      # @option options [Symbol] :read_access alias for :read
+      # @option options [Symbol] :reader alias for :read
+      # @option options [Boolean] :required whether attribute is required
+      # @option options [Array<Object>, Object] :validate validators for the attribute (priority over :validate_with,
+      #   :validators)
+      # @option options [Array<Object>, Object] :validate_with alias for :validate
+      # @option options [Array<Object>, Object] :validators alias for :validate
+      # @option options [Symbol] :write_access write visibility (:public, :protected, :private) (priority over :writer)
+      # @option options [Symbol] :writer alias for :write_access
+      #
+      # @yield [DSL::AttributeBuilder] optional configuration block
+      # @return [void]
+      def argument: (String | Symbol attribute_name, ?Attribute::Validator::handler type_validator, ?callbacks: Array[Attribute::Callback::handler] | Attribute::Callback::handler, ?callback: Array[Attribute::Callback::handler] | Attribute::Callback::handler, ?coerce: Array[Attribute::Coercer::handler] | Attribute::Coercer::handler, ?coercers: Array[Attribute::Coercer::handler], ?coerce_with: [ Attribute::Coercer::handler ] | Attribute::Coercer::handler, ?default: untyped, ?default_generator: untyped, ?default_value: untyped, ?desc: String?, ?description: String, ?non_nil: bool, ?non_null: bool, ?non_nullable: bool, ?not_nil: bool, ?not_nilable: bool, ?not_null: bool, ?not_nullable: bool, ?null: bool, ?on_change: Array[Attribute::Callback::handler] | Attribute::Callback::handler, ?optional: bool, ?position: Integer?, ?read: Attribute::Signature::visibility_symbol, ?read_access: Attribute::Signature::visibility_symbol, ?reader: Attribute::Signature::visibility_symbol, ?required: bool, ?validate: Array[Attribute::Validator::handler] | Attribute::Validator::handler, ?validate_with: Array[Attribute::Validator::handler] | Attribute::Validator::handler, ?validators: Array[Attribute::Validator::handler] | Attribute::Validator::handler, ?write_access: Attribute::Signature::visibility_symbol, ?writer: Attribute::Signature::visibility_symbol) ?{ (?) [self: DSL::AttributeBuilder] -> void } -> void
+
+      # Define a named option attribute.
+      #
+      # Options are optional by default and can be provided in any order. They can be
+      # type-validated and configured with additional options like defaults and visibility.
+      #
+      # @overload option(attribute_name, type_validator = Undefined, **options, &block)
+      #   @param attribute_name [String, Symbol] the name of the attribute
+      #   @param type_validator [Proc, Object, nil] optional validation handler for type checking
+      #   @param options [Hash] additional configuration options
+      #
+      #   @option options [Array<Proc>, Proc] :callbacks handlers for attribute change events (priority over :callback,
+      #     :on_change)
+      #   @option options [Array<Proc>, Proc] :callback alias for :callbacks
+      #   @option options [Array<Proc, Symbol>, Proc, Symbol] :coerce handlers for value coercion (priority over
+      #     :coercers, :coerce_with)
+      #   @option options [Array<Proc, Symbol>, Proc, Symbol] :coercers alias for :coerce
+      #   @option options [Array<Proc, Symbol>, Proc, Symbol] :coerce_with alias for :coerce
+      #   @option options [Object] :default the default value (priority over :default_generator, :default_value)
+      #   @option options [Object] :default_generator alias for :default
+      #   @option options [Object] :default_value alias for :default
+      #   @option options [String] :desc short description (overridden by :description)
+      #   @option options [String] :description description text
+      #   @option options [Boolean] :non_nil require non-nil values (priority over :non_null, :non_nullable, :not_nil,
+      #     :not_nilable, :not_null, :not_nullable)
+      #   @option options [Boolean] :non_null alias for :non_nil
+      #   @option options [Boolean] :non_nullable alias for :non_nil
+      #   @option options [Boolean] :not_nil alias for :non_nil
+      #   @option options [Boolean] :not_nilable alias for :non_nil
+      #   @option options [Boolean] :not_null alias for :non_nil
+      #   @option options [Boolean] :not_nullable alias for :non_nil
+      #   @option options [Boolean] :null inverse of :non_nil
+      #   @option options [Array<Proc>, Proc] :on_change alias for :callbacks
+      #   @option options [Boolean] :optional whether attribute is optional (overridden by :required)
+      #   @option options [Integer] :position specify order position
+      #   @option options [Symbol] :read read visibility (:public, :protected, :private) (priority over :read_access,
+      #     :reader)
+      #   @option options [Symbol] :read_access alias for :read
+      #   @option options [Symbol] :reader alias for :read
+      #   @option options [Boolean] :required whether attribute is required
+      #   @option options [Array<Object>, Object] :validate validators for the attribute (priority over :validate_with,
+      #     :validators)
+      #   @option options [Array<Object>, Object] :validate_with alias for :validate
+      #   @option options [Array<Object>, Object] :validators alias for :validate
+      #   @option options [Symbol] :write_access write visibility (:public, :protected, :private)
+      #     (priority over :writer)
+      #   @option options [Symbol] :writer alias for :write_access
+      #
+      # @yield [DSL::AttributeBuilder] optional configuration block
+      # @return [void]
+      #
+      #   @yield [DSL::AttributeBuilder] optional configuration block
+      #   @return [void]
+      def option: (String | Symbol attribute_name, ?Attribute::Validator::handler type_validator, ?callbacks: Array[Attribute::Callback::handler] | Attribute::Callback::handler, ?callback: Array[Attribute::Callback::handler] | Attribute::Callback::handler, ?coerce: Array[Attribute::Coercer::handler] | Attribute::Coercer::handler, ?coercers: Array[Attribute::Coercer::handler], ?coerce_with: [ Attribute::Coercer::handler ] | Attribute::Coercer::handler, ?default: untyped, ?default_generator: untyped, ?default_value: untyped, ?desc: String?, ?description: String, ?non_nil: bool, ?non_null: bool, ?non_nullable: bool, ?not_nil: bool, ?not_nilable: bool, ?not_null: bool, ?not_nullable: bool, ?null: bool, ?on_change: Array[Attribute::Callback::handler] | Attribute::Callback::handler, ?optional: bool, ?position: Integer?, ?read: Attribute::Signature::visibility_symbol, ?read_access: Attribute::Signature::visibility_symbol, ?reader: Attribute::Signature::visibility_symbol, ?required: bool, ?validate: Array[Attribute::Validator::handler] | Attribute::Validator::handler, ?validate_with: Array[Attribute::Validator::handler] | Attribute::Validator::handler, ?validators: Array[Attribute::Validator::handler] | Attribute::Validator::handler, ?write_access: Attribute::Signature::visibility_symbol, ?writer: Attribute::Signature::visibility_symbol) ?{ (?) [self: DSL::AttributeBuilder] -> void } -> void
+
+      private
+
+      # Handle class inheritance for attributes.
+      #
+      # Ensures that subclasses inherit a copy of their parent's attributes while
+      # maintaining proper ownership relationships.
+      #
+      # @param subclass [Class] the inheriting class
+      # @return [void]
+      def inherited: (Class | Module subclass) -> void
+
+      # Get the attribute set for this class.
+      #
+      # @return [AttributeSet] the set of attributes defined for this class
+      def __attributes__: () -> AttributeSet
+    end
+  end
+end

data/sig/domainic/attributer/dsl/attribute_builder/option_parser.rbs

@@ -0,0 +1,130 @@
+module Domainic
+  module Attributer
+    module DSL
+      class AttributeBuilder
+        # A class responsible for parsing and normalizing attribute options.
+        #
+        # This class handles the conversion of flexible DSL options into a normalized
+        # format for attribute creation. It supports multiple ways of specifying common
+        # options (like visibility, nullability, validation) and consolidates them
+        # into a consistent internal representation.
+        #
+        # @author {https://aaronmallen.me Aaron Allen}
+        # @since 0.1.0
+        class OptionParser
+          type options = { ?callbacks: Array[Attribute::Callback::handler] | Attribute::Callback::handler, ?callback: Array[Attribute::Callback::handler] | Attribute::Callback::handler, ?coerce: Array[Attribute::Coercer::handler] | Attribute::Coercer::handler, ?coercers: Array[Attribute::Coercer::handler], ?coerce_with: [ Attribute::Coercer::handler ] | Attribute::Coercer::handler, ?default: untyped, ?default_generator: untyped, ?default_value: untyped, ?desc: String?, ?description: String, ?non_nil: bool, ?non_null: bool, ?non_nullable: bool, ?not_nil: bool, ?not_nilable: bool, ?not_null: bool, ?not_nullable: bool, ?null: bool, ?on_change: Array[Attribute::Callback::handler] | Attribute::Callback::handler, ?optional: bool, ?position: Integer?, ?read: Attribute::Signature::visibility_symbol, ?read_access: Attribute::Signature::visibility_symbol, ?reader: Attribute::Signature::visibility_symbol, ?required: bool, ?validate: Array[Attribute::Validator::handler] | Attribute::Validator::handler, ?validate_with: Array[Attribute::Validator::handler] | Attribute::Validator::handler, ?validators: Array[Attribute::Validator::handler] | Attribute::Validator::handler, ?write_access: Attribute::Signature::visibility_symbol, ?writer: Attribute::Signature::visibility_symbol } & Hash[Symbol, untyped]
+
+          type result = { callbacks: Array[Attribute::Callback::handler], coercers: Array[Attribute::Coercer::handler], ?default: untyped, ?description: String, name: Symbol, ?nilable: bool, ?position: Integer?, ?required: bool, ?read: Attribute::Signature::visibility_symbol, type: Attribute::Signature::type_symbol, validators: Array[Attribute::Validator::handler], ?write: Attribute::Signature::visibility_symbol }
+
+          # Alternative keys for reader visibility settings
+          ACCESSOR_READER_KEYS: Array[Symbol]
+
+          # Alternative keys for writer visibility settings
+          ACCESSOR_WRITER_KEYS: Array[Symbol]
+
+          # Alternative keys for change callbacks
+          CALLBACK_KEYS: Array[Symbol]
+
+          # Alternative keys for coercion handlers
+          COERCER_KEYS: Array[Symbol]
+
+          # Alternative keys for default value settings
+          DEFAULT_KEYS: Array[Symbol]
+
+          # Alternative keys for description
+          DESCRIPTION_KEYS: Array[Symbol]
+
+          # Pattern for matching nilability-related keys
+          NILABLE_PATTERN: Regexp
+
+          # Keys that indicate non-nilable requirement
+          NON_NILABLE_KEYS: Array[Symbol]
+
+          # Alternative keys for validators
+          VALIDATOR_KEYS: Array[Symbol]
+
+          @result: result
+
+          @options: options
+
+          # Parse attribute options into a normalized format.
+          #
+          # @param attribute_name [String, Symbol] the name of the attribute
+          # @param attribute_type [String, Symbol] the type of attribute
+          # @param options [Hash] the options to parse
+          #
+          # @return [Hash] normalized options suitable for attribute creation
+          def self.parse!: (String | Symbol attribute_name, String | Symbol attribute_type, options options) -> void
+
+          # Initialize a new OptionParser.
+          #
+          # @param attribute_name [String, Symbol] the name of the attribute
+          # @param attribute_type [String, Symbol] the type of attribute
+          # @param options [Hash] the options to parse
+          #
+          # @return [void]
+          def initialize: (String | Symbol attribute_name, String | Symbol attribute_type, options options) -> void
+
+          # Parse the options into a normalized format.
+          #
+          # @return [Hash] normalized options suitable for attribute creation
+          def parse!: () -> result
+
+          private
+
+          # Find the last set value among multiple option keys.
+          #
+          # @param keys [Array<Symbol>] the keys to check
+          #
+          # @return [Object] the last set value or Undefined
+          def find_last_option: (Array[Symbol]) -> untyped
+
+          # Parse accessor (reader/writer) visibility options.
+          #
+          # @return [void]
+          def parse_accessor_options!: () -> void
+
+          # Parse callback handler options.
+          #
+          # @return [void]
+          def parse_callbacks_options!: () -> void
+
+          # Parse coercion handler options.
+          #
+          # @return [void]
+          def parse_coercers_options!: () -> void
+
+          # Parse default value options.
+          #
+          # @return [void]
+          def parse_default_options!: () -> void
+
+          # Parse description options.
+          #
+          # @return [void]
+          def parse_description_options!: () -> void
+
+          # Parse nilability options.
+          #
+          # @return [void]
+          def parse_nilable_options!: () -> void
+
+          # Parse all option types.
+          #
+          # @return [void]
+          def parse_options!: () -> void
+
+          # Parse required/optional options.
+          #
+          # @return [void]
+          def parse_required_options!: () -> void
+
+          # Parse validator options.
+          #
+          # @return [void]
+          def parse_validator_options!: () -> void
+        end
+      end
+    end
+  end
+end

data/sig/domainic/attributer/dsl/attribute_builder.rbs

@@ -0,0 +1,156 @@
+module Domainic
+  module Attributer
+    module DSL
+      # A class responsible for configuring attributes through a fluent interface.
+      #
+      # This class provides a rich DSL for configuring attributes with support for
+      # default values, coercion, validation, visibility controls, and change tracking.
+      # It uses method chaining to allow natural, declarative attribute definitions.
+      #
+      # @author {https://aaronmallen.me Aaron Allen}
+      # @since 0.1.0
+      class AttributeBuilder
+        @base: __todo__
+
+        @options: OptionParser::result
+
+        # Initialize a new AttributeBuilder.
+        #
+        # @param base [Class, Module] the class or module to build the attribute in
+        # @param attribute_name [String, Symbol] the name of the attribute
+        # @param attribute_type [String, Symbol] the type of attribute
+        # @param type_validator [Proc, Object, nil] optional type validator
+        # @param options [Hash] additional options for attribute configuration
+        # @yield configuration block for additional attribute settings
+        #
+        # @return [void]
+        def initialize: (__todo__ base, String | Symbol attribute_name, String | Symbol attribute_type, ?Attribute::Validator::handler? type_validator, OptionParser::options options) ?{ (?) [self: AttributeBuilder] -> void } -> void
+
+        # Builds and finalizes the attribute.
+        #
+        # @return [Attribute] the configured attribute
+        def build!: () -> Attribute
+
+        # Configure value coercion.
+        #
+        # @param proc_symbol [Proc, Symbol, nil] optional coercion handler
+        # @yield optional coercion block
+        #
+        # @return [self] the builder for method chaining
+        def coerce_with: (?(Attribute::Coercer::proc | Object)? proc_symbol) ?{ (untyped value) -> untyped } -> self
+
+        alias coerce coerce_with
+
+        # Configure default value.
+        #
+        # @param value_or_proc [Object, Proc, nil] optional default value or generator
+        # @yield optional default value generator block
+        #
+        # @return [self] the builder for method chaining
+        def default: (?untyped? value_or_proc) ?{ (?) -> untyped } -> self
+
+        alias default_generator default
+
+        alias default_value default
+
+        # Set attribute description.
+        #
+        # @param text [String] the description text
+        #
+        # @return [self] the builder for method chaining
+        def description: (String? text) -> self
+
+        alias desc description
+
+        # Mark attribute as non-nilable.
+        #
+        # @return [self] the builder for method chaining
+        def non_nilable: () -> self
+
+        alias non_nil non_nilable
+
+        alias non_null non_nilable
+
+        alias non_nullable non_nilable
+
+        alias not_nil non_nilable
+
+        alias not_nilable non_nilable
+
+        alias not_null non_nilable
+
+        alias not_nullable non_nilable
+
+        # Configure change callback.
+        #
+        # @param proc [Proc, nil] optional callback handler
+        # @yield optional callback block
+        #
+        # @return [self] the builder for method chaining
+        def on_change: (?Attribute::Callback::handler? proc) ?{ (untyped old_value, untyped new_value) -> void } -> self
+
+        # Set private visibility for both read and write.
+        #
+        # @return [self] the builder for method chaining
+        def private: () -> self
+
+        # Set private visibility for read.
+        #
+        # @return [self] the builder for method chaining
+        def private_read: () -> self
+
+        # Set private visibility for write.
+        #
+        # @return [self] the builder for method chaining
+        def private_write: () -> self
+
+        # Set protected visibility for both read and write.
+        #
+        # @return [self] the builder for method chaining
+        def protected: () -> self
+
+        # Set protected visibility for read.
+        #
+        # @return [self] the builder for method chaining
+        def protected_read: () -> self
+
+        # Set protected visibility for write.
+        #
+        # @return [self] the builder for method chaining
+        def protected_write: () -> self
+
+        # Set public visibility for both read and write.
+        #
+        # @return [self] the builder for method chaining
+        def public: () -> self
+
+        # Set public visibility for read.
+        #
+        # @return [self] the builder for method chaining
+        def public_read: () -> self
+
+        # Set public visibility for write.
+        #
+        # @return [self] the builder for method chaining
+        def public_write: () -> self
+
+        # Mark attribute as required.
+        #
+        # @return [self] the builder for method chaining
+        def required: () -> self
+
+        # Configure value validation.
+        #
+        # @param object_or_proc [Object, Proc, nil] optional validation handler
+        # @yield optional validation block
+        #
+        # @return [self] the builder for method chaining
+        def validate_with: (?Attribute::Validator::handler? object_or_proc) ?{ (untyped value) -> boolish } -> self
+
+        alias validate validate_with
+
+        alias validates validate_with
+      end
+    end
+  end
+end

data/sig/domainic/attributer/dsl/initializer.rbs

@@ -0,0 +1,91 @@
+module Domainic
+  module Attributer
+    module DSL
+      # A class responsible for handling object initialization with attributes.
+      #
+      # This class manages the process of setting attribute values during object
+      # initialization. It handles both positional arguments and keyword options,
+      # applying them to their corresponding attributes while respecting default
+      # values and required attributes.
+      #
+      # @author {https://aaronmallen.me Aaron Allen}
+      # @since 0.1.0
+      class Initializer
+        @argument_attributes: Array[Attribute]
+
+        @option_attributes: Array[Attribute]
+
+        @base: Object
+
+        @attributes: AttributeSet
+
+        # Initialize a new Initializer.
+        #
+        # @param base [Object] the instance being initialized
+        #
+        # @return [void]
+        def initialize: (Object base) -> void
+
+        # Assign values to attributes.
+        #
+        # Validates and applies both positional arguments and keyword options to
+        # their corresponding attributes. Raises an error if required arguments
+        # are missing.
+        #
+        # @param arguments [Array] positional arguments to assign
+        # @param keyword_arguments [Hash] keyword arguments to assign
+        #
+        # @raise [ArgumentError] if required arguments are missing
+        # @return [void]
+        def assign!: (*untyped arguments, **untyped keyword_arguments) -> void
+
+        private
+
+        # Access to the current attribute set.
+        #
+        # @return [AttributeSet] the attribute set for this instance
+        attr_reader attributes: AttributeSet
+
+        # Apply positional arguments to their attributes.
+        #
+        # @param arguments [Array] the positional arguments to apply
+        #
+        # @return [void]
+        def apply_arguments: (Array[untyped]) -> void
+
+        # Apply keyword arguments to their attributes.
+        #
+        # @param options [Hash] the keyword options to apply
+        #
+        # @return [void]
+        def apply_options!: (Hash[String | Symbol, untyped]) -> void
+
+        # Get all argument attributes.
+        #
+        # @return [Array<Attribute>] the argument attributes
+        def argument_attributes: () -> Array[Attribute]
+
+        # Assign a value to an attribute.
+        #
+        # @param attribute_name [Symbol] the name of the attribute
+        # @param value [Object] the value to assign
+        #
+        # @return [void]
+        def assign_value: (untyped attribute_name, untyped value) -> untyped
+
+        # Get all option attributes.
+        #
+        # @return [Array<Attribute>] the option attributes
+        def option_attributes: () -> Array[Attribute]
+
+        # Validate that all required positional arguments are provided.
+        #
+        # @param arguments [Array] the arguments to validate
+        #
+        # @raise [ArgumentError] if required arguments are missing
+        # @return [void]
+        def validate_positional_arguments!: (Array[untyped]) -> void
+      end
+    end
+  end
+end