spotted 0.1.0

data/rbi/spotted/resources/me/player.rbi

@@ -0,0 +1,315 @@
+# typed: strong
+
+module Spotted
+  module Resources
+    class Me
+      class Player
+        sig { returns(Spotted::Resources::Me::Player::Queue) }
+        attr_reader :queue
+
+        # Get the object currently being played on the user's Spotify account.
+        sig do
+          params(
+            additional_types: String,
+            market: String,
+            request_options: Spotted::RequestOptions::OrHash
+          ).returns(Spotted::Models::Me::PlayerGetCurrentlyPlayingResponse)
+        end
+        def get_currently_playing(
+          # 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
+
+        # Get information about a user’s available Spotify Connect devices. Some device
+        # models are not supported and will not be listed in the API response.
+        sig do
+          params(request_options: Spotted::RequestOptions::OrHash).returns(
+            Spotted::Models::Me::PlayerGetDevicesResponse
+          )
+        end
+        def get_devices(request_options: {})
+        end
+
+        # Get information about the user’s current playback state, including track or
+        # episode, progress, and active device.
+        sig do
+          params(
+            additional_types: String,
+            market: String,
+            request_options: Spotted::RequestOptions::OrHash
+          ).returns(Spotted::Models::Me::PlayerGetStateResponse)
+        end
+        def get_state(
+          # 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
+
+        # Get tracks from the current user's recently played tracks. _**Note**: Currently
+        # doesn't support podcast episodes._
+        sig do
+          params(
+            after: Integer,
+            before: Integer,
+            limit: Integer,
+            request_options: Spotted::RequestOptions::OrHash
+          ).returns(
+            Spotted::Internal::CursorURLPage[
+              Spotted::Models::Me::PlayerListRecentlyPlayedResponse
+            ]
+          )
+        end
+        def list_recently_played(
+          # A Unix timestamp in milliseconds. Returns all items after (but not including)
+          # this cursor position. If `after` is specified, `before` must not be specified.
+          after: nil,
+          # A Unix timestamp in milliseconds. Returns all items before (but not including)
+          # this cursor position. If `before` is specified, `after` must not be specified.
+          before: nil,
+          # The maximum number of items to return. Default: 20. Minimum: 1. Maximum: 50.
+          limit: nil,
+          request_options: {}
+        )
+        end
+
+        # Pause playback on the user's account. This API only works for users who have
+        # Spotify Premium. The order of execution is not guaranteed when you use this API
+        # with other Player API endpoints.
+        sig do
+          params(
+            device_id: String,
+            request_options: Spotted::RequestOptions::OrHash
+          ).void
+        end
+        def pause_playback(
+          # 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
+
+        # Seeks to the given position in the user’s currently playing track. This API only
+        # works for users who have Spotify Premium. The order of execution is not
+        # guaranteed when you use this API with other Player API endpoints.
+        sig do
+          params(
+            position_ms: Integer,
+            device_id: String,
+            request_options: Spotted::RequestOptions::OrHash
+          ).void
+        end
+        def seek_to_position(
+          # The position in milliseconds to seek to. Must be a positive number. Passing in a
+          # position that is greater than the length of the track will cause the player to
+          # start playing the next song.
+          position_ms:,
+          # 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
+
+        # Set the repeat mode for the user's playback. This API only works for users who
+        # have Spotify Premium. The order of execution is not guaranteed when you use this
+        # API with other Player API endpoints.
+        sig do
+          params(
+            state: String,
+            device_id: String,
+            request_options: Spotted::RequestOptions::OrHash
+          ).void
+        end
+        def set_repeat_mode(
+          # **track**, **context** or **off**.<br/> **track** will repeat the current
+          # track.<br/> **context** will repeat the current context.<br/> **off** will turn
+          # repeat off.
+          state:,
+          # 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
+
+        # Set the volume for the user’s current playback device. This API only works for
+        # users who have Spotify Premium. The order of execution is not guaranteed when
+        # you use this API with other Player API endpoints.
+        sig do
+          params(
+            volume_percent: Integer,
+            device_id: String,
+            request_options: Spotted::RequestOptions::OrHash
+          ).void
+        end
+        def set_volume(
+          # The volume to set. Must be a value from 0 to 100 inclusive.
+          volume_percent:,
+          # 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
+
+        # Skips to next track in the user’s queue. This API only works for users who have
+        # Spotify Premium. The order of execution is not guaranteed when you use this API
+        # with other Player API endpoints.
+        sig do
+          params(
+            device_id: String,
+            request_options: Spotted::RequestOptions::OrHash
+          ).void
+        end
+        def skip_next(
+          # 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
+
+        # Skips to previous track in the user’s queue. This API only works for users who
+        # have Spotify Premium. The order of execution is not guaranteed when you use this
+        # API with other Player API endpoints.
+        sig do
+          params(
+            device_id: String,
+            request_options: Spotted::RequestOptions::OrHash
+          ).void
+        end
+        def skip_previous(
+          # 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
+
+        # Start a new context or resume current playback on the user's active device. This
+        # API only works for users who have Spotify Premium. The order of execution is not
+        # guaranteed when you use this API with other Player API endpoints.
+        sig do
+          params(
+            device_id: String,
+            context_uri: String,
+            offset: T::Hash[Symbol, T.anything],
+            position_ms: Integer,
+            uris: T::Array[String],
+            request_options: Spotted::RequestOptions::OrHash
+          ).void
+        end
+        def start_playback(
+          # Query param: The id of the device this command is targeting. If not supplied,
+          # the user's currently active device is the target.
+          device_id: nil,
+          # Body param: Optional. Spotify URI of the context to play. Valid contexts are
+          # albums, artists & playlists.
+          # `{context_uri:"spotify:album:1Je1IMUlBXcx1Fz0WE7oPT"}`
+          context_uri: nil,
+          # Body param: Optional. Indicates from where in the context playback should start.
+          # Only available when context_uri corresponds to an album or playlist object
+          # "position" is zero based and can’t be negative. Example:
+          # `"offset": {"position": 5}` "uri" is a string representing the uri of the item
+          # to start at. Example:
+          # `"offset": {"uri": "spotify:track:1301WleyT98MSxVHPZCA6M"}`
+          offset: nil,
+          # Body param: Indicates from what position to start playback. Must be a positive
+          # number. Passing in a position that is greater than the length of the track will
+          # cause the player to start playing the next song.
+          position_ms: nil,
+          # Body param: Optional. A JSON array of the Spotify track URIs to play. For
+          # example:
+          # `{"uris": ["spotify:track:4iV5W9uYEdYUVa79Axb7Rh", "spotify:track:1301WleyT98MSxVHPZCA6M"]}`
+          uris: nil,
+          request_options: {}
+        )
+        end
+
+        # Toggle shuffle on or off for user’s playback. This API only works for users who
+        # have Spotify Premium. The order of execution is not guaranteed when you use this
+        # API with other Player API endpoints.
+        sig do
+          params(
+            state: T::Boolean,
+            device_id: String,
+            request_options: Spotted::RequestOptions::OrHash
+          ).void
+        end
+        def toggle_shuffle(
+          # **true** : Shuffle user's playback.<br/> **false** : Do not shuffle user's
+          # playback.
+          state:,
+          # 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
+
+        # Transfer playback to a new device and optionally begin playback. This API only
+        # works for users who have Spotify Premium. The order of execution is not
+        # guaranteed when you use this API with other Player API endpoints.
+        sig do
+          params(
+            device_ids: T::Array[String],
+            play: T::Boolean,
+            request_options: Spotted::RequestOptions::OrHash
+          ).void
+        end
+        def transfer(
+          # A JSON array containing the ID of the device on which playback should be
+          # started/transferred.<br/>For
+          # example:`{device_ids:["74ASZWbe4lXaubB36ztrGX"]}`<br/>_**Note**: Although an
+          # array is accepted, only a single device_id is currently supported. Supplying
+          # more than one will return `400 Bad Request`_
+          device_ids:,
+          # **true**: ensure playback happens on new device.<br/>**false** or not provided:
+          # keep the current playback state.
+          play: nil,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: Spotted::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/spotted/resources/me/playlists.rbi

@@ -0,0 +1,34 @@
+# typed: strong
+
+module Spotted
+  module Resources
+    class Me
+      class Playlists
+        # Get a list of the playlists owned or followed by the current Spotify user.
+        sig do
+          params(
+            limit: Integer,
+            offset: Integer,
+            request_options: Spotted::RequestOptions::OrHash
+          ).returns(
+            Spotted::Internal::CursorURLPage[Spotted::SimplifiedPlaylistObject]
+          )
+        end
+        def list(
+          # The maximum number of items to return. Default: 20. Minimum: 1. Maximum: 50.
+          limit: nil,
+          # 'The index of the first playlist to return. Default: 0 (the first object).
+          # Maximum offset: 100.000\. Use with `limit` to get the next set of playlists.'
+          offset: nil,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: Spotted::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/spotted/resources/me/shows.rbi

@@ -0,0 +1,101 @@
+# typed: strong
+
+module Spotted
+  module Resources
+    class Me
+      class Shows
+        # Get a list of shows saved in the current Spotify user's library. Optional
+        # parameters can be used to limit the number of shows returned.
+        sig do
+          params(
+            limit: Integer,
+            offset: Integer,
+            request_options: Spotted::RequestOptions::OrHash
+          ).returns(
+            Spotted::Internal::CursorURLPage[
+              Spotted::Models::Me::ShowListResponse
+            ]
+          )
+        end
+        def list(
+          # The maximum number of items to return. Default: 20. Minimum: 1. Maximum: 50.
+          limit: nil,
+          # The index of the first item to return. Default: 0 (the first item). Use with
+          # limit to get the next set of items.
+          offset: nil,
+          request_options: {}
+        )
+        end
+
+        # Check if one or more shows is already saved in the current Spotify user's
+        # library.
+        sig do
+          params(
+            ids: String,
+            request_options: Spotted::RequestOptions::OrHash
+          ).returns(T::Array[T::Boolean])
+        end
+        def check(
+          # A comma-separated list of the
+          # [Spotify IDs](/documentation/web-api/concepts/spotify-uris-ids) for the shows.
+          # Maximum: 50 IDs.
+          ids:,
+          request_options: {}
+        )
+        end
+
+        # Delete one or more shows from current Spotify user's library.
+        sig do
+          params(
+            body_ids: T::Array[String],
+            market: String,
+            request_options: Spotted::RequestOptions::OrHash
+          ).void
+        end
+        def remove(
+          # Body param: A JSON array of the
+          # [Spotify IDs](https://developer.spotify.com/documentation/web-api/#spotify-uris-and-ids).
+          # A maximum of 50 items can be specified 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,
+          # Query param: 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
+
+        # Save one or more shows to current Spotify user's library.
+        sig do
+          params(
+            body_ids: T::Array[String],
+            request_options: Spotted::RequestOptions::OrHash
+          ).void
+        end
+        def save(
+          # Body param: A JSON array of the
+          # [Spotify IDs](https://developer.spotify.com/documentation/web-api/#spotify-uris-and-ids).
+          # A maximum of 50 items can be specified 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
+
+        # @api private
+        sig { params(client: Spotted::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/spotted/resources/me/top.rbi

@@ -0,0 +1,62 @@
+# typed: strong
+
+module Spotted
+  module Resources
+    class Me
+      class Top
+        # Get the current user's top artists based on calculated affinity.
+        sig do
+          params(
+            limit: Integer,
+            offset: Integer,
+            time_range: String,
+            request_options: Spotted::RequestOptions::OrHash
+          ).returns(Spotted::Internal::CursorURLPage[Spotted::ArtistObject])
+        end
+        def list_top_artists(
+          # The maximum number of items to return. Default: 20. Minimum: 1. Maximum: 50.
+          limit: nil,
+          # The index of the first item to return. Default: 0 (the first item). Use with
+          # limit to get the next set of items.
+          offset: nil,
+          # Over what time frame the affinities are computed. Valid values: `long_term`
+          # (calculated from ~1 year of data and including all new data as it becomes
+          # available), `medium_term` (approximately last 6 months), `short_term`
+          # (approximately last 4 weeks). Default: `medium_term`
+          time_range: nil,
+          request_options: {}
+        )
+        end
+
+        # Get the current user's top tracks based on calculated affinity.
+        sig do
+          params(
+            limit: Integer,
+            offset: Integer,
+            time_range: String,
+            request_options: Spotted::RequestOptions::OrHash
+          ).returns(Spotted::Internal::CursorURLPage[Spotted::TrackObject])
+        end
+        def list_top_tracks(
+          # The maximum number of items to return. Default: 20. Minimum: 1. Maximum: 50.
+          limit: nil,
+          # The index of the first item to return. Default: 0 (the first item). Use with
+          # limit to get the next set of items.
+          offset: nil,
+          # Over what time frame the affinities are computed. Valid values: `long_term`
+          # (calculated from ~1 year of data and including all new data as it becomes
+          # available), `medium_term` (approximately last 6 months), `short_term`
+          # (approximately last 4 weeks). Default: `medium_term`
+          time_range: nil,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: Spotted::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/spotted/resources/me/tracks.rbi

@@ -0,0 +1,112 @@
+# typed: strong
+
+module Spotted
+  module Resources
+    class Me
+      class Tracks
+        # Get a list of the songs saved in the current Spotify user's 'Your Music'
+        # library.
+        sig do
+          params(
+            limit: Integer,
+            market: String,
+            offset: Integer,
+            request_options: Spotted::RequestOptions::OrHash
+          ).returns(
+            Spotted::Internal::CursorURLPage[
+              Spotted::Models::Me::TrackListResponse
+            ]
+          )
+        end
+        def list(
+          # The maximum number of items to return. Default: 20. Minimum: 1. Maximum: 50.
+          limit: 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,
+          # The index of the first item to return. Default: 0 (the first item). Use with
+          # limit to get the next set of items.
+          offset: nil,
+          request_options: {}
+        )
+        end
+
+        # Check if one or more tracks is already saved in the current Spotify user's 'Your
+        # Music' library.
+        sig do
+          params(
+            ids: String,
+            request_options: Spotted::RequestOptions::OrHash
+          ).returns(T::Array[T::Boolean])
+        end
+        def check(
+          # A comma-separated list of the
+          # [Spotify IDs](/documentation/web-api/concepts/spotify-uris-ids). For example:
+          # `ids=4iV5W9uYEdYUVa79Axb7Rh,1301WleyT98MSxVHPZCA6M`. Maximum: 50 IDs.
+          ids:,
+          request_options: {}
+        )
+        end
+
+        # Remove one or more tracks from the current user's 'Your Music' library.
+        sig do
+          params(
+            body_ids: T::Array[String],
+            request_options: Spotted::RequestOptions::OrHash
+          ).void
+        end
+        def remove(
+          # Body param: A JSON array of the
+          # [Spotify IDs](/documentation/web-api/concepts/spotify-uris-ids). For example:
+          # `["4iV5W9uYEdYUVa79Axb7Rh", "1301WleyT98MSxVHPZCA6M"]`<br/>A maximum of 50 items
+          # can be specified 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
+
+        # Save one or more tracks to the current user's 'Your Music' library.
+        sig do
+          params(
+            ids: T::Array[String],
+            timestamped_ids:
+              T::Array[Spotted::Me::TrackSaveParams::TimestampedID::OrHash],
+            request_options: Spotted::RequestOptions::OrHash
+          ).void
+        end
+        def save(
+          # A JSON array of the
+          # [Spotify IDs](/documentation/web-api/concepts/spotify-uris-ids). For example:
+          # `["4iV5W9uYEdYUVa79Axb7Rh", "1301WleyT98MSxVHPZCA6M"]`<br/>A maximum of 50 items
+          # can be specified in one request. _**Note**: if the `timestamped_ids` is present
+          # in the body, any IDs listed in the query parameters (deprecated) or the `ids`
+          # field in the body will be ignored._
+          ids:,
+          # A JSON array of objects containing track IDs with their corresponding
+          # timestamps. Each object must include a track ID and an `added_at` timestamp.
+          # This allows you to specify when tracks were added to maintain a specific
+          # chronological order in the user's library.<br/>A maximum of 50 items can be
+          # specified in one request. _**Note**: if the `timestamped_ids` is present in the
+          # body, any IDs listed in the query parameters (deprecated) or the `ids` field in
+          # the body will be ignored._
+          timestamped_ids: nil,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: Spotted::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/spotted/resources/me.rbi

@@ -0,0 +1,49 @@
+# typed: strong
+
+module Spotted
+  module Resources
+    class Me
+      sig { returns(Spotted::Resources::Me::Audiobooks) }
+      attr_reader :audiobooks
+
+      sig { returns(Spotted::Resources::Me::Playlists) }
+      attr_reader :playlists
+
+      sig { returns(Spotted::Resources::Me::Top) }
+      attr_reader :top
+
+      sig { returns(Spotted::Resources::Me::Albums) }
+      attr_reader :albums
+
+      sig { returns(Spotted::Resources::Me::Tracks) }
+      attr_reader :tracks
+
+      sig { returns(Spotted::Resources::Me::Episodes) }
+      attr_reader :episodes
+
+      sig { returns(Spotted::Resources::Me::Shows) }
+      attr_reader :shows
+
+      sig { returns(Spotted::Resources::Me::Following) }
+      attr_reader :following
+
+      sig { returns(Spotted::Resources::Me::Player) }
+      attr_reader :player
+
+      # Get detailed profile information about the current user (including the current
+      # user's username).
+      sig do
+        params(request_options: Spotted::RequestOptions::OrHash).returns(
+          Spotted::Models::MeRetrieveResponse
+        )
+      end
+      def retrieve(request_options: {})
+      end
+
+      # @api private
+      sig { params(client: Spotted::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end