believe 0.7.0

data/lib/believe/resources/team_members.rb

@@ -0,0 +1,267 @@
+# frozen_string_literal: true
+
+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
+      # }
+      # ```
+      #
+      # @overload create(member:, request_options: {})
+      #
+      # @param member [::Believe::Models::TeamMemberCreateParams::Member::Player, ::Believe::Models::TeamMemberCreateParams::Member::Coach, ::Believe::Models::TeamMemberCreateParams::Member::MedicalStaff, ::Believe::Models::TeamMemberCreateParams::Member::EquipmentManager] A football player on the team.
+      #
+      # @param request_options [::Believe::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [::Believe::Models::Player, ::Believe::Models::Coach, ::Believe::Models::MedicalStaff, ::Believe::Models::EquipmentManager]
+      #
+      # @see ::Believe::Models::TeamMemberCreateParams
+      def create(params)
+        parsed, options = ::Believe::TeamMemberCreateParams.dump_request(params)
+        @client.request(
+          method: :post,
+          path: "team-members",
+          body: parsed[:member],
+          model: ::Believe::Models::TeamMemberCreateResponse,
+          options: 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}`.
+      #
+      # @overload retrieve(member_id, request_options: {})
+      #
+      # @param member_id [String]
+      # @param request_options [::Believe::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [::Believe::Models::Player, ::Believe::Models::Coach, ::Believe::Models::MedicalStaff, ::Believe::Models::EquipmentManager]
+      #
+      # @see ::Believe::Models::TeamMemberRetrieveParams
+      def retrieve(member_id, params = {})
+        @client.request(
+          method: :get,
+          path: ["team-members/%1$s", member_id],
+          model: ::Believe::Models::TeamMemberRetrieveResponse,
+          options: params[:request_options]
+        )
+      end
+
+      # Update specific fields of an existing team member. Fields vary by member type.
+      #
+      # @overload update(member_id, updates:, request_options: {})
+      #
+      # @param member_id [String]
+      #
+      # @param updates [::Believe::Models::TeamMemberUpdateParams::Updates::PlayerUpdate, ::Believe::Models::TeamMemberUpdateParams::Updates::CoachUpdate, ::Believe::Models::TeamMemberUpdateParams::Updates::MedicalStaffUpdate, ::Believe::Models::TeamMemberUpdateParams::Updates::EquipmentManagerUpdate] Update model for players.
+      #
+      # @param request_options [::Believe::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [::Believe::Models::Player, ::Believe::Models::Coach, ::Believe::Models::MedicalStaff, ::Believe::Models::EquipmentManager]
+      #
+      # @see ::Believe::Models::TeamMemberUpdateParams
+      def update(member_id, params)
+        parsed, options = ::Believe::TeamMemberUpdateParams.dump_request(params)
+        @client.request(
+          method: :patch,
+          path: ["team-members/%1$s", member_id],
+          body: parsed[:updates],
+          model: ::Believe::Models::TeamMemberUpdateResponse,
+          options: 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.
+      #
+      # @overload list(limit: nil, member_type: nil, skip: nil, team_id: nil, request_options: {})
+      #
+      # @param limit [Integer] Maximum number of items to return (max: 100)
+      #
+      # @param member_type [Symbol, ::Believe::Models::TeamMemberListParams::MemberType, nil] Filter by member type
+      #
+      # @param skip [Integer] Number of items to skip (offset)
+      #
+      # @param team_id [String, nil] Filter by team ID
+      #
+      # @param request_options [::Believe::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [::Believe::Internal::SkipLimitPage<::Believe::Models::Player, ::Believe::Models::Coach, ::Believe::Models::MedicalStaff, ::Believe::Models::EquipmentManager>]
+      #
+      # @see ::Believe::Models::TeamMemberListParams
+      def list(params = {})
+        parsed, options = ::Believe::TeamMemberListParams.dump_request(params)
+        query = ::Believe::Internal::Util.encode_query_params(parsed)
+        @client.request(
+          method: :get,
+          path: "team-members",
+          query: query,
+          page: ::Believe::Internal::SkipLimitPage,
+          model: ::Believe::Models::TeamMemberListResponse,
+          options: options
+        )
+      end
+
+      # Remove a team member from the roster.
+      #
+      # @overload delete(member_id, request_options: {})
+      #
+      # @param member_id [String]
+      # @param request_options [::Believe::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [nil]
+      #
+      # @see ::Believe::Models::TeamMemberDeleteParams
+      def delete(member_id, params = {})
+        @client.request(
+          method: :delete,
+          path: ["team-members/%1$s", member_id],
+          model: NilClass,
+          options: params[:request_options]
+        )
+      end
+
+      # Get only coaches (filtered subset of team members).
+      #
+      # @overload list_coaches(limit: nil, skip: nil, specialty: nil, team_id: nil, request_options: {})
+      #
+      # @param limit [Integer] Maximum number of items to return (max: 100)
+      #
+      # @param skip [Integer] Number of items to skip (offset)
+      #
+      # @param specialty [Symbol, ::Believe::Models::CoachSpecialty, nil] Filter by specialty
+      #
+      # @param team_id [String, nil] Filter by team ID
+      #
+      # @param request_options [::Believe::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [::Believe::Internal::SkipLimitPage<::Believe::Models::Coach>]
+      #
+      # @see ::Believe::Models::TeamMemberListCoachesParams
+      def list_coaches(params = {})
+        parsed, options = ::Believe::TeamMemberListCoachesParams.dump_request(params)
+        query = ::Believe::Internal::Util.encode_query_params(parsed)
+        @client.request(
+          method: :get,
+          path: "team-members/coaches/",
+          query: query,
+          page: ::Believe::Internal::SkipLimitPage,
+          model: ::Believe::Coach,
+          options: options
+        )
+      end
+
+      # Get only players (filtered subset of team members).
+      #
+      # @overload list_players(limit: nil, position: nil, skip: nil, team_id: nil, request_options: {})
+      #
+      # @param limit [Integer] Maximum number of items to return (max: 100)
+      #
+      # @param position [Symbol, ::Believe::Models::Position, nil] Filter by position
+      #
+      # @param skip [Integer] Number of items to skip (offset)
+      #
+      # @param team_id [String, nil] Filter by team ID
+      #
+      # @param request_options [::Believe::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [::Believe::Internal::SkipLimitPage<::Believe::Models::Player>]
+      #
+      # @see ::Believe::Models::TeamMemberListPlayersParams
+      def list_players(params = {})
+        parsed, options = ::Believe::TeamMemberListPlayersParams.dump_request(params)
+        query = ::Believe::Internal::Util.encode_query_params(parsed)
+        @client.request(
+          method: :get,
+          path: "team-members/players/",
+          query: query,
+          page: ::Believe::Internal::SkipLimitPage,
+          model: ::Believe::Player,
+          options: options
+        )
+      end
+
+      # Get all staff members (medical staff and equipment managers).
+      #
+      # This demonstrates a **narrower union type** - the response is oneOf MedicalStaff
+      # or EquipmentManager.
+      #
+      # @overload list_staff(limit: nil, skip: nil, team_id: nil, request_options: {})
+      #
+      # @param limit [Integer] Maximum number of items to return (max: 100)
+      #
+      # @param skip [Integer] Number of items to skip (offset)
+      #
+      # @param team_id [String, nil] Filter by team ID
+      #
+      # @param request_options [::Believe::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [::Believe::Internal::SkipLimitPage<::Believe::Models::MedicalStaff, ::Believe::Models::EquipmentManager>]
+      #
+      # @see ::Believe::Models::TeamMemberListStaffParams
+      def list_staff(params = {})
+        parsed, options = ::Believe::TeamMemberListStaffParams.dump_request(params)
+        query = ::Believe::Internal::Util.encode_query_params(parsed)
+        @client.request(
+          method: :get,
+          path: "team-members/staff/",
+          query: query,
+          page: ::Believe::Internal::SkipLimitPage,
+          model: ::Believe::Models::TeamMemberListStaffResponse,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [::Believe::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/believe/resources/teams/logo.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Believe
+  module Resources
+    class Teams
+      # Operations related to football teams
+      class Logo
+        # Delete a team's logo.
+        #
+        # @overload delete(file_id, team_id:, request_options: {})
+        #
+        # @param file_id [String]
+        # @param team_id [String]
+        # @param request_options [::Believe::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [nil]
+        #
+        # @see ::Believe::Models::Teams::LogoDeleteParams
+        def delete(file_id, params)
+          parsed, options = ::Believe::Teams::LogoDeleteParams.dump_request(params)
+          team_id =
+            parsed.delete(:team_id) do
+              raise ArgumentError.new("missing required path argument #{_1}")
+            end
+          @client.request(
+            method: :delete,
+            path: ["teams/%1$s/logo/%2$s", team_id, file_id],
+            model: NilClass,
+            options: options
+          )
+        end
+
+        # Download a team's logo by file ID.
+        #
+        # @overload download(file_id, team_id:, request_options: {})
+        #
+        # @param file_id [String]
+        # @param team_id [String]
+        # @param request_options [::Believe::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Object]
+        #
+        # @see ::Believe::Models::Teams::LogoDownloadParams
+        def download(file_id, params)
+          parsed, options = ::Believe::Teams::LogoDownloadParams.dump_request(params)
+          team_id =
+            parsed.delete(:team_id) do
+              raise ArgumentError.new("missing required path argument #{_1}")
+            end
+          @client.request(
+            method: :get,
+            path: ["teams/%1$s/logo/%2$s", team_id, file_id],
+            model: ::Believe::Internal::Type::Unknown,
+            options: options
+          )
+        end
+
+        # Upload a logo image for a team. Accepts image files (jpg, png, gif, webp).
+        #
+        # @overload upload(team_id, file:, request_options: {})
+        #
+        # @param team_id [String]
+        #
+        # @param file [Pathname, StringIO, IO, String, ::Believe::FilePart] Logo image file
+        #
+        # @param request_options [::Believe::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [::Believe::Models::Teams::FileUpload]
+        #
+        # @see ::Believe::Models::Teams::LogoUploadParams
+        def upload(team_id, params)
+          parsed, options = ::Believe::Teams::LogoUploadParams.dump_request(params)
+          @client.request(
+            method: :post,
+            path: ["teams/%1$s/logo", team_id],
+            headers: {"content-type" => "multipart/form-data"},
+            body: parsed,
+            model: ::Believe::Teams::FileUpload,
+            options: options
+          )
+        end
+
+        # @api private
+        #
+        # @param client [::Believe::Client]
+        def initialize(client:)
+          @client = client
+        end
+      end
+    end
+  end
+end

data/lib/believe/resources/teams.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+module Believe
+  module Resources
+    # Operations related to football teams
+    class Teams
+      # Operations related to football teams
+      # @return [::Believe::Resources::Teams::Logo]
+      attr_reader :logo
+
+      # Add a new team to the league.
+      #
+      # @overload create(culture_score:, founded_year:, league:, name:, stadium:, values:, annual_budget_gbp: nil, average_attendance: nil, contact_email: nil, is_active: nil, nickname: nil, primary_color: nil, rival_teams: nil, secondary_color: nil, stadium_location: nil, website: nil, win_percentage: nil, request_options: {})
+      #
+      # @param culture_score [Integer] Team culture/morale score (0-100)
+      #
+      # @param founded_year [Integer] Year the club was founded
+      #
+      # @param league [Symbol, ::Believe::Models::League] Current league
+      #
+      # @param name [String] Team name
+      #
+      # @param stadium [String] Home stadium name
+      #
+      # @param values [::Believe::Models::TeamValues] Team's core values
+      #
+      # @param annual_budget_gbp [Float, String, nil] Annual budget in GBP
+      #
+      # @param average_attendance [Float, nil] Average match attendance
+      #
+      # @param contact_email [String, nil] Team contact email
+      #
+      # @param is_active [Boolean] Whether the team is currently active
+      #
+      # @param nickname [String, nil] Team nickname
+      #
+      # @param primary_color [String, nil] Primary team color (hex)
+      #
+      # @param rival_teams [Array<String>] List of rival team IDs
+      #
+      # @param secondary_color [String, nil] Secondary team color (hex)
+      #
+      # @param stadium_location [::Believe::Models::GeoLocation, nil] Geographic coordinates for a location.
+      #
+      # @param website [String, nil] Official team website
+      #
+      # @param win_percentage [Float, nil] Season win percentage
+      #
+      # @param request_options [::Believe::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [::Believe::Models::Team]
+      #
+      # @see ::Believe::Models::TeamCreateParams
+      def create(params)
+        parsed, options = ::Believe::TeamCreateParams.dump_request(params)
+        @client.request(method: :post, path: "teams", body: parsed, model: ::Believe::Team, options: options)
+      end
+
+      # Retrieve detailed information about a specific team.
+      #
+      # @overload retrieve(team_id, request_options: {})
+      #
+      # @param team_id [String]
+      # @param request_options [::Believe::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [::Believe::Models::Team]
+      #
+      # @see ::Believe::Models::TeamRetrieveParams
+      def retrieve(team_id, params = {})
+        @client.request(
+          method: :get,
+          path: ["teams/%1$s", team_id],
+          model: ::Believe::Team,
+          options: params[:request_options]
+        )
+      end
+
+      # Update specific fields of an existing team.
+      #
+      # @overload update(team_id, annual_budget_gbp: nil, average_attendance: nil, contact_email: nil, culture_score: nil, founded_year: nil, is_active: nil, league: nil, name: nil, nickname: nil, primary_color: nil, rival_teams: nil, secondary_color: nil, stadium: nil, stadium_location: nil, values: nil, website: nil, win_percentage: nil, request_options: {})
+      #
+      # @param team_id [String]
+      #
+      # @param annual_budget_gbp [Float, String, nil]
+      #
+      # @param average_attendance [Float, nil]
+      #
+      # @param contact_email [String, nil]
+      #
+      # @param culture_score [Integer, nil]
+      #
+      # @param founded_year [Integer, nil]
+      #
+      # @param is_active [Boolean, nil]
+      #
+      # @param league [Symbol, ::Believe::Models::League, nil] Football leagues.
+      #
+      # @param name [String, nil]
+      #
+      # @param nickname [String, nil]
+      #
+      # @param primary_color [String, nil]
+      #
+      # @param rival_teams [Array<String>, nil]
+      #
+      # @param secondary_color [String, nil]
+      #
+      # @param stadium [String, nil]
+      #
+      # @param stadium_location [::Believe::Models::GeoLocation, nil] Geographic coordinates for a location.
+      #
+      # @param values [::Believe::Models::TeamValues, nil] Core values that define a team's culture.
+      #
+      # @param website [String, nil]
+      #
+      # @param win_percentage [Float, nil]
+      #
+      # @param request_options [::Believe::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [::Believe::Models::Team]
+      #
+      # @see ::Believe::Models::TeamUpdateParams
+      def update(team_id, params = {})
+        parsed, options = ::Believe::TeamUpdateParams.dump_request(params)
+        @client.request(
+          method: :patch,
+          path: ["teams/%1$s", team_id],
+          body: parsed,
+          model: ::Believe::Team,
+          options: options
+        )
+      end
+
+      # Get a paginated list of all teams with optional filtering by league or culture
+      # score.
+      #
+      # @overload list(league: nil, limit: nil, min_culture_score: nil, skip: nil, request_options: {})
+      #
+      # @param league [Symbol, ::Believe::Models::League, nil] Filter by league
+      #
+      # @param limit [Integer] Maximum number of items to return (max: 100)
+      #
+      # @param min_culture_score [Integer, nil] Minimum culture score
+      #
+      # @param skip [Integer] Number of items to skip (offset)
+      #
+      # @param request_options [::Believe::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [::Believe::Internal::SkipLimitPage<::Believe::Models::Team>]
+      #
+      # @see ::Believe::Models::TeamListParams
+      def list(params = {})
+        parsed, options = ::Believe::TeamListParams.dump_request(params)
+        query = ::Believe::Internal::Util.encode_query_params(parsed)
+        @client.request(
+          method: :get,
+          path: "teams",
+          query: query,
+          page: ::Believe::Internal::SkipLimitPage,
+          model: ::Believe::Team,
+          options: options
+        )
+      end
+
+      # Remove a team from the database (relegation to oblivion).
+      #
+      # @overload delete(team_id, request_options: {})
+      #
+      # @param team_id [String]
+      # @param request_options [::Believe::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [nil]
+      #
+      # @see ::Believe::Models::TeamDeleteParams
+      def delete(team_id, params = {})
+        @client.request(
+          method: :delete,
+          path: ["teams/%1$s", team_id],
+          model: NilClass,
+          options: params[:request_options]
+        )
+      end
+
+      # Get detailed culture and values information for a team.
+      #
+      # @overload get_culture(team_id, request_options: {})
+      #
+      # @param team_id [String]
+      # @param request_options [::Believe::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Hash{Symbol=>Object}]
+      #
+      # @see ::Believe::Models::TeamGetCultureParams
+      def get_culture(team_id, params = {})
+        @client.request(
+          method: :get,
+          path: ["teams/%1$s/culture", team_id],
+          model: ::Believe::Internal::Type::HashOf[::Believe::Internal::Type::Unknown],
+          options: params[:request_options]
+        )
+      end
+
+      # Get all rival teams for a specific team.
+      #
+      # @overload get_rivals(team_id, request_options: {})
+      #
+      # @param team_id [String]
+      # @param request_options [::Believe::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Array<::Believe::Models::Team>]
+      #
+      # @see ::Believe::Models::TeamGetRivalsParams
+      def get_rivals(team_id, params = {})
+        @client.request(
+          method: :get,
+          path: ["teams/%1$s/rivals", team_id],
+          model: ::Believe::Internal::Type::ArrayOf[::Believe::Team],
+          options: params[:request_options]
+        )
+      end
+
+      # List all uploaded logos for a team.
+      #
+      # @overload list_logos(team_id, request_options: {})
+      #
+      # @param team_id [String]
+      # @param request_options [::Believe::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Array<::Believe::Models::Teams::FileUpload>]
+      #
+      # @see ::Believe::Models::TeamListLogosParams
+      def list_logos(team_id, params = {})
+        @client.request(
+          method: :get,
+          path: ["teams/%1$s/logos", team_id],
+          model: ::Believe::Internal::Type::ArrayOf[::Believe::Teams::FileUpload],
+          options: params[:request_options]
+        )
+      end
+
+      # @api private
+      #
+      # @param client [::Believe::Client]
+      def initialize(client:)
+        @client = client
+        @logo = ::Believe::Resources::Teams::Logo.new(client: client)
+      end
+    end
+  end
+end