sports-odds-api 1.0.0

data/rbi/sports_odds_api/models/team.rbi

@@ -0,0 +1,305 @@
+# typed: strong
+
+module SportsOddsAPI
+  module Models
+    class Team < SportsOddsAPI::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(SportsOddsAPI::Team, SportsOddsAPI::Internal::AnyHash)
+        end
+
+      sig { returns(T.nilable(SportsOddsAPI::Team::Colors)) }
+      attr_reader :colors
+
+      sig { params(colors: SportsOddsAPI::Team::Colors::OrHash).void }
+      attr_writer :colors
+
+      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 :logo
+
+      sig { params(logo: String).void }
+      attr_writer :logo
+
+      sig { returns(T.nilable(SportsOddsAPI::Team::Lookups)) }
+      attr_reader :lookups
+
+      sig { params(lookups: SportsOddsAPI::Team::Lookups::OrHash).void }
+      attr_writer :lookups
+
+      sig { returns(T.nilable(SportsOddsAPI::Team::Names)) }
+      attr_reader :names
+
+      sig { params(names: SportsOddsAPI::Team::Names::OrHash).void }
+      attr_writer :names
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :sport_id
+
+      sig { params(sport_id: String).void }
+      attr_writer :sport_id
+
+      sig { returns(T.nilable(SportsOddsAPI::Team::Standings)) }
+      attr_reader :standings
+
+      sig { params(standings: SportsOddsAPI::Team::Standings::OrHash).void }
+      attr_writer :standings
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :team_id
+
+      sig { params(team_id: String).void }
+      attr_writer :team_id
+
+      sig do
+        params(
+          colors: SportsOddsAPI::Team::Colors::OrHash,
+          league_id: String,
+          logo: String,
+          lookups: SportsOddsAPI::Team::Lookups::OrHash,
+          names: SportsOddsAPI::Team::Names::OrHash,
+          sport_id: String,
+          standings: SportsOddsAPI::Team::Standings::OrHash,
+          team_id: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        colors: nil,
+        league_id: nil,
+        logo: nil,
+        lookups: nil,
+        names: nil,
+        sport_id: nil,
+        standings: nil,
+        team_id: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            colors: SportsOddsAPI::Team::Colors,
+            league_id: String,
+            logo: String,
+            lookups: SportsOddsAPI::Team::Lookups,
+            names: SportsOddsAPI::Team::Names,
+            sport_id: String,
+            standings: SportsOddsAPI::Team::Standings,
+            team_id: String
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Colors < SportsOddsAPI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(SportsOddsAPI::Team::Colors, SportsOddsAPI::Internal::AnyHash)
+          end
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :primary
+
+        sig { params(primary: String).void }
+        attr_writer :primary
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :primary_contrast
+
+        sig { params(primary_contrast: String).void }
+        attr_writer :primary_contrast
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :secondary
+
+        sig { params(secondary: String).void }
+        attr_writer :secondary
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :secondary_contrast
+
+        sig { params(secondary_contrast: String).void }
+        attr_writer :secondary_contrast
+
+        sig do
+          params(
+            primary: String,
+            primary_contrast: String,
+            secondary: String,
+            secondary_contrast: String
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          primary: nil,
+          primary_contrast: nil,
+          secondary: nil,
+          secondary_contrast: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              primary: String,
+              primary_contrast: String,
+              secondary: String,
+              secondary_contrast: String
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+
+      class Lookups < SportsOddsAPI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              SportsOddsAPI::Team::Lookups,
+              SportsOddsAPI::Internal::AnyHash
+            )
+          end
+
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_reader :team_name
+
+        sig { params(team_name: T::Array[String]).void }
+        attr_writer :team_name
+
+        sig { params(team_name: T::Array[String]).returns(T.attached_class) }
+        def self.new(team_name: nil)
+        end
+
+        sig { override.returns({ team_name: T::Array[String] }) }
+        def to_hash
+        end
+      end
+
+      class Names < SportsOddsAPI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(SportsOddsAPI::Team::Names, SportsOddsAPI::Internal::AnyHash)
+          end
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :long
+
+        sig { params(long: String).void }
+        attr_writer :long
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :medium
+
+        sig { params(medium: String).void }
+        attr_writer :medium
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :short
+
+        sig { params(short: String).void }
+        attr_writer :short
+
+        sig do
+          params(long: String, medium: String, short: String).returns(
+            T.attached_class
+          )
+        end
+        def self.new(long: nil, medium: nil, short: nil)
+        end
+
+        sig do
+          override.returns({ long: String, medium: String, short: String })
+        end
+        def to_hash
+        end
+      end
+
+      class Standings < SportsOddsAPI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              SportsOddsAPI::Team::Standings,
+              SportsOddsAPI::Internal::AnyHash
+            )
+          end
+
+        sig { returns(T.nilable(Float)) }
+        attr_reader :losses
+
+        sig { params(losses: Float).void }
+        attr_writer :losses
+
+        sig { returns(T.nilable(Float)) }
+        attr_reader :played
+
+        sig { params(played: Float).void }
+        attr_writer :played
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :position
+
+        sig { params(position: String).void }
+        attr_writer :position
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :record
+
+        sig { params(record: String).void }
+        attr_writer :record
+
+        sig { returns(T.nilable(Float)) }
+        attr_reader :ties
+
+        sig { params(ties: Float).void }
+        attr_writer :ties
+
+        sig { returns(T.nilable(Float)) }
+        attr_reader :wins
+
+        sig { params(wins: Float).void }
+        attr_writer :wins
+
+        sig do
+          params(
+            losses: Float,
+            played: Float,
+            position: String,
+            record: String,
+            ties: Float,
+            wins: Float
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          losses: nil,
+          played: nil,
+          position: nil,
+          record: nil,
+          ties: nil,
+          wins: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              losses: Float,
+              played: Float,
+              position: String,
+              record: String,
+              ties: Float,
+              wins: Float
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/sports_odds_api/models/team_get_params.rbi

@@ -0,0 +1,92 @@
+# typed: strong
+
+module SportsOddsAPI
+  module Models
+    class TeamGetParams < SportsOddsAPI::Internal::Type::BaseModel
+      extend SportsOddsAPI::Internal::Type::RequestParameters::Converter
+      include SportsOddsAPI::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(SportsOddsAPI::TeamGetParams, SportsOddsAPI::Internal::AnyHash)
+        end
+
+      # The cursor for the request. Used to get the next group of Teams. 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
+
+      # A single leagueID or comma-separated list of leagueIDs to get Teams for
+      sig { returns(T.nilable(String)) }
+      attr_reader :league_id
+
+      sig { params(league_id: String).void }
+      attr_writer :league_id
+
+      # The maximum number of Teams to return
+      sig { returns(T.nilable(Float)) }
+      attr_reader :limit
+
+      sig { params(limit: Float).void }
+      attr_writer :limit
+
+      # A single sportID or comma-separated list of sportIDs to get Teams for
+      sig { returns(T.nilable(String)) }
+      attr_reader :sport_id
+
+      sig { params(sport_id: String).void }
+      attr_writer :sport_id
+
+      # A single teamID or comma-separated list of teamIDs to get data for
+      sig { returns(T.nilable(String)) }
+      attr_reader :team_id
+
+      sig { params(team_id: String).void }
+      attr_writer :team_id
+
+      sig do
+        params(
+          cursor: String,
+          league_id: String,
+          limit: Float,
+          sport_id: String,
+          team_id: String,
+          request_options: SportsOddsAPI::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The cursor for the request. Used to get the next group of Teams. This should be
+        # the nextCursor from the prior response.
+        cursor: nil,
+        # A single leagueID or comma-separated list of leagueIDs to get Teams for
+        league_id: nil,
+        # The maximum number of Teams to return
+        limit: nil,
+        # A single sportID or comma-separated list of sportIDs to get Teams for
+        sport_id: nil,
+        # A single teamID or comma-separated list of teamIDs to get data for
+        team_id: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            cursor: String,
+            league_id: String,
+            limit: Float,
+            sport_id: String,
+            team_id: String,
+            request_options: SportsOddsAPI::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/sports_odds_api/models.rbi

@@ -0,0 +1,35 @@
+# typed: strong
+
+module SportsOddsAPI
+  AccountGetUsageParams = SportsOddsAPI::Models::AccountGetUsageParams
+
+  AccountUsage = SportsOddsAPI::Models::AccountUsage
+
+  Event = SportsOddsAPI::Models::Event
+
+  EventGetParams = SportsOddsAPI::Models::EventGetParams
+
+  League = SportsOddsAPI::Models::League
+
+  LeagueGetParams = SportsOddsAPI::Models::LeagueGetParams
+
+  Player = SportsOddsAPI::Models::Player
+
+  PlayerGetParams = SportsOddsAPI::Models::PlayerGetParams
+
+  RateLimitInterval = SportsOddsAPI::Models::RateLimitInterval
+
+  Sport = SportsOddsAPI::Models::Sport
+
+  SportGetParams = SportsOddsAPI::Models::SportGetParams
+
+  Stat = SportsOddsAPI::Models::Stat
+
+  StatGetParams = SportsOddsAPI::Models::StatGetParams
+
+  StreamEventsParams = SportsOddsAPI::Models::StreamEventsParams
+
+  Team = SportsOddsAPI::Models::Team
+
+  TeamGetParams = SportsOddsAPI::Models::TeamGetParams
+end

data/rbi/sports_odds_api/request_options.rbi

@@ -0,0 +1,59 @@
+# typed: strong
+
+module SportsOddsAPI
+  # Specify HTTP behaviour to use for a specific request. These options supplement
+  # or override those provided at the client level.
+  #
+  # When making a request, you can pass an actual {RequestOptions} instance, or
+  # simply pass a Hash with symbol keys matching the attributes on this class.
+  class RequestOptions < SportsOddsAPI::Internal::Type::BaseModel
+    OrHash =
+      T.type_alias do
+        T.any(SportsOddsAPI::RequestOptions, SportsOddsAPI::Internal::AnyHash)
+      end
+
+    # @api private
+    sig { params(opts: SportsOddsAPI::RequestOptions::OrHash).void }
+    def self.validate!(opts)
+    end
+
+    # Idempotency key to send with request and all associated retries. Will only be
+    # sent for write requests.
+    sig { returns(T.nilable(String)) }
+    attr_accessor :idempotency_key
+
+    # Extra query params to send with the request. These are `.merge`’d into any
+    # `query` given at the client level.
+    sig do
+      returns(
+        T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))])
+      )
+    end
+    attr_accessor :extra_query
+
+    # Extra headers to send with the request. These are `.merged`’d into any
+    # `extra_headers` given at the client level.
+    sig { returns(T.nilable(T::Hash[String, T.nilable(String)])) }
+    attr_accessor :extra_headers
+
+    # Extra data to send with the request. These are deep merged into any data
+    # generated as part of the normal request.
+    sig { returns(T.nilable(T.anything)) }
+    attr_accessor :extra_body
+
+    # Maximum number of retries to attempt after a failed initial request.
+    sig { returns(T.nilable(Integer)) }
+    attr_accessor :max_retries
+
+    # Request timeout in seconds.
+    sig { returns(T.nilable(Float)) }
+    attr_accessor :timeout
+
+    # Returns a new instance of RequestOptions.
+    sig do
+      params(values: SportsOddsAPI::Internal::AnyHash).returns(T.attached_class)
+    end
+    def self.new(values = {})
+    end
+  end
+end

data/rbi/sports_odds_api/resources/account.rbi

@@ -0,0 +1,21 @@
+# typed: strong
+
+module SportsOddsAPI
+  module Resources
+    class Account
+      # Get rate-limits and usage data about your API key
+      sig do
+        params(request_options: SportsOddsAPI::RequestOptions::OrHash).returns(
+          SportsOddsAPI::AccountUsage
+        )
+      end
+      def get_usage(request_options: {})
+      end
+
+      # @api private
+      sig { params(client: SportsOddsAPI::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/sports_odds_api/resources/events.rbi

@@ -0,0 +1,96 @@
+# typed: strong
+
+module SportsOddsAPI
+  module Resources
+    class Events
+      # Get a list of Events
+      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(SportsOddsAPI::Internal::NextCursorPage[SportsOddsAPI::Event])
+      end
+      def get(
+        # 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
+
+      # @api private
+      sig { params(client: SportsOddsAPI::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/sports_odds_api/resources/leagues.rbi

@@ -0,0 +1,29 @@
+# typed: strong
+
+module SportsOddsAPI
+  module Resources
+    class Leagues
+      # Get a list of Leagues
+      sig do
+        params(
+          league_id: String,
+          sport_id: String,
+          request_options: SportsOddsAPI::RequestOptions::OrHash
+        ).returns(T::Array[SportsOddsAPI::League])
+      end
+      def get(
+        # The league to get data for
+        league_id: nil,
+        # The sport to get leagues for
+        sport_id: nil,
+        request_options: {}
+      )
+      end
+
+      # @api private
+      sig { params(client: SportsOddsAPI::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/sports_odds_api/resources/players.rbi

@@ -0,0 +1,41 @@
+# typed: strong
+
+module SportsOddsAPI
+  module Resources
+    class Players
+      # Get a list of Players for a specific Team or Event
+      sig do
+        params(
+          cursor: String,
+          event_id: String,
+          limit: Float,
+          player_id: String,
+          team_id: String,
+          request_options: SportsOddsAPI::RequestOptions::OrHash
+        ).returns(
+          SportsOddsAPI::Internal::NextCursorPage[SportsOddsAPI::Player]
+        )
+      end
+      def get(
+        # The cursor for the request. Used to get the next group of Players. This should
+        # be the nextCursor from the prior response.
+        cursor: nil,
+        # EventID to get Players data for
+        event_id: nil,
+        # The maximum number of Players to return
+        limit: nil,
+        # PlayerID to get data for
+        player_id: nil,
+        # TeamID to get Players data for
+        team_id: nil,
+        request_options: {}
+      )
+      end
+
+      # @api private
+      sig { params(client: SportsOddsAPI::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/sports_odds_api/resources/sports.rbi

@@ -0,0 +1,21 @@
+# typed: strong
+
+module SportsOddsAPI
+  module Resources
+    class Sports
+      # Get a list of sports
+      sig do
+        params(request_options: SportsOddsAPI::RequestOptions::OrHash).returns(
+          T::Array[SportsOddsAPI::Sport]
+        )
+      end
+      def get(request_options: {})
+      end
+
+      # @api private
+      sig { params(client: SportsOddsAPI::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end