believe 0.7.0

data/rbi/believe/models/team_create_params.rbi

@@ -0,0 +1,206 @@
+# typed: strong
+
+module Believe
+  module Models
+    class TeamCreateParams < ::Believe::Internal::Type::BaseModel
+      extend ::Believe::Internal::Type::RequestParameters::Converter
+      include ::Believe::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(::Believe::TeamCreateParams, ::Believe::Internal::AnyHash)
+        end
+
+      # 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::OrSymbol) }
+      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 do
+        returns(
+          T.nilable(::Believe::TeamCreateParams::AnnualBudgetGbp::Variants)
+        )
+      end
+      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
+
+      sig do
+        params(
+          culture_score: Integer,
+          founded_year: Integer,
+          league: ::Believe::League::OrSymbol,
+          name: String,
+          stadium: String,
+          values: ::Believe::TeamValues::OrHash,
+          annual_budget_gbp:
+            T.nilable(::Believe::TeamCreateParams::AnnualBudgetGbp::Variants),
+          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),
+          request_options: ::Believe::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # 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,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            culture_score: Integer,
+            founded_year: Integer,
+            league: ::Believe::League::OrSymbol,
+            name: String,
+            stadium: String,
+            values: ::Believe::TeamValues,
+            annual_budget_gbp:
+              T.nilable(::Believe::TeamCreateParams::AnnualBudgetGbp::Variants),
+            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),
+            request_options: ::Believe::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # Annual budget in GBP
+      module AnnualBudgetGbp
+        extend ::Believe::Internal::Type::Union
+
+        Variants = T.type_alias { T.any(Float, String) }
+
+        sig do
+          override.returns(
+            T::Array[::Believe::TeamCreateParams::AnnualBudgetGbp::Variants]
+          )
+        end
+        def self.variants
+        end
+      end
+    end
+  end
+end

data/rbi/believe/models/team_delete_params.rbi

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

data/rbi/believe/models/team_get_culture_params.rbi

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

data/rbi/believe/models/team_get_culture_response.rbi

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

data/rbi/believe/models/team_get_rivals_params.rbi

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

data/rbi/believe/models/team_get_rivals_response.rbi

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

data/rbi/believe/models/team_list_logos_params.rbi

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

data/rbi/believe/models/team_list_logos_response.rbi

@@ -0,0 +1,11 @@
+# typed: strong
+
+module Believe
+  module Models
+    TeamListLogosResponse =
+      T.let(
+        ::Believe::Internal::Type::ArrayOf[::Believe::Teams::FileUpload],
+        ::Believe::Internal::Type::Converter
+      )
+  end
+end

data/rbi/believe/models/team_list_params.rbi

@@ -0,0 +1,73 @@
+# typed: strong
+
+module Believe
+  module Models
+    class TeamListParams < ::Believe::Internal::Type::BaseModel
+      extend ::Believe::Internal::Type::RequestParameters::Converter
+      include ::Believe::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(::Believe::TeamListParams, ::Believe::Internal::AnyHash)
+        end
+
+      # Filter by league
+      sig { returns(T.nilable(::Believe::League::OrSymbol)) }
+      attr_accessor :league
+
+      # 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 culture score
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :min_culture_score
+
+      # 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(
+          league: T.nilable(::Believe::League::OrSymbol),
+          limit: Integer,
+          min_culture_score: T.nilable(Integer),
+          skip: Integer,
+          request_options: ::Believe::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Filter by league
+        league: nil,
+        # Maximum number of items to return (max: 100)
+        limit: nil,
+        # Minimum culture score
+        min_culture_score: nil,
+        # Number of items to skip (offset)
+        skip: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            league: T.nilable(::Believe::League::OrSymbol),
+            limit: Integer,
+            min_culture_score: T.nilable(Integer),
+            skip: Integer,
+            request_options: ::Believe::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end