sec_id 5.2.0 → 6.0.0

data/lib/sec_id.rb

@@ -2,6 +2,11 @@
 
 require 'sec_id/version'
 
+# Toolkit for securities identifiers — validate, normalize, parse, detect, convert,
+# generate, and classify ISIN, CUSIP, CEI, SEDOL, FIGI, LEI, IBAN, CIK, OCC, WKN,
+# Valoren, CFI, FISN, BIC, and DTI.
+#
+# @see https://github.com/svyatov/sec_id
 module SecID
   # Base error class for all SecID errors.
   class Error < StandardError; end
@@ -52,7 +57,7 @@ module SecID
     # @return [Boolean]
     # @raise [ArgumentError] if any key in types is unknown
     def valid?(str, types: nil)
-      return detect(str).any? if types.nil?
+      return detector.matches?(str) if types.nil?
 
       types.any? { |key| self[key].valid?(str) }
     end
@@ -120,6 +125,20 @@ module SecID
       result || raise(InvalidFormatError, parse_error_message(str, types))
     end
 
+    # Generates a new, format-valid identifier instance of the given type.
+    #
+    # @note Generated identifiers are valid in format only — they are not real,
+    #   registered securities.
+    #
+    # @param key [Symbol] identifier type (e.g. :isin, :cusip)
+    # @param random [Random] seedable source for reproducible output
+    # @return [SecID::Base] a generated, format-valid instance of the type mapped to `key`
+    #   (e.g. {SecID::ISIN} for `:isin`)
+    # @raise [ArgumentError] if key is unknown
+    def generate(key, random: Random.new)
+      self[key].generate(random: random)
+    end
+
     private
 
     # @return [void]
@@ -132,8 +151,7 @@ module SecID
     end
 
     def parse_any(str)
-      key = detect(str).first
-      key && self[key].new(str)
+      detector.first_match(str)
     end
 
     def parse_from(str, types)
@@ -178,11 +196,12 @@ module SecID
   end
 end
 
+require 'sec_id/deep_freeze'
 require 'sec_id/errors'
-require 'sec_id/concerns/identifier_metadata'
 require 'sec_id/concerns/normalizable'
 require 'sec_id/concerns/validatable'
 require 'sec_id/concerns/checkable'
+require 'sec_id/concerns/generatable'
 require 'sec_id/base'
 require 'sec_id/detector'
 require 'sec_id/scanner'
@@ -199,3 +218,9 @@ require 'sec_id/valoren'
 require 'sec_id/cei'
 require 'sec_id/cfi'
 require 'sec_id/fisn'
+require 'sec_id/bic'
+require 'sec_id/dti'
+
+# Auto-activate the ActiveModel validator inside Rails; a no-op everywhere else (keeps the
+# default require zero-dependency). See SecID::Railtie and lib/sec_id/active_model.rb.
+require 'sec_id/railtie' if defined?(Rails::Railtie)

data/sec_id.gemspec

@@ -10,19 +10,25 @@ Gem::Specification.new do |spec|
   spec.authors       = ['Leonid Svyatov']
   spec.email         = ['leonid@svyatov.ru']
 
-  spec.summary       = 'A Ruby toolkit for securities identifiers — validate, parse, normalize, detect, and convert.'
-  spec.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.'
+  spec.summary       = 'A Ruby toolkit for securities identifiers — validate, parse, normalize, detect, convert, ' \
+                       'generate, and classify.'
+  spec.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.'
   spec.homepage      = 'https://github.com/svyatov/sec_id'
   spec.license       = 'MIT'
 
   spec.required_ruby_version = '>= 3.2.0'
 
   spec.require_paths = ['lib']
-  spec.files = Dir['lib/**/*.rb'] + %w[CHANGELOG.md LICENSE.txt MIGRATION.md README.md sec_id.gemspec]
+  spec.files = Dir['lib/**/*.rb'] + Dir['sig/**/*'] +
+               %w[.yardopts CHANGELOG.md LICENSE.txt MIGRATION.md README.md sec_id.gemspec]
 
   spec.metadata['rubygems_mfa_required'] = 'true'
+  spec.metadata['documentation_uri'] = 'https://rubydoc.info/gems/sec_id'
   spec.metadata['source_code_uri'] = 'https://github.com/svyatov/sec_id'
   spec.metadata['changelog_uri'] = 'https://github.com/svyatov/sec_id/blob/main/CHANGELOG.md'
   spec.metadata['bug_tracker_uri'] = 'https://github.com/svyatov/sec_id/issues'

data/sig/manifest.yaml

@@ -0,0 +1,8 @@
+# Standard-library signatures these RBS files reference. Consumers' RBS/Steep
+# load these automatically when they depend on sec_id. (The gem has no runtime
+# gem dependencies, so none are auto-derived from the gemspec.)
+#
+# Set (ISIN, SEDOL, FIGI, Valoren, BIC) is a core class in rbs 4.0 — always
+# loaded, so it needs no manifest entry.
+dependencies:
+  - name: date  # Date in OCC

data/sig/sec_id/base.rbs

@@ -0,0 +1,72 @@
+module SecID
+  # Accepted raw input for parsing/validating an identifier: a String, an Integer
+  # (Valoren/CIK/CUSIP accept numeric input), or nil.
+  type input = String | Integer | nil
+
+  # The class-object surface the concern ClassMethods modules call through `self`
+  # once extended onto an identifier class (they construct instances via `new`).
+  interface _IdentifierClass
+    def new: (SecID::input) -> Base
+  end
+
+  # Base class for securities identifiers, providing a common interface for
+  # validation, normalization, parsing, and generation.
+  class Base
+    include Normalizable
+    include Validatable
+    include Generatable
+    extend Normalizable::ClassMethods
+    extend Validatable::ClassMethods
+    extend Generatable::ClassMethods
+
+    # Metadata constants each subclass overrides with its concrete shape. Declared
+    # here (as the widest shape) so the shared concern method bodies type-check.
+    FULL_NAME: String
+    ID_LENGTH: Integer | ::Range[Integer] | ::Array[Integer]
+    EXAMPLE: String
+    VALID_CHARS_REGEX: ::Regexp
+    ID_REGEX: ::Regexp
+
+    attr_reader full_id: String
+    # Reader is nilable (nil for invalid input, checked by `valid_format?`); the ivar is
+    # typed `untyped` because subclasses use `@identifier` as non-nil after validation and
+    # RBS forbids narrowing an inherited ivar's type.
+    def identifier: () -> String?
+
+    def self.short_name: () -> String
+    def self.full_name: () -> String
+    def self.id_length: () -> (Integer | ::Range[Integer] | ::Array[Integer])
+    def self.length_values: () -> (::Array[Integer] | ::Range[Integer])
+    def self.length_specificity: () -> (Integer | Float | nil)
+    def self.example: () -> String
+    def self.has_check_digit?: () -> bool
+    def self.inherited: (singleton(Base) subclass) -> void
+
+    def initialize: (SecID::input _sec_id_number) -> void
+
+    def ==: (Base other) -> bool
+    alias eql? ==
+    def hash: () -> Integer
+    def to_h: () -> Hash[Symbol, untyped]
+    def as_json: (*untyped) -> Hash[Symbol, untyped]
+
+    # Check-digit surface. Only the types that `include Checkable` implement these
+    # (they raise/NoMethodError otherwise); declared on Base so `Generatable#generate`
+    # and `Checkable::ClassMethods` type-check without narrowing on `has_check_digit?`.
+    def restore: () -> String
+    def restore!: () -> self
+    def calculate_check_digit: () -> (Integer | String)
+
+    def comparison_id: () -> String
+
+    private
+
+    def components: () -> Hash[Symbol, untyped]
+    def parse: (SecID::input sec_id_number) -> (::MatchData | ::Hash[Symbol, untyped])
+
+    @full_id: String
+    @identifier: untyped
+    self.@short_name: String
+    self.@has_check_digit: bool
+  end
+end

data/sig/sec_id/bic/country_codes.rbs

@@ -0,0 +1,5 @@
+module SecID
+  class BIC < Base
+    COUNTRY_CODES: Set[String]
+  end
+end

data/sig/sec_id/bic.rbs

@@ -0,0 +1,30 @@
+module SecID
+  # Business Identifier Code (BIC / SWIFT code).
+  class BIC < Base
+    FULL_NAME: String
+    ID_LENGTH: Array[Integer]
+    EXAMPLE: String
+    VALID_CHARS_REGEX: ::Regexp
+    ID_REGEX: ::Regexp
+
+    def self.countries: () -> Array[String]
+
+    attr_reader bank_code: String?
+    attr_reader country_code: String?
+    attr_reader location_code: String?
+    attr_reader branch_code: String?
+
+    def initialize: (SecID::input bic) -> void
+    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?
+    def recognized_country?: () -> bool
+
+    self.@countries: Array[String]
+  end
+end

data/sig/sec_id/cei.rbs

@@ -0,0 +1,26 @@
+module SecID
+  # CUSIP Entity Identifier (CEI).
+  class CEI < Base
+    include Checkable
+    extend Checkable::ClassMethods
+
+    FULL_NAME: String
+    ID_LENGTH: Integer
+    EXAMPLE: String
+    VALID_CHARS_REGEX: ::Regexp
+    ID_REGEX: ::Regexp
+
+    attr_reader prefix: String?
+    attr_reader numeric: String?
+    attr_reader entity_id: String?
+
+    def initialize: (SecID::input cei) -> void
+    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]
+  end
+end

data/sig/sec_id/cfi/attribute_set.rbs

@@ -0,0 +1,68 @@
+# Generated by `rake sig:cfi` from SecID::CFI::Tables. Do not edit by hand.
+module SecID
+  class CFI < Base
+    # The ordered collection of decoded attribute Fields.
+    class AttributeSet
+      include Enumerable[Field]
+
+      # `fields` is typed `untyped` because `#initialize` calls
+      # `define_singleton_method(field.meaning)` and `field.meaning` is nilable.
+      def initialize: (untyped fields) -> void
+      def each: () { (Field) -> void } -> self
+              | () -> Enumerator[Field, self]
+      def []: (Symbol meaning) -> Field?
+      def empty?: () -> bool
+      def to_h: () -> Hash[untyped, untyped]
+      def as_json: (*untyped) -> Hash[Symbol, untyped]
+
+      # Per-meaning readers — the union of every attribute meaning. Each instance
+      # only answers the meanings actually present; an absent one raises
+      # NoMethodError at runtime. Use #[] for the presence-uncertain path.
+      def asset_class: () -> Field
+      def assets: () -> Field
+      def barrier_dependency: () -> Field
+      def calculation_frequency: () -> Field
+      def call_put: () -> Field
+      def closed_open: () -> Field
+      def components: () -> Field
+      def composition: () -> Field
+      def currency: () -> Field
+      def delivery: () -> Field
+      def distribution: () -> Field
+      def distribution_policy: () -> Field
+      def equity_type: () -> Field
+      def exercise_style: () -> Field
+      def form: () -> Field
+      def further_grouping: () -> Field
+      def guarantee: () -> Field
+      def income: () -> Field
+      def interest_rate_type: () -> Field
+      def interest_type: () -> Field
+      def investment_strategy: () -> Field
+      def issuer_type: () -> Field
+      def long_short: () -> Field
+      def notional: () -> Field
+      def option_style: () -> Field
+      def ownership_restrictions: () -> Field
+      def payment_status: () -> Field
+      def redemption: () -> Field
+      def repayment: () -> Field
+      def return_trigger: () -> Field
+      def return_type: () -> Field
+      def security_type: () -> Field
+      def standardized: () -> Field
+      def strategy_style: () -> Field
+      def termination: () -> Field
+      def type: () -> Field
+      def underlying: () -> Field
+      def underlying_assets: () -> Field
+      def underlying_fund_type: () -> Field
+      def valuation: () -> Field
+      def voting_right: () -> Field
+      def warrant_type: () -> Field
+      def weighting: () -> Field
+
+      @fields: Array[Field]
+    end
+  end
+end

data/sig/sec_id/cfi/classification.rbs

@@ -0,0 +1,23 @@
+module SecID
+  class CFI < Base
+    # The decoded ISO 10962:2021 classification of a valid CFI, built by {CFI#decode}.
+    class Classification
+      attr_reader category: Field
+      attr_reader group: Field
+      attr_reader attributes: AttributeSet
+
+      def initialize: (String category_code, String group_code, Array[String] letters) -> void
+      def to_s: () -> String
+      def to_h: () -> Hash[Symbol, untyped]
+      def as_json: (*untyped) -> Hash[Symbol, untyped]
+
+      private
+
+      def build_category: (String code) -> Field
+      def build_group: (String category_code, String code) -> Field
+      def build_attributes: (String category_code, String group_code, Array[String] letters) -> AttributeSet
+      def build_attribute: (untyped position, String letter) -> Field
+      def decode_value: (untyped value_map, String letter) -> [Symbol, String]
+    end
+  end
+end

data/sig/sec_id/cfi/field.rbs

@@ -0,0 +1,337 @@
+# Generated by `rake sig:cfi` from SecID::CFI::Tables. Do not edit by hand.
+module SecID
+  class CFI < Base
+    # A single decoded CFI position (category, group, or one attribute).
+    class Field
+      attr_reader code: String
+      attr_reader name: Symbol
+      attr_reader label: String
+      attr_reader meaning: Symbol?
+
+      def initialize: (String code, Symbol name, String label, Array[Symbol] domain, ?meaning: Symbol?) -> void
+      def to_s: () -> String
+      def to_h: () -> Hash[Symbol, untyped]
+      def as_json: (*untyped) -> Hash[Symbol, untyped]
+
+      # Per-domain predicates — the union of every symbol a Field may hold. Each
+      # instance only answers the symbols in its own domain; an out-of-domain call
+      # raises NoMethodError at runtime (RBS can't express per-instance domains).
+      def accreting?: () -> bool
+      def accumulation_funds?: () -> bool
+      def adjustable_rate?: () -> bool
+      def agriculture?: () -> bool
+      def allotment_rights?: () -> bool
+      def american?: () -> bool
+      def american_call?: () -> bool
+      def american_chooser?: () -> bool
+      def american_put?: () -> bool
+      def amortization_plan?: () -> bool
+      def amortization_with_call?: () -> bool
+      def amortization_with_put?: () -> bool
+      def amortization_with_put_and_call?: () -> bool
+      def amortizing?: () -> bool
+      def annually?: () -> bool
+      def arbitrage?: () -> bool
+      def asian?: () -> bool
+      def asset_backed?: () -> bool
+      def asset_backed_securities?: () -> bool
+      def asset_based_lending?: () -> bool
+      def auction?: () -> bool
+      def auction_rate?: () -> bool
+      def balanced_conservative?: () -> bool
+      def bank_loan?: () -> bool
+      def barrier?: () -> bool
+      def barrier_capital_protection?: () -> bool
+      def barrier_discount_certificate?: () -> bool
+      def barrier_instrument_based?: () -> bool
+      def barrier_reverse_convertible?: () -> bool
+      def barrier_underlying_based?: () -> bool
+      def basis_swap?: () -> bool
+      def basket?: () -> bool
+      def baskets?: () -> bool
+      def bearer?: () -> bool
+      def bearer_registered?: () -> bool
+      def bermudan?: () -> bool
+      def bermudan_call?: () -> bool
+      def bermudan_chooser?: () -> bool
+      def bermudan_put?: () -> bool
+      def bonds?: () -> bool
+      def bonds_with_warrants?: () -> bool
+      def bonus_certificate?: () -> bool
+      def bullion_coins?: () -> bool
+      def call?: () -> bool
+      def call_and_put?: () -> bool
+      def call_options?: () -> bool
+      def capital_protection_convertible?: () -> bool
+      def capital_protection_with_coupons?: () -> bool
+      def capital_protection_with_participation?: () -> bool
+      def capitalization_weighted?: () -> bool
+      def carbon_credit?: () -> bool
+      def cash?: () -> bool
+      def cash_collateral?: () -> bool
+      def cash_payment?: () -> bool
+      def cash_repayment?: () -> bool
+      def cds_basket?: () -> bool
+      def cds_index?: () -> bool
+      def cds_index_tranche?: () -> bool
+      def cds_single_name?: () -> bool
+      def certificate_of_deposit?: () -> bool
+      def closed_end?: () -> bool
+      def collective_investment_vehicles?: () -> bool
+      def combination_of_bonds?: () -> bool
+      def combination_of_shares?: () -> bool
+      def combined_instruments?: () -> bool
+      def commercial_property?: () -> bool
+      def commodities?: () -> bool
+      def commodities_futures?: () -> bool
+      def common_shares?: () -> bool
+      def constant?: () -> bool
+      def contract_for_difference?: () -> bool
+      def convertible?: () -> bool
+      def convertible_bonds?: () -> bool
+      def convertible_common_shares?: () -> bool
+      def convertible_preferred_shares?: () -> bool
+      def convertible_redeemable?: () -> bool
+      def convertible_securities?: () -> bool
+      def corporate?: () -> bool
+      def corporate_bonds?: () -> bool
+      def covered?: () -> bool
+      def credit?: () -> bool
+      def credit_default?: () -> bool
+      def credits?: () -> bool
+      def cross_currency?: () -> bool
+      def cumulative_fixed_rate?: () -> bool
+      def cumulative_participating?: () -> bool
+      def currencies?: () -> bool
+      def custom?: () -> bool
+      def daily?: () -> bool
+      def debt?: () -> bool
+      def debt_instruments?: () -> bool
+      def defined_benefit?: () -> bool
+      def defined_contribution?: () -> bool
+      def delivery_versus_payment?: () -> bool
+      def depositary_receipts?: () -> bool
+      def derivatives?: () -> bool
+      def digital?: () -> bool
+      def digital_barrier?: () -> bool
+      def directional?: () -> bool
+      def discount_certificate?: () -> bool
+      def dividend?: () -> bool
+      def dividend_payments?: () -> bool
+      def dividends?: () -> bool
+      def elect_at_exercise?: () -> bool
+      def elect_at_settlement?: () -> bool
+      def energy?: () -> bool
+      def enhanced_voting?: () -> bool
+      def entitlements?: () -> bool
+      def environmental?: () -> bool
+      def equal_weighted?: () -> bool
+      def equities?: () -> bool
+      def equity?: () -> bool
+      def escrow_receipts?: () -> bool
+      def etf?: () -> bool
+      def european?: () -> bool
+      def european_call?: () -> bool
+      def european_chooser?: () -> bool
+      def european_put?: () -> bool
+      def event_driven?: () -> bool
+      def exchange_traded_funds?: () -> bool
+      def exchangeable?: () -> bool
+      def express_certificate?: () -> bool
+      def extendible?: () -> bool
+      def extraction_resources?: () -> bool
+      def fertilizer?: () -> bool
+      def financial_futures?: () -> bool
+      def financing?: () -> bool
+      def fixed?: () -> bool
+      def fixed_cash_repayment?: () -> bool
+      def fixed_fixed?: () -> bool
+      def fixed_floating?: () -> bool
+      def fixed_interest?: () -> bool
+      def fixed_maturity?: () -> bool
+      def fixed_maturity_with_call?: () -> bool
+      def fixed_maturity_with_put?: () -> bool
+      def fixed_maturity_with_put_and_call?: () -> bool
+      def fixed_rate?: () -> bool
+      def flexible?: () -> bool
+      def foreign_exchange?: () -> bool
+      def forward?: () -> bool
+      def forward_forward_swap?: () -> bool
+      def forward_price?: () -> bool
+      def forwards?: () -> bool
+      def free_of_payment?: () -> bool
+      def free_of_restrictions?: () -> bool
+      def freight?: () -> bool
+      def fully_paid?: () -> bool
+      def fund_unit_and_other?: () -> bool
+      def funds_of_funds?: () -> bool
+      def futures?: () -> bool
+      def general_collateral?: () -> bool
+      def generated_resources?: () -> bool
+      def government_bonds?: () -> bool
+      def government_guarantee?: () -> bool
+      def gross_total_return?: () -> bool
+      def growth?: () -> bool
+      def hedge_funds?: () -> bool
+      def hold_in_custody?: () -> bool
+      def income_funds?: () -> bool
+      def index?: () -> bool
+      def index_tranche?: () -> bool
+      def indices?: () -> bool
+      def industrial_products?: () -> bool
+      def inflation_rate_index?: () -> bool
+      def insurance_policies?: () -> bool
+      def interest_rate_index?: () -> bool
+      def interest_rates?: () -> bool
+      def joint_guarantee?: () -> bool
+      def junior?: () -> bool
+      def junior_subordinated?: () -> bool
+      def legacy_currency?: () -> bool
+      def letter_of_credit?: () -> bool
+      def life_style?: () -> bool
+      def limited_partnership_units?: () -> bool
+      def listed_options?: () -> bool
+      def loan_lease?: () -> bool
+      def local?: () -> bool
+      def long?: () -> bool
+      def lookback?: () -> bool
+      def medium_term_notes?: () -> bool
+      def metals?: () -> bool
+      def mini_future_certificates?: () -> bool
+      def miscellaneous?: () -> bool
+      def mixed?: () -> bool
+      def mixed_funds?: () -> bool
+      def modified_market_cap_weighted?: () -> bool
+      def money_market?: () -> bool
+      def money_market_instruments?: () -> bool
+      def monthly?: () -> bool
+      def mortgage_backed?: () -> bool
+      def mortgage_backed_securities?: () -> bool
+      def multi_commodity?: () -> bool
+      def multi_strategy?: () -> bool
+      def municipal_bonds?: () -> bool
+      def naked?: () -> bool
+      def national_currency?: () -> bool
+      def negative_pledge?: () -> bool
+      def net_total_return?: () -> bool
+      def nil_paid?: () -> bool
+      def no_payments?: () -> bool
+      def nominal?: () -> bool
+      def non_deliverable?: () -> bool
+      def non_listed_options?: () -> bool
+      def non_standardized?: () -> bool
+      def non_voting?: () -> bool
+      def normal_rate?: () -> bool
+      def not_applicable?: () -> bool
+      def open?: () -> bool
+      def open_end?: () -> bool
+      def options?: () -> bool
+      def other_assets?: () -> bool
+      def other_otc_derivatives?: () -> bool
+      def other_path_dependent?: () -> bool
+      def others?: () -> bool
+      def outperformance_bonus_certificate?: () -> bool
+      def outperforming_certificate?: () -> bool
+      def overnight?: () -> bool
+      def overnight_index_swap?: () -> bool
+      def paper?: () -> bool
+      def participating?: () -> bool
+      def partly_paid?: () -> bool
+      def payment_in_kind?: () -> bool
+      def pension_funds?: () -> bool
+      def perpetual?: () -> bool
+      def perpetual_with_call?: () -> bool
+      def perpetual_with_put?: () -> bool
+      def physical?: () -> bool
+      def physical_repayment?: () -> bool
+      def polypropylene_products?: () -> bool
+      def precious_metal_receipts?: () -> bool
+      def preferred_shares?: () -> bool
+      def price?: () -> bool
+      def price_return?: () -> bool
+      def price_weighted?: () -> bool
+      def private_equity?: () -> bool
+      def private_equity_funds?: () -> bool
+      def promissory_note?: () -> bool
+      def purchase_rights?: () -> bool
+      def put?: () -> bool
+      def put_options?: () -> bool
+      def quarterly?: () -> bool
+      def rates?: () -> bool
+      def real?: () -> bool
+      def real_estate?: () -> bool
+      def real_estate_deeds?: () -> bool
+      def real_estate_investment_trusts?: () -> bool
+      def redeemable?: () -> bool
+      def redeemable_exchangeable?: () -> bool
+      def redeemable_exchangeable_extendible?: () -> bool
+      def redeemable_extendible?: () -> bool
+      def referential_instruments?: () -> bool
+      def registered?: () -> bool
+      def reit?: () -> bool
+      def relative_value?: () -> bool
+      def repayment_in_assets?: () -> bool
+      def repayment_in_assets_and_cash?: () -> bool
+      def repayment_in_assets_or_cash?: () -> bool
+      def repayment_in_cash?: () -> bool
+      def repurchase_agreements?: () -> bool
+      def restricted_voting?: () -> bool
+      def restrictions?: () -> bool
+      def reverse_convertible?: () -> bool
+      def secured?: () -> bool
+      def securities_lending?: () -> bool
+      def security_selection?: () -> bool
+      def semi_annually?: () -> bool
+      def senior?: () -> bool
+      def senior_subordinated?: () -> bool
+      def services?: () -> bool
+      def share_and_bond?: () -> bool
+      def share_and_warrant?: () -> bool
+      def shares?: () -> bool
+      def shares_for_qualified_investors?: () -> bool
+      def short?: () -> bool
+      def single_currency?: () -> bool
+      def single_name?: () -> bool
+      def single_stock?: () -> bool
+      def sovereign?: () -> bool
+      def specific_security_collateral?: () -> bool
+      def spot?: () -> bool
+      def spot_forward_swap?: () -> bool
+      def spread_bet?: () -> bool
+      def standard_funds?: () -> bool
+      def standard_investment_funds?: () -> bool
+      def standardized?: () -> bool
+      def stock_dividend?: () -> bool
+      def stock_dividends?: () -> bool
+      def strategies?: () -> bool
+      def structured_instruments?: () -> bool
+      def structured_products_with_protection?: () -> bool
+      def structured_products_without_protection?: () -> bool
+      def subscription_rights?: () -> bool
+      def supranational?: () -> bool
+      def swaps?: () -> bool
+      def term?: () -> bool
+      def total_return?: () -> bool
+      def tracker_certificate?: () -> bool
+      def trade_finance_instruments?: () -> bool
+      def traditional?: () -> bool
+      def tri_party?: () -> bool
+      def twin_win_certificate?: () -> bool
+      def units?: () -> bool
+      def units_for_qualified_investors?: () -> bool
+      def unsecured?: () -> bool
+      def vanilla?: () -> bool
+      def variable?: () -> bool
+      def variable_cash_repayment?: () -> bool
+      def variable_interest?: () -> bool
+      def variance?: () -> bool
+      def volatility?: () -> bool
+      def voting?: () -> bool
+      def warrant_and_warrant?: () -> bool
+      def warrants?: () -> bool
+      def weekly?: () -> bool
+      def zero_coupon?: () -> bool
+      def zero_rate?: () -> bool
+    end
+  end
+end