believe 0.7.0

data/rbi/believe/resources/team_members.rbi

@@ -0,0 +1,223 @@
+# typed: strong
+
+module Believe
+  module Resources
+    # Team members with union types (oneOf) - Players, Coaches, Medical Staff,
+    # Equipment Managers
+    class TeamMembers
+      # Add a new team member to a team.
+      #
+      # The request body is a **union type (oneOf)** - you must include the
+      # `member_type` discriminator field:
+      #
+      # - `"member_type": "player"` - Creates a player (requires position,
+      #   jersey_number, etc.)
+      # - `"member_type": "coach"` - Creates a coach (requires specialty, etc.)
+      # - `"member_type": "medical_staff"` - Creates medical staff (requires medical
+      #   specialty, etc.)
+      # - `"member_type": "equipment_manager"` - Creates equipment manager (requires
+      #   responsibilities, etc.)
+      #
+      # The `character_id` field references an existing character from
+      # `/characters/{id}`.
+      #
+      # **Example for creating a player:**
+      #
+      # ```json
+      # {
+      #   "member_type": "player",
+      #   "character_id": "sam-obisanya",
+      #   "team_id": "afc-richmond",
+      #   "years_with_team": 2,
+      #   "position": "midfielder",
+      #   "jersey_number": 24,
+      #   "goals_scored": 12,
+      #   "assists": 15
+      # }
+      # ```
+      sig do
+        params(
+          member:
+            T.any(
+              ::Believe::TeamMemberCreateParams::Member::Player::OrHash,
+              ::Believe::TeamMemberCreateParams::Member::Coach::OrHash,
+              ::Believe::TeamMemberCreateParams::Member::MedicalStaff::OrHash,
+              ::Believe::TeamMemberCreateParams::Member::EquipmentManager::OrHash
+            ),
+          request_options: ::Believe::RequestOptions::OrHash
+        ).returns(::Believe::Models::TeamMemberCreateResponse::Variants)
+      end
+      def create(
+        # A football player on the team.
+        member:,
+        request_options: {}
+      )
+      end
+
+      # Retrieve detailed information about a specific team member.
+      #
+      # The response is a **union type (oneOf)** - the actual shape depends on the
+      # member's type:
+      #
+      # - **player**: Includes position, jersey_number, goals_scored, assists,
+      #   is_captain
+      # - **coach**: Includes specialty, certifications, win_rate
+      # - **medical_staff**: Includes specialty, qualifications, license_number
+      # - **equipment_manager**: Includes responsibilities, is_head_kitman
+      #
+      # Use `character_id` to fetch full character details from
+      # `/characters/{character_id}`.
+      sig do
+        params(
+          member_id: String,
+          request_options: ::Believe::RequestOptions::OrHash
+        ).returns(::Believe::Models::TeamMemberRetrieveResponse::Variants)
+      end
+      def retrieve(member_id, request_options: {})
+      end
+
+      # Update specific fields of an existing team member. Fields vary by member type.
+      sig do
+        params(
+          member_id: String,
+          updates:
+            T.any(
+              ::Believe::TeamMemberUpdateParams::Updates::PlayerUpdate::OrHash,
+              ::Believe::TeamMemberUpdateParams::Updates::CoachUpdate::OrHash,
+              ::Believe::TeamMemberUpdateParams::Updates::MedicalStaffUpdate::OrHash,
+              ::Believe::TeamMemberUpdateParams::Updates::EquipmentManagerUpdate::OrHash
+            ),
+          request_options: ::Believe::RequestOptions::OrHash
+        ).returns(::Believe::Models::TeamMemberUpdateResponse::Variants)
+      end
+      def update(
+        member_id,
+        # Update model for players.
+        updates:,
+        request_options: {}
+      )
+      end
+
+      # Get a paginated list of all team members.
+      #
+      # This endpoint demonstrates **union types (oneOf)** in the response. Each team
+      # member can be one of: Player, Coach, MedicalStaff, or EquipmentManager. The
+      # `member_type` field acts as a discriminator to determine the shape of each
+      # object.
+      sig do
+        params(
+          limit: Integer,
+          member_type:
+            T.nilable(::Believe::TeamMemberListParams::MemberType::OrSymbol),
+          skip: Integer,
+          team_id: T.nilable(String),
+          request_options: ::Believe::RequestOptions::OrHash
+        ).returns(
+          ::Believe::Internal::SkipLimitPage[
+            ::Believe::Models::TeamMemberListResponse::Variants
+          ]
+        )
+      end
+      def list(
+        # Maximum number of items to return (max: 100)
+        limit: nil,
+        # Filter by member type
+        member_type: nil,
+        # Number of items to skip (offset)
+        skip: nil,
+        # Filter by team ID
+        team_id: nil,
+        request_options: {}
+      )
+      end
+
+      # Remove a team member from the roster.
+      sig do
+        params(
+          member_id: String,
+          request_options: ::Believe::RequestOptions::OrHash
+        ).void
+      end
+      def delete(member_id, request_options: {})
+      end
+
+      # Get only coaches (filtered subset of team members).
+      sig do
+        params(
+          limit: Integer,
+          skip: Integer,
+          specialty: T.nilable(::Believe::CoachSpecialty::OrSymbol),
+          team_id: T.nilable(String),
+          request_options: ::Believe::RequestOptions::OrHash
+        ).returns(::Believe::Internal::SkipLimitPage[::Believe::Coach])
+      end
+      def list_coaches(
+        # Maximum number of items to return (max: 100)
+        limit: nil,
+        # Number of items to skip (offset)
+        skip: nil,
+        # Filter by specialty
+        specialty: nil,
+        # Filter by team ID
+        team_id: nil,
+        request_options: {}
+      )
+      end
+
+      # Get only players (filtered subset of team members).
+      sig do
+        params(
+          limit: Integer,
+          position: T.nilable(::Believe::Position::OrSymbol),
+          skip: Integer,
+          team_id: T.nilable(String),
+          request_options: ::Believe::RequestOptions::OrHash
+        ).returns(::Believe::Internal::SkipLimitPage[::Believe::Player])
+      end
+      def list_players(
+        # Maximum number of items to return (max: 100)
+        limit: nil,
+        # Filter by position
+        position: nil,
+        # Number of items to skip (offset)
+        skip: nil,
+        # Filter by team ID
+        team_id: nil,
+        request_options: {}
+      )
+      end
+
+      # Get all staff members (medical staff and equipment managers).
+      #
+      # This demonstrates a **narrower union type** - the response is oneOf MedicalStaff
+      # or EquipmentManager.
+      sig do
+        params(
+          limit: Integer,
+          skip: Integer,
+          team_id: T.nilable(String),
+          request_options: ::Believe::RequestOptions::OrHash
+        ).returns(
+          ::Believe::Internal::SkipLimitPage[
+            ::Believe::Models::TeamMemberListStaffResponse::Variants
+          ]
+        )
+      end
+      def list_staff(
+        # Maximum number of items to return (max: 100)
+        limit: nil,
+        # Number of items to skip (offset)
+        skip: nil,
+        # Filter by team ID
+        team_id: 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/teams/logo.rbi

@@ -0,0 +1,53 @@
+# typed: strong
+
+module Believe
+  module Resources
+    class Teams
+      # Operations related to football teams
+      class Logo
+        # Delete a team's logo.
+        sig do
+          params(
+            file_id: String,
+            team_id: String,
+            request_options: ::Believe::RequestOptions::OrHash
+          ).void
+        end
+        def delete(file_id, team_id:, request_options: {})
+        end
+
+        # Download a team's logo by file ID.
+        sig do
+          params(
+            file_id: String,
+            team_id: String,
+            request_options: ::Believe::RequestOptions::OrHash
+          ).returns(T.anything)
+        end
+        def download(file_id, team_id:, request_options: {})
+        end
+
+        # Upload a logo image for a team. Accepts image files (jpg, png, gif, webp).
+        sig do
+          params(
+            team_id: String,
+            file: ::Believe::Internal::FileInput,
+            request_options: ::Believe::RequestOptions::OrHash
+          ).returns(::Believe::Teams::FileUpload)
+        end
+        def upload(
+          team_id,
+          # Logo image file
+          file:,
+          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/teams.rbi

@@ -0,0 +1,205 @@
+# typed: strong
+
+module Believe
+  module Resources
+    # Operations related to football teams
+    class Teams
+      # Operations related to football teams
+      sig { returns(::Believe::Resources::Teams::Logo) }
+      attr_reader :logo
+
+      # Add a new team to the league.
+      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(::Believe::Team)
+      end
+      def create(
+        # 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
+
+      # Retrieve detailed information about a specific team.
+      sig do
+        params(
+          team_id: String,
+          request_options: ::Believe::RequestOptions::OrHash
+        ).returns(::Believe::Team)
+      end
+      def retrieve(team_id, request_options: {})
+      end
+
+      # Update specific fields of an existing team.
+      sig do
+        params(
+          team_id: String,
+          annual_budget_gbp:
+            T.nilable(::Believe::TeamUpdateParams::AnnualBudgetGbp::Variants),
+          average_attendance: T.nilable(Float),
+          contact_email: T.nilable(String),
+          culture_score: T.nilable(Integer),
+          founded_year: T.nilable(Integer),
+          is_active: T.nilable(T::Boolean),
+          league: T.nilable(::Believe::League::OrSymbol),
+          name: T.nilable(String),
+          nickname: T.nilable(String),
+          primary_color: T.nilable(String),
+          rival_teams: T.nilable(T::Array[String]),
+          secondary_color: T.nilable(String),
+          stadium: T.nilable(String),
+          stadium_location: T.nilable(::Believe::GeoLocation::OrHash),
+          values: T.nilable(::Believe::TeamValues::OrHash),
+          website: T.nilable(String),
+          win_percentage: T.nilable(Float),
+          request_options: ::Believe::RequestOptions::OrHash
+        ).returns(::Believe::Team)
+      end
+      def update(
+        team_id,
+        annual_budget_gbp: nil,
+        average_attendance: nil,
+        contact_email: nil,
+        culture_score: nil,
+        founded_year: nil,
+        is_active: nil,
+        # Football leagues.
+        league: nil,
+        name: nil,
+        nickname: nil,
+        primary_color: nil,
+        rival_teams: nil,
+        secondary_color: nil,
+        stadium: nil,
+        # Geographic coordinates for a location.
+        stadium_location: nil,
+        # Core values that define a team's culture.
+        values: nil,
+        website: nil,
+        win_percentage: nil,
+        request_options: {}
+      )
+      end
+
+      # Get a paginated list of all teams with optional filtering by league or culture
+      # score.
+      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(::Believe::Internal::SkipLimitPage[::Believe::Team])
+      end
+      def list(
+        # 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
+
+      # Remove a team from the database (relegation to oblivion).
+      sig do
+        params(
+          team_id: String,
+          request_options: ::Believe::RequestOptions::OrHash
+        ).void
+      end
+      def delete(team_id, request_options: {})
+      end
+
+      # Get detailed culture and values information for a team.
+      sig do
+        params(
+          team_id: String,
+          request_options: ::Believe::RequestOptions::OrHash
+        ).returns(T::Hash[Symbol, T.anything])
+      end
+      def get_culture(team_id, request_options: {})
+      end
+
+      # Get all rival teams for a specific team.
+      sig do
+        params(
+          team_id: String,
+          request_options: ::Believe::RequestOptions::OrHash
+        ).returns(T::Array[::Believe::Team])
+      end
+      def get_rivals(team_id, request_options: {})
+      end
+
+      # List all uploaded logos for a team.
+      sig do
+        params(
+          team_id: String,
+          request_options: ::Believe::RequestOptions::OrHash
+        ).returns(T::Array[::Believe::Teams::FileUpload])
+      end
+      def list_logos(team_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/ticket_sales.rbi

@@ -0,0 +1,149 @@
+# typed: strong
+
+module Believe
+  module Resources
+    # Ticket sales with 300 records for practicing pagination, filtering, and
+    # financial data
+    class TicketSales
+      # Record a new ticket sale.
+      sig do
+        params(
+          buyer_name: String,
+          currency: String,
+          discount: String,
+          match_id: String,
+          purchase_method: ::Believe::PurchaseMethod::OrSymbol,
+          quantity: Integer,
+          subtotal: String,
+          tax: String,
+          total: String,
+          unit_price: String,
+          buyer_email: T.nilable(String),
+          coupon_code: T.nilable(String),
+          request_options: ::Believe::RequestOptions::OrHash
+        ).returns(::Believe::TicketSale)
+      end
+      def create(
+        # Name of the ticket buyer
+        buyer_name:,
+        # Currency code (GBP, USD, or EUR)
+        currency:,
+        # Discount amount applied from coupon
+        discount:,
+        # ID of the match
+        match_id:,
+        # How the ticket was purchased
+        purchase_method:,
+        # Number of tickets purchased
+        quantity:,
+        # Subtotal before discount and tax (unit_price \* quantity)
+        subtotal:,
+        # Tax amount (20% UK VAT on discounted subtotal)
+        tax:,
+        # Final total (subtotal - discount + tax)
+        total:,
+        # Price per ticket (decimal string)
+        unit_price:,
+        # Email of the ticket buyer
+        buyer_email: nil,
+        # Coupon code applied, if any
+        coupon_code: nil,
+        request_options: {}
+      )
+      end
+
+      # Retrieve detailed information about a specific ticket sale.
+      sig do
+        params(
+          ticket_sale_id: String,
+          request_options: ::Believe::RequestOptions::OrHash
+        ).returns(::Believe::TicketSale)
+      end
+      def retrieve(ticket_sale_id, request_options: {})
+      end
+
+      # Update specific fields of an existing ticket sale.
+      sig do
+        params(
+          ticket_sale_id: String,
+          buyer_email: T.nilable(String),
+          buyer_name: T.nilable(String),
+          coupon_code: T.nilable(String),
+          currency: T.nilable(String),
+          discount: T.nilable(String),
+          match_id: T.nilable(String),
+          purchase_method: T.nilable(::Believe::PurchaseMethod::OrSymbol),
+          quantity: T.nilable(Integer),
+          subtotal: T.nilable(String),
+          tax: T.nilable(String),
+          total: T.nilable(String),
+          unit_price: T.nilable(String),
+          request_options: ::Believe::RequestOptions::OrHash
+        ).returns(::Believe::TicketSale)
+      end
+      def update(
+        ticket_sale_id,
+        buyer_email: nil,
+        buyer_name: nil,
+        coupon_code: nil,
+        currency: nil,
+        discount: nil,
+        match_id: nil,
+        # How the ticket was purchased.
+        purchase_method: nil,
+        quantity: nil,
+        subtotal: nil,
+        tax: nil,
+        total: nil,
+        unit_price: nil,
+        request_options: {}
+      )
+      end
+
+      # Get a paginated list of all ticket sales with optional filtering. With 300
+      # records, this endpoint is ideal for practicing pagination.
+      sig do
+        params(
+          coupon_code: T.nilable(String),
+          currency: T.nilable(String),
+          limit: Integer,
+          match_id: T.nilable(String),
+          purchase_method: T.nilable(::Believe::PurchaseMethod::OrSymbol),
+          skip: Integer,
+          request_options: ::Believe::RequestOptions::OrHash
+        ).returns(::Believe::Internal::SkipLimitPage[::Believe::TicketSale])
+      end
+      def list(
+        # Filter by coupon code (use 'none' for sales without coupons)
+        coupon_code: nil,
+        # Filter by currency (GBP, USD, EUR)
+        currency: nil,
+        # Maximum number of items to return (max: 100)
+        limit: nil,
+        # Filter by match ID
+        match_id: nil,
+        # Filter by purchase method
+        purchase_method: nil,
+        # Number of items to skip (offset)
+        skip: nil,
+        request_options: {}
+      )
+      end
+
+      # Remove a ticket sale from the database.
+      sig do
+        params(
+          ticket_sale_id: String,
+          request_options: ::Believe::RequestOptions::OrHash
+        ).void
+      end
+      def delete(ticket_sale_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/version.rbi

@@ -0,0 +1,21 @@
+# typed: strong
+
+module Believe
+  module Resources
+    class Version
+      # Get detailed information about API versioning.
+      sig do
+        params(request_options: ::Believe::RequestOptions::OrHash).returns(
+          T.anything
+        )
+      end
+      def retrieve(request_options: {})
+      end
+
+      # @api private
+      sig { params(client: ::Believe::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end