spotted 0.1.0

data/rbi/spotted/models/me/following_list_params.rbi

@@ -0,0 +1,89 @@
+# typed: strong
+
+module Spotted
+  module Models
+    module Me
+      class FollowingListParams < Spotted::Internal::Type::BaseModel
+        extend Spotted::Internal::Type::RequestParameters::Converter
+        include Spotted::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(Spotted::Me::FollowingListParams, Spotted::Internal::AnyHash)
+          end
+
+        # The ID type: currently only `artist` is supported.
+        sig { returns(Spotted::Me::FollowingListParams::Type::OrSymbol) }
+        attr_accessor :type
+
+        # The last artist ID retrieved from the previous request.
+        sig { returns(T.nilable(String)) }
+        attr_reader :after
+
+        sig { params(after: String).void }
+        attr_writer :after
+
+        # The maximum number of items to return. Default: 20. Minimum: 1. Maximum: 50.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :limit
+
+        sig { params(limit: Integer).void }
+        attr_writer :limit
+
+        sig do
+          params(
+            type: Spotted::Me::FollowingListParams::Type::OrSymbol,
+            after: String,
+            limit: Integer,
+            request_options: Spotted::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The ID type: currently only `artist` is supported.
+          type:,
+          # The last artist ID retrieved from the previous request.
+          after: nil,
+          # The maximum number of items to return. Default: 20. Minimum: 1. Maximum: 50.
+          limit: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              type: Spotted::Me::FollowingListParams::Type::OrSymbol,
+              after: String,
+              limit: Integer,
+              request_options: Spotted::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # The ID type: currently only `artist` is supported.
+        module Type
+          extend Spotted::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, Spotted::Me::FollowingListParams::Type)
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          ARTIST =
+            T.let(:artist, Spotted::Me::FollowingListParams::Type::TaggedSymbol)
+
+          sig do
+            override.returns(
+              T::Array[Spotted::Me::FollowingListParams::Type::TaggedSymbol]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/spotted/models/me/following_list_response.rbi

@@ -0,0 +1,187 @@
+# typed: strong
+
+module Spotted
+  module Models
+    module Me
+      class FollowingListResponse < Spotted::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Spotted::Models::Me::FollowingListResponse,
+              Spotted::Internal::AnyHash
+            )
+          end
+
+        sig { returns(Spotted::Models::Me::FollowingListResponse::Artists) }
+        attr_reader :artists
+
+        sig do
+          params(
+            artists: Spotted::Models::Me::FollowingListResponse::Artists::OrHash
+          ).void
+        end
+        attr_writer :artists
+
+        sig do
+          params(
+            artists: Spotted::Models::Me::FollowingListResponse::Artists::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(artists:)
+        end
+
+        sig do
+          override.returns(
+            { artists: Spotted::Models::Me::FollowingListResponse::Artists }
+          )
+        end
+        def to_hash
+        end
+
+        class Artists < Spotted::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Spotted::Models::Me::FollowingListResponse::Artists,
+                Spotted::Internal::AnyHash
+              )
+            end
+
+          # The cursors used to find the next set of items.
+          sig do
+            returns(
+              T.nilable(
+                Spotted::Models::Me::FollowingListResponse::Artists::Cursors
+              )
+            )
+          end
+          attr_reader :cursors
+
+          sig do
+            params(
+              cursors:
+                Spotted::Models::Me::FollowingListResponse::Artists::Cursors::OrHash
+            ).void
+          end
+          attr_writer :cursors
+
+          # A link to the Web API endpoint returning the full result of the request.
+          sig { returns(T.nilable(String)) }
+          attr_reader :href
+
+          sig { params(href: String).void }
+          attr_writer :href
+
+          sig { returns(T.nilable(T::Array[Spotted::ArtistObject])) }
+          attr_reader :items
+
+          sig { params(items: T::Array[Spotted::ArtistObject::OrHash]).void }
+          attr_writer :items
+
+          # The maximum number of items in the response (as set in the query or by default).
+          sig { returns(T.nilable(Integer)) }
+          attr_reader :limit
+
+          sig { params(limit: Integer).void }
+          attr_writer :limit
+
+          # URL to the next page of items. ( `null` if none)
+          sig { returns(T.nilable(String)) }
+          attr_reader :next_
+
+          sig { params(next_: String).void }
+          attr_writer :next_
+
+          # The total number of items available to return.
+          sig { returns(T.nilable(Integer)) }
+          attr_reader :total
+
+          sig { params(total: Integer).void }
+          attr_writer :total
+
+          sig do
+            params(
+              cursors:
+                Spotted::Models::Me::FollowingListResponse::Artists::Cursors::OrHash,
+              href: String,
+              items: T::Array[Spotted::ArtistObject::OrHash],
+              limit: Integer,
+              next_: String,
+              total: Integer
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # The cursors used to find the next set of items.
+            cursors: nil,
+            # A link to the Web API endpoint returning the full result of the request.
+            href: nil,
+            items: nil,
+            # The maximum number of items in the response (as set in the query or by default).
+            limit: nil,
+            # URL to the next page of items. ( `null` if none)
+            next_: nil,
+            # The total number of items available to return.
+            total: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                cursors:
+                  Spotted::Models::Me::FollowingListResponse::Artists::Cursors,
+                href: String,
+                items: T::Array[Spotted::ArtistObject],
+                limit: Integer,
+                next_: String,
+                total: Integer
+              }
+            )
+          end
+          def to_hash
+          end
+
+          class Cursors < Spotted::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  Spotted::Models::Me::FollowingListResponse::Artists::Cursors,
+                  Spotted::Internal::AnyHash
+                )
+              end
+
+            # The cursor to use as key to find the next page of items.
+            sig { returns(T.nilable(String)) }
+            attr_reader :after
+
+            sig { params(after: String).void }
+            attr_writer :after
+
+            # The cursor to use as key to find the previous page of items.
+            sig { returns(T.nilable(String)) }
+            attr_reader :before
+
+            sig { params(before: String).void }
+            attr_writer :before
+
+            # The cursors used to find the next set of items.
+            sig do
+              params(after: String, before: String).returns(T.attached_class)
+            end
+            def self.new(
+              # The cursor to use as key to find the next page of items.
+              after: nil,
+              # The cursor to use as key to find the previous page of items.
+              before: nil
+            )
+            end
+
+            sig { override.returns({ after: String, before: String }) }
+            def to_hash
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/spotted/models/me/following_unfollow_params.rbi

@@ -0,0 +1,97 @@
+# typed: strong
+
+module Spotted
+  module Models
+    module Me
+      class FollowingUnfollowParams < Spotted::Internal::Type::BaseModel
+        extend Spotted::Internal::Type::RequestParameters::Converter
+        include Spotted::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Spotted::Me::FollowingUnfollowParams,
+              Spotted::Internal::AnyHash
+            )
+          end
+
+        # A JSON array of the artist or user
+        # [Spotify IDs](/documentation/web-api/concepts/spotify-uris-ids). For example:
+        # `{ids:["74ASZWbe4lXaubB36ztrGX", "08td7MxkoHQkXnWAYD8d6Q"]}`. A maximum of 50
+        # IDs can be sent in one request. _**Note**: if the `ids` parameter is present in
+        # the query string, any IDs listed here in the body will be ignored._
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_reader :body_ids
+
+        sig { params(body_ids: T::Array[String]).void }
+        attr_writer :body_ids
+
+        # The ID type: either `artist` or `user`.
+        sig { returns(Spotted::Me::FollowingUnfollowParams::Type::OrSymbol) }
+        attr_accessor :type
+
+        sig do
+          params(
+            type: Spotted::Me::FollowingUnfollowParams::Type::OrSymbol,
+            body_ids: T::Array[String],
+            request_options: Spotted::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The ID type: either `artist` or `user`.
+          type:,
+          # A JSON array of the artist or user
+          # [Spotify IDs](/documentation/web-api/concepts/spotify-uris-ids). For example:
+          # `{ids:["74ASZWbe4lXaubB36ztrGX", "08td7MxkoHQkXnWAYD8d6Q"]}`. A maximum of 50
+          # IDs can be sent in one request. _**Note**: if the `ids` parameter is present in
+          # the query string, any IDs listed here in the body will be ignored._
+          body_ids: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              body_ids: T::Array[String],
+              type: Spotted::Me::FollowingUnfollowParams::Type::OrSymbol,
+              request_options: Spotted::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # The ID type: either `artist` or `user`.
+        module Type
+          extend Spotted::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, Spotted::Me::FollowingUnfollowParams::Type)
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          ARTIST =
+            T.let(
+              :artist,
+              Spotted::Me::FollowingUnfollowParams::Type::TaggedSymbol
+            )
+          USER =
+            T.let(
+              :user,
+              Spotted::Me::FollowingUnfollowParams::Type::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[Spotted::Me::FollowingUnfollowParams::Type::TaggedSymbol]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/spotted/models/me/player/queue_add_params.rbi

@@ -0,0 +1,63 @@
+# typed: strong
+
+module Spotted
+  module Models
+    module Me
+      module Player
+        class QueueAddParams < Spotted::Internal::Type::BaseModel
+          extend Spotted::Internal::Type::RequestParameters::Converter
+          include Spotted::Internal::Type::RequestParameters
+
+          OrHash =
+            T.type_alias do
+              T.any(
+                Spotted::Me::Player::QueueAddParams,
+                Spotted::Internal::AnyHash
+              )
+            end
+
+          # The uri of the item to add to the queue. Must be a track or an episode uri.
+          sig { returns(String) }
+          attr_accessor :uri
+
+          # The id of the device this command is targeting. If not supplied, the user's
+          # currently active device is the target.
+          sig { returns(T.nilable(String)) }
+          attr_reader :device_id
+
+          sig { params(device_id: String).void }
+          attr_writer :device_id
+
+          sig do
+            params(
+              uri: String,
+              device_id: String,
+              request_options: Spotted::RequestOptions::OrHash
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # The uri of the item to add to the queue. Must be a track or an episode uri.
+            uri:,
+            # The id of the device this command is targeting. If not supplied, the user's
+            # currently active device is the target.
+            device_id: nil,
+            request_options: {}
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                uri: String,
+                device_id: String,
+                request_options: Spotted::RequestOptions
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/spotted/models/me/player/queue_get_params.rbi

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

data/rbi/spotted/models/me/player/queue_get_response.rbi

@@ -0,0 +1,143 @@
+# typed: strong
+
+module Spotted
+  module Models
+    module Me
+      module Player
+        class QueueGetResponse < Spotted::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Spotted::Models::Me::Player::QueueGetResponse,
+                Spotted::Internal::AnyHash
+              )
+            end
+
+          # The currently playing track or episode. Can be `null`.
+          sig do
+            returns(
+              T.nilable(
+                Spotted::Models::Me::Player::QueueGetResponse::CurrentlyPlaying::Variants
+              )
+            )
+          end
+          attr_reader :currently_playing
+
+          sig do
+            params(
+              currently_playing:
+                T.any(
+                  Spotted::TrackObject::OrHash,
+                  Spotted::EpisodeObject::OrHash
+                )
+            ).void
+          end
+          attr_writer :currently_playing
+
+          # The tracks or episodes in the queue. Can be empty.
+          sig do
+            returns(
+              T.nilable(
+                T::Array[
+                  Spotted::Models::Me::Player::QueueGetResponse::Queue::Variants
+                ]
+              )
+            )
+          end
+          attr_reader :queue
+
+          sig do
+            params(
+              queue:
+                T::Array[
+                  T.any(
+                    Spotted::TrackObject::OrHash,
+                    Spotted::EpisodeObject::OrHash
+                  )
+                ]
+            ).void
+          end
+          attr_writer :queue
+
+          sig do
+            params(
+              currently_playing:
+                T.any(
+                  Spotted::TrackObject::OrHash,
+                  Spotted::EpisodeObject::OrHash
+                ),
+              queue:
+                T::Array[
+                  T.any(
+                    Spotted::TrackObject::OrHash,
+                    Spotted::EpisodeObject::OrHash
+                  )
+                ]
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # The currently playing track or episode. Can be `null`.
+            currently_playing: nil,
+            # The tracks or episodes in the queue. Can be empty.
+            queue: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                currently_playing:
+                  Spotted::Models::Me::Player::QueueGetResponse::CurrentlyPlaying::Variants,
+                queue:
+                  T::Array[
+                    Spotted::Models::Me::Player::QueueGetResponse::Queue::Variants
+                  ]
+              }
+            )
+          end
+          def to_hash
+          end
+
+          # The currently playing track or episode. Can be `null`.
+          module CurrentlyPlaying
+            extend Spotted::Internal::Type::Union
+
+            Variants =
+              T.type_alias do
+                T.any(Spotted::TrackObject, Spotted::EpisodeObject)
+              end
+
+            sig do
+              override.returns(
+                T::Array[
+                  Spotted::Models::Me::Player::QueueGetResponse::CurrentlyPlaying::Variants
+                ]
+              )
+            end
+            def self.variants
+            end
+          end
+
+          module Queue
+            extend Spotted::Internal::Type::Union
+
+            Variants =
+              T.type_alias do
+                T.any(Spotted::TrackObject, Spotted::EpisodeObject)
+              end
+
+            sig do
+              override.returns(
+                T::Array[
+                  Spotted::Models::Me::Player::QueueGetResponse::Queue::Variants
+                ]
+              )
+            end
+            def self.variants
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/spotted/models/me/player_get_currently_playing_params.rbi

@@ -0,0 +1,88 @@
+# typed: strong
+
+module Spotted
+  module Models
+    module Me
+      class PlayerGetCurrentlyPlayingParams < Spotted::Internal::Type::BaseModel
+        extend Spotted::Internal::Type::RequestParameters::Converter
+        include Spotted::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Spotted::Me::PlayerGetCurrentlyPlayingParams,
+              Spotted::Internal::AnyHash
+            )
+          end
+
+        # A comma-separated list of item types that your client supports besides the
+        # default `track` type. Valid types are: `track` and `episode`.<br/> _**Note**:
+        # This parameter was introduced to allow existing clients to maintain their
+        # current behaviour and might be deprecated in the future._<br/> In addition to
+        # providing this parameter, make sure that your client properly handles cases of
+        # new types in the future by checking against the `type` field of each object.
+        sig { returns(T.nilable(String)) }
+        attr_reader :additional_types
+
+        sig { params(additional_types: String).void }
+        attr_writer :additional_types
+
+        # An
+        # [ISO 3166-1 alpha-2 country code](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2).
+        # If a country code is specified, only content that is available in that market
+        # will be returned.<br/> If a valid user access token is specified in the request
+        # header, the country associated with the user account will take priority over
+        # this parameter.<br/> _**Note**: If neither market or user country are provided,
+        # the content is considered unavailable for the client._<br/> Users can view the
+        # country that is associated with their account in the
+        # [account settings](https://www.spotify.com/account/overview/).
+        sig { returns(T.nilable(String)) }
+        attr_reader :market
+
+        sig { params(market: String).void }
+        attr_writer :market
+
+        sig do
+          params(
+            additional_types: String,
+            market: String,
+            request_options: Spotted::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # A comma-separated list of item types that your client supports besides the
+          # default `track` type. Valid types are: `track` and `episode`.<br/> _**Note**:
+          # This parameter was introduced to allow existing clients to maintain their
+          # current behaviour and might be deprecated in the future._<br/> In addition to
+          # providing this parameter, make sure that your client properly handles cases of
+          # new types in the future by checking against the `type` field of each object.
+          additional_types: nil,
+          # An
+          # [ISO 3166-1 alpha-2 country code](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2).
+          # If a country code is specified, only content that is available in that market
+          # will be returned.<br/> If a valid user access token is specified in the request
+          # header, the country associated with the user account will take priority over
+          # this parameter.<br/> _**Note**: If neither market or user country are provided,
+          # the content is considered unavailable for the client._<br/> Users can view the
+          # country that is associated with their account in the
+          # [account settings](https://www.spotify.com/account/overview/).
+          market: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              additional_types: String,
+              market: String,
+              request_options: Spotted::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end