sec_id 5.2.0 → 6.1.0

data/sig/sec_id/detector.rbs

@@ -0,0 +1,29 @@
+module SecID
+  # Detects which identifier types match a given string.
+  #
+  # @api private
+  class Detector
+    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 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)]]
+  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

data/sig/sec_id/scanner.rbs

@@ -0,0 +1,44 @@
+module SecID
+  # Immutable value object representing a matched identifier found in text.
+  class Match < Data
+    attr_reader type: Symbol
+    attr_reader raw: String
+    attr_reader range: Range[Integer]
+    attr_reader identifier: Base
+
+    def self.new: (type: Symbol, raw: String, range: Range[Integer], identifier: Base) -> instance
+                | (Symbol type, String raw, Range[Integer] range, Base identifier) -> instance
+    def self.[]: (type: Symbol, raw: String, range: Range[Integer], identifier: Base) -> instance
+               | (Symbol type, String raw, Range[Integer] range, Base identifier) -> instance
+  end
+
+  # Finds securities identifiers in freeform text.
+  #
+  # @api private
+  class Scanner
+    # Regex plumbing works with nilable MatchData throughout; typed `untyped` so the
+    # nil-unguarded capture access in the internal helpers stays free of noise.
+    CANDIDATE_RE: untyped
+
+    def initialize: (Array[singleton(Base)] identifier_list) -> void
+    def call: (String? text, ?classes: Array[singleton(Base)]?) { (Match) -> void } -> void
+            | (String? text, ?classes: Array[singleton(Base)]?) -> Enumerator[Match, void]
+            | (String? text, ?classes: Array[singleton(Base)]?) ?{ (Match) -> void } -> Enumerator[Match, void]?
+
+    private
+
+    def precompute: () -> void
+    def build_candidate_partitions: () -> void
+    def build_length_table: () -> void
+    def scan_text: (String input, Array[singleton(Base)] target_classes) { (Match) -> void } -> void
+    def identify_candidate: (untyped match_data, Array[singleton(Base)] target_classes) -> Match?
+    def try_classes: (String raw, String cleaned, Integer start_pos, Array[singleton(Base)] classes) -> Match?
+    def best_match: (String cleaned, Array[singleton(Base)] classes) -> singleton(Base)?
+
+    @classes: Array[singleton(Base)]
+    @fisn_classes: Array[singleton(Base)]
+    @occ_classes: Array[singleton(Base)]
+    @simple_classes: Array[singleton(Base)]
+    @candidates_by_length: Hash[Integer, Array[singleton(Base)]]
+  end
+end

data/sig/sec_id/sedol.rbs

@@ -0,0 +1,34 @@
+module SecID
+  # Stock Exchange Daily Official List (SEDOL).
+  class SEDOL < Base
+    include Checkable
+    extend Checkable::ClassMethods
+
+    FULL_NAME: String
+    ID_LENGTH: Integer
+    EXAMPLE: String
+    VALID_CHARS_REGEX: ::Regexp
+    ID_REGEX: ::Regexp
+    CHARACTER_WEIGHTS: Array[Integer]
+    GENERATE_CHARSET: Array[String]
+    ISIN_COUNTRY_CODES: Set[String]
+
+    # Used unguarded as non-nil after validation (`#id_digits`); typed loosely so static
+    # Steep and runtime RBS::Test (which sees nil for invalid) agree.
+    def identifier: () -> untyped
+
+    def initialize: (SecID::input sedol) -> void
+    def to_isin: (?String country_code) -> ISIN
+    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 weighted_sum: () -> Integer
+    def id_digits: () -> Array[Integer]
+
+    @id_digits: Array[Integer]
+  end
+end

data/sig/sec_id/valoren.rbs

@@ -0,0 +1,29 @@
+module SecID
+  class Valoren < 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
+    ISIN_COUNTRY_CODES: Set[String]
+
+    attr_reader padding: String?
+
+    # Used unguarded after validation (`#normalized`/`#to_pretty_s`); typed loosely so
+    # static Steep and runtime RBS::Test (which sees nil for invalid) agree.
+    def identifier: () -> untyped
+
+    def initialize: (SecID::input valoren) -> void
+    def to_pretty_s: () -> String?
+    def to_isin: (?String country_code) -> ISIN
+    def normalized: () -> String
+    def normalize!: () -> self
+    def to_s: () -> String
+    private def self.generate_body: (Random random) -> String
+
+    private
+
+    def components: () -> Hash[Symbol, untyped]
+  end
+end

data/sig/sec_id/version.rbs

@@ -0,0 +1,3 @@
+module SecID
+  VERSION: String
+end

data/sig/sec_id/wkn.rbs

@@ -0,0 +1,15 @@
+module SecID
+  # Wertpapierkennnummer (WKN).
+  class WKN < Base
+    FULL_NAME: String
+    ID_LENGTH: Integer
+    EXAMPLE: String
+    VALID_CHARS_REGEX: ::Regexp
+    ID_REGEX: ::Regexp
+    GENERATE_CHARSET: Array[String]
+
+    def initialize: (SecID::input wkn) -> void
+    def to_isin: (?String country_code) -> ISIN
+    private def self.generate_body: (Random random) -> String
+  end
+end

data/sig/sec_id.rbs

@@ -0,0 +1,58 @@
+module SecID
+  # Base error class for all SecID errors.
+  class Error < StandardError
+  end
+
+  # Raised for invalid format, length, or characters.
+  class InvalidFormatError < Error
+  end
+
+  # Raised when the check digit does not match the calculated value.
+  class InvalidCheckDigitError < Error
+  end
+
+  # Raised for type-specific structural errors.
+  class InvalidStructureError < Error
+  end
+
+  # Raised when multiple identifier types match and on_ambiguous: :raise is used.
+  class AmbiguousMatchError < Error
+  end
+
+  def self.[]: (Symbol key) -> singleton(Base)
+  def self.identifiers: () -> Array[singleton(Base)]
+  def self.detect: (SecID::input str) -> Array[Symbol]
+  def self.valid?: (SecID::input str, ?types: Array[Symbol]?) -> bool
+  def self.extract: (String? text, ?types: Array[Symbol]?) -> Array[Match]
+  def self.scan: (String? text, ?types: Array[Symbol]?) { (Match) -> void } -> void
+               | (String? text, ?types: Array[Symbol]?) -> Enumerator[Match, void]
+  def self.explain: (SecID::input str, ?types: Array[Symbol]?) -> Hash[Symbol, untyped]
+  def self.parse: (SecID::input str, ?types: Array[Symbol]?, on_ambiguous: :all) -> Array[Base]
+                | (SecID::input str, ?types: Array[Symbol]?, ?on_ambiguous: (:first | :raise)) -> Base?
+                | (SecID::input str, ?types: Array[Symbol]?, ?on_ambiguous: Symbol) -> untyped
+  # Single broad return, not per-`on_ambiguous` overloads: the shared `parse!` body calls
+  # `result.empty?` on the `:all` path, so precise overloads would make Steep check `.empty?`
+  # against the `:first`/`:raise` arm's `Base?` and fail. Widening here keeps `result` untyped.
+  def self.parse!: (SecID::input str, ?types: Array[Symbol]?, ?on_ambiguous: Symbol) -> (Base | Array[Base])
+  def self.generate: (Symbol key, ?random: Random) -> Base
+
+  # Singleton-method privacy must be declared inline (`private def self.…`); a bare
+  # `private` section only affects instance methods, leaving these public.
+  private def self.register_identifier: (singleton(Base) klass) -> void
+  private def self.parse_any: (SecID::input str) -> Base?
+  private def self.parse_from: (SecID::input str, Array[Symbol] types) -> Base?
+  private def self.parse_strict: (SecID::input str, Array[Symbol]? types) -> Base?
+  private def self.parse_all: (SecID::input str, Array[Symbol]? types) -> Array[Base]
+  private def self.resolve_candidates: (SecID::input str, Array[Symbol]? types) -> Array[Symbol]
+  private def self.ambiguous_message: (SecID::input str, Array[Symbol] candidates) -> String
+  private def self.parse_error_message: (SecID::input str, Array[Symbol]? types) -> String
+  private def self.detector: () -> Detector
+  private def self.scanner: () -> Scanner
+  private def self.identifier_map: () -> Hash[Symbol, singleton(Base)]
+  private def self.identifier_list: () -> Array[singleton(Base)]
+
+  self.@identifier_map: Hash[Symbol, singleton(Base)]
+  self.@identifier_list: Array[singleton(Base)]
+  self.@detector: Detector?
+  self.@scanner: Scanner?
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sec_id
 version: !ruby/object:Gem::Version
-  version: 5.2.0
+  version: 6.1.0
 platform: ruby
 authors:
 - Leonid Svyatov
@@ -9,30 +9,43 @@ bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
-description: Validate, normalize, parse, and convert securities identifiers. Auto-detect
-  identifier type from any string. Calculate and restore check digits. Supports ISIN,
-  CUSIP, CEI, SEDOL, FIGI, LEI, IBAN, CIK, OCC, WKN, Valoren, CFI, and FISN.
+description: Validate, normalize, parse, convert, generate, and classify securities
+  identifiers. Auto-detect identifier type from any string. Calculate and restore
+  check digits. Generate format-valid identifiers as test fixtures. Decode CFI codes
+  to full ISO 10962:2021 classifications. Includes an opt-in ActiveModel/Rails validator
+  that adds no runtime dependency. Supports ISIN, CUSIP, CEI, SEDOL, FIGI, LEI, IBAN,
+  CIK, OCC, WKN, Valoren, CFI, FISN, BIC, and DTI.
 email:
 - leonid@svyatov.ru
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".yardopts"
 - CHANGELOG.md
 - LICENSE.txt
 - MIGRATION.md
 - README.md
 - lib/sec_id.rb
+- lib/sec_id/active_model.rb
 - lib/sec_id/base.rb
+- lib/sec_id/bic.rb
+- lib/sec_id/bic/country_codes.rb
 - lib/sec_id/cei.rb
 - lib/sec_id/cfi.rb
+- lib/sec_id/cfi/attribute_set.rb
+- lib/sec_id/cfi/classification.rb
+- lib/sec_id/cfi/field.rb
+- lib/sec_id/cfi/tables.rb
 - lib/sec_id/cik.rb
 - lib/sec_id/concerns/checkable.rb
-- lib/sec_id/concerns/identifier_metadata.rb
+- lib/sec_id/concerns/generatable.rb
 - lib/sec_id/concerns/normalizable.rb
 - lib/sec_id/concerns/validatable.rb
 - lib/sec_id/cusip.rb
+- lib/sec_id/deep_freeze.rb
 - lib/sec_id/detector.rb
+- lib/sec_id/dti.rb
 - lib/sec_id/errors.rb
 - lib/sec_id/figi.rb
 - lib/sec_id/fisn.rb
@@ -41,17 +54,52 @@ files:
 - lib/sec_id/isin.rb
 - lib/sec_id/lei.rb
 - lib/sec_id/occ.rb
+- lib/sec_id/railtie.rb
 - lib/sec_id/scanner.rb
 - lib/sec_id/sedol.rb
 - lib/sec_id/valoren.rb
 - lib/sec_id/version.rb
 - lib/sec_id/wkn.rb
 - sec_id.gemspec
+- sig/manifest.yaml
+- sig/sec_id.rbs
+- sig/sec_id/base.rbs
+- sig/sec_id/bic.rbs
+- sig/sec_id/bic/country_codes.rbs
+- sig/sec_id/cei.rbs
+- sig/sec_id/cfi.rbs
+- sig/sec_id/cfi/attribute_set.rbs
+- sig/sec_id/cfi/classification.rbs
+- sig/sec_id/cfi/field.rbs
+- sig/sec_id/cfi/tables.rbs
+- sig/sec_id/cik.rbs
+- sig/sec_id/concerns/checkable.rbs
+- sig/sec_id/concerns/generatable.rbs
+- sig/sec_id/concerns/normalizable.rbs
+- sig/sec_id/concerns/validatable.rbs
+- sig/sec_id/cusip.rbs
+- sig/sec_id/deep_freeze.rbs
+- sig/sec_id/detector.rbs
+- sig/sec_id/dti.rbs
+- sig/sec_id/errors.rbs
+- sig/sec_id/figi.rbs
+- sig/sec_id/fisn.rbs
+- sig/sec_id/iban.rbs
+- sig/sec_id/iban/country_rules.rbs
+- sig/sec_id/isin.rbs
+- sig/sec_id/lei.rbs
+- sig/sec_id/occ.rbs
+- sig/sec_id/scanner.rbs
+- sig/sec_id/sedol.rbs
+- sig/sec_id/valoren.rbs
+- sig/sec_id/version.rbs
+- sig/sec_id/wkn.rbs
 homepage: https://github.com/svyatov/sec_id
 licenses:
 - MIT
 metadata:
   rubygems_mfa_required: 'true'
+  documentation_uri: https://rubydoc.info/gems/sec_id
   source_code_uri: https://github.com/svyatov/sec_id
   changelog_uri: https://github.com/svyatov/sec_id/blob/main/CHANGELOG.md
   bug_tracker_uri: https://github.com/svyatov/sec_id/issues
@@ -69,8 +117,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 4.0.12
 specification_version: 4
 summary: A Ruby toolkit for securities identifiers — validate, parse, normalize, detect,
-  and convert.
+  convert, generate, and classify.
 test_files: []