sec_id 5.2.0 → 6.0.0

data/sig/sec_id/cfi/tables.rbs

@@ -0,0 +1,68 @@
+module SecID
+  class CFI < Base
+    # ISO 10962:2021 CFI code tables.
+    #
+    # @api private
+    module Tables
+      # `{ letter => [value_symbol, value_label] }` for one attribute position.
+      # Values are typed loosely: the `[symbol, label]` tuple literals widen to
+      # `Array[Symbol | String]` under `Hash#freeze`, and `map(&:first)` on them feeds
+      # Field domains (Array[Symbol]) — untyped keeps both sides consistent.
+      type value_map = Hash[String, untyped]
+
+      # A group definition and the (loosely-typed, deeply-nested) group table.
+      type group_def = Hash[Symbol, untyped]
+
+      NA: nil
+
+      FORM: value_map
+      VOTING: value_map
+      OWNERSHIP: value_map
+      PAYMENT: value_map
+      PREF_REDEMPTION: value_map
+      PREF_INCOME: value_map
+      DEBT_GUARANTEE: value_map
+      DEBT_REDEMPTION: value_map
+      DEBT_INTEREST_FZVK: value_map
+      DEBT_INTEREST_FZV: value_map
+      STRUCTURED_DISTRIBUTION: value_map
+      STRUCTURED_UNDERLYING: value_map
+      WARRANT_UNDERLYING: value_map
+      EXERCISE_STYLE: value_map
+      CIV_CLOSED_OPEN: value_map
+      CIV_DISTRIBUTION: value_map
+      CIV_ASSETS: value_map
+      CIV_SECURITY_FULL: value_map
+      CIV_SECURITY_SHORT: value_map
+      OPTION_STYLE: value_map
+      OPTION_UNDERLYING: value_map
+      STANDARDIZED: value_map
+      COMMODITY_ASSETS: value_map
+      RETURN_TRIGGER: value_map
+      H_OPTION_STYLE: value_map
+      H_VALUATION: value_map
+      DELIVERY_CP: value_map
+      DELIVERY_PN: value_map
+      DELIVERY_PCN: value_map
+      DELIVERY_CPE: value_map
+      H_DELIVERY: value_map
+      H_DELIVERY_N: value_map
+      H_DELIVERY_NA: value_map
+      FWD_TRIGGER_CSF: value_map
+      FWD_TRIGGER_SF: value_map
+      FWD_TRIGGER_CF: value_map
+
+      # `{ letter => [category_symbol, category_label] }`. Typed loosely (widening tuple
+      # values; generation also indexes with nilable `.keys.sample` results).
+      CATEGORIES: Hash[untyped, untyped]
+
+      # `{ cat_letter => { grp_letter => group_def } }` (typed loosely, as above).
+      GROUPS: Hash[untyped, untyped]
+
+      ED_REDEMPTION_RULE: Hash[Symbol, untyped]
+
+      def self.ed_rule_applies?: (untyped category_code, untyped group_code, untyped letters) -> bool
+      def self.group: (untyped category_code, untyped group_code) -> untyped
+    end
+  end
+end

data/sig/sec_id/cfi.rbs

@@ -0,0 +1,56 @@
+module SecID
+  # Classification of Financial Instruments (CFI) — ISO 10962:2021.
+  class CFI < Base
+    FULL_NAME: String
+    ID_LENGTH: Integer
+    EXAMPLE: String
+    VALID_CHARS_REGEX: ::Regexp
+    ID_REGEX: ::Regexp
+
+    # Derived semantic maps (letter => symbol).
+    CATEGORIES: Hash[String, Symbol]
+    GROUPS: Hash[String, Hash[String, Symbol]]
+
+    def self.categories: () -> Hash[String, Symbol]
+    def self.groups_for: (String category_code) -> Hash[String, Symbol]?
+
+    # Used unguarded as non-nil after validation (indexed into the tables); typed loosely
+    # so static Steep and runtime RBS::Test (which sees nil for invalid) agree.
+    attr_reader category_code: untyped
+    attr_reader group_code: untyped
+    attr_reader attr1: untyped
+    attr_reader attr2: untyped
+    attr_reader attr3: untyped
+    attr_reader attr4: untyped
+
+    def initialize: (SecID::input cfi) -> void
+    def category: () -> Symbol?
+    def group: () -> Symbol?
+    def decode: () -> Classification?
+    def to_s: () -> String
+
+    private def self.generate_body: (Random random) -> String
+    private def self.sample_attribute: (untyped position, Random random) -> String
+    private def self.enforce_ed_rule: (untyped category_code, untyped group_code, untyped letters, Random random) -> void
+
+    private
+
+    def components: () -> Hash[Symbol, untyped]
+    def valid_format?: () -> bool
+    def detect_errors: () -> Array[Symbol]
+    def validation_message: (Symbol code) -> String?
+    def valid_category?: () -> bool
+    def valid_group?: () -> bool
+    def valid_attributes?: () -> bool
+    # `[position, letter]` pairs; typed loosely since the tuple literals widen.
+    def attribute_violations: () -> Array[untyped]
+    def compute_attribute_violations: () -> Array[untyped]
+    def permitted_attribute?: (untyped position, String letter) -> bool
+    def ed_rule_violations: () -> Array[untyped]
+    def ed_rule_applies?: () -> bool
+    def attribute_letters: () -> Array[String]
+    def attribute_error_message: () -> String
+
+    @attribute_violations: Array[untyped]
+  end
+end

data/sig/sec_id/cik.rbs

@@ -0,0 +1,19 @@
+module SecID
+  # Central Index Key (CIK).
+  class CIK < Base
+    FULL_NAME: String
+    # Typed loosely: `#normalized` does `ID_LENGTH.max` and Range#max is nilable in RBS.
+    ID_LENGTH: untyped
+    EXAMPLE: String
+    VALID_CHARS_REGEX: ::Regexp
+    ID_REGEX: ::Regexp
+
+    attr_reader padding: String?
+
+    def initialize: (SecID::input cik) -> void
+    def normalized: () -> String
+    def normalize!: () -> self
+    def to_s: () -> String
+    private def self.generate_body: (Random random) -> String
+  end
+end

data/sig/sec_id/concerns/checkable.rbs

@@ -0,0 +1,41 @@
+module SecID
+  # Provides check-digit validation and calculation for identifiers with a check digit.
+  module Checkable : SecID::Base
+    CHAR_TO_DIGITS: Hash[String, Integer | Array[Integer]]
+    CHAR_TO_DIGIT: Hash[String, Integer]
+
+    def self.included: (Module base) -> void
+
+    attr_reader check_digit: (Integer | String)?
+
+    # Class methods added when Checkable is included.
+    module ClassMethods : SecID::_IdentifierClass
+      def restore: (SecID::input id_without_check_digit) -> String
+      def restore!: (SecID::input id_without_check_digit) -> Base
+      def check_digit: (SecID::input id) -> (Integer | String)
+    end
+
+    def valid?: () -> bool
+    def restore: () -> String
+    def restore!: () -> self
+    def calculate_check_digit: () -> (Integer | String)
+    def to_s: () -> String
+
+    private
+
+    def luhn_sum_double_add_double: (Array[Integer] digits) -> Integer
+    def luhn_sum_indexed: (Array[Integer] digits) -> Integer
+    def luhn_sum_standard: (Array[Integer] digits) -> Integer
+    def reversed_digits_single: (untyped id) -> Array[Integer]
+    def reversed_digits_multi: (untyped id) -> Array[Integer]
+    def error_codes: () -> Array[Symbol]
+    def check_digit_width: () -> Integer
+    def validation_message: (Symbol code) -> String?
+    def validate_format_for_calculation!: () -> void
+    def mod10: (Integer sum) -> Integer
+    def div10mod10: (Integer number) -> Integer
+    def mod97: (String numeric_string) -> Integer
+
+    @check_digit: (Integer | String)?
+  end
+end

data/sig/sec_id/concerns/generatable.rbs

@@ -0,0 +1,26 @@
+module SecID
+  # Provides generation of new, format-valid identifiers for use as test fixtures.
+  module Generatable
+    ALPHA: Array[String]
+    DIGITS: Array[String]
+    ALPHANUMERIC: Array[String]
+
+    def self.included: (Module base) -> void
+
+    # The class-object surface Generatable's methods call once extended.
+    interface _GeneratableClass
+      def new: (SecID::input) -> Base
+      def has_check_digit?: () -> bool
+    end
+
+    # Class methods added when Generatable is included.
+    module ClassMethods : SecID::Generatable::_GeneratableClass
+      def generate: (?random: Random) -> Base
+
+      private
+
+      def generate_body: (Random _random) -> String
+      def random_string: (Array[String] charset, Integer length, random: Random) -> String
+    end
+  end
+end

data/sig/sec_id/concerns/normalizable.rbs

@@ -0,0 +1,34 @@
+module SecID
+  # Host surface Normalizable's instance methods call through `self`.
+  interface _NormalizableHost
+    def identifier: () -> String?
+    def valid?: () -> bool
+    def validate!: () -> void
+  end
+
+  # Provides normalization and display-formatting methods for identifier types.
+  #
+  # `ClassMethods#normalize`/`#to_pretty_s` read `self::SEPARATORS` (polymorphic
+  # constant dispatch); the extend-module `self` can't be typed as `singleton(Base)`,
+  # so that access resolves via the relaxed UnknownConstant diagnostic (see Steepfile).
+  module Normalizable : SecID::_NormalizableHost
+    SEPARATORS: ::Regexp
+
+    def self.included: (Module base) -> void
+
+    # Class methods added when Normalizable is included.
+    module ClassMethods : SecID::_IdentifierClass
+      def normalize: (_ToS id) -> String
+      def to_pretty_s: (_ToS id) -> String?
+    end
+
+    def normalized: () -> String
+    alias normalize normalized
+    def normalize!: () -> self
+    def to_pretty_s: () -> String?
+    def to_s: () -> String
+    def to_str: () -> String
+
+    @full_id: String
+  end
+end

data/sig/sec_id/concerns/validatable.rbs

@@ -0,0 +1,42 @@
+module SecID
+  # Host surface Validatable's instance methods call through `self`. The refined
+  # `class` return lets `self.class::ID_LENGTH` and the class metadata resolve.
+  interface _ValidatableHost
+    def identifier: () -> String?
+    def full_id: () -> String
+    def class: () -> singleton(SecID::Base)
+  end
+
+  # Provides validation methods for identifier types.
+  module Validatable : SecID::_ValidatableHost
+    ERROR_MAP: Hash[Symbol, singleton(SecID::Error)]
+
+    def self.included: (Module base) -> void
+
+    # Class methods added when Validatable is included.
+    module ClassMethods : SecID::_IdentifierClass
+      def valid?: (SecID::input id) -> bool
+      def validate: (SecID::input id) -> Base
+      def validate!: (SecID::input id) -> Base
+      def error_class_for: (Symbol code) -> singleton(SecID::Error)
+    end
+
+    def valid?: () -> bool
+    def validate: () -> self
+    def errors: () -> Errors
+    def validate!: () -> self
+
+    private
+
+    def valid_format?: () -> bool
+    def error_codes: () -> Array[Symbol]
+    def detect_errors: () -> Array[Symbol]
+    def valid_length?: () -> bool
+    def valid_characters?: () -> bool
+    def check_digit_width: () -> Integer
+    def validation_message: (Symbol code) -> String?
+    def build_error: (Symbol code, String? message) -> Errors::detail
+
+    @errors: Errors
+  end
+end

data/sig/sec_id/cusip.rbs

@@ -0,0 +1,29 @@
+module SecID
+  # Committee on Uniform Securities Identification Procedures (CUSIP).
+  class CUSIP < Base
+    include Checkable
+    extend Checkable::ClassMethods
+
+    FULL_NAME: String
+    ID_LENGTH: Integer
+    EXAMPLE: String
+    VALID_CHARS_REGEX: ::Regexp
+    ID_REGEX: ::Regexp
+
+    # `#cins?` indexes `cusip6[0]` (nilable even for a non-nil String); typed loosely.
+    attr_reader cusip6: untyped
+    attr_reader issue: String?
+
+    def initialize: (SecID::input cusip) -> void
+    def to_pretty_s: () -> String?
+    def calculate_check_digit: () -> Integer
+    def self.check_digit: (SecID::input id) -> Integer
+    private def self.generate_body: (Random random) -> String
+    def to_isin: (String country_code) -> ISIN
+    def cins?: () -> bool
+
+    private
+
+    def components: () -> Hash[Symbol, untyped]
+  end
+end

data/sig/sec_id/deep_freeze.rbs

@@ -0,0 +1,6 @@
+module SecID
+  # Recursively freezes a nested structure of Hashes and Arrays and returns it.
+  module DeepFreeze
+    def self.call: (untyped object) -> untyped
+  end
+end

data/sig/sec_id/detector.rbs

@@ -0,0 +1,35 @@
+module SecID
+  # Detects which identifier types match a given string.
+  #
+  # @api private
+  class Detector
+    type priority = Array[Integer | Float | nil]
+
+    def initialize: (Array[singleton(Base)] identifier_list) -> void
+    def call: (SecID::input str) -> Array[Symbol]
+    def matches?: (SecID::input str) -> bool
+    def first_match: (SecID::input str) -> Base?
+
+    private
+
+    def filter_candidates: (String upcased) -> Array[singleton(Base)]
+    def validate_and_sort: (String input, Array[untyped] candidates) -> Array[Symbol]
+    def precompute: () -> void
+    def build_discriminator_sets: () -> void
+    def build_length_table: () -> void
+    def build_priority_table: () -> void
+    def build_key_table: () -> void
+    def stage1_special_chars: (String upcased) -> Array[singleton(Base)]?
+    def stage2_length: (Integer length) -> Array[singleton(Base)]
+    def stage3_charset: (String upcased, Array[singleton(Base)] candidates) -> Array[singleton(Base)]
+    def accepts_char?: (singleton(Base) klass, String char) -> bool
+
+    @classes: Array[singleton(Base)]
+    @slash_types: Array[singleton(Base)]
+    @space_only_types: Array[singleton(Base)]
+    @special_types: Array[singleton(Base)]
+    @candidates_by_length: Hash[Integer, Array[singleton(Base)]]
+    @priority_for: Hash[singleton(Base), priority]
+    @key_for: Hash[singleton(Base), Symbol]
+  end
+end

data/sig/sec_id/dti.rbs

@@ -0,0 +1,27 @@
+module SecID
+  # Digital Token Identifier (DTI, ISO 24165).
+  class DTI < Base
+    include Checkable
+    extend Checkable::ClassMethods
+
+    FULL_NAME: String
+    ID_LENGTH: Integer
+    EXAMPLE: String
+    VALID_CHARS_REGEX: ::Regexp
+    ID_REGEX: ::Regexp
+    ALPHABET: Array[String]
+    ALPHABET_VALUE: Hash[String, Integer]
+    GENERATE_CHARSET: Array[String]
+    GRANDFATHERED_CODES: Hash[String, String]
+
+    def initialize: (SecID::input dti) -> void
+    def calculate_check_digit: () -> String
+    private def self.generate_body: (Random random) -> String
+
+    private
+
+    def components: () -> Hash[Symbol, untyped]
+    def grandfathered_check_digit: (untyped base) -> String?
+    def iso7064_mod31_30_check_char: (untyped base) -> String
+  end
+end

data/sig/sec_id/errors.rbs

@@ -0,0 +1,28 @@
+module SecID
+  # Immutable value object representing validation errors for an identifier.
+  class Errors
+    # A single error entry. `{ error:, message: }` in the source, but `Hash#freeze`
+    # in `build_error` widens the record literal, so it is modelled as a Hash.
+    type detail = Hash[Symbol, untyped]
+
+    attr_reader details: Array[detail]
+
+    def initialize: (Array[detail] errors) -> void
+
+    def messages: () -> Array[String?]
+
+    def any?: () -> bool
+
+    def empty?: () -> bool
+
+    alias none? empty?
+
+    def size: () -> Integer
+
+    def each: () { (detail) -> void } -> Array[detail]
+
+    def to_a: () -> Array[String?]
+
+    def as_json: (*untyped) -> Array[detail]
+  end
+end

data/sig/sec_id/figi.rbs

@@ -0,0 +1,31 @@
+module SecID
+  # Financial Instrument Global Identifier (FIGI).
+  class FIGI < Base
+    include Checkable
+    extend Checkable::ClassMethods
+
+    FULL_NAME: String
+    ID_LENGTH: Integer
+    EXAMPLE: String
+    VALID_CHARS_REGEX: ::Regexp
+    ID_REGEX: ::Regexp
+    RESTRICTED_PREFIXES: Set[String]
+    GENERATE_CHARSET: Array[String]
+
+    attr_reader prefix: String?
+    attr_reader random_part: String?
+
+    def initialize: (SecID::input figi) -> void
+    def to_pretty_s: () -> String?
+    def calculate_check_digit: () -> Integer
+    def self.check_digit: (SecID::input id) -> Integer
+    private def self.generate_body: (Random random) -> String
+
+    private
+
+    def components: () -> Hash[Symbol, untyped]
+    def valid_format?: () -> bool
+    def detect_errors: () -> Array[Symbol]
+    def validation_message: (Symbol code) -> String?
+  end
+end

data/sig/sec_id/fisn.rbs

@@ -0,0 +1,24 @@
+module SecID
+  # Financial Instrument Short Name (FISN).
+  class FISN < Base
+    FULL_NAME: String
+    ID_LENGTH: ::Range[Integer]
+    EXAMPLE: String
+    VALID_CHARS_REGEX: ::Regexp
+    SEPARATORS: ::Regexp
+    ID_REGEX: ::Regexp
+    FISN_CHARSET: Array[String]
+
+    attr_reader issuer: String?
+    attr_reader description: String?
+
+    def initialize: (SecID::input fisn) -> void
+    def to_s: () -> String
+    private def self.generate_body: (Random random) -> String
+    private def self.generate_part: (Integer length, Random random) -> String
+
+    private
+
+    def components: () -> Hash[Symbol, untyped]
+  end
+end

data/sig/sec_id/iban/country_rules.rbs

@@ -0,0 +1,10 @@
+module SecID
+  class IBAN < Base
+    # `{ length: Integer, format: Regexp, components?: {name => [start, length]} }`, but
+    # the nested literal infers as a broad Hash, so it is modelled loosely.
+    type rule = Hash[Symbol, untyped]
+
+    COUNTRY_RULES: Hash[String, rule]
+    LENGTH_ONLY_COUNTRIES: Hash[String, Integer]
+  end
+end

data/sig/sec_id/iban.rbs

@@ -0,0 +1,54 @@
+module SecID
+  # International Bank Account Number (IBAN).
+  class IBAN < Base
+    include Checkable
+    extend Checkable::ClassMethods
+
+    FULL_NAME: String
+    ID_LENGTH: ::Range[Integer]
+    EXAMPLE: String
+    VALID_CHARS_REGEX: ::Regexp
+    ID_REGEX: ::Regexp
+    NUMERIC_COUNTRY_RULES: Array[[String, rule]]
+
+    def self.supported_countries: () -> Array[String]
+
+    # country_code/bban are used unguarded after validation; typed loosely so static
+    # Steep and runtime RBS::Test (which sees nil for invalid) agree.
+    attr_reader country_code: untyped
+    attr_reader bban: untyped
+    # Optional BBAN components; typed loosely so `#components` (which conditionally
+    # assigns them into an inferred hash) type-checks.
+    attr_reader bank_code: untyped
+    attr_reader branch_code: untyped
+    attr_reader account_number: untyped
+    attr_reader national_check: untyped
+
+    def initialize: (SecID::input iban) -> void
+    def restore: () -> String
+    def calculate_check_digit: () -> Integer
+    def self.check_digit: (SecID::input id) -> Integer
+    private def self.generate_body: (Random random) -> String
+    def valid_bban_format?: () -> bool
+    def country_rule: () -> rule?
+    def known_country?: () -> bool
+    def to_s: () -> String
+    def to_pretty_s: () -> String?
+
+    private
+
+    def components: () -> Hash[Symbol, untyped]
+    def check_digit_width: () -> Integer
+    def valid_format?: () -> bool
+    def detect_errors: () -> Array[Symbol]
+    def validation_message: (Symbol code) -> String?
+    def extract_check_digit_and_bban: (String rest) -> void
+    def expected_bban_length_for_country: () -> Integer?
+    def check_digits?: (untyped rest, Integer? expected_bban_length) -> bool
+    def extract_bban_components: () -> void
+    def valid_bban_length_only?: () -> bool
+    def numeric_string_for_check: () -> String
+
+    self.@supported_countries: Array[String]
+  end
+end

data/sig/sec_id/isin.rbs

@@ -0,0 +1,40 @@
+module SecID
+  # International Securities Identification Number (ISIN).
+  class ISIN < Base
+    include Checkable
+    extend Checkable::ClassMethods
+
+    FULL_NAME: String
+    ID_LENGTH: Integer
+    EXAMPLE: String
+    VALID_CHARS_REGEX: ::Regexp
+    ID_REGEX: ::Regexp
+    CGS_COUNTRY_CODES: Set[String]
+    NSIN_COUNTRY_TYPES: Hash[String, Symbol]
+
+    # Used unguarded as non-nil after validation (indexed/looked-up); typed loosely
+    # so both static Steep and runtime RBS::Test (which sees nil for invalid) agree.
+    attr_reader country_code: untyped
+    attr_reader nsin: untyped
+
+    def initialize: (SecID::input isin) -> void
+    def to_pretty_s: () -> String?
+    def calculate_check_digit: () -> Integer
+    def self.check_digit: (SecID::input id) -> Integer
+    private def self.generate_body: (Random random) -> String
+    def to_cusip: () -> CUSIP
+    def cgs?: () -> bool
+    def sedol?: () -> bool
+    def wkn?: () -> bool
+    def valoren?: () -> bool
+    def to_sedol: () -> SEDOL
+    def to_wkn: () -> WKN
+    def to_valoren: () -> Valoren
+    def nsin_type: () -> Symbol
+    def to_nsin: () -> (CUSIP | SEDOL | WKN | Valoren | String | nil)
+
+    private
+
+    def components: () -> Hash[Symbol, untyped]
+  end
+end

data/sig/sec_id/lei.rbs

@@ -0,0 +1,33 @@
+module SecID
+  # Legal Entity Identifier (LEI).
+  class LEI < Base
+    include Checkable
+    extend Checkable::ClassMethods
+
+    FULL_NAME: String
+    ID_LENGTH: Integer
+    EXAMPLE: String
+    VALID_CHARS_REGEX: ::Regexp
+    ID_REGEX: ::Regexp
+
+    attr_reader lou_id: String?
+    attr_reader reserved: String?
+    attr_reader entity_id: String?
+
+    # Used unguarded after validation (`#numeric_identifier`); typed loosely so static
+    # Steep and runtime RBS::Test (which sees nil for invalid) agree.
+    def identifier: () -> untyped
+
+    def initialize: (SecID::input lei) -> void
+    def to_pretty_s: () -> String?
+    def calculate_check_digit: () -> Integer
+    def self.check_digit: (SecID::input id) -> Integer
+    private def self.generate_body: (Random random) -> String
+
+    private
+
+    def components: () -> Hash[Symbol, untyped]
+    def check_digit_width: () -> Integer
+    def numeric_identifier: () -> String
+  end
+end

data/sig/sec_id/occ.rbs

@@ -0,0 +1,45 @@
+module SecID
+  # OCC Option Symbol.
+  class OCC < Base
+    FULL_NAME: String
+    ID_LENGTH: ::Range[Integer]
+    EXAMPLE: String
+    VALID_CHARS_REGEX: ::Regexp
+    SEPARATORS: ::Regexp
+    ID_REGEX: ::Regexp
+
+    # Used unguarded as non-nil after validation; typed loosely so static Steep and
+    # runtime RBS::Test (which sees nil for invalid) agree.
+    attr_reader underlying: untyped
+    attr_reader date_str: untyped
+    attr_reader type: untyped
+    attr_reader strike_mills: untyped
+
+    def self.generate: (?random: Random) -> OCC
+    # build/compose accept any Numeric strike (e.g. Rational) and a String or Symbol type.
+    def self.build: (underlying: untyped, date: String | Date, type: untyped, strike: Integer | Float | Rational | String) -> OCC
+    def self.compose_symbol: (untyped underlying, untyped date_str, untyped type, untyped strike_mills) -> String
+
+    def initialize: (SecID::input symbol) -> void
+    def normalized: () -> String
+    def valid?: () -> bool
+    def date: () -> Date?
+    alias date_obj date
+    def strike: () -> Float?
+    def to_s: () -> String
+    def to_pretty_s: () -> String?
+
+    private
+
+    # `Integer | Float | Rational` (not `Numeric`, which lacks `#*` in RBS) so the
+    # `when Numeric then strike * 1000` branch type-checks; String is the 8-digit form.
+    def self.normalize_strike_mills: (Integer | Float | Rational | String strike) -> String
+
+    def components: () -> Hash[Symbol, untyped]
+    def error_codes: () -> Array[Symbol]
+    def validation_message: (Symbol code) -> String?
+
+    @date: Date?
+    @strike: Float?
+  end
+end