believe 0.7.0

data/rbi/believe/models/medical_staff.rbi

@@ -0,0 +1,127 @@
+# typed: strong
+
+module Believe
+  module Models
+    class MedicalStaff < ::Believe::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(::Believe::MedicalStaff, ::Believe::Internal::AnyHash)
+        end
+
+      # Unique identifier for this team membership
+      sig { returns(String) }
+      attr_accessor :id
+
+      # ID of the character (references /characters/{id})
+      sig { returns(String) }
+      attr_accessor :character_id
+
+      # Medical specialty
+      sig { returns(::Believe::MedicalSpecialty::TaggedSymbol) }
+      attr_accessor :specialty
+
+      # ID of the team they belong to
+      sig { returns(String) }
+      attr_accessor :team_id
+
+      # Number of years with the current team
+      sig { returns(Integer) }
+      attr_accessor :years_with_team
+
+      # Professional license number
+      sig { returns(T.nilable(String)) }
+      attr_accessor :license_number
+
+      # Discriminator field indicating this is medical staff
+      sig do
+        returns(T.nilable(::Believe::MedicalStaff::MemberType::TaggedSymbol))
+      end
+      attr_reader :member_type
+
+      sig do
+        params(member_type: ::Believe::MedicalStaff::MemberType::OrSymbol).void
+      end
+      attr_writer :member_type
+
+      # Medical qualifications and degrees
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_reader :qualifications
+
+      sig { params(qualifications: T::Array[String]).void }
+      attr_writer :qualifications
+
+      # Full medical staff model with ID.
+      sig do
+        params(
+          id: String,
+          character_id: String,
+          specialty: ::Believe::MedicalSpecialty::OrSymbol,
+          team_id: String,
+          years_with_team: Integer,
+          license_number: T.nilable(String),
+          member_type: ::Believe::MedicalStaff::MemberType::OrSymbol,
+          qualifications: T::Array[String]
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Unique identifier for this team membership
+        id:,
+        # ID of the character (references /characters/{id})
+        character_id:,
+        # Medical specialty
+        specialty:,
+        # ID of the team they belong to
+        team_id:,
+        # Number of years with the current team
+        years_with_team:,
+        # Professional license number
+        license_number: nil,
+        # Discriminator field indicating this is medical staff
+        member_type: nil,
+        # Medical qualifications and degrees
+        qualifications: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            character_id: String,
+            specialty: ::Believe::MedicalSpecialty::TaggedSymbol,
+            team_id: String,
+            years_with_team: Integer,
+            license_number: T.nilable(String),
+            member_type: ::Believe::MedicalStaff::MemberType::TaggedSymbol,
+            qualifications: T::Array[String]
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # Discriminator field indicating this is medical staff
+      module MemberType
+        extend ::Believe::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, ::Believe::MedicalStaff::MemberType) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        MEDICAL_STAFF =
+          T.let(
+            :medical_staff,
+            ::Believe::MedicalStaff::MemberType::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[::Believe::MedicalStaff::MemberType::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/believe/models/paginated_response.rbi

@@ -0,0 +1,77 @@
+# typed: strong
+
+module Believe
+  module Models
+    class PaginatedResponse < ::Believe::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(::Believe::PaginatedResponse, ::Believe::Internal::AnyHash)
+        end
+
+      sig { returns(T::Array[::Believe::Episode]) }
+      attr_accessor :data
+
+      sig { returns(Integer) }
+      attr_accessor :limit
+
+      sig { returns(Integer) }
+      attr_accessor :skip
+
+      sig { returns(Integer) }
+      attr_accessor :total
+
+      # Whether there are more items after this page.
+      sig { returns(T::Boolean) }
+      attr_accessor :has_more
+
+      # Current page number (1-indexed, for display purposes).
+      sig { returns(Integer) }
+      attr_accessor :page
+
+      # Total number of pages.
+      sig { returns(Integer) }
+      attr_accessor :pages
+
+      sig do
+        params(
+          data: T::Array[::Believe::Episode::OrHash],
+          has_more: T::Boolean,
+          limit: Integer,
+          page: Integer,
+          pages: Integer,
+          skip: Integer,
+          total: Integer
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        data:,
+        # Whether there are more items after this page.
+        has_more:,
+        limit:,
+        # Current page number (1-indexed, for display purposes).
+        page:,
+        # Total number of pages.
+        pages:,
+        skip:,
+        total:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            data: T::Array[::Believe::Episode],
+            has_more: T::Boolean,
+            limit: Integer,
+            page: Integer,
+            pages: Integer,
+            skip: Integer,
+            total: Integer
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/believe/models/paginated_response_quote.rbi

@@ -0,0 +1,77 @@
+# typed: strong
+
+module Believe
+  module Models
+    class PaginatedResponseQuote < ::Believe::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(::Believe::PaginatedResponseQuote, ::Believe::Internal::AnyHash)
+        end
+
+      sig { returns(T::Array[::Believe::Quote]) }
+      attr_accessor :data
+
+      sig { returns(Integer) }
+      attr_accessor :limit
+
+      sig { returns(Integer) }
+      attr_accessor :skip
+
+      sig { returns(Integer) }
+      attr_accessor :total
+
+      # Whether there are more items after this page.
+      sig { returns(T::Boolean) }
+      attr_accessor :has_more
+
+      # Current page number (1-indexed, for display purposes).
+      sig { returns(Integer) }
+      attr_accessor :page
+
+      # Total number of pages.
+      sig { returns(Integer) }
+      attr_accessor :pages
+
+      sig do
+        params(
+          data: T::Array[::Believe::Quote::OrHash],
+          has_more: T::Boolean,
+          limit: Integer,
+          page: Integer,
+          pages: Integer,
+          skip: Integer,
+          total: Integer
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        data:,
+        # Whether there are more items after this page.
+        has_more:,
+        limit:,
+        # Current page number (1-indexed, for display purposes).
+        page:,
+        # Total number of pages.
+        pages:,
+        skip:,
+        total:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            data: T::Array[::Believe::Quote],
+            has_more: T::Boolean,
+            limit: Integer,
+            page: Integer,
+            pages: Integer,
+            skip: Integer,
+            total: Integer
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/believe/models/pep_talk_retrieve_params.rbi

@@ -0,0 +1,43 @@
+# typed: strong
+
+module Believe
+  module Models
+    class PepTalkRetrieveParams < ::Believe::Internal::Type::BaseModel
+      extend ::Believe::Internal::Type::RequestParameters::Converter
+      include ::Believe::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(::Believe::PepTalkRetrieveParams, ::Believe::Internal::AnyHash)
+        end
+
+      # If true, returns SSE stream instead of full response
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :stream
+
+      sig { params(stream: T::Boolean).void }
+      attr_writer :stream
+
+      sig do
+        params(
+          stream: T::Boolean,
+          request_options: ::Believe::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # If true, returns SSE stream instead of full response
+        stream: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          { stream: T::Boolean, request_options: ::Believe::RequestOptions }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/believe/models/pep_talk_retrieve_response.rbi

@@ -0,0 +1,114 @@
+# typed: strong
+
+module Believe
+  module Models
+    class PepTalkRetrieveResponse < ::Believe::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            ::Believe::Models::PepTalkRetrieveResponse,
+            ::Believe::Internal::AnyHash
+          )
+        end
+
+      # Individual chunks of the pep talk
+      sig do
+        returns(T::Array[::Believe::Models::PepTalkRetrieveResponse::Chunk])
+      end
+      attr_accessor :chunks
+
+      # The full pep talk text
+      sig { returns(String) }
+      attr_accessor :text
+
+      # A complete pep talk response.
+      sig do
+        params(
+          chunks:
+            T::Array[::Believe::Models::PepTalkRetrieveResponse::Chunk::OrHash],
+          text: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Individual chunks of the pep talk
+        chunks:,
+        # The full pep talk text
+        text:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            chunks: T::Array[::Believe::Models::PepTalkRetrieveResponse::Chunk],
+            text: String
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Chunk < ::Believe::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              ::Believe::Models::PepTalkRetrieveResponse::Chunk,
+              ::Believe::Internal::AnyHash
+            )
+          end
+
+        # Chunk sequence number
+        sig { returns(Integer) }
+        attr_accessor :chunk_id
+
+        # Is this the final chunk
+        sig { returns(T::Boolean) }
+        attr_accessor :is_final
+
+        # The text of this chunk
+        sig { returns(String) }
+        attr_accessor :text
+
+        # The emotional purpose of this chunk (e.g., greeting, acknowledgment, wisdom,
+        # affirmation, encouragement)
+        sig { returns(T.nilable(String)) }
+        attr_accessor :emotional_beat
+
+        # A chunk of a streaming pep talk from Ted.
+        sig do
+          params(
+            chunk_id: Integer,
+            is_final: T::Boolean,
+            text: String,
+            emotional_beat: T.nilable(String)
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Chunk sequence number
+          chunk_id:,
+          # Is this the final chunk
+          is_final:,
+          # The text of this chunk
+          text:,
+          # The emotional purpose of this chunk (e.g., greeting, acknowledgment, wisdom,
+          # affirmation, encouragement)
+          emotional_beat: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              chunk_id: Integer,
+              is_final: T::Boolean,
+              text: String,
+              emotional_beat: T.nilable(String)
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/believe/models/player.rbi

@@ -0,0 +1,139 @@
+# typed: strong
+
+module Believe
+  module Models
+    class Player < ::Believe::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(::Believe::Player, ::Believe::Internal::AnyHash) }
+
+      # Unique identifier for this team membership
+      sig { returns(String) }
+      attr_accessor :id
+
+      # ID of the character (references /characters/{id})
+      sig { returns(String) }
+      attr_accessor :character_id
+
+      # Jersey/shirt number
+      sig { returns(Integer) }
+      attr_accessor :jersey_number
+
+      # Playing position on the field
+      sig { returns(::Believe::Position::TaggedSymbol) }
+      attr_accessor :position
+
+      # ID of the team they belong to
+      sig { returns(String) }
+      attr_accessor :team_id
+
+      # Number of years with the current team
+      sig { returns(Integer) }
+      attr_accessor :years_with_team
+
+      # Total assists for the team
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :assists
+
+      sig { params(assists: Integer).void }
+      attr_writer :assists
+
+      # Total goals scored for the team
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :goals_scored
+
+      sig { params(goals_scored: Integer).void }
+      attr_writer :goals_scored
+
+      # Whether this player is team captain
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :is_captain
+
+      sig { params(is_captain: T::Boolean).void }
+      attr_writer :is_captain
+
+      # Discriminator field indicating this is a player
+      sig { returns(T.nilable(::Believe::Player::MemberType::TaggedSymbol)) }
+      attr_reader :member_type
+
+      sig { params(member_type: ::Believe::Player::MemberType::OrSymbol).void }
+      attr_writer :member_type
+
+      # Full player model with ID.
+      sig do
+        params(
+          id: String,
+          character_id: String,
+          jersey_number: Integer,
+          position: ::Believe::Position::OrSymbol,
+          team_id: String,
+          years_with_team: Integer,
+          assists: Integer,
+          goals_scored: Integer,
+          is_captain: T::Boolean,
+          member_type: ::Believe::Player::MemberType::OrSymbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Unique identifier for this team membership
+        id:,
+        # ID of the character (references /characters/{id})
+        character_id:,
+        # Jersey/shirt number
+        jersey_number:,
+        # Playing position on the field
+        position:,
+        # ID of the team they belong to
+        team_id:,
+        # Number of years with the current team
+        years_with_team:,
+        # Total assists for the team
+        assists: nil,
+        # Total goals scored for the team
+        goals_scored: nil,
+        # Whether this player is team captain
+        is_captain: nil,
+        # Discriminator field indicating this is a player
+        member_type: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            character_id: String,
+            jersey_number: Integer,
+            position: ::Believe::Position::TaggedSymbol,
+            team_id: String,
+            years_with_team: Integer,
+            assists: Integer,
+            goals_scored: Integer,
+            is_captain: T::Boolean,
+            member_type: ::Believe::Player::MemberType::TaggedSymbol
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # Discriminator field indicating this is a player
+      module MemberType
+        extend ::Believe::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, ::Believe::Player::MemberType) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        PLAYER = T.let(:player, ::Believe::Player::MemberType::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[::Believe::Player::MemberType::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/believe/models/position.rbi

@@ -0,0 +1,22 @@
+# typed: strong
+
+module Believe
+  module Models
+    # Football positions for players.
+    module Position
+      extend ::Believe::Internal::Type::Enum
+
+      TaggedSymbol = T.type_alias { T.all(Symbol, ::Believe::Position) }
+      OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+      GOALKEEPER = T.let(:goalkeeper, ::Believe::Position::TaggedSymbol)
+      DEFENDER = T.let(:defender, ::Believe::Position::TaggedSymbol)
+      MIDFIELDER = T.let(:midfielder, ::Believe::Position::TaggedSymbol)
+      FORWARD = T.let(:forward, ::Believe::Position::TaggedSymbol)
+
+      sig { override.returns(T::Array[::Believe::Position::TaggedSymbol]) }
+      def self.values
+      end
+    end
+  end
+end

data/rbi/believe/models/press_simulate_params.rbi

@@ -0,0 +1,62 @@
+# typed: strong
+
+module Believe
+  module Models
+    class PressSimulateParams < ::Believe::Internal::Type::BaseModel
+      extend ::Believe::Internal::Type::RequestParameters::Converter
+      include ::Believe::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(::Believe::PressSimulateParams, ::Believe::Internal::AnyHash)
+        end
+
+      # The press question to answer
+      sig { returns(String) }
+      attr_accessor :question
+
+      # Is this a hostile question from Trent Crimm?
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :hostile
+
+      sig { params(hostile: T::Boolean).void }
+      attr_writer :hostile
+
+      # Topic category
+      sig { returns(T.nilable(String)) }
+      attr_accessor :topic
+
+      sig do
+        params(
+          question: String,
+          hostile: T::Boolean,
+          topic: T.nilable(String),
+          request_options: ::Believe::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The press question to answer
+        question:,
+        # Is this a hostile question from Trent Crimm?
+        hostile: nil,
+        # Topic category
+        topic: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            question: String,
+            hostile: T::Boolean,
+            topic: T.nilable(String),
+            request_options: ::Believe::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end