money 7.0.2 → 7.1.0

data/sig/lib/money/bank/base.rbs

@@ -0,0 +1,117 @@
+class Money
+  # Provides classes that aid in the ability of exchange one currency with
+  # another.
+  module Bank
+    # The lowest Money::Bank error class.
+    # All Money::Bank errors should inherit from it.
+    class Error < StandardError
+    end
+
+    # Raised when the bank doesn't know about the conversion rate
+    # for specified currencies.
+    class UnknownRate < Error
+    end
+
+    # Money::Bank::Base is the basic interface for creating a money exchange
+    # object, also called Bank.
+    #
+    # A Bank is responsible for storing exchange rates, take a Money object as
+    # input and returns the corresponding Money object converted into an other
+    # currency.
+    #
+    # This class exists for aiding in the creating of other classes to exchange
+    # money between different currencies. When creating a subclass you will
+    # need to implement the following methods to exchange money between
+    # currencies:
+    #
+    # - #exchange_with(Money) #=> Money
+    #
+    # See Money::Bank::VariableExchange for a real example.
+    #
+    # Also, you can extend +Money::Bank::VariableExchange+ instead of
+    # +Money::Bank::Base+ if your bank implementation needs to store rates
+    # internally.
+    #
+    # @abstract Subclass and override +#exchange_with+ to implement a custom
+    #  +Money::Bank+ class. You can also override +#setup+ instead of
+    #  +#initialize+ to setup initial variables, etc.
+    class Base
+      @singleton: Money::Bank::Base
+
+      # Returns the singleton instance of the Base bank.
+      #
+      # @return [Money::Bank::Base]
+      def self.instance: () -> Money::Bank::Base
+
+      # The rounding method to use when exchanging rates.
+      #
+      # @return [Proc]
+      attr_reader rounding_method: untyped
+
+      # Initializes a new +Money::Bank::Base+ object. An optional block can be
+      # passed to dictate the rounding method that +#exchange_with+ can use.
+      #
+      # @yield [n] Optional block to use when rounding after exchanging one
+      #  currency for another.
+      # @yieldparam [Float] n The resulting float after exchanging one currency
+      #  for another.
+      # @yieldreturn [Integer]
+      #
+      # @return [Money::Bank::Base]
+      #
+      # @example
+      #   Money::Bank::Base.new #=> #<Money::Bank::Base @rounding_method=nil>
+      #   Money::Bank::Base.new {|n|
+      #     n.floor
+      #   } #=> #<Money::Bank::Base @round_method=#<Proc>>
+      def initialize: () { () -> untyped } -> void
+
+      # Called after initialize. Subclasses can use this method to setup
+      # variables, etc that they normally would in +#initialize+.
+      #
+      # @abstract Subclass and override +#setup+ to implement a custom
+      #  +Money::Bank+ class.
+      #
+      # @return [self]
+      def setup: () -> nil
+
+      # Exchanges the given +Money+ object to a new +Money+ object in
+      # +to_currency+.
+      #
+      # @abstract Subclass and override +#exchange_with+ to implement a custom
+      #  +Money::Bank+ class.
+      #
+      # @raise NotImplementedError
+      #
+      # @param [Money] from The +Money+ object to exchange from.
+      # @param [Money::Currency, String, Symbol] to_currency The currency
+      #  string or object to exchange to.
+      # @yield [n] Optional block to use to round the result after making
+      #  the exchange.
+      # @yieldparam [Float] n The result after exchanging from one currency to
+      #  the other.
+      # @yieldreturn [Integer]
+      #
+      # @return [Money]
+      def exchange_with: (Money from, (Money::Currency | string | Symbol) to_currency) { () -> int } -> Money
+
+      # Given two currency strings or object, checks whether they're both the
+      # same currency. Return +true+ if the currencies are the same, +false+
+      # otherwise.
+      #
+      # @param [Money::Currency, String, Symbol] currency1 The first currency
+      #  to compare.
+      # @param [Money::Currency, String, Symbol] currency2 The second currency
+      #  to compare.
+      #
+      # @return [Boolean]
+      #
+      # @example
+      #   same_currency?("usd", "USD")                #=> true
+      #   same_currency?("usd", "EUR")                #=> false
+      #   same_currency?("usd", Currency.new("USD"))   #=> true
+      #   same_currency?("usd", "USD")                #=> true
+      def same_currency?: ((Money::Currency | string | Symbol) currency1, (Money::Currency | string | Symbol) currency2) -> bool
+    end
+  end
+end

data/sig/lib/money/bank/single_currency.rbs

@@ -0,0 +1,15 @@
+class Money
+  module Bank
+    # Raised when trying to exchange currencies
+    class DifferentCurrencyError < Error
+    end
+
+    # Class to ensure client code is operating in a single currency
+    # by raising if an exchange attempts to happen.
+    class SingleCurrency < Base
+      # Raises a DifferentCurrencyError to remove possibility of accidentally
+      # exchanging currencies
+      def exchange_with: (Money from, (Money::Currency | string | Symbol) to_currency) ?{ (untyped) -> untyped } -> untyped
+    end
+  end
+end

data/sig/lib/money/bank/variable_exchange.rbs

@@ -0,0 +1,198 @@
+class Money
+  module Bank
+    # Thrown when an unknown rate format is requested.
+    class UnknownRateFormat < StandardError
+    end
+
+    # Class for aiding in exchanging money between different currencies. By
+    # default, the +Money+ class uses an object of this class (accessible
+    # through +Money#bank+) for performing currency exchanges.
+    #
+    # By default, +Money::Bank::VariableExchange+ has no knowledge about
+    # conversion rates. One must manually specify them with +add_rate+, after
+    # which one can perform exchanges with +#exchange_with+.
+    #
+    # Exchange rates are stored in memory using +Money::RatesStore::Memory+ by default.
+    # Pass custom rates stores for other types of storage (file, database, etc)
+    #
+    # @example
+    #   bank = Money::Bank::VariableExchange.new
+    #   bank.add_rate("USD", "CAD", 1.24515)
+    #   bank.add_rate("CAD", "USD", 0.803115)
+    #
+    #   c1 = Money.new(100_00, "USD")
+    #   c2 = Money.new(100_00, "CAD")
+    #
+    #   # Exchange 100 USD to CAD:
+    #   bank.exchange_with(c1, "CAD") #=> #<Money fractional:12451 currency:CAD>
+    #
+    #   # Exchange 100 CAD to USD:
+    #   bank.exchange_with(c2, "USD") #=> #<Money fractional:8031 currency:USD>
+    #
+    #   # With custom exchange rates storage
+    #   redis_store = MyCustomRedisStore.new(host: 'localhost:6379')
+    #   bank = Money::Bank::VariableExchange.new(redis_store)
+    #   # Store rates in redis
+    #   bank.add_rate 'USD', 'CAD', 0.98
+    #   # Get rate from redis
+    #   bank.get_rate 'USD', 'CAD'
+    class VariableExchange < Base
+      attr_reader mutex: untyped
+
+      # Available formats for importing/exporting rates.
+      RATE_FORMATS: Array[Symbol]
+
+      SERIALIZER_SEPARATOR: string
+
+      FORMAT_SERIALIZERS: Hash[Symbol, (JSON | Marshal | YAML)]
+
+      # Initializes a new +Money::Bank::VariableExchange+ object.
+      # It defaults to using an in-memory, thread safe store instance for
+      # storing exchange rates.
+      #
+      # @param [RateStore] st An exchange rate store, used to persist exchange rate pairs.
+      # @yield [n] Optional block to use when rounding after exchanging one
+      #  currency for another. See +Money::bank::base+
+      def initialize: (?untyped st) { () -> untyped } -> void
+
+      def store: () -> untyped
+
+      def marshal_dump: () -> ::Array[untyped]
+
+      def marshal_load: (untyped arr) -> untyped
+
+      # Exchanges the given +Money+ object to a new +Money+ object in
+      # +to_currency+.
+      #
+      # @param  [Money] from
+      #         The +Money+ object to exchange.
+      # @param  [Currency, String, Symbol] to_currency
+      #         The currency to exchange to.
+      #
+      # @yield [n] Optional block to use when rounding after exchanging one
+      #  currency for another.
+      # @yieldparam [Float] n The resulting float after exchanging one currency
+      #  for another.
+      # @yieldreturn [Integer]
+      #
+      # @return [Money]
+      #
+      # @raise +Money::Bank::UnknownRate+ if the conversion rate is unknown.
+      #
+      # @example
+      #   bank = Money::Bank::VariableExchange.new
+      #   bank.add_rate("USD", "CAD", 1.24515)
+      #   bank.add_rate("CAD", "USD", 0.803115)
+      #
+      #   c1 = Money.new(100_00, "USD")
+      #   c2 = Money.new(100_00, "CAD")
+      #
+      #   # Exchange 100 USD to CAD:
+      #   bank.exchange_with(c1, "CAD") #=> #<Money fractional:12451 currency:CAD>
+      #
+      #   # Exchange 100 CAD to USD:
+      #   bank.exchange_with(c2, "USD") #=> #<Money fractional:8031 currency:USD>
+      def exchange_with: (Money from, (Money::Currency | string | Symbol) to_currency) { () -> int } -> Money
+
+      def calculate_fractional: (untyped from, untyped to_currency) -> untyped
+
+      def exchange: (untyped fractional, untyped rate) ?{ (untyped) -> untyped } -> untyped
+
+      # Registers a conversion rate and returns it (uses +#set_rate+).
+      # Delegates to +Money::RatesStore::Memory+
+      #
+      # @param [Currency, String, Symbol] from Currency to exchange from.
+      # @param [Currency, String, Symbol] to Currency to exchange to.
+      # @param [Numeric] rate Rate to use when exchanging currencies.
+      #
+      # @return [Numeric]
+      #
+      # @example
+      #   bank = Money::Bank::VariableExchange.new
+      #   bank.add_rate("USD", "CAD", 1.24515)
+      #   bank.add_rate("CAD", "USD", 0.803115)
+      def add_rate: ((Money::Currency | string | Symbol) from, (Money::Currency | string | Symbol) to, Numeric rate) -> Numeric
+
+      # Set the rate for the given currencies.
+      # access.
+      # Delegates to +Money::RatesStore::Memory+
+      #
+      # @param [Currency, String, Symbol] from Currency to exchange from.
+      # @param [Currency, String, Symbol] to Currency to exchange to.
+      # @param [Numeric] rate Rate to use when exchanging currencies.
+      # @param [Hash] opts Options hash to set special parameters. Backwards compatibility only.
+      #
+      # @return [Numeric]
+      #
+      # @example
+      #   bank = Money::Bank::VariableExchange.new
+      #   bank.set_rate("USD", "CAD", 1.24515)
+      #   bank.set_rate("CAD", "USD", 0.803115)
+      def set_rate: ((Money::Currency | string | Symbol) from, (Money::Currency | string | Symbol) to, Numeric rate, ?::Hash[untyped, untyped] opts) -> Numeric
+
+      # Retrieve the rate for the given currencies.
+      # data access.
+      # Delegates to +Money::RatesStore::Memory+
+      #
+      # @param [Currency, String, Symbol] from Currency to exchange from.
+      # @param [Currency, String, Symbol] to Currency to exchange to.
+      # @param [Hash] opts Options hash to set special parameters. Backwards compatibility only.
+      #
+      # @return [Numeric]
+      #
+      # @example
+      #   bank = Money::Bank::VariableExchange.new
+      #   bank.set_rate("USD", "CAD", 1.24515)
+      #   bank.set_rate("CAD", "USD", 0.803115)
+      #
+      #   bank.get_rate("USD", "CAD") #=> 1.24515
+      #   bank.get_rate("CAD", "USD") #=> 0.803115
+      def get_rate: ((Money::Currency | string | Symbol) from, (Money::Currency | string | Symbol) to, ?::Hash[untyped, untyped] opts) -> Numeric
+
+      # Return the known rates as a string in the format specified. If +file+
+      # is given will also write the string out to the file specified.
+      # Available formats are +:json+, +:ruby+ and +:yaml+.
+      #
+      # @param [Symbol] format Request format for the resulting string.
+      # @param [String] file Optional file location to write the rates to.
+      # @param [Hash] opts Options hash to set special parameters. Backwards compatibility only.
+      #
+      # @return [String]
+      #
+      # @raise +Money::Bank::UnknownRateFormat+ if format is unknown.
+      #
+      # @example
+      #   bank = Money::Bank::VariableExchange.new
+      #   bank.set_rate("USD", "CAD", 1.24515)
+      #   bank.set_rate("CAD", "USD", 0.803115)
+      #
+      #   s = bank.export_rates(:json)
+      #   s #=> "{\"USD_TO_CAD\":1.24515,\"CAD_TO_USD\":0.803115}"
+      def export_rates: (Symbol format, ?string? file, ?::Hash[untyped, untyped] opts) -> string
+
+      # This should be deprecated.
+      def rates: () -> untyped
+
+      # Loads rates provided in +string+ given the specified format. Available
+      # formats are +:json+, +:ruby+ and +:yaml+.
+      # Delegates to +Money::RatesStore::Memory+
+      #
+      # @param [Symbol] format The format of +string+.
+      # @param [String] string The rates string.
+      # @param [Hash] opts Options hash to set special parameters. Backwards compatibility only.
+      #
+      # @return [self]
+      #
+      # @raise +Money::Bank::UnknownRateFormat+ if format is unknown.
+      #
+      # @example
+      #   string = "{\"USD_TO_CAD\":1.24515,\"CAD_TO_USD\":0.803115}"
+      #   bank = Money::Bank::VariableExchange.new
+      #   bank.import_rates(:json, string)
+      #
+      #   bank.get_rate("USD", "CAD") #=> 1.24515
+      #   bank.get_rate("CAD", "USD") #=> 0.803115
+      def import_rates: (Symbol format, string string, ?::Hash[untyped, untyped] opts) -> Money::Bank::VariableExchange
+    end
+  end
+end

data/sig/lib/money/currency/heuristics.rbs

@@ -0,0 +1,8 @@
+class Money
+  class Currency
+    # DEPRECATED. Use the money-heuristics gem instead.
+    module Heuristics
+      def analyze: (untyped _str) -> untyped
+    end
+  end
+end

data/sig/lib/money/currency.rbs

@@ -0,0 +1,322 @@
+class Money
+  # Represents a specific currency unit.
+  #
+  # @see https://en.wikipedia.org/wiki/Currency
+  # @see https://www.iso.org/iso-4217-currency-codes.html
+  class Currency
+    include Comparable
+
+    extend Enumerable[Money::Currency]
+
+    extend Money::Currency::Heuristics
+
+    # Thrown when a Currency has been registered without all the attributes
+    # which are required for the current action.
+    class MissingAttributeError < StandardError
+      def initialize: (untyped method, untyped currency, untyped attribute) -> void
+    end
+
+    # Thrown when an unknown currency is requested.
+    class UnknownCurrency < ArgumentError
+    end
+
+    # Thrown when a Money object is created without a currency.
+    class NoCurrency < ArgumentError
+    end
+
+    def self.new: (untyped id) -> untyped
+
+    def self._instances: () -> untyped
+
+    # Lookup a currency with given +id+ an returns a +Currency+ instance on
+    # success, +nil+ otherwise.
+    #
+    # @param [String, Symbol, #to_s] id Used to look into +table+ and
+    # retrieve the applicable attributes.
+    #
+    # @return [Money::Currency]
+    #
+    # @example
+    #   Money::Currency.find(:eur) #=> #<Money::Currency id: eur ...>
+    #   Money::Currency.find(:foo) #=> nil
+    def self.find: ((string | Symbol) id) -> Money::Currency
+
+    # Lookup a currency with given +num+ as an ISO 4217 numeric and returns an
+    # +Currency+ instance on success, +nil+ otherwise.
+    #
+    # @param [#to_s] num used to look into +table+ in +iso_numeric+ and find
+    # the right currency id.
+    #
+    # @return [Money::Currency]
+    #
+    # @example
+    #   Money::Currency.find_by_iso_numeric(978) #=> #<Money::Currency id: eur ...>
+    #   Money::Currency.find_by_iso_numeric(51) #=> #<Money::Currency id: amd ...>
+    #   Money::Currency.find_by_iso_numeric('001') #=> nil
+    def self.find_by_iso_numeric: ((string | Numeric) num) -> Money::Currency
+
+    # Wraps the object in a +Currency+ unless it's already a +Currency+
+    # object.
+    #
+    # @param [Object] object The object to attempt and wrap as a +Currency+
+    # object.
+    #
+    # @return [Money::Currency]
+    #
+    # @example
+    #   c1 = Money::Currency.new(:usd)
+    #   Money::Currency.wrap(nil)   #=> nil
+    #   Money::Currency.wrap(c1)    #=> #<Money::Currency id: usd ...>
+    #   Money::Currency.wrap("usd") #=> #<Money::Currency id: usd ...>
+    def self.wrap: (Object object) -> (nil | Money::Currency)
+
+    # List of known currencies.
+    #
+    # == monetary unit
+    # The standard unit of value of a currency, as the dollar in the United States or the peso in Mexico.
+    # https://www.answers.com/redirectSearch?query=monetary-unit
+    # == fractional monetary unit, subunit
+    # A monetary unit that is valued at a fraction (usually one hundredth) of the basic monetary unit
+    # https://www.answers.com/redirectSearch?query=fractional-monetary-unit-subunit
+    #
+    # See https://en.wikipedia.org/wiki/List_of_circulating_currencies and
+    # https://metacpan.org/release/TNGUYEN/Locale-Currency-Format-1.28/view/Format.pm
+    def self.table: () -> untyped
+
+    # List the currencies imported and registered
+    # @return [Array]
+    #
+    # @example
+    #   Money::Currency.all()
+    #   [#<Currency ..USD>, 'CAD', 'EUR']...
+    def self.all: () -> Array[untyped]
+
+    # We need a string-based validator before creating an unbounded number of
+    # symbols.
+    # http://www.randomhacks.net.s3-website-us-east-1.amazonaws.com/2007/01/20/13-ways-of-looking-at-a-ruby-symbol/#11
+    # https://github.com/RubyMoney/money/issues/132
+    #
+    # @return [Set]
+    def self.stringified_keys: () -> untyped
+
+    # Register a new currency
+    #
+    # @param curr [Hash] information about the currency
+    # @option priority [Numeric] a numerical value you can use to sort/group
+    #   the currency list
+    # @option iso_code [String] the international 3-letter code as defined
+    #   by the ISO 4217 standard
+    # @option iso_numeric [Integer] the international 3-digit code as
+    #   defined by the ISO 4217 standard
+    # @option name [String] the currency name
+    # @option symbol [String] the currency symbol (UTF-8 encoded)
+    # @option subunit [String] the name of the fractional monetary unit
+    # @option subunit_to_unit [Numeric] the proportion between the unit and
+    #   the subunit
+    # @option separator [String] character between the whole and fraction
+    #   amounts
+    # @option delimiter [String] character between each thousands place
+    def self.register: (Hash[untyped, untyped] curr) -> Money::Currency
+
+    # Inherit a new currency from existing one
+    #
+    # @param parent_iso_code [String] the international 3-letter code as defined
+    # @param curr [Hash] See {register} method for hash structure
+    def self.inherit: (string parent_iso_code, Hash[untyped, untyped] curr) -> untyped
+
+    # Unregister a currency.
+    #
+    # @param [Object] curr A Hash with the key `:iso_code`, or the ISO code
+    #   as a String or Symbol.
+    #
+    # @return [Boolean] true if the currency previously existed, false
+    #   if it didn't.
+    def self.unregister: (Hash[untyped, untyped] curr) -> bool
+
+    def self.each: () { (untyped) -> untyped } -> untyped
+
+    def self.reset!: () -> untyped
+
+    private
+
+    def self.stringify_keys: () -> untyped
+
+    public
+
+    attr_reader id: untyped
+
+    attr_reader priority: untyped
+
+    attr_reader iso_code: untyped
+
+    attr_reader iso_numeric: untyped
+
+    attr_reader name: untyped
+
+    attr_reader symbol: untyped
+
+    attr_reader disambiguate_symbol: untyped
+
+    attr_reader html_entity: untyped
+
+    attr_reader subunit: untyped
+
+    attr_reader subunit_to_unit: untyped
+
+    attr_reader decimal_mark: untyped
+
+    attr_reader thousands_separator: untyped
+
+    attr_reader symbol_first: untyped
+
+    attr_reader smallest_denomination: untyped
+
+    attr_reader format: untyped
+
+    alias separator decimal_mark
+
+    alias delimiter thousands_separator
+
+    alias eql? ==
+
+    # Create a new +Currency+ object.
+    #
+    # @param [String, Symbol, #to_s] id Used to look into +table+ and retrieve
+    #  the applicable attributes.
+    #
+    # @return [Money::Currency]
+    #
+    # @example
+    #   Money::Currency.new(:usd) #=> #<Money::Currency id: usd ...>
+    def initialize: (untyped id) -> void
+
+    # Compares +self+ with +other_currency+ against the value of +priority+
+    # attribute.
+    #
+    # @param [Money::Currency] other_currency The currency to compare to.
+    #
+    # @return [-1,0,1] -1 if less than, 0 is equal to, 1 if greater than
+    #
+    # @example
+    #   c1 = Money::Currency.new(:usd)
+    #   c2 = Money::Currency.new(:jpy)
+    #   c1 <=> c2 #=> 1
+    #   c2 <=> c1 #=> -1
+    #   c1 <=> c1 #=> 0
+    def <=>: (untyped other_currency) -> untyped
+
+    # Compares +self+ with +other_currency+ and returns +true+ if the are the
+    # same or if their +id+ attributes match.
+    #
+    # @param [Money::Currency] other_currency The currency to compare to.
+    #
+    # @return [Boolean]
+    #
+    # @example
+    #   c1 = Money::Currency.new(:usd)
+    #   c2 = Money::Currency.new(:jpy)
+    #   c1 == c1 #=> true
+    #   c1 == c2 #=> false
+    def ==: (Money::Currency? other_currency) -> bool
+
+    private
+
+    def compare_ids: (untyped other_currency) -> untyped
+
+    public
+
+    # Returns a Integer hash value based on the +id+ attribute in order to use
+    # functions like & (intersection), group_by, etc.
+    #
+    # @return [Integer]
+    #
+    # @example
+    #   Money::Currency.new(:usd).hash #=> 428936
+    def hash: () -> untyped
+
+    # Returns a human readable representation.
+    #
+    # @return [String]
+    #
+    # @example
+    #   Money::Currency.new(:usd) #=> #<Currency id: usd ...>
+    def inspect: () -> ::String
+
+    # Returns a string representation corresponding to the upcase +id+
+    # attribute.
+    #
+    # --
+    # DEV: id.to_s.upcase corresponds to iso_code but don't use ISO_CODE for consistency.
+    #
+    # @return [String]
+    #
+    # @example
+    #   Money::Currency.new(:usd).to_s #=> "USD"
+    #   Money::Currency.new(:eur).to_s #=> "EUR"
+    def to_s: () -> untyped
+
+    # Returns a string representation corresponding to the upcase +id+
+    # attribute. Useful in cases where only implicit conversions are made.
+    #
+    # @return [String]
+    #
+    # @example
+    #   Money::Currency.new(:usd).to_str #=> "USD"
+    #   Money::Currency.new(:eur).to_str #=> "EUR"
+    def to_str: () -> untyped
+
+    # Returns a symbol representation corresponding to the upcase +id+
+    # attribute.
+    #
+    # @return [Symbol]
+    #
+    # @example
+    #   Money::Currency.new(:usd).to_sym #=> :USD
+    #   Money::Currency.new(:eur).to_sym #=> :EUR
+    def to_sym: () -> untyped
+
+    # Conversion to +self+.
+    #
+    # @return [self]
+    def to_currency: () -> self
+
+    # Returns currency symbol or iso code for currencies with no symbol.
+    #
+    # @return [String]
+    def code: () -> untyped
+
+    def symbol_first?: () -> untyped
+
+    # Returns if a code currency is ISO.
+    #
+    # @return [Boolean]
+    #
+    # @example
+    #   Money::Currency.new(:usd).iso?
+    #
+    def iso?: () -> untyped
+
+    # Returns true if a subunit is cents-based.
+    #
+    # @return [Boolean]
+    #
+    # @example
+    #  Money::Currency.new(:usd).cents_based?
+    #
+    def cents_based?: () -> bool
+
+    # Returns the relation between subunit and unit as a base 10 exponent.
+    #
+    # Note that MGA and MRU are exceptions and are rounded to 1
+    # @see https://en.wikipedia.org/wiki/ISO_4217#Active_codes
+    #
+    # @return [Integer]
+    def exponent: () -> untyped
+
+    alias decimal_places exponent
+
+    private
+
+    def initialize_data!: () -> untyped
+  end
+end

data/sig/lib/money/locale_backend/base.rbs

@@ -0,0 +1,6 @@
+class Money
+  module LocaleBackend
+    class Base
+    end
+  end
+end

data/sig/lib/money/locale_backend/errors.rbs

@@ -0,0 +1,9 @@
+class Money
+  module LocaleBackend
+    class NotSupported < StandardError
+    end
+
+    class Unknown < ArgumentError
+    end
+  end
+end

data/sig/lib/money/locale_backend/i18n.rbs

@@ -0,0 +1,11 @@
+class Money
+  module LocaleBackend
+    class I18n < Base
+      KEY_MAP: Hash[Symbol, Symbol]
+
+      def initialize: () -> void
+
+      def lookup: (Symbol key, untyped _) -> untyped
+    end
+  end
+end