rubybikes 0.3.0

data/lib/rubybikes/native/xml_details.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+# Native ports of PyBikes bixi.py, decobike.py, xian.py, bicincitta.py,
+# pedalada.py and fsm.py. Copyright (C) eskerda, Martin Gonzalez Gomez,
+# aronsky and contributors. Distributed under AGPL-3.0; see LICENSE and NOTICE.
+
+class RubyBikes
+  module Native
+    class JsonProviders
+      DECOBIKE_HEADERS = {
+        'Accept' => 'application/xml, text/xml, */*; q=0.01',
+        'Accept-Language' => 'en-US,en;q=0.9',
+        'User-Agent' => 'Mozilla/5.0 (Linux; Android 13; Pixel 6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/112.0.0.0 Mobile Safari/537.36',
+        'X-Requested-With' => 'com.citibike.miami'
+      }.freeze
+      BICINCITTA_STATUSES = { 0 => 'online', 1 => 'maintenance', 2 => 'offline', 3 => 'under construction', 4 => 'planned' }.freeze
+      DETAIL_JSON_HEADERS = { 'Content-Type' => 'application/json; charset=utf-8' }.freeze
+      FSM_ENDPOINT = 'https://www.tel-o-fun.co.il/api/privatearea/v1'
+      FSM_HEADERS = { 'Accept-Language' => 'en' }.freeze
+      XIAN_SOAP = <<~XML
+        <soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:q0="http://ws.itcast.cn/" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+          <soapenv:Body><q0:findBikeSites></q0:findBikeSites></soapenv:Body>
+        </soapenv:Envelope>
+      XML
+
+      # Metadata generated by these clients belongs to their description too,
+      # before the first network update.
+      def initialize(spec, parameters, key: nil)
+        super
+        case spec.fetch('module')
+        when 'bicincitta'
+          endpoint = p('endpoint') || 'https://www.bicincitta.com/'
+          @meta['source'] = URI.join(endpoint, "frmLeStazioni.aspx?ID=#{p('city_ids').fetch(0)}").to_s
+        when 'pedalada'
+          @meta['company'] = Array(@parameters.fetch('meta')['company']) + Array(spec.fetch('meta')['company'])
+        end
+      end
+
+      def update_bixi
+        detail_xml(p('feed_url')).xpath('/stations/station').each do |node|
+          name = xml_text(node, 'name')
+          terminal = xml_text(node, 'terminalName')
+          extra = {
+            'uid' => number(xml_text(node, 'id')),
+            'name' => name,
+            'terminalName' => terminal,
+            'locked' => xml_boolean?(xml_text(node, 'locked')),
+            'installed' => xml_boolean?(xml_text(node, 'installed')),
+            'temporary' => xml_boolean?(xml_text(node, 'temporary')),
+            'installDate' => xml_text(node, 'installDate'),
+            'removalDate' => xml_text(node, 'removalDate')
+          }
+          updated = xml_text(node, 'latestUpdateTime')
+          extra['latestUpdateTime'] = updated if updated && updated != '0'
+          station("#{terminal} - #{name}", xml_text(node, 'lat'), xml_text(node, 'long'),
+                  number(xml_text(node, 'nbBikes')), number(xml_text(node, 'nbEmptyDocks')), extra)
+        end
+      end
+
+      def update_decobike
+        detail_xml(p('feed_url'), headers: DECOBIKE_HEADERS).xpath('//location').each do |node|
+          uid = xml_text(node, 'Id')
+          address = xml_text(node, 'Address')
+          station("#{uid} - #{address}", xml_text(node, 'Latitude'), xml_text(node, 'Longitude'),
+                  number(xml_text(node, 'Bikes')), number(xml_text(node, 'Dockings')),
+                  { 'uid' => uid, 'address' => address })
+        end
+      end
+
+      def update_xian
+        document = detail_xml(p('endpoint'), method: 'POST', data: XIAN_SOAP,
+                                             headers: { 'Content-Type' => 'text/xml; charset=utf-8' })
+        payload = document.xpath('string(//ns1:out)', 'ns1' => 'http://inter.webservice.web.ptpportal.guloo.org').delete(' ')
+        JSON.parse(payload).each do |item|
+          slots = number(item.fetch('locknum'))
+          free = number(item.fetch('emptynum'))
+          station(item.fetch('sitename'), item.fetch('latitude'), item.fetch('longitude'), slots - free, free,
+                  { 'uid' => item.fetch('siteid'), 'slots' => slots, 'address' => item.fetch('location') })
+        end
+      end
+
+      def update_bicincitta
+        endpoint = p('endpoint') || 'https://www.bicincitta.com/'
+        p('city_ids').each do |city|
+          payload = json(URI.join(endpoint, 'frmLeStazioniComune.aspx/RefreshStations').to_s,
+                         method: 'POST', data: JSON.generate('IDComune' => city.to_s), headers: DETAIL_JSON_HEADERS)
+          payload.fetch('d').drop(1).each do |raw|
+            uid, lat, lon, name, number, status = raw.split('§')
+            extra = { 'uid' => uid, 'number' => number(number), 'status' => BICINCITTA_STATUSES.fetch(number(status)) }
+            detail = json(URI.join(endpoint, 'frmLeStazioni.aspx/RefreshPopup').to_s,
+                          method: 'POST', data: JSON.generate('IDStazione' => uid.to_s), headers: DETAIL_JSON_HEADERS)
+            _, reviews, score, _, availability = detail.fetch('d').split('§').take(5)
+            extra['score'] = Float(score.tr(',', '.'))
+            extra['reviews'] = number(reviews)
+            station(name, bicincitta_coordinate(lat), bicincitta_coordinate(lon), availability.count('4'), availability.count('0'), extra)
+          end
+        end
+      end
+
+      def update_pedalada
+        endpoint = p('endpoint')
+        json("#{endpoint}/php/get-stations-details-map.php").each do |item|
+          uid = item.fetch('stationNumber')
+          slots = item.fetch('maximumNumberOfRides')
+          detail = json("#{endpoint}/php/get-station-details-and-rides.php", params: { 'n' => uid })
+          bikes = detail.fetch('rides').length
+          extra = {
+            'uid' => uid, 'slots' => slots, 'online' => item.fetch('state') == 1,
+            'photo' => "#{endpoint}/images/stations/station_#{uid}.jpg",
+            'status' => pedalada_status(detail.fetch('details').fetch(0))
+          }
+          station(item.fetch('stationName'), item.fetch('latitude'), item.fetch('longitude'), bikes, slots - bikes, extra)
+        end
+      end
+
+      def update_fsm
+        json("#{FSM_ENDPOINT}/map", headers: FSM_HEADERS).fetch('stations').each do |item|
+          detail = json("#{FSM_ENDPOINT}/station/#{item.fetch('id')}", headers: FSM_HEADERS)
+          electric = item.fetch('omniBikes')
+          normal = item.fetch('novatechBikes')
+          electric_slots = detail.fetch('availableOmniPoles')
+          normal_slots = detail.fetch('availableNovatechPoles')
+          extra = {
+            'uid' => item.fetch('id'), 'number' => item.fetch('stationNumber'),
+            'shabbat' => item.fetch('isShabbatStation'), 'has_ebikes' => true,
+            'ebikes' => electric, 'normal_bikes' => normal, 'normal_slots' => normal_slots,
+            'e_slots' => electric_slots, 'address' => detail.fetch('address')
+          }
+          station(item.fetch('name'), item.fetch('location').fetch('lat'), item.fetch('location').fetch('lng'),
+                  normal + electric, normal_slots + electric_slots, extra)
+        end
+      end
+
+      private
+
+      def detail_xml(url, **options)
+        Nokogiri::XML(request(url, **options)) { |config| config.strict.nonet }
+      end
+
+      def xml_text(node, name)
+        node.at_xpath(name)&.text
+      end
+
+      def xml_boolean?(value)
+        %w[yes true t 1].include?(value.downcase)
+      end
+
+      def bicincitta_coordinate(value)
+        Float(value[/\d+\.\d{5,15}/] || value)
+      end
+
+      def pedalada_status(detail)
+        return 'maintenance' if truthy?(detail.fetch('stationInMaintenance'))
+
+        truthy?(detail.fetch('stationIsOpen')) ? 'open' : 'closed'
+      end
+    end
+  end
+end

data/lib/rubybikes/native.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# rubocop:disable Style/OneClassPerFile -- The loader establishes data paths before exposing the native Engine alias.
+
+require_relative 'version'
+class RubyBikes
+  module Native
+    DATA = File.expand_path('../../data', File.dirname(__FILE__))
+  end
+end
+require_relative 'native/geometry'
+require_relative 'native/response_cache'
+require_relative 'native/transport'
+require_relative 'native/provider'
+require_relative 'native/gbfs'
+require_relative 'native/nextbike'
+require_relative 'native/json_providers'
+require_relative 'native/engine'
+require_relative 'native/authenticated'
+require_relative 'native/graphql'
+require_relative 'native/more_json'
+require_relative 'native/remaining_clients'
+require_relative 'native/html_clients'
+require_relative 'native/xml_details'
+class RubyBikes
+  Engine = Native::Engine unless const_defined?(:Engine, false)
+end
+require_relative '../rubybikes' unless defined?(RubyBikes::System)
+
+# rubocop:enable Style/OneClassPerFile

data/lib/rubybikes/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class RubyBikes
+  VERSION = '0.3.0'
+end

data/lib/rubybikes.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+# Copyright (C) Eduardo Mucelli Rezende Oliveira
+# Distributed under the AGPL license, see LICENSE.
+
+require 'json'
+require 'time'
+
+require_relative 'rubybikes/version'
+
+class RubyBikes
+  class Error < StandardError
+    attr_reader :details
+
+    def initialize(message, details: {})
+      @details = details
+      super(message)
+    end
+  end
+
+  class DependencyError < Error; end
+  class ProviderError < Error; end
+  class ProtocolError < Error; end
+  class TimeoutError < Error; end
+
+  class RateLimitedError < ProviderError
+    def retry_after = details.fetch('retry_after', 300).to_f
+    def host = details['host']
+  end
+
+  class NoSystemFoundError < Error; end
+  class NoGetCriteriaError < Error; end
+  class APIKeyNotAvailableError < Error; end
+
+  def initialize(timeout: 60, keys: {}, engine: nil)
+    @engine = engine || Engine.new(timeout: timeout)
+    @keys = keys.transform_keys(&:to_s)
+  end
+
+  def catalog
+    @catalog ||= @engine.request('catalog').fetch('networks')
+  end
+
+  def engine_info = @engine.request('version')
+  def providers = @providers ||= @engine.request('providers').fetch('providers')
+  def tags = catalog.map { |entry| entry.fetch('tag') }
+  def labels = catalog.map { |entry| entry.fetch('label') }.uniq.sort
+
+  # Original string-keyed hashes and modern keyword/string forms are accepted.
+  def get(options = {}, **keywords)
+    raise ArgumentError, 'options must be a tag or hash' unless options.is_a?(String) || options.is_a?(Hash)
+
+    options = options.is_a?(String) ? { 'tag' => options } : options.transform_keys(&:to_s)
+    options = options.merge(keywords.transform_keys(&:to_s))
+    if (tag = options['tag'])
+      entry = catalog.find { |row| row['tag'] == tag }
+      raise NoSystemFoundError, "Unknown system tag: #{tag}" unless entry
+
+      key = options['api_key'] || options['key'] || @keys[tag] || @keys[entry['module']] || @keys[entry['class']]
+      description = @engine.request('describe', tag: tag, key: key)
+      System.new(@engine, description, key)
+    elsif (label = options['label'])
+      entries = catalog.select do |row|
+        [row['label'], row['class'], row['module']].any? { |value| value.to_s.casecmp?(label.to_s) }
+      end
+      entries.map { |entry| get(options.merge('tag' => entry['tag'])) }
+    else
+      raise NoGetCriteriaError, "Supply a 'tag' or 'label'"
+    end
+  end
+
+  # Instantiate any upstream client, including clients without catalog entries.
+  # Parameters follow that client's PyBikes constructor (feed_url, domain, etc.).
+  def build(provider:, tag:, meta:, class_name: nil, api_key: nil, **parameters)
+    entries = providers.select { |row| row['class'].casecmp?(provider.to_s) } unless class_name
+    if !entries || entries.empty?
+      entries = providers.select do |row|
+        row['module'].casecmp?(provider.to_s) && (!class_name || row['class'].casecmp?(class_name.to_s))
+      end
+    end
+    raise NoSystemFoundError, "Unknown provider: #{provider}" if entries.empty?
+    raise ArgumentError, 'Select a class_name for this provider module' if entries.size > 1
+
+    entry = entries.first
+    key = api_key || @keys[tag] || @keys[entry['module']] || @keys[entry['class']]
+    definition = { 'module' => entry['module'], 'class' => entry['class'],
+                   'parameters' => parameters.merge(meta: meta) }
+    # Detach nested caller-owned values so updates and process restarts keep
+    # using the same definition that was originally described.
+    definition = JSON.parse(JSON.generate(definition))
+    description = @engine.request('describe', tag: tag, key: key, definition: definition)
+    System.new(@engine, description, key, definition: definition)
+  end
+
+  def close = @engine.close
+
+  def self.open(**options)
+    factory = new(**options)
+    return factory unless block_given?
+
+    begin
+      yield factory
+    ensure
+      factory.close
+    end
+  end
+
+  class Station
+    attr_reader :id, :name, :latitude, :longitude, :bikes, :free, :timestamp, :extra
+
+    def initialize(row)
+      @id, @name = row.fetch('id'), row.fetch('name')
+      @latitude, @longitude = row.fetch('latitude'), row.fetch('longitude')
+      @bikes, @free, @extra = row['bikes'], row['free'], row.fetch('extra', {})
+      @timestamp = row['timestamp'] && Time.iso8601(row['timestamp']).utc
+    end
+
+    def get_hash = id # rubocop:disable Naming/AccessorMethodName -- Retain the public compatibility method.
+
+    def to_h
+      { 'id' => id, 'name' => name, 'latitude' => latitude, 'longitude' => longitude,
+        'bikes' => bikes, 'free' => free, 'timestamp' => timestamp&.iso8601(6), 'extra' => extra }
+    end
+    alias to_dict to_h
+    def to_json(state = nil) = to_h.to_json(state)
+
+    def to_geojson
+      { 'type' => 'Feature', 'geometry' => { 'type' => 'Point', 'coordinates' => [longitude, latitude] },
+        'properties' => to_h.except('id', 'timestamp').merge('type' => 'station') }
+    end
+  end
+
+  class Vehicle
+    attr_reader :id, :latitude, :longitude, :kind, :timestamp, :extra
+
+    def initialize(row)
+      @id, @latitude, @longitude, @kind = row.values_at('id', 'latitude', 'longitude', 'kind')
+      @extra = row.fetch('extra', {})
+      @timestamp = row['timestamp'] && Time.iso8601(row['timestamp']).utc
+    end
+
+    def get_hash = id # rubocop:disable Naming/AccessorMethodName -- Retain the public compatibility method.
+
+    def to_h
+      { 'id' => id, 'latitude' => latitude, 'longitude' => longitude, 'kind' => kind,
+        'timestamp' => timestamp&.iso8601(6), 'extra' => extra }
+    end
+    alias to_dict to_h
+    def to_json(state = nil) = to_h.to_json(state)
+
+    def to_geojson
+      { 'type' => 'Feature', 'geometry' => { 'type' => 'Point', 'coordinates' => [longitude, latitude] },
+        'properties' => to_h.except('timestamp').merge('type' => 'vehicle') }
+    end
+  end
+
+  class System
+    attr_reader :tag, :meta, :stations, :vehicles, :authed, :sync, :unifeed, :provider, :client_class
+
+    def initialize(engine, description, key, definition: nil)
+      @engine, @key = engine, key
+      @definition = definition
+      @tag, @meta, @authed, @sync = description.values_at('tag', 'meta', 'authed', 'sync')
+      @provider, @client_class, @unifeed = description.values_at('module', 'class', 'unifeed')
+      @stations, @vehicles = [], []
+    end
+
+    def update(timeout: @engine.timeout, scraper: {})
+      arguments = { tag: tag, key: @key, scraper: scraper }
+      arguments[:definition] = @definition if @definition
+      row = @engine.request('update', timeout: timeout, **arguments)
+      raise ProtocolError, 'Provider returned a different system' unless row.fetch('tag') == tag
+
+      # Build the complete snapshot first, retaining the previous one on failure.
+      stations = row.fetch('stations').map { |station| Station.new(station) }
+      # @type var empty_vehicles: Array[RubyBikes::object]
+      empty_vehicles = []
+      vehicles = row.fetch('vehicles', empty_vehicles).map { |vehicle| Vehicle.new(vehicle) }
+      @meta, @stations, @vehicles = row.fetch('meta'), stations, vehicles
+      self
+    rescue KeyError, TypeError, ArgumentError
+      raise ProtocolError, 'Provider returned an invalid snapshot'
+    end
+
+    def to_h
+      { 'tag' => tag, 'meta' => meta, 'stations' => stations.map(&:to_h), 'vehicles' => vehicles.map(&:to_h) }
+    end
+    alias to_dict to_h
+    def to_json(state = nil) = to_h.to_json(state)
+
+    def to_geojson
+      { 'type' => 'FeatureCollection', 'features' => (stations + vehicles).map(&:to_geojson) }
+    end
+  end
+end
+
+# Preserve the exception names used by existing RubyBikes consumers.
+NoSystemFoundError = RubyBikes::NoSystemFoundError unless defined?(NoSystemFoundError)
+NoGetCriteriaError = RubyBikes::NoGetCriteriaError unless defined?(NoGetCriteriaError)
+APIKeyNotAvailableError = RubyBikes::APIKeyNotAvailableError unless defined?(APIKeyNotAvailableError)
+require_relative 'rubybikes/engine'

data/sig/external.rbs

@@ -0,0 +1,30 @@
+# Parser and cookie libraries form dynamic external-data boundaries.
+module Nokogiri
+  def self.XML: (String) ?{ (untyped) -> untyped } -> untyped
+  def self.HTML: (String) -> untyped
+  module HTML
+    def self.fragment: (String) -> untyped
+  end
+end
+
+module HTTP
+  class Cookie
+    def name: () -> String
+    def value: () -> String
+  end
+  class CookieJar
+    def initialize: () -> void
+    def cookies: (URI::Generic) -> Array[Cookie]
+    def parse: (String, URI::Generic) -> Array[Cookie]
+  end
+end
+
+# JSON generation accepts the optional JSON state passed by JSON.dump.
+class Hash[unchecked out K, unchecked out V]
+  def to_json: (?untyped) -> String
+end
+
+# RBS 3.9 omits the mandatory block on this documented synchronization API.
+class Thread
+  def self.handle_interrupt: [A] (untyped) { () -> A } -> A
+end

data/sig/manifest.yaml

@@ -0,0 +1,8 @@
+dependencies:
+  - name: json
+  - name: time
+  - name: uri
+  - name: net-http
+  - name: timeout
+  - name: csv
+  - name: strscan

data/sig/native.rbs

@@ -0,0 +1,230 @@
+class RubyBikes
+  module Native
+    DATA: String
+    type bounds = Hash[String, untyped] | Array[untyped] | nil
+
+    module Geometry
+      def self?.contains?: (bounds, Float, Float) -> bool
+      def self?.polygon?: (untyped, Float, Float) -> bool
+      def self?.ring: (untyped, Float, Float) -> (:inside | :outside | :boundary)
+    end
+
+class ResponseCache
+  @ttl: Integer | Float
+  @max_bytes: Integer
+  @max_entries: Integer
+  @entries: Hash[untyped, Entry]
+  @bytes: Integer
+  @mutex: Mutex
+  class Entry < Struct[untyped]
+    attr_accessor response: Transport::Response
+    attr_accessor stored_at: Float
+    attr_accessor bytes: Integer
+    def self.new: (response: Transport::Response, stored_at: Float, bytes: Integer) -> Entry
+    def initialize: (response: Transport::Response, stored_at: Float, bytes: Integer) -> void
+  end
+  def initialize: (?ttl: Integer | Float, ?max_bytes: Integer, ?max_entries: Integer) -> void
+  def get: (untyped, Float) -> Transport::Response?
+  def put: (untyped, Transport::Response, Float) -> void
+  private
+  def atomic: [A] () { () -> A } -> A
+  def expire: (Float) -> void
+end
+
+    class Transport
+      @clock: ^() -> Float
+      @deadline: Float
+      @headers: Hash[String, String]
+      @proxy: URI::Generic?
+      @cooldowns: Hash[String, Float]
+      @cookies: untyped
+      @cache: ResponseCache
+      @last_response: Response
+      @deadline_active: bool
+      attr_reader headers: Hash[String, String]
+      attr_reader last_response: Response
+      class Response < Struct[untyped]
+        attr_accessor status: Integer
+        attr_accessor headers: Hash[String, String]
+        attr_accessor body: String
+        def self.new: (status: Integer, headers: Hash[String, String], body: String) -> Response
+        def initialize: (status: Integer, headers: Hash[String, String], body: String) -> void
+      end
+      def initialize: (?timeout: Numeric, ?headers: Hash[String, String], ?proxy: String?, ?cooldowns: Hash[String, Float], ?cache: ResponseCache?, ?clock: ^() -> Float) -> void
+      def remaining: () -> Float
+      def within_deadline: [A] () { () -> A } -> A
+      def request: (String, ?method: String, ?params: untyped, ?data: untyped, ?headers: Hash[String, String], ?raw: bool, ?skip_cache: bool, ?default_encoding: String) -> String
+      private
+      def perform_request: (String, method: String, params: untyped, data: untyped, headers: Hash[String, String], raw: bool, skip_cache: bool, default_encoding: String) -> String
+      def decode: (Response, bool, String) -> String
+      def transport_uri: (String) -> URI::HTTP
+      def fetch: (URI::HTTP, String, untyped, Hash[String, String], Integer) -> Response
+    end
+
+    class Provider
+      @spec: object
+      @parameters: object
+      @tag: String
+      @meta: object
+      @key: untyped
+      @transport: Transport
+      @stations: Array[station_row]
+      @vehicles: Array[vehicle_row]
+      attr_reader tag: String
+      attr_reader meta: object
+      attr_reader spec: object
+      attr_reader parameters: object
+      def initialize: (object, object, ?key: api_key) -> void
+      def snapshot: (Transport) -> object
+      def update: () -> void
+      def station: (String?, untyped, untyped, ?Integer?, ?Integer?, ?object) -> Array[station_row]?
+      def vehicle: (untyped, untyped, ?object, ?String) -> Array[vehicle_row]?
+      def request: (String, **untyped) -> String
+      def json: (String, **untyped) -> untyped
+      def xml: (String, **untyped) -> untyped
+      def html: (String, **untyped) -> untyped
+      def p: (String, ?untyped) -> untyped
+      def number: (untyped) -> Integer
+      def list: (untyped) -> Array[untyped]
+      def integer: (untyped) -> Integer?
+      def truthy?: (untyped) -> bool?
+      def iso_date: (untyped) -> String?
+    end
+
+    class Gbfs < Provider
+      @feed_url: String
+      def initialize: (object, object, ?key: api_key) -> void
+      def update: () -> void
+      def vehicle_kind: (object) -> [String?, String?]
+      private
+      def discover_feeds: (untyped) -> Hash[String, String]
+      def parse_gbfs_station: (object, object) -> void
+    end
+
+    class Nextbike < Provider
+      def update: () -> void
+    end
+
+    class JsonProviders < Provider
+      EMOVITY_USER_AGENT: String
+      SAMBA_USER_AGENT: String
+      DECOBIKE_HEADERS: Hash[String, String]
+      BICINCITTA_STATUSES: Hash[Integer, String]
+      DETAIL_JSON_HEADERS: Hash[String, String]
+      FSM_ENDPOINT: String
+      FSM_HEADERS: Hash[String, String]
+      XIAN_SOAP: String
+      def initialize: (object, object, ?key: api_key) -> void
+      def update: () -> void
+      def update_aksu: () -> void
+      def update_baksi: () -> void
+      def update_batumvelo: () -> void
+      def update_bicicard: () -> void
+      def update_bicicas: () -> void
+      def update_bicielx: () -> void
+      def update_biciferrolterra: () -> void
+      def update_bicimad: () -> void
+      def update_bicincitta: () -> void
+      def update_bicing: () -> void
+      def update_bikeshare_ie: () -> void
+      def update_bikeu: () -> void
+      def update_bixi: () -> void
+      def update_charichari: () -> void
+      def update_chartered_bike: () -> void
+      def update_clujbike: () -> void
+      def update_cyclopolis: () -> void
+      def update_cyclopolis_api: () -> void
+      def update_cykleo: () -> void
+      def update_decobike: () -> void
+      def update_digitransit: () -> void
+      def update_easybike: () -> void
+      def update_emovity: () -> void
+      def update_encicla: () -> void
+      def update_fifteen: () -> void
+      def update_fsm: () -> void
+      def update_ganxeta: () -> void
+      def update_gira: () -> void
+      def update_gyorbike: () -> void
+      def update_joco: () -> void
+      def update_keolis: () -> void
+      def update_kolumbus: () -> void
+      def update_lastenvelo: () -> void
+      def update_linkbike: () -> void
+      def update_meiob: () -> void
+      def update_mobhis: () -> void
+      def update_movus: () -> void
+      def update_nubija: () -> void
+      def update_open_source_bike_share: () -> void
+      def update_openmove: () -> void
+      def update_otp: () -> void
+      def update_ov_fiets: () -> void
+      def update_pedalada: () -> void
+      def update_publibike: () -> void
+      def update_qrobici: () -> void
+      def update_roovee: () -> void
+      def update_samba: () -> void
+      def update_sejong: () -> void
+      def update_seoulbike: () -> void
+      def update_slovnaft_bajk: () -> void
+      def update_smartbike: () -> void
+      def update_smoove: () -> void
+      def update_soltrafego: () -> void
+      def update_tashu: () -> void
+      def update_urbansharing: () -> void
+      def update_velobike_kz: () -> void
+      def update_velok: () -> void
+      def update_veloway: () -> void
+      def update_weelo: () -> void
+      def update_wegoshare: () -> void
+      def update_xian: () -> void
+      def update_yelovelo: () -> void
+      def update_youbike: () -> void
+      def lower_keys: (untyped) -> untyped
+      def graphql: (String, String, ?object, ?operation: String?) -> untyped
+      def otp_type: (object) -> [String?, String]
+      private
+      def html_scan: (String, Regexp) -> Array[untyped]
+      def html_match: (String, Regexp) -> MatchData
+      def html_capture: (String, Regexp) -> String
+      def html_text: (untyped, String) -> String
+      def gyorbike_count: (untyped, String) -> Integer
+      def velobike_number: (untyped) -> Integer
+      def detail_xml: (String, **untyped) -> untyped
+      def xml_text: (untyped, String) -> untyped
+      def xml_boolean?: (String) -> bool
+      def bicincitta_coordinate: (String) -> Float
+      def pedalada_status: (object) -> String
+      def cyclopolis_count: (String) -> Integer
+    end
+
+    class DataLiteral
+      @scanner: StringScanner
+      def self.parse: (String) -> json
+      def initialize: (String) -> void
+      def parse: () -> json
+      private
+      def whitespace: () -> Integer?
+      def value: (Integer) -> json
+      def sequence: (Integer, String) -> Array[json]
+      def string: () -> String
+    end
+
+    class Engine
+      MANIFEST: object
+      @timeout: Float
+      @providers: Array[object]
+      @definitions: Hash[String, object]
+      @mutex: Mutex
+      @cooldowns: Hash[String, Float]
+      @systems: Hash[String, Provider]
+      @response_cache: ResponseCache
+      attr_reader timeout: Float
+      def initialize: (?timeout: Numeric) -> void
+      def request: (String, ?timeout: Numeric, **untyped) -> untyped
+      def close: () -> void
+      private
+      def catalog_instances: (untyped) -> Array[untyped]
+      def find_spec: (object) -> object
+    end
+  end
+end