believe 0.7.0

data/rbi/believe/models/character_list_params.rbi

@@ -0,0 +1,81 @@
+# typed: strong
+
+module Believe
+  module Models
+    class CharacterListParams < ::Believe::Internal::Type::BaseModel
+      extend ::Believe::Internal::Type::RequestParameters::Converter
+      include ::Believe::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(::Believe::CharacterListParams, ::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
+
+      # Minimum optimism score
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :min_optimism
+
+      # Filter by role
+      sig { returns(T.nilable(::Believe::CharacterRole::OrSymbol)) }
+      attr_accessor :role
+
+      # 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 ID
+      sig { returns(T.nilable(String)) }
+      attr_accessor :team_id
+
+      sig do
+        params(
+          limit: Integer,
+          min_optimism: T.nilable(Integer),
+          role: T.nilable(::Believe::CharacterRole::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,
+        # Minimum optimism score
+        min_optimism: nil,
+        # Filter by role
+        role: nil,
+        # Number of items to skip (offset)
+        skip: nil,
+        # Filter by team ID
+        team_id: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            limit: Integer,
+            min_optimism: T.nilable(Integer),
+            role: T.nilable(::Believe::CharacterRole::OrSymbol),
+            skip: Integer,
+            team_id: T.nilable(String),
+            request_options: ::Believe::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/believe/models/character_retrieve_params.rbi

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

data/rbi/believe/models/character_role.rbi

@@ -0,0 +1,28 @@
+# typed: strong
+
+module Believe
+  module Models
+    # Roles characters can have.
+    module CharacterRole
+      extend ::Believe::Internal::Type::Enum
+
+      TaggedSymbol = T.type_alias { T.all(Symbol, ::Believe::CharacterRole) }
+      OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+      COACH = T.let(:coach, ::Believe::CharacterRole::TaggedSymbol)
+      PLAYER = T.let(:player, ::Believe::CharacterRole::TaggedSymbol)
+      OWNER = T.let(:owner, ::Believe::CharacterRole::TaggedSymbol)
+      MANAGER = T.let(:manager, ::Believe::CharacterRole::TaggedSymbol)
+      STAFF = T.let(:staff, ::Believe::CharacterRole::TaggedSymbol)
+      JOURNALIST = T.let(:journalist, ::Believe::CharacterRole::TaggedSymbol)
+      FAMILY = T.let(:family, ::Believe::CharacterRole::TaggedSymbol)
+      FRIEND = T.let(:friend, ::Believe::CharacterRole::TaggedSymbol)
+      FAN = T.let(:fan, ::Believe::CharacterRole::TaggedSymbol)
+      OTHER = T.let(:other, ::Believe::CharacterRole::TaggedSymbol)
+
+      sig { override.returns(T::Array[::Believe::CharacterRole::TaggedSymbol]) }
+      def self.values
+      end
+    end
+  end
+end

data/rbi/believe/models/character_update_params.rbi

@@ -0,0 +1,150 @@
+# typed: strong
+
+module Believe
+  module Models
+    class CharacterUpdateParams < ::Believe::Internal::Type::BaseModel
+      extend ::Believe::Internal::Type::RequestParameters::Converter
+      include ::Believe::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(::Believe::CharacterUpdateParams, ::Believe::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :character_id
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :background
+
+      sig { returns(T.nilable(Date)) }
+      attr_accessor :date_of_birth
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :email
+
+      # Emotional intelligence statistics for a character.
+      sig { returns(T.nilable(::Believe::EmotionalStats)) }
+      attr_reader :emotional_stats
+
+      sig do
+        params(
+          emotional_stats: T.nilable(::Believe::EmotionalStats::OrHash)
+        ).void
+      end
+      attr_writer :emotional_stats
+
+      sig { returns(T.nilable(T::Array[::Believe::GrowthArc])) }
+      attr_accessor :growth_arcs
+
+      sig { returns(T.nilable(Float)) }
+      attr_accessor :height_meters
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :name
+
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_accessor :personality_traits
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :profile_image_url
+
+      # Roles characters can have.
+      sig { returns(T.nilable(::Believe::CharacterRole::OrSymbol)) }
+      attr_accessor :role
+
+      sig do
+        returns(
+          T.nilable(::Believe::CharacterUpdateParams::SalaryGbp::Variants)
+        )
+      end
+      attr_accessor :salary_gbp
+
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_accessor :signature_quotes
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :team_id
+
+      sig do
+        params(
+          character_id: String,
+          background: T.nilable(String),
+          date_of_birth: T.nilable(Date),
+          email: T.nilable(String),
+          emotional_stats: T.nilable(::Believe::EmotionalStats::OrHash),
+          growth_arcs: T.nilable(T::Array[::Believe::GrowthArc::OrHash]),
+          height_meters: T.nilable(Float),
+          name: T.nilable(String),
+          personality_traits: T.nilable(T::Array[String]),
+          profile_image_url: T.nilable(String),
+          role: T.nilable(::Believe::CharacterRole::OrSymbol),
+          salary_gbp:
+            T.nilable(::Believe::CharacterUpdateParams::SalaryGbp::Variants),
+          signature_quotes: T.nilable(T::Array[String]),
+          team_id: T.nilable(String),
+          request_options: ::Believe::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        character_id:,
+        background: nil,
+        date_of_birth: nil,
+        email: nil,
+        # Emotional intelligence statistics for a character.
+        emotional_stats: nil,
+        growth_arcs: nil,
+        height_meters: nil,
+        name: nil,
+        personality_traits: nil,
+        profile_image_url: nil,
+        # Roles characters can have.
+        role: nil,
+        salary_gbp: nil,
+        signature_quotes: nil,
+        team_id: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            character_id: String,
+            background: T.nilable(String),
+            date_of_birth: T.nilable(Date),
+            email: T.nilable(String),
+            emotional_stats: T.nilable(::Believe::EmotionalStats),
+            growth_arcs: T.nilable(T::Array[::Believe::GrowthArc]),
+            height_meters: T.nilable(Float),
+            name: T.nilable(String),
+            personality_traits: T.nilable(T::Array[String]),
+            profile_image_url: T.nilable(String),
+            role: T.nilable(::Believe::CharacterRole::OrSymbol),
+            salary_gbp:
+              T.nilable(::Believe::CharacterUpdateParams::SalaryGbp::Variants),
+            signature_quotes: T.nilable(T::Array[String]),
+            team_id: T.nilable(String),
+            request_options: ::Believe::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module SalaryGbp
+        extend ::Believe::Internal::Type::Union
+
+        Variants = T.type_alias { T.any(Float, String) }
+
+        sig do
+          override.returns(
+            T::Array[::Believe::CharacterUpdateParams::SalaryGbp::Variants]
+          )
+        end
+        def self.variants
+        end
+      end
+    end
+  end
+end

data/rbi/believe/models/client/w_test_params.rbi

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

data/rbi/believe/models/client_get_welcome_params.rbi

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

data/rbi/believe/models/coach.rbi

@@ -0,0 +1,115 @@
+# typed: strong
+
+module Believe
+  module Models
+    class Coach < ::Believe::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(::Believe::Coach, ::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
+
+      # Coaching specialty/role
+      sig { returns(::Believe::CoachSpecialty::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
+
+      # Coaching certifications and licenses
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_reader :certifications
+
+      sig { params(certifications: T::Array[String]).void }
+      attr_writer :certifications
+
+      # Discriminator field indicating this is a coach
+      sig { returns(T.nilable(::Believe::Coach::MemberType::TaggedSymbol)) }
+      attr_reader :member_type
+
+      sig { params(member_type: ::Believe::Coach::MemberType::OrSymbol).void }
+      attr_writer :member_type
+
+      # Career win rate (0.0 to 1.0)
+      sig { returns(T.nilable(Float)) }
+      attr_accessor :win_rate
+
+      # Full coach model with ID.
+      sig do
+        params(
+          id: String,
+          character_id: String,
+          specialty: ::Believe::CoachSpecialty::OrSymbol,
+          team_id: String,
+          years_with_team: Integer,
+          certifications: T::Array[String],
+          member_type: ::Believe::Coach::MemberType::OrSymbol,
+          win_rate: T.nilable(Float)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Unique identifier for this team membership
+        id:,
+        # ID of the character (references /characters/{id})
+        character_id:,
+        # Coaching specialty/role
+        specialty:,
+        # ID of the team they belong to
+        team_id:,
+        # Number of years with the current team
+        years_with_team:,
+        # Coaching certifications and licenses
+        certifications: nil,
+        # Discriminator field indicating this is a coach
+        member_type: nil,
+        # Career win rate (0.0 to 1.0)
+        win_rate: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            character_id: String,
+            specialty: ::Believe::CoachSpecialty::TaggedSymbol,
+            team_id: String,
+            years_with_team: Integer,
+            certifications: T::Array[String],
+            member_type: ::Believe::Coach::MemberType::TaggedSymbol,
+            win_rate: T.nilable(Float)
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # Discriminator field indicating this is a coach
+      module MemberType
+        extend ::Believe::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, ::Believe::Coach::MemberType) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        COACH = T.let(:coach, ::Believe::Coach::MemberType::TaggedSymbol)
+
+        sig do
+          override.returns(T::Array[::Believe::Coach::MemberType::TaggedSymbol])
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/believe/models/coach_specialty.rbi

@@ -0,0 +1,29 @@
+# typed: strong
+
+module Believe
+  module Models
+    # Coaching specialties.
+    module CoachSpecialty
+      extend ::Believe::Internal::Type::Enum
+
+      TaggedSymbol = T.type_alias { T.all(Symbol, ::Believe::CoachSpecialty) }
+      OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+      HEAD_COACH = T.let(:head_coach, ::Believe::CoachSpecialty::TaggedSymbol)
+      ASSISTANT_COACH =
+        T.let(:assistant_coach, ::Believe::CoachSpecialty::TaggedSymbol)
+      GOALKEEPING_COACH =
+        T.let(:goalkeeping_coach, ::Believe::CoachSpecialty::TaggedSymbol)
+      FITNESS_COACH =
+        T.let(:fitness_coach, ::Believe::CoachSpecialty::TaggedSymbol)
+      TACTICAL_ANALYST =
+        T.let(:tactical_analyst, ::Believe::CoachSpecialty::TaggedSymbol)
+
+      sig do
+        override.returns(T::Array[::Believe::CoachSpecialty::TaggedSymbol])
+      end
+      def self.values
+      end
+    end
+  end
+end

data/rbi/believe/models/coaching/coaching_principle.rbi

@@ -0,0 +1,85 @@
+# typed: strong
+
+module Believe
+  module Models
+    CoachingPrinciple = Coaching::CoachingPrinciple
+
+    module Coaching
+      class CoachingPrinciple < ::Believe::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              ::Believe::Coaching::CoachingPrinciple,
+              ::Believe::Internal::AnyHash
+            )
+          end
+
+        # Principle identifier
+        sig { returns(String) }
+        attr_accessor :id
+
+        # How to apply this principle
+        sig { returns(String) }
+        attr_accessor :application
+
+        # Example from the show
+        sig { returns(String) }
+        attr_accessor :example_from_show
+
+        # What this principle means
+        sig { returns(String) }
+        attr_accessor :explanation
+
+        # The coaching principle
+        sig { returns(String) }
+        attr_accessor :principle
+
+        # Related Ted quote
+        sig { returns(String) }
+        attr_accessor :ted_quote
+
+        # A Ted Lasso coaching principle.
+        sig do
+          params(
+            id: String,
+            application: String,
+            example_from_show: String,
+            explanation: String,
+            principle: String,
+            ted_quote: String
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Principle identifier
+          id:,
+          # How to apply this principle
+          application:,
+          # Example from the show
+          example_from_show:,
+          # What this principle means
+          explanation:,
+          # The coaching principle
+          principle:,
+          # Related Ted quote
+          ted_quote:
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              id: String,
+              application: String,
+              example_from_show: String,
+              explanation: String,
+              principle: String,
+              ted_quote: String
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/believe/models/coaching/principle_get_random_params.rbi

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

data/rbi/believe/models/coaching/principle_list_params.rbi

@@ -0,0 +1,62 @@
+# typed: strong
+
+module Believe
+  module Models
+    module Coaching
+      class PrincipleListParams < ::Believe::Internal::Type::BaseModel
+        extend ::Believe::Internal::Type::RequestParameters::Converter
+        include ::Believe::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              ::Believe::Coaching::PrincipleListParams,
+              ::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
+
+        # Number of items to skip (offset)
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :skip
+
+        sig { params(skip: Integer).void }
+        attr_writer :skip
+
+        sig do
+          params(
+            limit: Integer,
+            skip: Integer,
+            request_options: ::Believe::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Maximum number of items to return (max: 100)
+          limit: nil,
+          # Number of items to skip (offset)
+          skip: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              limit: Integer,
+              skip: Integer,
+              request_options: ::Believe::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end