believe 0.7.0

data/rbi/believe/models/match_get_lesson_params.rbi

@@ -0,0 +1,35 @@
+# typed: strong
+
+module Believe
+  module Models
+    class MatchGetLessonParams < ::Believe::Internal::Type::BaseModel
+      extend ::Believe::Internal::Type::RequestParameters::Converter
+      include ::Believe::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(::Believe::MatchGetLessonParams, ::Believe::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :match_id
+
+      sig do
+        params(
+          match_id: String,
+          request_options: ::Believe::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(match_id:, request_options: {})
+      end
+
+      sig do
+        override.returns(
+          { match_id: String, request_options: ::Believe::RequestOptions }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/believe/models/match_get_lesson_response.rbi

@@ -0,0 +1,11 @@
+# typed: strong
+
+module Believe
+  module Models
+    MatchGetLessonResponse =
+      T.let(
+        ::Believe::Internal::Type::HashOf[::Believe::Internal::Type::Unknown],
+        ::Believe::Internal::Type::Converter
+      )
+  end
+end

data/rbi/believe/models/match_get_turning_points_params.rbi

@@ -0,0 +1,38 @@
+# typed: strong
+
+module Believe
+  module Models
+    class MatchGetTurningPointsParams < ::Believe::Internal::Type::BaseModel
+      extend ::Believe::Internal::Type::RequestParameters::Converter
+      include ::Believe::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            ::Believe::MatchGetTurningPointsParams,
+            ::Believe::Internal::AnyHash
+          )
+        end
+
+      sig { returns(String) }
+      attr_accessor :match_id
+
+      sig do
+        params(
+          match_id: String,
+          request_options: ::Believe::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(match_id:, request_options: {})
+      end
+
+      sig do
+        override.returns(
+          { match_id: String, request_options: ::Believe::RequestOptions }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/believe/models/match_get_turning_points_response.rbi

@@ -0,0 +1,13 @@
+# typed: strong
+
+module Believe
+  module Models
+    MatchGetTurningPointsResponse =
+      T.let(
+        ::Believe::Internal::Type::ArrayOf[
+          ::Believe::Internal::Type::HashOf[::Believe::Internal::Type::Unknown]
+        ],
+        ::Believe::Internal::Type::Converter
+      )
+  end
+end

data/rbi/believe/models/match_list_params.rbi

@@ -0,0 +1,81 @@
+# typed: strong
+
+module Believe
+  module Models
+    class MatchListParams < ::Believe::Internal::Type::BaseModel
+      extend ::Believe::Internal::Type::RequestParameters::Converter
+      include ::Believe::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(::Believe::MatchListParams, ::Believe::Internal::AnyHash)
+        end
+
+      # Maximum number of items to return (max: 100)
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :limit
+
+      sig { params(limit: Integer).void }
+      attr_writer :limit
+
+      # Filter by match type
+      sig { returns(T.nilable(::Believe::MatchType::OrSymbol)) }
+      attr_accessor :match_type
+
+      # Filter by result
+      sig { returns(T.nilable(::Believe::MatchResult::OrSymbol)) }
+      attr_accessor :result
+
+      # Number of items to skip (offset)
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :skip
+
+      sig { params(skip: Integer).void }
+      attr_writer :skip
+
+      # Filter by team (home or away)
+      sig { returns(T.nilable(String)) }
+      attr_accessor :team_id
+
+      sig do
+        params(
+          limit: Integer,
+          match_type: T.nilable(::Believe::MatchType::OrSymbol),
+          result: T.nilable(::Believe::MatchResult::OrSymbol),
+          skip: Integer,
+          team_id: T.nilable(String),
+          request_options: ::Believe::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Maximum number of items to return (max: 100)
+        limit: nil,
+        # Filter by match type
+        match_type: nil,
+        # Filter by result
+        result: nil,
+        # Number of items to skip (offset)
+        skip: nil,
+        # Filter by team (home or away)
+        team_id: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            limit: Integer,
+            match_type: T.nilable(::Believe::MatchType::OrSymbol),
+            result: T.nilable(::Believe::MatchResult::OrSymbol),
+            skip: Integer,
+            team_id: T.nilable(String),
+            request_options: ::Believe::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/believe/models/match_result.rbi

@@ -0,0 +1,22 @@
+# typed: strong
+
+module Believe
+  module Models
+    # Match result types.
+    module MatchResult
+      extend ::Believe::Internal::Type::Enum
+
+      TaggedSymbol = T.type_alias { T.all(Symbol, ::Believe::MatchResult) }
+      OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+      WIN = T.let(:win, ::Believe::MatchResult::TaggedSymbol)
+      LOSS = T.let(:loss, ::Believe::MatchResult::TaggedSymbol)
+      DRAW = T.let(:draw, ::Believe::MatchResult::TaggedSymbol)
+      PENDING = T.let(:pending, ::Believe::MatchResult::TaggedSymbol)
+
+      sig { override.returns(T::Array[::Believe::MatchResult::TaggedSymbol]) }
+      def self.values
+      end
+    end
+  end
+end

data/rbi/believe/models/match_retrieve_params.rbi

@@ -0,0 +1,35 @@
+# typed: strong
+
+module Believe
+  module Models
+    class MatchRetrieveParams < ::Believe::Internal::Type::BaseModel
+      extend ::Believe::Internal::Type::RequestParameters::Converter
+      include ::Believe::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(::Believe::MatchRetrieveParams, ::Believe::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :match_id
+
+      sig do
+        params(
+          match_id: String,
+          request_options: ::Believe::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(match_id:, request_options: {})
+      end
+
+      sig do
+        override.returns(
+          { match_id: String, request_options: ::Believe::RequestOptions }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/believe/models/match_stream_live_params.rbi

@@ -0,0 +1,79 @@
+# typed: strong
+
+module Believe
+  module Models
+    class MatchStreamLiveParams < ::Believe::Internal::Type::BaseModel
+      extend ::Believe::Internal::Type::RequestParameters::Converter
+      include ::Believe::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(::Believe::MatchStreamLiveParams, ::Believe::Internal::AnyHash)
+        end
+
+      # Away team name
+      sig { returns(T.nilable(String)) }
+      attr_reader :away_team
+
+      sig { params(away_team: String).void }
+      attr_writer :away_team
+
+      # How eventful the match should be (1=boring, 10=chaos)
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :excitement_level
+
+      sig { params(excitement_level: Integer).void }
+      attr_writer :excitement_level
+
+      # Home team name
+      sig { returns(T.nilable(String)) }
+      attr_reader :home_team
+
+      sig { params(home_team: String).void }
+      attr_writer :home_team
+
+      # Simulation speed multiplier (1.0 = real-time)
+      sig { returns(T.nilable(Float)) }
+      attr_reader :speed
+
+      sig { params(speed: Float).void }
+      attr_writer :speed
+
+      sig do
+        params(
+          away_team: String,
+          excitement_level: Integer,
+          home_team: String,
+          speed: Float,
+          request_options: ::Believe::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Away team name
+        away_team: nil,
+        # How eventful the match should be (1=boring, 10=chaos)
+        excitement_level: nil,
+        # Home team name
+        home_team: nil,
+        # Simulation speed multiplier (1.0 = real-time)
+        speed: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            away_team: String,
+            excitement_level: Integer,
+            home_team: String,
+            speed: Float,
+            request_options: ::Believe::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/believe/models/match_type.rbi

@@ -0,0 +1,23 @@
+# typed: strong
+
+module Believe
+  module Models
+    # Types of matches.
+    module MatchType
+      extend ::Believe::Internal::Type::Enum
+
+      TaggedSymbol = T.type_alias { T.all(Symbol, ::Believe::MatchType) }
+      OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+      LEAGUE = T.let(:league, ::Believe::MatchType::TaggedSymbol)
+      CUP = T.let(:cup, ::Believe::MatchType::TaggedSymbol)
+      FRIENDLY = T.let(:friendly, ::Believe::MatchType::TaggedSymbol)
+      PLAYOFF = T.let(:playoff, ::Believe::MatchType::TaggedSymbol)
+      FINAL = T.let(:final, ::Believe::MatchType::TaggedSymbol)
+
+      sig { override.returns(T::Array[::Believe::MatchType::TaggedSymbol]) }
+      def self.values
+      end
+    end
+  end
+end

data/rbi/believe/models/match_update_params.rbi

@@ -0,0 +1,157 @@
+# typed: strong
+
+module Believe
+  module Models
+    class MatchUpdateParams < ::Believe::Internal::Type::BaseModel
+      extend ::Believe::Internal::Type::RequestParameters::Converter
+      include ::Believe::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(::Believe::MatchUpdateParams, ::Believe::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :match_id
+
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :attendance
+
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :away_score
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :away_team_id
+
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :date
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :episode_id
+
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :home_score
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :home_team_id
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :lesson_learned
+
+      # Types of matches.
+      sig { returns(T.nilable(::Believe::MatchType::OrSymbol)) }
+      attr_accessor :match_type
+
+      sig { returns(T.nilable(Float)) }
+      attr_accessor :possession_percentage
+
+      # Match result types.
+      sig { returns(T.nilable(::Believe::MatchResult::OrSymbol)) }
+      attr_accessor :result
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :ted_halftime_speech
+
+      sig do
+        returns(
+          T.nilable(::Believe::MatchUpdateParams::TicketRevenueGbp::Variants)
+        )
+      end
+      attr_accessor :ticket_revenue_gbp
+
+      sig { returns(T.nilable(T::Array[::Believe::TurningPoint])) }
+      attr_accessor :turning_points
+
+      sig { returns(T.nilable(Float)) }
+      attr_accessor :weather_temp_celsius
+
+      sig do
+        params(
+          match_id: String,
+          attendance: T.nilable(Integer),
+          away_score: T.nilable(Integer),
+          away_team_id: T.nilable(String),
+          date: T.nilable(Time),
+          episode_id: T.nilable(String),
+          home_score: T.nilable(Integer),
+          home_team_id: T.nilable(String),
+          lesson_learned: T.nilable(String),
+          match_type: T.nilable(::Believe::MatchType::OrSymbol),
+          possession_percentage: T.nilable(Float),
+          result: T.nilable(::Believe::MatchResult::OrSymbol),
+          ted_halftime_speech: T.nilable(String),
+          ticket_revenue_gbp:
+            T.nilable(::Believe::MatchUpdateParams::TicketRevenueGbp::Variants),
+          turning_points: T.nilable(T::Array[::Believe::TurningPoint::OrHash]),
+          weather_temp_celsius: T.nilable(Float),
+          request_options: ::Believe::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        match_id:,
+        attendance: nil,
+        away_score: nil,
+        away_team_id: nil,
+        date: nil,
+        episode_id: nil,
+        home_score: nil,
+        home_team_id: nil,
+        lesson_learned: nil,
+        # Types of matches.
+        match_type: nil,
+        possession_percentage: nil,
+        # Match result types.
+        result: nil,
+        ted_halftime_speech: nil,
+        ticket_revenue_gbp: nil,
+        turning_points: nil,
+        weather_temp_celsius: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            match_id: String,
+            attendance: T.nilable(Integer),
+            away_score: T.nilable(Integer),
+            away_team_id: T.nilable(String),
+            date: T.nilable(Time),
+            episode_id: T.nilable(String),
+            home_score: T.nilable(Integer),
+            home_team_id: T.nilable(String),
+            lesson_learned: T.nilable(String),
+            match_type: T.nilable(::Believe::MatchType::OrSymbol),
+            possession_percentage: T.nilable(Float),
+            result: T.nilable(::Believe::MatchResult::OrSymbol),
+            ted_halftime_speech: T.nilable(String),
+            ticket_revenue_gbp:
+              T.nilable(
+                ::Believe::MatchUpdateParams::TicketRevenueGbp::Variants
+              ),
+            turning_points: T.nilable(T::Array[::Believe::TurningPoint]),
+            weather_temp_celsius: T.nilable(Float),
+            request_options: ::Believe::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module TicketRevenueGbp
+        extend ::Believe::Internal::Type::Union
+
+        Variants = T.type_alias { T.any(Float, String) }
+
+        sig do
+          override.returns(
+            T::Array[::Believe::MatchUpdateParams::TicketRevenueGbp::Variants]
+          )
+        end
+        def self.variants
+        end
+      end
+    end
+  end
+end

data/rbi/believe/models/matches/commentary_stream_params.rbi

@@ -0,0 +1,40 @@
+# typed: strong
+
+module Believe
+  module Models
+    module Matches
+      class CommentaryStreamParams < ::Believe::Internal::Type::BaseModel
+        extend ::Believe::Internal::Type::RequestParameters::Converter
+        include ::Believe::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              ::Believe::Matches::CommentaryStreamParams,
+              ::Believe::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :match_id
+
+        sig do
+          params(
+            match_id: String,
+            request_options: ::Believe::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(match_id:, request_options: {})
+        end
+
+        sig do
+          override.returns(
+            { match_id: String, request_options: ::Believe::RequestOptions }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/believe/models/matches/commentary_stream_response.rbi

@@ -0,0 +1,10 @@
+# typed: strong
+
+module Believe
+  module Models
+    module Matches
+      CommentaryStreamResponse =
+        T.let(T.anything, ::Believe::Internal::Type::Converter)
+    end
+  end
+end

data/rbi/believe/models/medical_specialty.rbi

@@ -0,0 +1,30 @@
+# typed: strong
+
+module Believe
+  module Models
+    # Medical staff specialties.
+    module MedicalSpecialty
+      extend ::Believe::Internal::Type::Enum
+
+      TaggedSymbol = T.type_alias { T.all(Symbol, ::Believe::MedicalSpecialty) }
+      OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+      TEAM_DOCTOR =
+        T.let(:team_doctor, ::Believe::MedicalSpecialty::TaggedSymbol)
+      PHYSIOTHERAPIST =
+        T.let(:physiotherapist, ::Believe::MedicalSpecialty::TaggedSymbol)
+      SPORTS_PSYCHOLOGIST =
+        T.let(:sports_psychologist, ::Believe::MedicalSpecialty::TaggedSymbol)
+      NUTRITIONIST =
+        T.let(:nutritionist, ::Believe::MedicalSpecialty::TaggedSymbol)
+      MASSAGE_THERAPIST =
+        T.let(:massage_therapist, ::Believe::MedicalSpecialty::TaggedSymbol)
+
+      sig do
+        override.returns(T::Array[::Believe::MedicalSpecialty::TaggedSymbol])
+      end
+      def self.values
+      end
+    end
+  end
+end