believe 0.7.0

data/rbi/believe/models/quote_moment.rbi

@@ -0,0 +1,33 @@
+# typed: strong
+
+module Believe
+  module Models
+    # Types of moments when quotes occur.
+    module QuoteMoment
+      extend ::Believe::Internal::Type::Enum
+
+      TaggedSymbol = T.type_alias { T.all(Symbol, ::Believe::QuoteMoment) }
+      OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+      HALFTIME_SPEECH =
+        T.let(:halftime_speech, ::Believe::QuoteMoment::TaggedSymbol)
+      PRESS_CONFERENCE =
+        T.let(:press_conference, ::Believe::QuoteMoment::TaggedSymbol)
+      LOCKER_ROOM = T.let(:locker_room, ::Believe::QuoteMoment::TaggedSymbol)
+      TRAINING = T.let(:training, ::Believe::QuoteMoment::TaggedSymbol)
+      BISCUITS_WITH_BOSS =
+        T.let(:biscuits_with_boss, ::Believe::QuoteMoment::TaggedSymbol)
+      PUB = T.let(:pub, ::Believe::QuoteMoment::TaggedSymbol)
+      ONE_ON_ONE = T.let(:one_on_one, ::Believe::QuoteMoment::TaggedSymbol)
+      CELEBRATION = T.let(:celebration, ::Believe::QuoteMoment::TaggedSymbol)
+      CRISIS = T.let(:crisis, ::Believe::QuoteMoment::TaggedSymbol)
+      CASUAL = T.let(:casual, ::Believe::QuoteMoment::TaggedSymbol)
+      CONFRONTATION =
+        T.let(:confrontation, ::Believe::QuoteMoment::TaggedSymbol)
+
+      sig { override.returns(T::Array[::Believe::QuoteMoment::TaggedSymbol]) }
+      def self.values
+      end
+    end
+  end
+end

data/rbi/believe/models/quote_retrieve_params.rbi

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

data/rbi/believe/models/quote_theme.rbi

@@ -0,0 +1,51 @@
+# typed: strong
+
+module Believe
+  module Models
+    # Themes that quotes can be categorized under.
+    module QuoteTheme
+      extend ::Believe::Internal::Type::Enum
+
+      TaggedSymbol = T.type_alias { T.all(Symbol, ::Believe::QuoteTheme) }
+      OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+      BELIEF = T.let(:belief, ::Believe::QuoteTheme::TaggedSymbol)
+      TEAMWORK = T.let(:teamwork, ::Believe::QuoteTheme::TaggedSymbol)
+      CURIOSITY = T.let(:curiosity, ::Believe::QuoteTheme::TaggedSymbol)
+      KINDNESS = T.let(:kindness, ::Believe::QuoteTheme::TaggedSymbol)
+      RESILIENCE = T.let(:resilience, ::Believe::QuoteTheme::TaggedSymbol)
+      VULNERABILITY = T.let(:vulnerability, ::Believe::QuoteTheme::TaggedSymbol)
+      GROWTH = T.let(:growth, ::Believe::QuoteTheme::TaggedSymbol)
+      HUMOR = T.let(:humor, ::Believe::QuoteTheme::TaggedSymbol)
+      WISDOM = T.let(:wisdom, ::Believe::QuoteTheme::TaggedSymbol)
+      LEADERSHIP = T.let(:leadership, ::Believe::QuoteTheme::TaggedSymbol)
+      LOVE = T.let(:love, ::Believe::QuoteTheme::TaggedSymbol)
+      FORGIVENESS = T.let(:forgiveness, ::Believe::QuoteTheme::TaggedSymbol)
+      PHILOSOPHY = T.let(:philosophy, ::Believe::QuoteTheme::TaggedSymbol)
+      ROMANCE = T.let(:romance, ::Believe::QuoteTheme::TaggedSymbol)
+      CULTURAL_PRIDE =
+        T.let(:"cultural-pride", ::Believe::QuoteTheme::TaggedSymbol)
+      CULTURAL_DIFFERENCES =
+        T.let(:"cultural-differences", ::Believe::QuoteTheme::TaggedSymbol)
+      ANTAGONISM = T.let(:antagonism, ::Believe::QuoteTheme::TaggedSymbol)
+      CELEBRATION = T.let(:celebration, ::Believe::QuoteTheme::TaggedSymbol)
+      IDENTITY = T.let(:identity, ::Believe::QuoteTheme::TaggedSymbol)
+      ISOLATION = T.let(:isolation, ::Believe::QuoteTheme::TaggedSymbol)
+      POWER = T.let(:power, ::Believe::QuoteTheme::TaggedSymbol)
+      SACRIFICE = T.let(:sacrifice, ::Believe::QuoteTheme::TaggedSymbol)
+      STANDARDS = T.let(:standards, ::Believe::QuoteTheme::TaggedSymbol)
+      CONFIDENCE = T.let(:confidence, ::Believe::QuoteTheme::TaggedSymbol)
+      CONFLICT = T.let(:conflict, ::Believe::QuoteTheme::TaggedSymbol)
+      HONESTY = T.let(:honesty, ::Believe::QuoteTheme::TaggedSymbol)
+      INTEGRITY = T.let(:integrity, ::Believe::QuoteTheme::TaggedSymbol)
+      INTIMIDATION = T.let(:intimidation, ::Believe::QuoteTheme::TaggedSymbol)
+      AMBITION = T.let(:ambition, ::Believe::QuoteTheme::TaggedSymbol)
+      NARCISSISM = T.let(:narcissism, ::Believe::QuoteTheme::TaggedSymbol)
+      MATURITY = T.let(:maturity, ::Believe::QuoteTheme::TaggedSymbol)
+
+      sig { override.returns(T::Array[::Believe::QuoteTheme::TaggedSymbol]) }
+      def self.values
+      end
+    end
+  end
+end

data/rbi/believe/models/quote_update_params.rbi

@@ -0,0 +1,113 @@
+# typed: strong
+
+module Believe
+  module Models
+    class QuoteUpdateParams < ::Believe::Internal::Type::BaseModel
+      extend ::Believe::Internal::Type::RequestParameters::Converter
+      include ::Believe::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(::Believe::QuoteUpdateParams, ::Believe::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :quote_id
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :character_id
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :context
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :episode_id
+
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_accessor :is_funny
+
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_accessor :is_inspirational
+
+      # Types of moments when quotes occur.
+      sig { returns(T.nilable(::Believe::QuoteMoment::OrSymbol)) }
+      attr_accessor :moment_type
+
+      sig { returns(T.nilable(Float)) }
+      attr_accessor :popularity_score
+
+      sig { returns(T.nilable(T::Array[::Believe::QuoteTheme::OrSymbol])) }
+      attr_accessor :secondary_themes
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :text
+
+      # Themes that quotes can be categorized under.
+      sig { returns(T.nilable(::Believe::QuoteTheme::OrSymbol)) }
+      attr_accessor :theme
+
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :times_shared
+
+      sig do
+        params(
+          quote_id: String,
+          character_id: T.nilable(String),
+          context: T.nilable(String),
+          episode_id: T.nilable(String),
+          is_funny: T.nilable(T::Boolean),
+          is_inspirational: T.nilable(T::Boolean),
+          moment_type: T.nilable(::Believe::QuoteMoment::OrSymbol),
+          popularity_score: T.nilable(Float),
+          secondary_themes:
+            T.nilable(T::Array[::Believe::QuoteTheme::OrSymbol]),
+          text: T.nilable(String),
+          theme: T.nilable(::Believe::QuoteTheme::OrSymbol),
+          times_shared: T.nilable(Integer),
+          request_options: ::Believe::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        quote_id:,
+        character_id: nil,
+        context: nil,
+        episode_id: nil,
+        is_funny: nil,
+        is_inspirational: nil,
+        # Types of moments when quotes occur.
+        moment_type: nil,
+        popularity_score: nil,
+        secondary_themes: nil,
+        text: nil,
+        # Themes that quotes can be categorized under.
+        theme: nil,
+        times_shared: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            quote_id: String,
+            character_id: T.nilable(String),
+            context: T.nilable(String),
+            episode_id: T.nilable(String),
+            is_funny: T.nilable(T::Boolean),
+            is_inspirational: T.nilable(T::Boolean),
+            moment_type: T.nilable(::Believe::QuoteMoment::OrSymbol),
+            popularity_score: T.nilable(Float),
+            secondary_themes:
+              T.nilable(T::Array[::Believe::QuoteTheme::OrSymbol]),
+            text: T.nilable(String),
+            theme: T.nilable(::Believe::QuoteTheme::OrSymbol),
+            times_shared: T.nilable(Integer),
+            request_options: ::Believe::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/believe/models/reframe_transform_negative_thoughts_params.rbi

@@ -0,0 +1,57 @@
+# typed: strong
+
+module Believe
+  module Models
+    class ReframeTransformNegativeThoughtsParams < ::Believe::Internal::Type::BaseModel
+      extend ::Believe::Internal::Type::RequestParameters::Converter
+      include ::Believe::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            ::Believe::ReframeTransformNegativeThoughtsParams,
+            ::Believe::Internal::AnyHash
+          )
+        end
+
+      # The negative thought to reframe
+      sig { returns(String) }
+      attr_accessor :negative_thought
+
+      # Is this a recurring thought?
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :recurring
+
+      sig { params(recurring: T::Boolean).void }
+      attr_writer :recurring
+
+      sig do
+        params(
+          negative_thought: String,
+          recurring: T::Boolean,
+          request_options: ::Believe::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The negative thought to reframe
+        negative_thought:,
+        # Is this a recurring thought?
+        recurring: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            negative_thought: String,
+            recurring: T::Boolean,
+            request_options: ::Believe::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/believe/models/reframe_transform_negative_thoughts_response.rbi

@@ -0,0 +1,73 @@
+# typed: strong
+
+module Believe
+  module Models
+    class ReframeTransformNegativeThoughtsResponse < ::Believe::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            ::Believe::Models::ReframeTransformNegativeThoughtsResponse,
+            ::Believe::Internal::AnyHash
+          )
+        end
+
+      # A daily affirmation to practice
+      sig { returns(String) }
+      attr_accessor :daily_affirmation
+
+      # The original negative thought
+      sig { returns(String) }
+      attr_accessor :original_thought
+
+      # The thought reframed positively
+      sig { returns(String) }
+      attr_accessor :reframed_thought
+
+      # Ted's take on this thought
+      sig { returns(String) }
+      attr_accessor :ted_perspective
+
+      # Dr. Sharon's therapeutic insight
+      sig { returns(T.nilable(String)) }
+      attr_accessor :dr_sharon_insight
+
+      # Reframed perspective response.
+      sig do
+        params(
+          daily_affirmation: String,
+          original_thought: String,
+          reframed_thought: String,
+          ted_perspective: String,
+          dr_sharon_insight: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # A daily affirmation to practice
+        daily_affirmation:,
+        # The original negative thought
+        original_thought:,
+        # The thought reframed positively
+        reframed_thought:,
+        # Ted's take on this thought
+        ted_perspective:,
+        # Dr. Sharon's therapeutic insight
+        dr_sharon_insight: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            daily_affirmation: String,
+            original_thought: String,
+            reframed_thought: String,
+            ted_perspective: String,
+            dr_sharon_insight: T.nilable(String)
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/believe/models/registered_webhook.rbi

@@ -0,0 +1,111 @@
+# typed: strong
+
+module Believe
+  module Models
+    class RegisteredWebhook < ::Believe::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(::Believe::RegisteredWebhook, ::Believe::Internal::AnyHash)
+        end
+
+      # Unique webhook identifier
+      sig { returns(String) }
+      attr_accessor :id
+
+      # When the webhook was registered
+      sig { returns(Time) }
+      attr_accessor :created_at
+
+      # List of event types this webhook is subscribed to
+      sig do
+        returns(T::Array[::Believe::RegisteredWebhook::EventType::TaggedSymbol])
+      end
+      attr_accessor :event_types
+
+      # The secret key for verifying webhook signatures (base64 encoded)
+      sig { returns(String) }
+      attr_accessor :secret
+
+      # The URL to send webhook events to
+      sig { returns(String) }
+      attr_accessor :url
+
+      # Optional description for this webhook
+      sig { returns(T.nilable(String)) }
+      attr_accessor :description
+
+      # A registered webhook endpoint.
+      sig do
+        params(
+          id: String,
+          created_at: Time,
+          event_types:
+            T::Array[::Believe::RegisteredWebhook::EventType::OrSymbol],
+          secret: String,
+          url: String,
+          description: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Unique webhook identifier
+        id:,
+        # When the webhook was registered
+        created_at:,
+        # List of event types this webhook is subscribed to
+        event_types:,
+        # The secret key for verifying webhook signatures (base64 encoded)
+        secret:,
+        # The URL to send webhook events to
+        url:,
+        # Optional description for this webhook
+        description: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            created_at: Time,
+            event_types:
+              T::Array[::Believe::RegisteredWebhook::EventType::TaggedSymbol],
+            secret: String,
+            url: String,
+            description: T.nilable(String)
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module EventType
+        extend ::Believe::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, ::Believe::RegisteredWebhook::EventType)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        MATCH_COMPLETED =
+          T.let(
+            :"match.completed",
+            ::Believe::RegisteredWebhook::EventType::TaggedSymbol
+          )
+        TEAM_MEMBER_TRANSFERRED =
+          T.let(
+            :"team_member.transferred",
+            ::Believe::RegisteredWebhook::EventType::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[::Believe::RegisteredWebhook::EventType::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/believe/models/stream_test_connection_params.rbi

@@ -0,0 +1,30 @@
+# typed: strong
+
+module Believe
+  module Models
+    class StreamTestConnectionParams < ::Believe::Internal::Type::BaseModel
+      extend ::Believe::Internal::Type::RequestParameters::Converter
+      include ::Believe::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            ::Believe::StreamTestConnectionParams,
+            ::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/stream_test_connection_response.rbi

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

data/rbi/believe/models/team.rbi

@@ -0,0 +1,186 @@
+# typed: strong
+
+module Believe
+  module Models
+    class Team < ::Believe::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(::Believe::Team, ::Believe::Internal::AnyHash) }
+
+      # Unique identifier
+      sig { returns(String) }
+      attr_accessor :id
+
+      # Team culture/morale score (0-100)
+      sig { returns(Integer) }
+      attr_accessor :culture_score
+
+      # Year the club was founded
+      sig { returns(Integer) }
+      attr_accessor :founded_year
+
+      # Current league
+      sig { returns(::Believe::League::TaggedSymbol) }
+      attr_accessor :league
+
+      # Team name
+      sig { returns(String) }
+      attr_accessor :name
+
+      # Home stadium name
+      sig { returns(String) }
+      attr_accessor :stadium
+
+      # Team's core values
+      sig { returns(::Believe::TeamValues) }
+      attr_reader :values
+
+      sig { params(values: ::Believe::TeamValues::OrHash).void }
+      attr_writer :values
+
+      # Annual budget in GBP
+      sig { returns(T.nilable(String)) }
+      attr_accessor :annual_budget_gbp
+
+      # Average match attendance
+      sig { returns(T.nilable(Float)) }
+      attr_accessor :average_attendance
+
+      # Team contact email
+      sig { returns(T.nilable(String)) }
+      attr_accessor :contact_email
+
+      # Whether the team is currently active
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :is_active
+
+      sig { params(is_active: T::Boolean).void }
+      attr_writer :is_active
+
+      # Team nickname
+      sig { returns(T.nilable(String)) }
+      attr_accessor :nickname
+
+      # Primary team color (hex)
+      sig { returns(T.nilable(String)) }
+      attr_accessor :primary_color
+
+      # List of rival team IDs
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_reader :rival_teams
+
+      sig { params(rival_teams: T::Array[String]).void }
+      attr_writer :rival_teams
+
+      # Secondary team color (hex)
+      sig { returns(T.nilable(String)) }
+      attr_accessor :secondary_color
+
+      # Geographic coordinates for a location.
+      sig { returns(T.nilable(::Believe::GeoLocation)) }
+      attr_reader :stadium_location
+
+      sig do
+        params(stadium_location: T.nilable(::Believe::GeoLocation::OrHash)).void
+      end
+      attr_writer :stadium_location
+
+      # Official team website
+      sig { returns(T.nilable(String)) }
+      attr_accessor :website
+
+      # Season win percentage
+      sig { returns(T.nilable(Float)) }
+      attr_accessor :win_percentage
+
+      # Full team model with ID.
+      sig do
+        params(
+          id: String,
+          culture_score: Integer,
+          founded_year: Integer,
+          league: ::Believe::League::OrSymbol,
+          name: String,
+          stadium: String,
+          values: ::Believe::TeamValues::OrHash,
+          annual_budget_gbp: T.nilable(String),
+          average_attendance: T.nilable(Float),
+          contact_email: T.nilable(String),
+          is_active: T::Boolean,
+          nickname: T.nilable(String),
+          primary_color: T.nilable(String),
+          rival_teams: T::Array[String],
+          secondary_color: T.nilable(String),
+          stadium_location: T.nilable(::Believe::GeoLocation::OrHash),
+          website: T.nilable(String),
+          win_percentage: T.nilable(Float)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Unique identifier
+        id:,
+        # Team culture/morale score (0-100)
+        culture_score:,
+        # Year the club was founded
+        founded_year:,
+        # Current league
+        league:,
+        # Team name
+        name:,
+        # Home stadium name
+        stadium:,
+        # Team's core values
+        values:,
+        # Annual budget in GBP
+        annual_budget_gbp: nil,
+        # Average match attendance
+        average_attendance: nil,
+        # Team contact email
+        contact_email: nil,
+        # Whether the team is currently active
+        is_active: nil,
+        # Team nickname
+        nickname: nil,
+        # Primary team color (hex)
+        primary_color: nil,
+        # List of rival team IDs
+        rival_teams: nil,
+        # Secondary team color (hex)
+        secondary_color: nil,
+        # Geographic coordinates for a location.
+        stadium_location: nil,
+        # Official team website
+        website: nil,
+        # Season win percentage
+        win_percentage: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            culture_score: Integer,
+            founded_year: Integer,
+            league: ::Believe::League::TaggedSymbol,
+            name: String,
+            stadium: String,
+            values: ::Believe::TeamValues,
+            annual_budget_gbp: T.nilable(String),
+            average_attendance: T.nilable(Float),
+            contact_email: T.nilable(String),
+            is_active: T::Boolean,
+            nickname: T.nilable(String),
+            primary_color: T.nilable(String),
+            rival_teams: T::Array[String],
+            secondary_color: T.nilable(String),
+            stadium_location: T.nilable(::Believe::GeoLocation),
+            website: T.nilable(String),
+            win_percentage: T.nilable(Float)
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end