spotted 0.1.0

data/rbi/spotted/models/playlists/track_list_params.rbi

@@ -0,0 +1,141 @@
+# typed: strong
+
+module Spotted
+  module Models
+    module Playlists
+      class TrackListParams < Spotted::Internal::Type::BaseModel
+        extend Spotted::Internal::Type::RequestParameters::Converter
+        include Spotted::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Spotted::Playlists::TrackListParams,
+              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
+
+        # Filters for the query: a comma-separated list of the fields to return. If
+        # omitted, all fields are returned. For example, to get just the total number of
+        # items and the request limit:<br/>`fields=total,limit`<br/>A dot separator can be
+        # used to specify non-reoccurring fields, while parentheses can be used to specify
+        # reoccurring fields within objects. For example, to get just the added date and
+        # user ID of the adder:<br/>`fields=items(added_at,added_by.id)`<br/>Use multiple
+        # parentheses to drill down into nested objects, for
+        # example:<br/>`fields=items(track(name,href,album(name,href)))`<br/>Fields can be
+        # excluded by prefixing them with an exclamation mark, for
+        # example:<br/>`fields=items.track.album(!external_urls,images)`
+        sig { returns(T.nilable(String)) }
+        attr_reader :fields
+
+        sig { params(fields: String).void }
+        attr_writer :fields
+
+        # The maximum number of items to return. Default: 20. Minimum: 1. Maximum: 100.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :limit
+
+        sig { params(limit: Integer).void }
+        attr_writer :limit
+
+        # 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
+
+        # The index of the first item to return. Default: 0 (the first item). Use with
+        # limit to get the next set of items.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :offset
+
+        sig { params(offset: Integer).void }
+        attr_writer :offset
+
+        sig do
+          params(
+            additional_types: String,
+            fields: String,
+            limit: Integer,
+            market: String,
+            offset: Integer,
+            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,
+          # Filters for the query: a comma-separated list of the fields to return. If
+          # omitted, all fields are returned. For example, to get just the total number of
+          # items and the request limit:<br/>`fields=total,limit`<br/>A dot separator can be
+          # used to specify non-reoccurring fields, while parentheses can be used to specify
+          # reoccurring fields within objects. For example, to get just the added date and
+          # user ID of the adder:<br/>`fields=items(added_at,added_by.id)`<br/>Use multiple
+          # parentheses to drill down into nested objects, for
+          # example:<br/>`fields=items(track(name,href,album(name,href)))`<br/>Fields can be
+          # excluded by prefixing them with an exclamation mark, for
+          # example:<br/>`fields=items.track.album(!external_urls,images)`
+          fields: nil,
+          # The maximum number of items to return. Default: 20. Minimum: 1. Maximum: 100.
+          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
+
+        sig do
+          override.returns(
+            {
+              additional_types: String,
+              fields: String,
+              limit: Integer,
+              market: String,
+              offset: Integer,
+              request_options: Spotted::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/spotted/models/playlists/track_remove_params.rbi

@@ -0,0 +1,100 @@
+# typed: strong
+
+module Spotted
+  module Models
+    module Playlists
+      class TrackRemoveParams < Spotted::Internal::Type::BaseModel
+        extend Spotted::Internal::Type::RequestParameters::Converter
+        include Spotted::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Spotted::Playlists::TrackRemoveParams,
+              Spotted::Internal::AnyHash
+            )
+          end
+
+        # An array of objects containing
+        # [Spotify URIs](/documentation/web-api/concepts/spotify-uris-ids) of the tracks
+        # or episodes to remove. For example:
+        # `{ "tracks": [{ "uri": "spotify:track:4iV5W9uYEdYUVa79Axb7Rh" },{ "uri": "spotify:track:1301WleyT98MSxVHPZCA6M" }] }`.
+        # A maximum of 100 objects can be sent at once.
+        sig { returns(T::Array[Spotted::Playlists::TrackRemoveParams::Track]) }
+        attr_accessor :tracks
+
+        # The playlist's snapshot ID against which you want to make the changes. The API
+        # will validate that the specified items exist and in the specified positions and
+        # make the changes, even if more recent changes have been made to the playlist.
+        sig { returns(T.nilable(String)) }
+        attr_reader :snapshot_id
+
+        sig { params(snapshot_id: String).void }
+        attr_writer :snapshot_id
+
+        sig do
+          params(
+            tracks:
+              T::Array[Spotted::Playlists::TrackRemoveParams::Track::OrHash],
+            snapshot_id: String,
+            request_options: Spotted::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # An array of objects containing
+          # [Spotify URIs](/documentation/web-api/concepts/spotify-uris-ids) of the tracks
+          # or episodes to remove. For example:
+          # `{ "tracks": [{ "uri": "spotify:track:4iV5W9uYEdYUVa79Axb7Rh" },{ "uri": "spotify:track:1301WleyT98MSxVHPZCA6M" }] }`.
+          # A maximum of 100 objects can be sent at once.
+          tracks:,
+          # The playlist's snapshot ID against which you want to make the changes. The API
+          # will validate that the specified items exist and in the specified positions and
+          # make the changes, even if more recent changes have been made to the playlist.
+          snapshot_id: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              tracks: T::Array[Spotted::Playlists::TrackRemoveParams::Track],
+              snapshot_id: String,
+              request_options: Spotted::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Track < Spotted::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Spotted::Playlists::TrackRemoveParams::Track,
+                Spotted::Internal::AnyHash
+              )
+            end
+
+          # Spotify URI
+          sig { returns(T.nilable(String)) }
+          attr_reader :uri
+
+          sig { params(uri: String).void }
+          attr_writer :uri
+
+          sig { params(uri: String).returns(T.attached_class) }
+          def self.new(
+            # Spotify URI
+            uri: nil
+          )
+          end
+
+          sig { override.returns({ uri: String }) }
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/spotted/models/playlists/track_remove_response.rbi

@@ -0,0 +1,31 @@
+# typed: strong
+
+module Spotted
+  module Models
+    module Playlists
+      class TrackRemoveResponse < Spotted::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Spotted::Models::Playlists::TrackRemoveResponse,
+              Spotted::Internal::AnyHash
+            )
+          end
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :snapshot_id
+
+        sig { params(snapshot_id: String).void }
+        attr_writer :snapshot_id
+
+        sig { params(snapshot_id: String).returns(T.attached_class) }
+        def self.new(snapshot_id: nil)
+        end
+
+        sig { override.returns({ snapshot_id: String }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/spotted/models/playlists/track_update_params.rbi

@@ -0,0 +1,111 @@
+# typed: strong
+
+module Spotted
+  module Models
+    module Playlists
+      class TrackUpdateParams < Spotted::Internal::Type::BaseModel
+        extend Spotted::Internal::Type::RequestParameters::Converter
+        include Spotted::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Spotted::Playlists::TrackUpdateParams,
+              Spotted::Internal::AnyHash
+            )
+          end
+
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_reader :body_uris
+
+        sig { params(body_uris: T::Array[String]).void }
+        attr_writer :body_uris
+
+        # The position where the items should be inserted.<br/>To reorder the items to the
+        # end of the playlist, simply set _insert_before_ to the position after the last
+        # item.<br/>Examples:<br/>To reorder the first item to the last position in a
+        # playlist with 10 items, set _range_start_ to 0, and _insert_before_
+        # to 10.<br/>To reorder the last item in a playlist with 10 items to the start of
+        # the playlist, set _range_start_ to 9, and _insert_before_ to 0.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :insert_before
+
+        sig { params(insert_before: Integer).void }
+        attr_writer :insert_before
+
+        # The amount of items to be reordered. Defaults to 1 if not set.<br/>The range of
+        # items to be reordered begins from the _range_start_ position, and includes the
+        # _range_length_ subsequent items.<br/>Example:<br/>To move the items at index
+        # 9-10 to the start of the playlist, _range_start_ is set to 9, and _range_length_
+        # is set to 2.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :range_length
+
+        sig { params(range_length: Integer).void }
+        attr_writer :range_length
+
+        # The position of the first item to be reordered.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :range_start
+
+        sig { params(range_start: Integer).void }
+        attr_writer :range_start
+
+        # The playlist's snapshot ID against which you want to make the changes.
+        sig { returns(T.nilable(String)) }
+        attr_reader :snapshot_id
+
+        sig { params(snapshot_id: String).void }
+        attr_writer :snapshot_id
+
+        sig do
+          params(
+            body_uris: T::Array[String],
+            insert_before: Integer,
+            range_length: Integer,
+            range_start: Integer,
+            snapshot_id: String,
+            request_options: Spotted::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          body_uris: nil,
+          # The position where the items should be inserted.<br/>To reorder the items to the
+          # end of the playlist, simply set _insert_before_ to the position after the last
+          # item.<br/>Examples:<br/>To reorder the first item to the last position in a
+          # playlist with 10 items, set _range_start_ to 0, and _insert_before_
+          # to 10.<br/>To reorder the last item in a playlist with 10 items to the start of
+          # the playlist, set _range_start_ to 9, and _insert_before_ to 0.
+          insert_before: nil,
+          # The amount of items to be reordered. Defaults to 1 if not set.<br/>The range of
+          # items to be reordered begins from the _range_start_ position, and includes the
+          # _range_length_ subsequent items.<br/>Example:<br/>To move the items at index
+          # 9-10 to the start of the playlist, _range_start_ is set to 9, and _range_length_
+          # is set to 2.
+          range_length: nil,
+          # The position of the first item to be reordered.
+          range_start: nil,
+          # The playlist's snapshot ID against which you want to make the changes.
+          snapshot_id: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              body_uris: T::Array[String],
+              insert_before: Integer,
+              range_length: Integer,
+              range_start: Integer,
+              snapshot_id: String,
+              request_options: Spotted::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/spotted/models/playlists/track_update_response.rbi

@@ -0,0 +1,31 @@
+# typed: strong
+
+module Spotted
+  module Models
+    module Playlists
+      class TrackUpdateResponse < Spotted::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Spotted::Models::Playlists::TrackUpdateResponse,
+              Spotted::Internal::AnyHash
+            )
+          end
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :snapshot_id
+
+        sig { params(snapshot_id: String).void }
+        attr_writer :snapshot_id
+
+        sig { params(snapshot_id: String).returns(T.attached_class) }
+        def self.new(snapshot_id: nil)
+        end
+
+        sig { override.returns({ snapshot_id: String }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end