sports-odds-api 1.0.0

data/rbi/sports_odds_api/models/stat.rbi

@@ -0,0 +1,273 @@
+# typed: strong
+
+module SportsOddsAPI
+  module Models
+    class Stat < SportsOddsAPI::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(SportsOddsAPI::Stat, SportsOddsAPI::Internal::AnyHash)
+        end
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :description
+
+      sig { params(description: String).void }
+      attr_writer :description
+
+      sig { returns(T.nilable(SportsOddsAPI::Stat::Displays)) }
+      attr_reader :displays
+
+      sig { params(displays: SportsOddsAPI::Stat::Displays::OrHash).void }
+      attr_writer :displays
+
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :is_score_stat
+
+      sig { params(is_score_stat: T::Boolean).void }
+      attr_writer :is_score_stat
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :stat_id
+
+      sig { params(stat_id: String).void }
+      attr_writer :stat_id
+
+      sig { returns(T.nilable(SportsOddsAPI::Stat::SupportedLevels)) }
+      attr_reader :supported_levels
+
+      sig do
+        params(
+          supported_levels: SportsOddsAPI::Stat::SupportedLevels::OrHash
+        ).void
+      end
+      attr_writer :supported_levels
+
+      sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+      attr_reader :supported_sports
+
+      sig { params(supported_sports: T::Hash[Symbol, T.anything]).void }
+      attr_writer :supported_sports
+
+      sig { returns(T.nilable(SportsOddsAPI::Stat::Units)) }
+      attr_reader :units
+
+      sig { params(units: SportsOddsAPI::Stat::Units::OrHash).void }
+      attr_writer :units
+
+      sig do
+        params(
+          description: String,
+          displays: SportsOddsAPI::Stat::Displays::OrHash,
+          is_score_stat: T::Boolean,
+          stat_id: String,
+          supported_levels: SportsOddsAPI::Stat::SupportedLevels::OrHash,
+          supported_sports: T::Hash[Symbol, T.anything],
+          units: SportsOddsAPI::Stat::Units::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        description: nil,
+        displays: nil,
+        is_score_stat: nil,
+        stat_id: nil,
+        supported_levels: nil,
+        supported_sports: nil,
+        units: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            description: String,
+            displays: SportsOddsAPI::Stat::Displays,
+            is_score_stat: T::Boolean,
+            stat_id: String,
+            supported_levels: SportsOddsAPI::Stat::SupportedLevels,
+            supported_sports: T::Hash[Symbol, T.anything],
+            units: SportsOddsAPI::Stat::Units
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Displays < SportsOddsAPI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              SportsOddsAPI::Stat::Displays,
+              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 :short
+
+        sig { params(short: String).void }
+        attr_writer :short
+
+        sig { params(long: String, short: String).returns(T.attached_class) }
+        def self.new(long: nil, short: nil)
+        end
+
+        sig { override.returns({ long: String, short: String }) }
+        def to_hash
+        end
+      end
+
+      class SupportedLevels < SportsOddsAPI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              SportsOddsAPI::Stat::SupportedLevels,
+              SportsOddsAPI::Internal::AnyHash
+            )
+          end
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :all
+
+        sig { params(all: T::Boolean).void }
+        attr_writer :all
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :player
+
+        sig { params(player: T::Boolean).void }
+        attr_writer :player
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :team
+
+        sig { params(team: T::Boolean).void }
+        attr_writer :team
+
+        sig do
+          params(all: T::Boolean, player: T::Boolean, team: T::Boolean).returns(
+            T.attached_class
+          )
+        end
+        def self.new(all: nil, player: nil, team: nil)
+        end
+
+        sig do
+          override.returns(
+            { all: T::Boolean, player: T::Boolean, team: T::Boolean }
+          )
+        end
+        def to_hash
+        end
+      end
+
+      class Units < SportsOddsAPI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(SportsOddsAPI::Stat::Units, SportsOddsAPI::Internal::AnyHash)
+          end
+
+        sig { returns(T.nilable(SportsOddsAPI::Stat::Units::Long)) }
+        attr_reader :long
+
+        sig { params(long: SportsOddsAPI::Stat::Units::Long::OrHash).void }
+        attr_writer :long
+
+        sig { returns(T.nilable(SportsOddsAPI::Stat::Units::Short)) }
+        attr_reader :short
+
+        sig { params(short: SportsOddsAPI::Stat::Units::Short::OrHash).void }
+        attr_writer :short
+
+        sig do
+          params(
+            long: SportsOddsAPI::Stat::Units::Long::OrHash,
+            short: SportsOddsAPI::Stat::Units::Short::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(long: nil, short: nil)
+        end
+
+        sig do
+          override.returns(
+            {
+              long: SportsOddsAPI::Stat::Units::Long,
+              short: SportsOddsAPI::Stat::Units::Short
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Long < SportsOddsAPI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                SportsOddsAPI::Stat::Units::Long,
+                SportsOddsAPI::Internal::AnyHash
+              )
+            end
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :plural
+
+          sig { params(plural: String).void }
+          attr_writer :plural
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :singular
+
+          sig { params(singular: String).void }
+          attr_writer :singular
+
+          sig do
+            params(plural: String, singular: String).returns(T.attached_class)
+          end
+          def self.new(plural: nil, singular: nil)
+          end
+
+          sig { override.returns({ plural: String, singular: String }) }
+          def to_hash
+          end
+        end
+
+        class Short < SportsOddsAPI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                SportsOddsAPI::Stat::Units::Short,
+                SportsOddsAPI::Internal::AnyHash
+              )
+            end
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :plural
+
+          sig { params(plural: String).void }
+          attr_writer :plural
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :singular
+
+          sig { params(singular: String).void }
+          attr_writer :singular
+
+          sig do
+            params(plural: String, singular: String).returns(T.attached_class)
+          end
+          def self.new(plural: nil, singular: nil)
+          end
+
+          sig { override.returns({ plural: String, singular: String }) }
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/sports_odds_api/models/stat_get_params.rbi

@@ -0,0 +1,72 @@
+# typed: strong
+
+module SportsOddsAPI
+  module Models
+    class StatGetParams < SportsOddsAPI::Internal::Type::BaseModel
+      extend SportsOddsAPI::Internal::Type::RequestParameters::Converter
+      include SportsOddsAPI::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(SportsOddsAPI::StatGetParams, SportsOddsAPI::Internal::AnyHash)
+        end
+
+      # SportID to get StatIDs for
+      sig { returns(T.nilable(String)) }
+      attr_reader :sport_id
+
+      sig { params(sport_id: String).void }
+      attr_writer :sport_id
+
+      # StatID to get data for
+      sig { returns(T.nilable(String)) }
+      attr_reader :stat_id
+
+      sig { params(stat_id: String).void }
+      attr_writer :stat_id
+
+      # Level of the stat, must be used in combination with sportID. Must be one of all,
+      # player, or team. Shows stats that are applicable to that specified entity,
+      # defaults to all.
+      sig { returns(T.nilable(String)) }
+      attr_reader :stat_level
+
+      sig { params(stat_level: String).void }
+      attr_writer :stat_level
+
+      sig do
+        params(
+          sport_id: String,
+          stat_id: String,
+          stat_level: String,
+          request_options: SportsOddsAPI::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # SportID to get StatIDs for
+        sport_id: nil,
+        # StatID to get data for
+        stat_id: nil,
+        # Level of the stat, must be used in combination with sportID. Must be one of all,
+        # player, or team. Shows stats that are applicable to that specified entity,
+        # defaults to all.
+        stat_level: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            sport_id: String,
+            stat_id: String,
+            stat_level: String,
+            request_options: SportsOddsAPI::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/sports_odds_api/models/stat_get_response.rbi

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

data/rbi/sports_odds_api/models/stream_events_params.rbi

@@ -0,0 +1,71 @@
+# typed: strong
+
+module SportsOddsAPI
+  module Models
+    class StreamEventsParams < SportsOddsAPI::Internal::Type::BaseModel
+      extend SportsOddsAPI::Internal::Type::RequestParameters::Converter
+      include SportsOddsAPI::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            SportsOddsAPI::StreamEventsParams,
+            SportsOddsAPI::Internal::AnyHash
+          )
+        end
+
+      # An eventID to stream events for
+      sig { returns(T.nilable(String)) }
+      attr_reader :event_id
+
+      sig { params(event_id: String).void }
+      attr_writer :event_id
+
+      # The feed you would like to subscribe to
+      sig { returns(T.nilable(String)) }
+      attr_reader :feed
+
+      sig { params(feed: String).void }
+      attr_writer :feed
+
+      # A leagueID to stream events for
+      sig { returns(T.nilable(String)) }
+      attr_reader :league_id
+
+      sig { params(league_id: String).void }
+      attr_writer :league_id
+
+      sig do
+        params(
+          event_id: String,
+          feed: String,
+          league_id: String,
+          request_options: SportsOddsAPI::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # An eventID to stream events for
+        event_id: nil,
+        # The feed you would like to subscribe to
+        feed: nil,
+        # A leagueID to stream events for
+        league_id: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            event_id: String,
+            feed: String,
+            league_id: String,
+            request_options: SportsOddsAPI::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/sports_odds_api/models/stream_events_response.rbi

@@ -0,0 +1,247 @@
+# typed: strong
+
+module SportsOddsAPI
+  module Models
+    class StreamEventsResponse < SportsOddsAPI::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            SportsOddsAPI::Models::StreamEventsResponse,
+            SportsOddsAPI::Internal::AnyHash
+          )
+        end
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :channel
+
+      sig { params(channel: String).void }
+      attr_writer :channel
+
+      sig { returns(T.nilable(T::Array[SportsOddsAPI::Event])) }
+      attr_reader :data
+
+      sig { params(data: T::Array[SportsOddsAPI::Event::OrHash]).void }
+      attr_writer :data
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :pusher_key
+
+      sig { params(pusher_key: String).void }
+      attr_writer :pusher_key
+
+      sig do
+        returns(
+          T.nilable(SportsOddsAPI::Models::StreamEventsResponse::PusherOptions)
+        )
+      end
+      attr_reader :pusher_options
+
+      sig do
+        params(
+          pusher_options:
+            SportsOddsAPI::Models::StreamEventsResponse::PusherOptions::OrHash
+        ).void
+      end
+      attr_writer :pusher_options
+
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :success
+
+      sig { params(success: T::Boolean).void }
+      attr_writer :success
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :user
+
+      sig { params(user: String).void }
+      attr_writer :user
+
+      sig do
+        params(
+          channel: String,
+          data: T::Array[SportsOddsAPI::Event::OrHash],
+          pusher_key: String,
+          pusher_options:
+            SportsOddsAPI::Models::StreamEventsResponse::PusherOptions::OrHash,
+          success: T::Boolean,
+          user: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        channel: nil,
+        data: nil,
+        pusher_key: nil,
+        pusher_options: nil,
+        success: nil,
+        user: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            channel: String,
+            data: T::Array[SportsOddsAPI::Event],
+            pusher_key: String,
+            pusher_options:
+              SportsOddsAPI::Models::StreamEventsResponse::PusherOptions,
+            success: T::Boolean,
+            user: String
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class PusherOptions < SportsOddsAPI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              SportsOddsAPI::Models::StreamEventsResponse::PusherOptions,
+              SportsOddsAPI::Internal::AnyHash
+            )
+          end
+
+        sig do
+          returns(
+            T.nilable(
+              SportsOddsAPI::Models::StreamEventsResponse::PusherOptions::ChannelAuthorization
+            )
+          )
+        end
+        attr_reader :channel_authorization
+
+        sig do
+          params(
+            channel_authorization:
+              SportsOddsAPI::Models::StreamEventsResponse::PusherOptions::ChannelAuthorization::OrHash
+          ).void
+        end
+        attr_writer :channel_authorization
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :cluster
+
+        sig { params(cluster: String).void }
+        attr_writer :cluster
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :http_host
+
+        sig { params(http_host: String).void }
+        attr_writer :http_host
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :http_port
+
+        sig { params(http_port: Integer).void }
+        attr_writer :http_port
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :https_port
+
+        sig { params(https_port: Integer).void }
+        attr_writer :https_port
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :ws_host
+
+        sig { params(ws_host: String).void }
+        attr_writer :ws_host
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :ws_port
+
+        sig { params(ws_port: Integer).void }
+        attr_writer :ws_port
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :wss_port
+
+        sig { params(wss_port: Integer).void }
+        attr_writer :wss_port
+
+        sig do
+          params(
+            channel_authorization:
+              SportsOddsAPI::Models::StreamEventsResponse::PusherOptions::ChannelAuthorization::OrHash,
+            cluster: String,
+            http_host: String,
+            http_port: Integer,
+            https_port: Integer,
+            ws_host: String,
+            ws_port: Integer,
+            wss_port: Integer
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          channel_authorization: nil,
+          cluster: nil,
+          http_host: nil,
+          http_port: nil,
+          https_port: nil,
+          ws_host: nil,
+          ws_port: nil,
+          wss_port: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              channel_authorization:
+                SportsOddsAPI::Models::StreamEventsResponse::PusherOptions::ChannelAuthorization,
+              cluster: String,
+              http_host: String,
+              http_port: Integer,
+              https_port: Integer,
+              ws_host: String,
+              ws_port: Integer,
+              wss_port: Integer
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class ChannelAuthorization < SportsOddsAPI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                SportsOddsAPI::Models::StreamEventsResponse::PusherOptions::ChannelAuthorization,
+                SportsOddsAPI::Internal::AnyHash
+              )
+            end
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :endpoint
+
+          sig { params(endpoint: String).void }
+          attr_writer :endpoint
+
+          sig { returns(T.nilable(T::Hash[Symbol, String])) }
+          attr_reader :headers
+
+          sig { params(headers: T::Hash[Symbol, String]).void }
+          attr_writer :headers
+
+          sig do
+            params(endpoint: String, headers: T::Hash[Symbol, String]).returns(
+              T.attached_class
+            )
+          end
+          def self.new(endpoint: nil, headers: nil)
+          end
+
+          sig do
+            override.returns(
+              { endpoint: String, headers: T::Hash[Symbol, String] }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end