sports-odds-api 1.0.0

data/rbi/sports_odds_api/models/event_get_params.rbi

@@ -0,0 +1,286 @@
+# typed: strong
+
+module SportsOddsAPI
+  module Models
+    class EventGetParams < SportsOddsAPI::Internal::Type::BaseModel
+      extend SportsOddsAPI::Internal::Type::RequestParameters::Converter
+      include SportsOddsAPI::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(SportsOddsAPI::EventGetParams, SportsOddsAPI::Internal::AnyHash)
+        end
+
+      # A bookmakerID or comma-separated list of bookmakerIDs to include odds for
+      sig { returns(T.nilable(String)) }
+      attr_reader :bookmaker_id
+
+      sig { params(bookmaker_id: String).void }
+      attr_writer :bookmaker_id
+
+      # Only include cancelled Events (true), only non-cancelled Events (false) or all
+      # Events (omit)
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :cancelled
+
+      sig { params(cancelled: T::Boolean).void }
+      attr_writer :cancelled
+
+      # The cursor for the request. Used to get the next group of Events. This should be
+      # the nextCursor from the prior response.
+      sig { returns(T.nilable(String)) }
+      attr_reader :cursor
+
+      sig { params(cursor: String).void }
+      attr_writer :cursor
+
+      # Only include Events which have have ended (true), only Events which have not
+      # ended (false) or all Events (omit)
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :ended
+
+      sig { params(ended: T::Boolean).void }
+      attr_writer :ended
+
+      # An eventID or comma-separated list of eventIDs to get Event data for
+      sig { returns(T.nilable(String)) }
+      attr_reader :event_id
+
+      sig { params(event_id: String).void }
+      attr_writer :event_id
+
+      # Only include finalized Events (true), exclude unfinalized Events (false) or all
+      # Events (omit)
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :finalized
+
+      sig { params(finalized: T::Boolean).void }
+      attr_writer :finalized
+
+      # Whether to include alternate lines in the odds byBookmaker data
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :include_alt_lines
+
+      sig { params(include_alt_lines: T::Boolean).void }
+      attr_writer :include_alt_lines
+
+      # Whether to include opposing odds for each included oddID
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :include_opposing_odds
+
+      sig { params(include_opposing_odds: T::Boolean).void }
+      attr_writer :include_opposing_odds
+
+      # A leagueID or comma-separated list of leagueIDs to get Events for
+      sig { returns(T.nilable(String)) }
+      attr_reader :league_id
+
+      sig { params(league_id: String).void }
+      attr_writer :league_id
+
+      # The maximum number of Events to return
+      sig { returns(T.nilable(Float)) }
+      attr_reader :limit
+
+      sig { params(limit: Float).void }
+      attr_writer :limit
+
+      # Only include live Events (true), only non-live Events (false) or all Events
+      # (omit)
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :live
+
+      sig { params(live: T::Boolean).void }
+      attr_writer :live
+
+      # An oddID or comma-separated list of oddIDs to include odds for
+      sig { returns(T.nilable(String)) }
+      attr_reader :odd_id
+
+      sig { params(odd_id: String).void }
+      attr_writer :odd_id
+
+      # Whether you want only Events which do (true) or do not (false) have odds markets
+      # which are currently available (open for wagering)
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :odds_available
+
+      sig { params(odds_available: T::Boolean).void }
+      attr_writer :odds_available
+
+      # Whether you want only Events which do (true) or do not (false) have any
+      # associated odds markets regardless of whether those odds markets are currently
+      # available (open for wagering)
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :odds_present
+
+      sig { params(odds_present: T::Boolean).void }
+      attr_writer :odds_present
+
+      # A playerID or comma-separated list of playerIDs to include Events (and
+      # associated odds) for
+      sig { returns(T.nilable(String)) }
+      attr_reader :player_id
+
+      sig { params(player_id: String).void }
+      attr_writer :player_id
+
+      # A sportID or comma-separated list of sportIDs to get Events for
+      sig { returns(T.nilable(String)) }
+      attr_reader :sport_id
+
+      sig { params(sport_id: String).void }
+      attr_writer :sport_id
+
+      # Only include Events which have have previously started (true), only Events which
+      # have not previously started (false) or all Events (omit)
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :started
+
+      sig { params(started: T::Boolean).void }
+      attr_writer :started
+
+      # Get Events that start after this date
+      sig { returns(T.nilable(Time)) }
+      attr_reader :starts_after
+
+      sig { params(starts_after: Time).void }
+      attr_writer :starts_after
+
+      # Get Events that start before this date
+      sig { returns(T.nilable(Time)) }
+      attr_reader :starts_before
+
+      sig { params(starts_before: Time).void }
+      attr_writer :starts_before
+
+      # A teamID or comma-separated list of teamIDs to include Events for
+      sig { returns(T.nilable(String)) }
+      attr_reader :team_id
+
+      sig { params(team_id: String).void }
+      attr_writer :team_id
+
+      # Only include Events of the specified type
+      sig { returns(T.nilable(String)) }
+      attr_reader :type
+
+      sig { params(type: String).void }
+      attr_writer :type
+
+      sig do
+        params(
+          bookmaker_id: String,
+          cancelled: T::Boolean,
+          cursor: String,
+          ended: T::Boolean,
+          event_id: String,
+          finalized: T::Boolean,
+          include_alt_lines: T::Boolean,
+          include_opposing_odds: T::Boolean,
+          league_id: String,
+          limit: Float,
+          live: T::Boolean,
+          odd_id: String,
+          odds_available: T::Boolean,
+          odds_present: T::Boolean,
+          player_id: String,
+          sport_id: String,
+          started: T::Boolean,
+          starts_after: Time,
+          starts_before: Time,
+          team_id: String,
+          type: String,
+          request_options: SportsOddsAPI::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # A bookmakerID or comma-separated list of bookmakerIDs to include odds for
+        bookmaker_id: nil,
+        # Only include cancelled Events (true), only non-cancelled Events (false) or all
+        # Events (omit)
+        cancelled: nil,
+        # The cursor for the request. Used to get the next group of Events. This should be
+        # the nextCursor from the prior response.
+        cursor: nil,
+        # Only include Events which have have ended (true), only Events which have not
+        # ended (false) or all Events (omit)
+        ended: nil,
+        # An eventID or comma-separated list of eventIDs to get Event data for
+        event_id: nil,
+        # Only include finalized Events (true), exclude unfinalized Events (false) or all
+        # Events (omit)
+        finalized: nil,
+        # Whether to include alternate lines in the odds byBookmaker data
+        include_alt_lines: nil,
+        # Whether to include opposing odds for each included oddID
+        include_opposing_odds: nil,
+        # A leagueID or comma-separated list of leagueIDs to get Events for
+        league_id: nil,
+        # The maximum number of Events to return
+        limit: nil,
+        # Only include live Events (true), only non-live Events (false) or all Events
+        # (omit)
+        live: nil,
+        # An oddID or comma-separated list of oddIDs to include odds for
+        odd_id: nil,
+        # Whether you want only Events which do (true) or do not (false) have odds markets
+        # which are currently available (open for wagering)
+        odds_available: nil,
+        # Whether you want only Events which do (true) or do not (false) have any
+        # associated odds markets regardless of whether those odds markets are currently
+        # available (open for wagering)
+        odds_present: nil,
+        # A playerID or comma-separated list of playerIDs to include Events (and
+        # associated odds) for
+        player_id: nil,
+        # A sportID or comma-separated list of sportIDs to get Events for
+        sport_id: nil,
+        # Only include Events which have have previously started (true), only Events which
+        # have not previously started (false) or all Events (omit)
+        started: nil,
+        # Get Events that start after this date
+        starts_after: nil,
+        # Get Events that start before this date
+        starts_before: nil,
+        # A teamID or comma-separated list of teamIDs to include Events for
+        team_id: nil,
+        # Only include Events of the specified type
+        type: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            bookmaker_id: String,
+            cancelled: T::Boolean,
+            cursor: String,
+            ended: T::Boolean,
+            event_id: String,
+            finalized: T::Boolean,
+            include_alt_lines: T::Boolean,
+            include_opposing_odds: T::Boolean,
+            league_id: String,
+            limit: Float,
+            live: T::Boolean,
+            odd_id: String,
+            odds_available: T::Boolean,
+            odds_present: T::Boolean,
+            player_id: String,
+            sport_id: String,
+            started: T::Boolean,
+            starts_after: Time,
+            starts_before: Time,
+            team_id: String,
+            type: String,
+            request_options: SportsOddsAPI::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/sports_odds_api/models/league.rbi

@@ -0,0 +1,74 @@
+# typed: strong
+
+module SportsOddsAPI
+  module Models
+    class League < SportsOddsAPI::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(SportsOddsAPI::League, SportsOddsAPI::Internal::AnyHash)
+        end
+
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :enabled
+
+      sig { params(enabled: T::Boolean).void }
+      attr_writer :enabled
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :league_id
+
+      sig { params(league_id: String).void }
+      attr_writer :league_id
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :name
+
+      sig { params(name: String).void }
+      attr_writer :name
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :short_name
+
+      sig { params(short_name: String).void }
+      attr_writer :short_name
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :sport_id
+
+      sig { params(sport_id: String).void }
+      attr_writer :sport_id
+
+      sig do
+        params(
+          enabled: T::Boolean,
+          league_id: String,
+          name: String,
+          short_name: String,
+          sport_id: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        enabled: nil,
+        league_id: nil,
+        name: nil,
+        short_name: nil,
+        sport_id: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            enabled: T::Boolean,
+            league_id: String,
+            name: String,
+            short_name: String,
+            sport_id: String
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/sports_odds_api/models/league_get_params.rbi

@@ -0,0 +1,60 @@
+# typed: strong
+
+module SportsOddsAPI
+  module Models
+    class LeagueGetParams < SportsOddsAPI::Internal::Type::BaseModel
+      extend SportsOddsAPI::Internal::Type::RequestParameters::Converter
+      include SportsOddsAPI::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            SportsOddsAPI::LeagueGetParams,
+            SportsOddsAPI::Internal::AnyHash
+          )
+        end
+
+      # The league to get data for
+      sig { returns(T.nilable(String)) }
+      attr_reader :league_id
+
+      sig { params(league_id: String).void }
+      attr_writer :league_id
+
+      # The sport to get leagues for
+      sig { returns(T.nilable(String)) }
+      attr_reader :sport_id
+
+      sig { params(sport_id: String).void }
+      attr_writer :sport_id
+
+      sig do
+        params(
+          league_id: String,
+          sport_id: String,
+          request_options: SportsOddsAPI::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The league to get data for
+        league_id: nil,
+        # The sport to get leagues for
+        sport_id: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            league_id: String,
+            sport_id: String,
+            request_options: SportsOddsAPI::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/sports_odds_api/models/league_get_response.rbi

@@ -0,0 +1,11 @@
+# typed: strong
+
+module SportsOddsAPI
+  module Models
+    LeagueGetResponse =
+      T.let(
+        SportsOddsAPI::Internal::Type::ArrayOf[SportsOddsAPI::League],
+        SportsOddsAPI::Internal::Type::Converter
+      )
+  end
+end

data/rbi/sports_odds_api/models/player.rbi

@@ -0,0 +1,247 @@
+# typed: strong
+
+module SportsOddsAPI
+  module Models
+    class Player < SportsOddsAPI::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(SportsOddsAPI::Player, SportsOddsAPI::Internal::AnyHash)
+        end
+
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_reader :aliases
+
+      sig { params(aliases: T::Array[String]).void }
+      attr_writer :aliases
+
+      sig { returns(T.nilable(Float)) }
+      attr_reader :jersey_number
+
+      sig { params(jersey_number: Float).void }
+      attr_writer :jersey_number
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :league_id
+
+      sig { params(league_id: String).void }
+      attr_writer :league_id
+
+      sig { returns(T.nilable(SportsOddsAPI::Player::Lookups)) }
+      attr_reader :lookups
+
+      sig { params(lookups: SportsOddsAPI::Player::Lookups::OrHash).void }
+      attr_writer :lookups
+
+      sig { returns(T.nilable(SportsOddsAPI::Player::Names)) }
+      attr_reader :names
+
+      sig { params(names: SportsOddsAPI::Player::Names::OrHash).void }
+      attr_writer :names
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :player_id
+
+      sig { params(player_id: String).void }
+      attr_writer :player_id
+
+      sig do
+        returns(T.nilable(T::Hash[Symbol, SportsOddsAPI::Player::PlayerTeam]))
+      end
+      attr_reader :player_teams
+
+      sig do
+        params(
+          player_teams:
+            T::Hash[Symbol, SportsOddsAPI::Player::PlayerTeam::OrHash]
+        ).void
+      end
+      attr_writer :player_teams
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :position
+
+      sig { params(position: String).void }
+      attr_writer :position
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :sport_id
+
+      sig { params(sport_id: String).void }
+      attr_writer :sport_id
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :team_id
+
+      sig { params(team_id: String).void }
+      attr_writer :team_id
+
+      sig do
+        params(
+          aliases: T::Array[String],
+          jersey_number: Float,
+          league_id: String,
+          lookups: SportsOddsAPI::Player::Lookups::OrHash,
+          names: SportsOddsAPI::Player::Names::OrHash,
+          player_id: String,
+          player_teams:
+            T::Hash[Symbol, SportsOddsAPI::Player::PlayerTeam::OrHash],
+          position: String,
+          sport_id: String,
+          team_id: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        aliases: nil,
+        jersey_number: nil,
+        league_id: nil,
+        lookups: nil,
+        names: nil,
+        player_id: nil,
+        player_teams: nil,
+        position: nil,
+        sport_id: nil,
+        team_id: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            aliases: T::Array[String],
+            jersey_number: Float,
+            league_id: String,
+            lookups: SportsOddsAPI::Player::Lookups,
+            names: SportsOddsAPI::Player::Names,
+            player_id: String,
+            player_teams: T::Hash[Symbol, SportsOddsAPI::Player::PlayerTeam],
+            position: String,
+            sport_id: String,
+            team_id: String
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Lookups < SportsOddsAPI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              SportsOddsAPI::Player::Lookups,
+              SportsOddsAPI::Internal::AnyHash
+            )
+          end
+
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_reader :any_name
+
+        sig { params(any_name: T::Array[String]).void }
+        attr_writer :any_name
+
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_reader :full_name
+
+        sig { params(full_name: T::Array[String]).void }
+        attr_writer :full_name
+
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_reader :initials
+
+        sig { params(initials: T::Array[String]).void }
+        attr_writer :initials
+
+        sig do
+          params(
+            any_name: T::Array[String],
+            full_name: T::Array[String],
+            initials: T::Array[String]
+          ).returns(T.attached_class)
+        end
+        def self.new(any_name: nil, full_name: nil, initials: nil)
+        end
+
+        sig do
+          override.returns(
+            {
+              any_name: T::Array[String],
+              full_name: T::Array[String],
+              initials: T::Array[String]
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+
+      class Names < SportsOddsAPI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              SportsOddsAPI::Player::Names,
+              SportsOddsAPI::Internal::AnyHash
+            )
+          end
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :display_
+
+        sig { params(display_: String).void }
+        attr_writer :display_
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :first_name
+
+        sig { params(first_name: String).void }
+        attr_writer :first_name
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :last_name
+
+        sig { params(last_name: String).void }
+        attr_writer :last_name
+
+        sig do
+          params(
+            display_: String,
+            first_name: String,
+            last_name: String
+          ).returns(T.attached_class)
+        end
+        def self.new(display_: nil, first_name: nil, last_name: nil)
+        end
+
+        sig do
+          override.returns(
+            { display_: String, first_name: String, last_name: String }
+          )
+        end
+        def to_hash
+        end
+      end
+
+      class PlayerTeam < SportsOddsAPI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              SportsOddsAPI::Player::PlayerTeam,
+              SportsOddsAPI::Internal::AnyHash
+            )
+          end
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :team_id
+
+        sig { params(team_id: String).void }
+        attr_writer :team_id
+
+        sig { params(team_id: String).returns(T.attached_class) }
+        def self.new(team_id: nil)
+        end
+
+        sig { override.returns({ team_id: String }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end