diagram 0.2.1 → 0.3.2

data/lib/diagrams/pie_diagram.rb

@@ -1,48 +1,127 @@
 # frozen_string_literal: true
 
 module Diagrams
-  class PieDiagram < AbstractDiagram
-    attribute :id, Types::String.optional.default(nil)
-    attribute :title, Types::String.optional.default('')
-    attribute :sections, Types::Array.of(Section).optional.default([].freeze)
+  # Represents a Pie Chart diagram consisting of slices.
+  class PieDiagram < Base
+    attr_reader :title, :slices
 
-    def type
-      :pie
+    # Initializes a new PieDiagram.
+    #
+    # @param title [String] The title of the pie chart.
+    # @param slices [Array<Element::Slice>] An array of slice objects.
+    # @param version [String, Integer, nil] User-defined version identifier.
+    def initialize(title: '', slices: [], version: 1)
+      super(version: version) # Corrected super call
+      @title = title.is_a?(String) ? title : ''
+      @slices = [] # Initialize empty
+      # Add initial slices using the corrected add_slice method
+      (slices.is_a?(Array) ? slices : []).each { |s| add_slice(s, update_checksum: false, initial_load: true) }
+      recalculate_percentages! # Calculate initial percentages
+      update_checksum! # Calculate final checksum after initial load
     end
 
-    def validate!
-      raise EmptyDiagramError, 'Pie diagram must have at least one section' if sections.empty?
+    # Adds a slice to the diagram.
+    #
+    # @param slice [Element::Slice] The slice object to add.
+    # @raise [ArgumentError] if a slice with the same label already exists.
+    # @return [Element::Slice] The added slice.
+    # Added initial_load flag to skip checksum update during initialize loop
+    def add_slice(slice, update_checksum: true, initial_load: false)
+      raise ArgumentError, 'Slice must be a Diagrams::Elements::Slice' unless slice.is_a?(Diagrams::Elements::Slice)
+      raise ArgumentError, "Slice with label '#{slice.label}' already exists" if find_slice(slice.label)
 
-      return true if sections.map(&:label).uniq.size == sections.size
+      # Store a new instance to hold the calculated percentage later
+      # Ensure percentage is nil initially
+      new_slice_instance = slice.class.new(slice.attributes.except(:percentage))
+      @slices << new_slice_instance
+      recalculate_percentages! # Update percentages for all slices
+      update_checksum! if update_checksum && !initial_load # Avoid multiple checksums during init
+      new_slice_instance # Return the instance added to the array
+    end
+
+    # Finds a slice by its label.
+    #
+    # @param label [String] The label of the slice to find.
+    # @return [Element::Slice, nil] The found slice or nil.
+    def find_slice(label)
+      @slices.find { |s| s.label == label }
+    end
+
+    # Calculates the total raw value of all slices.
+    # @return [Float]
+    def total_value
+      @slices.sum(&:value)
+    end
+
+    # Returns the specific content of the pie diagram as a hash.
+    # Called by `Diagrams::Base#to_h`.
+    #
+    # @return [Hash{Symbol => String | Array<Hash>}]
+    def to_h_content
+      {
+        title: @title,
+        # Ensure slices include calculated percentage in their hash
+        slices: @slices.map(&:to_h)
+      }
+    end
 
-      raise DuplicateLabelError,
-            'Pie diagram sections must have unique labels'
+    # Returns a hash mapping element types to their collections for diffing.
+    # @see Diagrams::Base#identifiable_elements
+    # @return [Hash{Symbol => Array<Diagrams::Elements::Slice>}]
+    def identifiable_elements
+      {
+        slices: @slices
+      }
     end
 
-    def plot
-      circle_char = '*'
-      pie_diameter = 10
-      pie_radius = pie_diameter / 2.0
+    # Class method to create a PieDiagram from a hash.
+    # Used by the deserialization factory in `Diagrams::Base`.
+    #
+    # @param data_hash [Hash] Hash containing `:title` and `:slices` array.
+    # @param version [String, Integer, nil] Diagram version.
+    # @param checksum [String, nil] Expected checksum (optional, for verification).
+    # @return [PieDiagram] The instantiated diagram.
+    def self.from_h(data_hash, version:, checksum:)
+      title = data_hash[:title] || data_hash['title'] || ''
+      slices_data = data_hash[:slices] || data_hash['slices'] || []
 
-      (-pie_radius.to_i..pie_radius.to_i).each do |i|
-        (-pie_radius.to_i..pie_radius.to_i).each do |j|
-          distance_to_center = Math.sqrt((i**2) + (j**2))
-          if distance_to_center > pie_radius - 0.5 && distance_to_center < pie_radius + 0.5
-            print circle_char
-          else
-            print ' '
-          end
-        end
-        print "\n"
+      # Initialize with raw values, percentage will be recalculated by `new` -> `add_slice` -> `recalculate_percentages!`
+      slices = slices_data.map do |slice_h|
+        Diagrams::Elements::Slice.new(slice_h.transform_keys(&:to_sym).except(:percentage))
       end
 
-      sections.each do |section|
-        puts "#{section.label}: #{section.value}%"
+      diagram = new(title: title, slices: slices, version: version)
+
+      # Optional: Verify checksum if provided AFTER initialization is complete
+      if checksum && diagram.checksum != checksum
+        warn "Checksum mismatch for loaded PieDiagram (version: #{version}). Expected #{checksum}, got #{diagram.checksum}."
+        # Or raise an error: raise "Checksum mismatch..."
       end
+
+      diagram
     end
 
-    def valid?
-      validate!
+    private
+
+    # Recalculates the percentage for each slice based on the total value.
+    # This method modifies the @slices array in place by replacing Slice instances.
+    def recalculate_percentages!
+      total = total_value
+      new_slices = @slices.map do |slice|
+        percentage = total.zero? ? 0.0 : (slice.value / total * 100.0).round(2)
+        # Create a new instance with the calculated percentage
+        slice.class.new(slice.attributes.merge(percentage: percentage))
+      end
+      # Replace the entire array to ensure changes are reflected
+      @slices = new_slices
+    end
+
+    # Validates the consistency of slices during initialization.
+    def validate_elements!
+      labels = @slices.map(&:label)
+      return if labels.uniq.size == @slices.size
+
+      raise ArgumentError, 'Duplicate slice labels found'
     end
   end
 end

data/lib/diagrams/state_diagram.rb

@@ -1,9 +1,162 @@
 # frozen_string_literal: true
 
 module Diagrams
-  class StateDiagram < AbstractDiagram
-    attribute :id, Types::String
-    attribute :states, Types::Array.of(State)
-    attribute :transitions, Types::Array.of(Transition)
+  # Represents a State Diagram consisting of states and transitions between them.
+  class StateDiagram < Base
+    attr_reader :title, :states, :transitions, :events
+
+    # Initializes a new StateDiagram.
+    #
+    # @param title [String] Optional title for the diagram.
+    # @param states [Array<Element::State>] An array of state objects.
+    # @param transitions [Array<Element::Transition>] An array of transition objects.
+    # @param events [Array<Element::Event>] An array of event objects (optional).
+    # @param version [String, Integer, nil] User-defined version identifier.
+    def initialize(title: '', states: [], transitions: [], events: [], version: 1)
+      super(version:)
+      @title = title.is_a?(String) ? title : ''
+      @states = states.is_a?(Array) ? states : []
+      @transitions = transitions.is_a?(Array) ? transitions : []
+      @events = events.is_a?(Array) ? events : [] # Keep events for now
+      validate_elements!
+      update_checksum!
+    end
+
+    # Adds a state to the diagram.
+    #
+    # @param state [Element::State] The state object to add.
+    # @raise [ArgumentError] if a state with the same ID already exists.
+    # @return [Element::State] The added state.
+    def add_state(state)
+      raise ArgumentError, 'State must be a Diagrams::Elements::State' unless state.is_a?(Diagrams::Elements::State)
+      raise ArgumentError, "State with ID '#{state.id}' already exists" if find_state(state.id)
+
+      @states << state
+      update_checksum!
+      state
+    end
+
+    # Adds a transition to the diagram.
+    #
+    # @param transition [Element::Transition] The transition object to add.
+    # @raise [ArgumentError] if the transition refers to non-existent state IDs.
+    # @return [Element::Transition] The added transition.
+    def add_transition(transition)
+      unless transition.is_a?(Diagrams::Elements::Transition)
+        raise ArgumentError,
+              'Transition must be a Diagrams::Elements::Transition'
+      end
+      unless find_state(transition.source_state_id) && find_state(transition.target_state_id)
+        raise ArgumentError,
+              "Transition refers to non-existent state IDs ('#{transition.source_state_id}' or '#{transition.target_state_id}')"
+      end
+
+      @transitions << transition
+      update_checksum!
+      transition
+    end
+
+    # Adds an event to the diagram.
+    #
+    # @param event [Element::Event] The event object to add.
+    # @raise [ArgumentError] if an event with the same ID already exists.
+    # @return [Element::Event] The added event.
+    def add_event(event)
+      raise ArgumentError, 'Event must be a Diagrams::Elements::Event' unless event.is_a?(Diagrams::Elements::Event)
+      raise ArgumentError, "Event with ID '#{event.id}' already exists" if find_event(event.id)
+
+      @events << event
+      update_checksum!
+      event
+    end
+
+    # Finds a state by its ID.
+    #
+    # @param state_id [String] The ID of the state to find.
+    # @return [Element::State, nil] The found state or nil.
+    def find_state(state_id)
+      @states.find { |s| s.id == state_id }
+    end
+
+    # Finds an event by its ID.
+    #
+    # @param event_id [String] The ID of the event to find.
+    # @return [Element::Event, nil] The found event or nil.
+    def find_event(event_id)
+      @events.find { |e| e.id == event_id }
+    end
+
+    # Returns the specific content of the state diagram as a hash.
+    # Called by `Diagrams::Base#to_h`.
+    #
+    # @return [Hash{Symbol => String | Array<Hash>}]
+    def to_h_content
+      {
+        title: @title,
+        states: @states.map(&:to_h),
+        transitions: @transitions.map(&:to_h),
+        events: @events.map(&:to_h)
+      }
+    end
+
+    # Returns a hash mapping element types to their collections for diffing.
+    # @see Diagrams::Base#identifiable_elements
+    # @return [Hash{Symbol => Array<Diagrams::Elements::State | Diagrams::Elements::Transition | Diagrams::Elements::Event>}]
+    def identifiable_elements
+      {
+        states: @states,
+        transitions: @transitions,
+        events: @events
+      }
+    end
+
+    # Class method to create a StateDiagram from a hash.
+    # Used by the deserialization factory in `Diagrams::Base`.
+    #
+    # @param data_hash [Hash] Hash containing `:title`, `:states`, `:transitions`, `:events`.
+    # @param version [String, Integer, nil] Diagram version.
+    # @param checksum [String, nil] Expected checksum (optional, for verification).
+    # @return [StateDiagram] The instantiated diagram.
+    def self.from_h(data_hash, version:, checksum:)
+      title = data_hash[:title] || data_hash['title'] || ''
+      states_data = data_hash[:states] || data_hash['states'] || []
+      transitions_data = data_hash[:transitions] || data_hash['transitions'] || []
+      events_data = data_hash[:events] || data_hash['events'] || []
+
+      states = states_data.map { |state_h| Diagrams::Elements::State.new(state_h.transform_keys(&:to_sym)) }
+      transitions = transitions_data.map do |trans_h|
+        Diagrams::Elements::Transition.new(trans_h.transform_keys(&:to_sym))
+      end
+      events = events_data.map { |event_h| Diagrams::Elements::Event.new(event_h.transform_keys(&:to_sym)) }
+
+      diagram = new(title:, states:, transitions:, events:, version:)
+
+      # Optional: Verify checksum if provided
+      if checksum && diagram.checksum != checksum
+        warn "Checksum mismatch for loaded StateDiagram (version: #{version}). Expected #{checksum}, got #{diagram.checksum}."
+        # Or raise an error: raise "Checksum mismatch..."
+      end
+
+      diagram
+    end
+
+    private
+
+    # Validates the consistency of elements during initialization.
+    def validate_elements!
+      state_ids = @states.map(&:id)
+      raise ArgumentError, 'Duplicate state IDs found' unless state_ids.uniq.size == @states.size
+
+      event_ids = @events.map(&:id)
+      raise ArgumentError, 'Duplicate event IDs found' unless event_ids.uniq.size == @events.size
+
+      @transitions.each do |t|
+        unless state_ids.include?(t.source_state_id) && state_ids.include?(t.target_state_id)
+          raise ArgumentError,
+                "Transition refers to non-existent state IDs ('#{t.source_state_id}' or '#{t.target_state_id}')"
+        end
+      end
+      # Add more validation if needed (e.g., transition labels match event IDs?)
+    end
   end
 end

data/lib/diagrams/timeline_diagram.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module Diagrams
+  # Represents a timeline diagram illustrating a chronology of events.
+  class TimelineDiagram < Base
+    DEFAULT_SECTION_TITLE = 'Default Section'
+
+    attr_reader :title, :sections
+
+    # Initializes a new TimelineDiagram.
+    #
+    # @param title [String, nil] Optional title for the timeline.
+    # @param sections [Array<Element::TimelineSection>] Initial sections (optional).
+    # @param version [String, Integer, nil] User-defined version identifier.
+    def initialize(title: nil, sections: [], version: 1)
+      super(version:)
+      @title = title&.strip
+      @sections = sections.is_a?(Array) ? sections : []
+      # Ensure there's always at least a default section if none provided initially
+      ensure_default_section if @sections.empty?
+      update_checksum!
+    end
+
+    # Sets the title of the timeline.
+    #
+    # @param new_title [String] The title text.
+    # @return [String] The new title.
+    def set_title(new_title)
+      @title = new_title.strip
+      update_checksum!
+      @title
+    end
+
+    # Adds a new section to the timeline.
+    # Subsequent periods/events will be added to this section.
+    #
+    # @param section_title [String] The title of the section.
+    # @raise [ArgumentError] if a section with the same title already exists.
+    # @return [Elements::TimelineSection] The newly added section.
+    def add_section(section_title)
+      clean_title = section_title.strip
+      raise ArgumentError, "Section title '#{clean_title}' cannot be empty" if clean_title.empty?
+      if find_section(clean_title)
+        raise ArgumentError, "Section with title '#{clean_title}' already exists"
+      end
+
+      # Remove default section if it's empty and we're adding a real one
+      if @sections.size == 1 && @sections.first.title == DEFAULT_SECTION_TITLE && @sections.first.periods.empty?
+        @sections.clear
+      end
+
+      new_section = Elements::TimelineSection.new(title: clean_title)
+      @sections << new_section
+      update_checksum!
+      new_section
+    end
+
+    # Adds a time period with one or more events to the current (last) section.
+    #
+    # @param period_label [String] The label for the time period (e.g., "2004", "Bronze Age").
+    # @param events [Array<String> | String] A single event description or an array of event descriptions.
+    # @raise [ArgumentError] if period_label or any event description is empty.
+    # @raise [StandardError] if no sections exist (shouldn't happen due to default section).
+    # @return [Elements::TimelinePeriod] The newly added period.
+    def add_period(period_label:, events:)
+      clean_label = period_label.strip
+      raise ArgumentError, "Period label cannot be empty" if clean_label.empty?
+
+      event_list = Array(events).map(&:strip).reject(&:empty?)
+      raise ArgumentError, "Events cannot be empty" if event_list.empty?
+
+      timeline_events = event_list.map { |desc| Elements::TimelineEvent.new(description: desc) }
+      new_period = Elements::TimelinePeriod.new(label: clean_label, events: timeline_events)
+
+      current_section = @sections.last
+      raise StandardError, "Cannot add period: No section available." unless current_section
+
+      # Add period to the current section's periods array
+      # Dry::Struct arrays are immutable, so we need to create a new section object
+      updated_periods = current_section.periods + [new_period]
+      # Create a completely new section instance with the updated periods array
+      updated_section = Elements::TimelineSection.new(title: current_section.title, periods: updated_periods)
+
+      # Find the index of the current section and update it in place
+      # Rebuild the sections array, replacing the modified section
+      current_section_title = current_section.title
+      # Rebuild the sections array by mapping, replacing the target section
+      @sections = @sections.map do |section|
+        section.title == current_section_title ? updated_section : section
+      end
+
+      update_checksum!
+      new_period
+    end
+
+    # --- Base Class Implementation ---
+
+    def to_h_content
+      content = {
+        sections: @sections.map(&:to_h)
+      }
+      content[:title] = @title if @title
+      content
+    end
+
+    def identifiable_elements
+      # Sections and Periods are the main identifiable structures. Events are nested.
+      # Use section title and period label as identifiers.
+      {
+        sections: @sections,
+        periods: @sections.flat_map(&:periods) # Flatten periods from all sections
+      }
+    end
+
+    def self.from_h(data_hash, version:, checksum:)
+      title = data_hash[:title] || data_hash['title']
+      sections_data = data_hash[:sections] || data_hash['sections'] || []
+
+      sections = sections_data.map do |section_h|
+        section_data = section_h.transform_keys(&:to_sym)
+        periods_data = section_data[:periods] || []
+        periods = periods_data.map do |period_h|
+          period_data = period_h.transform_keys(&:to_sym)
+          events_data = period_data[:events] || []
+          events = events_data.map do |event_h|
+            event_data = event_h.transform_keys(&:to_sym)
+            Elements::TimelineEvent.new(event_data)
+          end
+          Elements::TimelinePeriod.new(period_data.merge(events:))
+        end
+        Elements::TimelineSection.new(section_data.merge(periods:))
+      end
+
+      diagram = new(title:, sections:, version:)
+
+      # Optional: Verify checksum
+      if checksum && diagram.checksum != checksum
+        warn "Checksum mismatch for loaded TimelineDiagram (version: #{version}). Expected #{checksum}, got #{diagram.checksum}."
+      end
+
+      diagram
+    end
+
+    private
+
+    # Ensures a default section exists if the sections array is empty.
+    def ensure_default_section
+      unless @sections.any? { |s| s.title == DEFAULT_SECTION_TITLE }
+        @sections << Elements::TimelineSection.new(title: DEFAULT_SECTION_TITLE)
+      end
+    end
+
+    # Finds a section by its title.
+    def find_section(section_title)
+      @sections.find { |s| s.title == section_title }
+    end
+
+    # Protected method access for from_h
+    protected :update_checksum!
+  end
+end

data/lib/diagrams/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Diagrams
-  VERSION = '0.2.1'
+  VERSION = '0.3.2'
 end

data/lib/diagrams.rb

@@ -1,9 +1,14 @@
 # frozen_string_literal: true
 
-require_relative 'diagrams/version'
+require 'zeitwerk'
+require 'digest'
+require 'json'
+require 'dry-equalizer'
 require 'dry-struct'
+require_relative 'diagrams/version'
 
 loader = Zeitwerk::Loader.for_gem
+loader.ignore("#{__dir__}/diagram.rb")
 loader.setup
 
 # This module handles diagrams creation and manipulation.

data/sig/diagrams/base.rbs

@@ -0,0 +1,86 @@
+module Diagrams
+  # Abstract base class for all diagram types.
+  # Provides common functionality like versioning, checksum calculation,
+  # serialization, and equality comparison.
+  class Base
+    # Provides `==`, `eql?`, and `hash` methods based on specified attributes.
+    include Dry::Equalizer
+
+    # User-defined version identifier (e.g., Integer or String).
+    attr_reader version: Integer | String
+
+    # SHA256 checksum of the diagram's content (hex string). Nil until calculated.
+    attr_reader checksum: String?
+
+    # Initializes the base diagram attributes.
+    # Subclasses should call super.
+    # Cannot be called directly on Diagrams::Base.
+    def initialize: (?version: Integer | String?) -> void
+
+    # Abstract method: Subclasses must implement this to return a hash
+    # representing their specific content, suitable for serialization.
+    # @return [Hash[Symbol, untyped]]
+    def to_h_content: () -> Hash[Symbol, untyped]
+
+    # Abstract method: Subclasses must implement this to return a hash
+    # mapping element type symbols (e.g., :nodes, :edges) to arrays
+    # of the corresponding element objects within the diagram.
+    # Used for comparison and diffing.
+    # @return [Hash[Symbol, Array[untyped]]] # More specific types in subclasses
+    def identifiable_elements: () -> Hash[Symbol, Array[untyped]]
+
+    # Returns a hash representation of the diagram, suitable for serialization.
+    # Includes common metadata and calls `#to_h_content` for specific data.
+    # @return [Hash[Symbol, untyped]]
+    def to_h: () -> Hash[Symbol, untyped]
+
+    # Returns a JSON string representation of the diagram.
+    # Delegates to `#to_h` and uses `JSON.generate`.
+    # @param args Any arguments accepted by `JSON.generate`.
+    # @return [String]
+    def to_json: (*untyped args) -> String
+
+    # --- Class methods for Deserialization ---
+
+    # Deserializes a diagram from a hash representation.
+    # Acts as a factory, dispatching to the appropriate subclass based on the 'type' field.
+    # @param hash [Hash[Symbol | String, untyped]] The hash representation.
+    # @return [Diagrams::Base] An instance of the specific diagram subclass.
+    def self.from_hash: (Hash[Symbol | String, untyped] hash) -> Diagrams::Base
+
+    # Deserializes a diagram from a JSON string.
+    # Parses the JSON and delegates to `.from_hash`.
+    # @param json_string [String] The JSON representation of the diagram.
+    # @return [Diagrams::Base] An instance of the specific diagram subclass.
+    def self.from_json: (String json_string) -> Diagrams::Base
+
+    # Performs a basic diff against another diagram object.
+    # @param other [Diagrams::Base] The diagram to compare against.
+    # @return [Hash[Symbol, Hash[Symbol, Array[untyped]]]] A hash describing differences.
+    def diff: (Diagrams::Base other) -> Hash[Symbol, Hash[Symbol, Array[untyped]]]
+
+    # --- End Deserialization Methods ---
+
+    # Recalculates the diagram's checksum based on its current content
+    # and updates the @checksum instance variable.
+    # Subclasses should call this after initialization and any mutation.
+    # @return [String?] The new checksum value.
+    def update_checksum!: () -> String?
+
+    private
+
+    # Computes the SHA256 checksum of the diagram's content.
+    # @return [String] The hex digest of the checksum.
+    def compute_checksum: () -> String
+  end
+
+  # --- Errors ---
+  class ValidationError < StandardError
+  end
+
+  class EmptyDiagramError < ValidationError
+  end
+
+  class DuplicateLabelError < ValidationError
+  end
+end

data/sig/diagrams/class_diagram.rbs

@@ -0,0 +1,33 @@
+
+module Diagrams
+  class ClassDiagram < Base
+    attr_reader classes: ::Array[Elements::ClassEntity]
+    attr_reader relationships: ::Array[Elements::Relationship]
+
+    # Initializes a new ClassDiagram.
+    def initialize: (?classes: ::Array[Elements::ClassEntity]?, ?relationships: ::Array[Elements::Relationship]?, ?version: Integer | String?) -> void
+
+    # Adds a class entity to the diagram.
+    def add_class: (Elements::ClassEntity class_entity) -> Elements::ClassEntity
+
+    # Adds a relationship to the diagram.
+    def add_relationship: (Elements::Relationship relationship) -> Elements::Relationship
+
+    # Finds a class entity by its name.
+    def find_class: (::String class_name) -> Elements::ClassEntity?
+
+    # Returns the specific content of the class diagram as a hash.
+    def to_h_content: () -> { classes: ::Array[Hash[Symbol, untyped]], relationships: ::Array[Hash[Symbol, untyped]] }
+
+    # Returns a hash mapping element types to their collections for diffing.
+    def identifiable_elements: () -> { classes: ::Array[Elements::ClassEntity], relationships: ::Array[Elements::Relationship] }
+
+    # Class method to create a ClassDiagram from a hash.
+    def self.from_h: (Hash[Symbol | String, untyped] data_hash, version: Integer | String?, checksum: String?) -> ClassDiagram
+
+    private
+
+    # Validates the consistency of classes and relationships during initialization.
+    def validate_elements!: () -> void
+  end
+end

data/sig/diagrams/elements/class_entity.rbs

@@ -0,0 +1,15 @@
+module Diagrams
+  module Elements
+    class ClassEntity < ::Dry::Struct
+      include Diagrams::Elements::Types
+
+      # Attributes
+      def name: () -> ::String
+      def attributes: () -> ::Array[::String]
+      def methods: () -> ::Array[::String]
+
+      # Methods
+      def to_h: () -> { name: ::String, attributes: ::Array[::String], methods: ::Array[::String] }
+    end
+  end
+end

data/sig/diagrams/elements/edge.rbs

@@ -0,0 +1,16 @@
+module Diagrams
+  module Elements
+    class Edge < ::Dry::Struct
+      include Diagrams::Elements::Types
+
+      # Attributes
+      def source_id: () -> ::String
+      def target_id: () -> ::String
+      def label: () -> ::String?
+
+      # Methods
+      # Dry::Struct provides to_h, signature reflects potential nil label removal
+      def to_h: () -> { source_id: ::String, target_id: ::String, ?label: ::String }
+    end
+  end
+end

data/sig/diagrams/elements/event.rbs

@@ -0,0 +1,14 @@
+module Diagrams
+  module Elements
+    class Event < ::Dry::Struct
+      include Diagrams::Elements::Types
+
+      # Attributes
+      def id: () -> ::String
+      def label: () -> ::String?
+
+      # Methods
+      def to_h: () -> { id: ::String, ?label: ::String }
+    end
+  end
+end