believe 0.7.0

data/rbi/believe/resources/characters.rbi

@@ -0,0 +1,162 @@
+# typed: strong
+
+module Believe
+  module Resources
+    # Operations related to Ted Lasso characters
+    class Characters
+      # Add a new character to the Ted Lasso universe.
+      sig do
+        params(
+          background: String,
+          emotional_stats: ::Believe::EmotionalStats::OrHash,
+          name: String,
+          personality_traits: T::Array[String],
+          role: ::Believe::CharacterRole::OrSymbol,
+          date_of_birth: T.nilable(Date),
+          email: T.nilable(String),
+          growth_arcs: T::Array[::Believe::GrowthArc::OrHash],
+          height_meters: T.nilable(Float),
+          profile_image_url: T.nilable(String),
+          salary_gbp:
+            T.nilable(::Believe::CharacterCreateParams::SalaryGbp::Variants),
+          signature_quotes: T::Array[String],
+          team_id: T.nilable(String),
+          request_options: ::Believe::RequestOptions::OrHash
+        ).returns(::Believe::Character)
+      end
+      def create(
+        # Character background and history
+        background:,
+        # Emotional intelligence stats
+        emotional_stats:,
+        # Character's full name
+        name:,
+        # Key personality traits
+        personality_traits:,
+        # Character's role
+        role:,
+        # Character's date of birth
+        date_of_birth: nil,
+        # Character's email address
+        email: nil,
+        # Character development across seasons
+        growth_arcs: nil,
+        # Height in meters
+        height_meters: nil,
+        # URL to character's profile image
+        profile_image_url: nil,
+        # Annual salary in GBP
+        salary_gbp: nil,
+        # Memorable quotes from this character
+        signature_quotes: nil,
+        # ID of the team they belong to
+        team_id: nil,
+        request_options: {}
+      )
+      end
+
+      # Retrieve detailed information about a specific character.
+      sig do
+        params(
+          character_id: String,
+          request_options: ::Believe::RequestOptions::OrHash
+        ).returns(::Believe::Character)
+      end
+      def retrieve(character_id, request_options: {})
+      end
+
+      # Update specific fields of an existing character.
+      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(::Believe::Character)
+      end
+      def update(
+        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
+
+      # Get a paginated list of Ted Lasso characters.
+      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(::Believe::Internal::SkipLimitPage[::Believe::Character])
+      end
+      def list(
+        # 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
+
+      # Remove a character from the database.
+      sig do
+        params(
+          character_id: String,
+          request_options: ::Believe::RequestOptions::OrHash
+        ).void
+      end
+      def delete(character_id, request_options: {})
+      end
+
+      # Get all signature quotes from a specific character.
+      sig do
+        params(
+          character_id: String,
+          request_options: ::Believe::RequestOptions::OrHash
+        ).returns(T::Array[String])
+      end
+      def get_quotes(character_id, request_options: {})
+      end
+
+      # @api private
+      sig { params(client: ::Believe::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/believe/resources/client/ws.rbi

@@ -0,0 +1,34 @@
+# typed: strong
+
+module Believe
+  module Resources
+    class Client
+      # WebSocket endpoints for real-time bidirectional communication - Live match
+      # simulation
+      class Ws
+        # Simple WebSocket test endpoint for connectivity testing.
+        #
+        # Connect to test WebSocket functionality. The server will:
+        #
+        # 1. Send a welcome message on connection
+        # 2. Echo back any message you send
+        #
+        # ## Example
+        #
+        # ```javascript
+        # const ws = new WebSocket("ws://localhost:8000/ws/test");
+        # ws.onmessage = (event) => console.log(event.data);
+        # ws.send("Hello!"); // Server responds with echo
+        # ```
+        sig { params(request_options: ::Believe::RequestOptions::OrHash).void }
+        def test_(request_options: {})
+        end
+
+        # @api private
+        sig { params(client: ::Believe::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/believe/resources/client.rbi

@@ -0,0 +1,17 @@
+# typed: strong
+
+module Believe
+  module Resources
+    class Client
+      # WebSocket endpoints for real-time bidirectional communication - Live match
+      # simulation
+      sig { returns(::Believe::Resources::Client::Ws) }
+      attr_reader :ws
+
+      # @api private
+      sig { params(client: ::Believe::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/believe/resources/coaching/principles.rbi

@@ -0,0 +1,55 @@
+# typed: strong
+
+module Believe
+  module Resources
+    class Coaching
+      # Interactive endpoints for motivation and guidance
+      class Principles
+        # Get details about a specific coaching principle.
+        sig do
+          params(
+            principle_id: String,
+            request_options: ::Believe::RequestOptions::OrHash
+          ).returns(::Believe::Coaching::CoachingPrinciple)
+        end
+        def retrieve(principle_id, request_options: {})
+        end
+
+        # Get a paginated list of Ted Lasso's core coaching principles and philosophy.
+        sig do
+          params(
+            limit: Integer,
+            skip: Integer,
+            request_options: ::Believe::RequestOptions::OrHash
+          ).returns(
+            ::Believe::Internal::SkipLimitPage[
+              ::Believe::Coaching::CoachingPrinciple
+            ]
+          )
+        end
+        def list(
+          # Maximum number of items to return (max: 100)
+          limit: nil,
+          # Number of items to skip (offset)
+          skip: nil,
+          request_options: {}
+        )
+        end
+
+        # Get a random coaching principle to inspire your day.
+        sig do
+          params(request_options: ::Believe::RequestOptions::OrHash).returns(
+            ::Believe::Coaching::CoachingPrinciple
+          )
+        end
+        def get_random(request_options: {})
+        end
+
+        # @api private
+        sig { params(client: ::Believe::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/believe/resources/coaching.rbi

@@ -0,0 +1,16 @@
+# typed: strong
+
+module Believe
+  module Resources
+    class Coaching
+      # Interactive endpoints for motivation and guidance
+      sig { returns(::Believe::Resources::Coaching::Principles) }
+      attr_reader :principles
+
+      # @api private
+      sig { params(client: ::Believe::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/believe/resources/conflicts.rbi

@@ -0,0 +1,37 @@
+# typed: strong
+
+module Believe
+  module Resources
+    # Interactive endpoints for motivation and guidance
+    class Conflicts
+      # Get Ted Lasso-style advice for resolving conflicts.
+      sig do
+        params(
+          conflict_type:
+            ::Believe::ConflictResolveParams::ConflictType::OrSymbol,
+          description: String,
+          parties_involved: T::Array[String],
+          attempts_made: T.nilable(T::Array[String]),
+          request_options: ::Believe::RequestOptions::OrHash
+        ).returns(::Believe::Models::ConflictResolveResponse)
+      end
+      def resolve(
+        # Type of conflict
+        conflict_type:,
+        # Describe the conflict
+        description:,
+        # Who is involved in the conflict
+        parties_involved:,
+        # What you've already tried
+        attempts_made: nil,
+        request_options: {}
+      )
+      end
+
+      # @api private
+      sig { params(client: ::Believe::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/believe/resources/episodes.rbi

@@ -0,0 +1,166 @@
+# typed: strong
+
+module Believe
+  module Resources
+    # Operations related to TV episodes
+    class Episodes
+      # Add a new episode to the series.
+      sig do
+        params(
+          air_date: Date,
+          character_focus: T::Array[String],
+          director: String,
+          episode_number: Integer,
+          main_theme: String,
+          runtime_minutes: Integer,
+          season: Integer,
+          synopsis: String,
+          ted_wisdom: String,
+          title: String,
+          writer: String,
+          biscuits_with_boss_moment: T.nilable(String),
+          memorable_moments: T::Array[String],
+          us_viewers_millions: T.nilable(Float),
+          viewer_rating: T.nilable(Float),
+          request_options: ::Believe::RequestOptions::OrHash
+        ).returns(::Believe::Episode)
+      end
+      def create(
+        # Original air date
+        air_date:,
+        # Characters with significant development
+        character_focus:,
+        # Episode director
+        director:,
+        # Episode number within season
+        episode_number:,
+        # Central theme of the episode
+        main_theme:,
+        # Episode runtime in minutes
+        runtime_minutes:,
+        # Season number
+        season:,
+        # Brief plot synopsis
+        synopsis:,
+        # Key piece of Ted wisdom from the episode
+        ted_wisdom:,
+        # Episode title
+        title:,
+        # Episode writer(s)
+        writer:,
+        # Notable biscuits with the boss scene
+        biscuits_with_boss_moment: nil,
+        # Standout moments from the episode
+        memorable_moments: nil,
+        # US viewership in millions
+        us_viewers_millions: nil,
+        # Viewer rating out of 10
+        viewer_rating: nil,
+        request_options: {}
+      )
+      end
+
+      # Retrieve detailed information about a specific episode.
+      sig do
+        params(
+          episode_id: String,
+          request_options: ::Believe::RequestOptions::OrHash
+        ).returns(::Believe::Episode)
+      end
+      def retrieve(episode_id, request_options: {})
+      end
+
+      # Update specific fields of an existing episode.
+      sig do
+        params(
+          episode_id: String,
+          air_date: T.nilable(Date),
+          biscuits_with_boss_moment: T.nilable(String),
+          character_focus: T.nilable(T::Array[String]),
+          director: T.nilable(String),
+          episode_number: T.nilable(Integer),
+          main_theme: T.nilable(String),
+          memorable_moments: T.nilable(T::Array[String]),
+          runtime_minutes: T.nilable(Integer),
+          season: T.nilable(Integer),
+          synopsis: T.nilable(String),
+          ted_wisdom: T.nilable(String),
+          title: T.nilable(String),
+          us_viewers_millions: T.nilable(Float),
+          viewer_rating: T.nilable(Float),
+          writer: T.nilable(String),
+          request_options: ::Believe::RequestOptions::OrHash
+        ).returns(::Believe::Episode)
+      end
+      def update(
+        episode_id,
+        air_date: nil,
+        biscuits_with_boss_moment: nil,
+        character_focus: nil,
+        director: nil,
+        episode_number: nil,
+        main_theme: nil,
+        memorable_moments: nil,
+        runtime_minutes: nil,
+        season: nil,
+        synopsis: nil,
+        ted_wisdom: nil,
+        title: nil,
+        us_viewers_millions: nil,
+        viewer_rating: nil,
+        writer: nil,
+        request_options: {}
+      )
+      end
+
+      # Get a paginated list of all Ted Lasso episodes with optional filtering by
+      # season.
+      sig do
+        params(
+          character_focus: T.nilable(String),
+          limit: Integer,
+          season: T.nilable(Integer),
+          skip: Integer,
+          request_options: ::Believe::RequestOptions::OrHash
+        ).returns(::Believe::Internal::SkipLimitPage[::Believe::Episode])
+      end
+      def list(
+        # Filter by character focus (character ID)
+        character_focus: nil,
+        # Maximum number of items to return (max: 100)
+        limit: nil,
+        # Filter by season
+        season: nil,
+        # Number of items to skip (offset)
+        skip: nil,
+        request_options: {}
+      )
+      end
+
+      # Remove an episode from the database.
+      sig do
+        params(
+          episode_id: String,
+          request_options: ::Believe::RequestOptions::OrHash
+        ).void
+      end
+      def delete(episode_id, request_options: {})
+      end
+
+      # Get Ted's wisdom and memorable moments from a specific episode.
+      sig do
+        params(
+          episode_id: String,
+          request_options: ::Believe::RequestOptions::OrHash
+        ).returns(T::Hash[Symbol, T.anything])
+      end
+      def get_wisdom(episode_id, request_options: {})
+      end
+
+      # @api private
+      sig { params(client: ::Believe::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/believe/resources/health.rbi

@@ -0,0 +1,21 @@
+# typed: strong
+
+module Believe
+  module Resources
+    class Health
+      # Check if the API is running and healthy.
+      sig do
+        params(request_options: ::Believe::RequestOptions::OrHash).returns(
+          T.anything
+        )
+      end
+      def check(request_options: {})
+      end
+
+      # @api private
+      sig { params(client: ::Believe::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/believe/resources/matches/commentary.rbi

@@ -0,0 +1,26 @@
+# typed: strong
+
+module Believe
+  module Resources
+    class Matches
+      # Server-Sent Events (SSE) streaming endpoints
+      class Commentary
+        # Stream live match commentary for a specific match. Uses Server-Sent Events (SSE)
+        # to stream commentary events in real-time.
+        sig do
+          params(
+            match_id: String,
+            request_options: ::Believe::RequestOptions::OrHash
+          ).returns(T.anything)
+        end
+        def stream(match_id, request_options: {})
+        end
+
+        # @api private
+        sig { params(client: ::Believe::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end