spotted 0.1.0

data/rbi/spotted/models/paging_playlist_object.rbi

@@ -0,0 +1,83 @@
+# typed: strong
+
+module Spotted
+  module Models
+    class PagingPlaylistObject < Spotted::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Spotted::PagingPlaylistObject, Spotted::Internal::AnyHash)
+        end
+
+      # A link to the Web API endpoint returning the full result of the request
+      sig { returns(String) }
+      attr_accessor :href
+
+      sig { returns(T::Array[Spotted::SimplifiedPlaylistObject]) }
+      attr_accessor :items
+
+      # The maximum number of items in the response (as set in the query or by default).
+      sig { returns(Integer) }
+      attr_accessor :limit
+
+      # URL to the next page of items. ( `null` if none)
+      sig { returns(T.nilable(String)) }
+      attr_accessor :next_
+
+      # The offset of the items returned (as set in the query or by default)
+      sig { returns(Integer) }
+      attr_accessor :offset
+
+      # URL to the previous page of items. ( `null` if none)
+      sig { returns(T.nilable(String)) }
+      attr_accessor :previous
+
+      # The total number of items available to return.
+      sig { returns(Integer) }
+      attr_accessor :total
+
+      sig do
+        params(
+          href: String,
+          items: T::Array[Spotted::SimplifiedPlaylistObject::OrHash],
+          limit: Integer,
+          next_: T.nilable(String),
+          offset: Integer,
+          previous: T.nilable(String),
+          total: Integer
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # A link to the Web API endpoint returning the full result of the request
+        href:,
+        items:,
+        # The maximum number of items in the response (as set in the query or by default).
+        limit:,
+        # URL to the next page of items. ( `null` if none)
+        next_:,
+        # The offset of the items returned (as set in the query or by default)
+        offset:,
+        # URL to the previous page of items. ( `null` if none)
+        previous:,
+        # The total number of items available to return.
+        total:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            href: String,
+            items: T::Array[Spotted::SimplifiedPlaylistObject],
+            limit: Integer,
+            next_: T.nilable(String),
+            offset: Integer,
+            previous: T.nilable(String),
+            total: Integer
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/spotted/models/playlist_retrieve_params.rbi

@@ -0,0 +1,112 @@
+# typed: strong
+
+module Spotted
+  module Models
+    class PlaylistRetrieveParams < Spotted::Internal::Type::BaseModel
+      extend Spotted::Internal::Type::RequestParameters::Converter
+      include Spotted::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Spotted::PlaylistRetrieveParams, 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 playlist''s
+      # description and URI: `fields=description,uri`. 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: `fields=tracks.items(added_at,added_by.id)`. Use multiple
+      # parentheses to drill down into nested objects, for example:
+      # `fields=tracks.items(track(name,href,album(name,href)))`. Fields can be excluded
+      # by prefixing them with an exclamation mark, for example:
+      # `fields=tracks.items(track(name,href,album(!name,href)))`
+      sig { returns(T.nilable(String)) }
+      attr_reader :fields
+
+      sig { params(fields: String).void }
+      attr_writer :fields
+
+      # 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,
+          fields: 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,
+        # 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 playlist''s
+        # description and URI: `fields=description,uri`. 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: `fields=tracks.items(added_at,added_by.id)`. Use multiple
+        # parentheses to drill down into nested objects, for example:
+        # `fields=tracks.items(track(name,href,album(name,href)))`. Fields can be excluded
+        # by prefixing them with an exclamation mark, for example:
+        # `fields=tracks.items(track(name,href,album(!name,href)))`
+        fields: 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,
+            fields: String,
+            market: String,
+            request_options: Spotted::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/spotted/models/playlist_retrieve_response.rbi

@@ -0,0 +1,327 @@
+# typed: strong
+
+module Spotted
+  module Models
+    class PlaylistRetrieveResponse < Spotted::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Spotted::Models::PlaylistRetrieveResponse,
+            Spotted::Internal::AnyHash
+          )
+        end
+
+      # The [Spotify ID](/documentation/web-api/concepts/spotify-uris-ids) for the
+      # playlist.
+      sig { returns(T.nilable(String)) }
+      attr_reader :id
+
+      sig { params(id: String).void }
+      attr_writer :id
+
+      # `true` if the owner allows other users to modify the playlist.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :collaborative
+
+      sig { params(collaborative: T::Boolean).void }
+      attr_writer :collaborative
+
+      # The playlist description. _Only returned for modified, verified playlists,
+      # otherwise_ `null`.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :description
+
+      # Known external URLs for this playlist.
+      sig { returns(T.nilable(Spotted::ExternalURLObject)) }
+      attr_reader :external_urls
+
+      sig { params(external_urls: Spotted::ExternalURLObject::OrHash).void }
+      attr_writer :external_urls
+
+      # Information about the followers of the playlist.
+      sig { returns(T.nilable(Spotted::FollowersObject)) }
+      attr_reader :followers
+
+      sig { params(followers: Spotted::FollowersObject::OrHash).void }
+      attr_writer :followers
+
+      # A link to the Web API endpoint providing full details of the playlist.
+      sig { returns(T.nilable(String)) }
+      attr_reader :href
+
+      sig { params(href: String).void }
+      attr_writer :href
+
+      # Images for the playlist. The array may be empty or contain up to three images.
+      # The images are returned by size in descending order. See
+      # [Working with Playlists](/documentation/web-api/concepts/playlists). _**Note**:
+      # If returned, the source URL for the image (`url`) is temporary and will expire
+      # in less than a day._
+      sig { returns(T.nilable(T::Array[Spotted::ImageObject])) }
+      attr_reader :images
+
+      sig { params(images: T::Array[Spotted::ImageObject::OrHash]).void }
+      attr_writer :images
+
+      # The name of the playlist.
+      sig { returns(T.nilable(String)) }
+      attr_reader :name
+
+      sig { params(name: String).void }
+      attr_writer :name
+
+      # The user who owns the playlist
+      sig do
+        returns(T.nilable(Spotted::Models::PlaylistRetrieveResponse::Owner))
+      end
+      attr_reader :owner
+
+      sig do
+        params(
+          owner: Spotted::Models::PlaylistRetrieveResponse::Owner::OrHash
+        ).void
+      end
+      attr_writer :owner
+
+      # The playlist's public/private status (if it is added to the user's profile):
+      # `true` the playlist is public, `false` the playlist is private, `null` the
+      # playlist status is not relevant. For more about public/private status, see
+      # [Working with Playlists](/documentation/web-api/concepts/playlists)
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :public
+
+      sig { params(public: T::Boolean).void }
+      attr_writer :public
+
+      # The version identifier for the current playlist. Can be supplied in other
+      # requests to target a specific playlist version
+      sig { returns(T.nilable(String)) }
+      attr_reader :snapshot_id
+
+      sig { params(snapshot_id: String).void }
+      attr_writer :snapshot_id
+
+      # The tracks of the playlist.
+      sig do
+        returns(T.nilable(Spotted::Models::PlaylistRetrieveResponse::Tracks))
+      end
+      attr_reader :tracks
+
+      sig do
+        params(
+          tracks: Spotted::Models::PlaylistRetrieveResponse::Tracks::OrHash
+        ).void
+      end
+      attr_writer :tracks
+
+      # The object type: "playlist"
+      sig { returns(T.nilable(String)) }
+      attr_reader :type
+
+      sig { params(type: String).void }
+      attr_writer :type
+
+      # The [Spotify URI](/documentation/web-api/concepts/spotify-uris-ids) for the
+      # playlist.
+      sig { returns(T.nilable(String)) }
+      attr_reader :uri
+
+      sig { params(uri: String).void }
+      attr_writer :uri
+
+      sig do
+        params(
+          id: String,
+          collaborative: T::Boolean,
+          description: T.nilable(String),
+          external_urls: Spotted::ExternalURLObject::OrHash,
+          followers: Spotted::FollowersObject::OrHash,
+          href: String,
+          images: T::Array[Spotted::ImageObject::OrHash],
+          name: String,
+          owner: Spotted::Models::PlaylistRetrieveResponse::Owner::OrHash,
+          public: T::Boolean,
+          snapshot_id: String,
+          tracks: Spotted::Models::PlaylistRetrieveResponse::Tracks::OrHash,
+          type: String,
+          uri: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The [Spotify ID](/documentation/web-api/concepts/spotify-uris-ids) for the
+        # playlist.
+        id: nil,
+        # `true` if the owner allows other users to modify the playlist.
+        collaborative: nil,
+        # The playlist description. _Only returned for modified, verified playlists,
+        # otherwise_ `null`.
+        description: nil,
+        # Known external URLs for this playlist.
+        external_urls: nil,
+        # Information about the followers of the playlist.
+        followers: nil,
+        # A link to the Web API endpoint providing full details of the playlist.
+        href: nil,
+        # Images for the playlist. The array may be empty or contain up to three images.
+        # The images are returned by size in descending order. See
+        # [Working with Playlists](/documentation/web-api/concepts/playlists). _**Note**:
+        # If returned, the source URL for the image (`url`) is temporary and will expire
+        # in less than a day._
+        images: nil,
+        # The name of the playlist.
+        name: nil,
+        # The user who owns the playlist
+        owner: nil,
+        # The playlist's public/private status (if it is added to the user's profile):
+        # `true` the playlist is public, `false` the playlist is private, `null` the
+        # playlist status is not relevant. For more about public/private status, see
+        # [Working with Playlists](/documentation/web-api/concepts/playlists)
+        public: nil,
+        # The version identifier for the current playlist. Can be supplied in other
+        # requests to target a specific playlist version
+        snapshot_id: nil,
+        # The tracks of the playlist.
+        tracks: nil,
+        # The object type: "playlist"
+        type: nil,
+        # The [Spotify URI](/documentation/web-api/concepts/spotify-uris-ids) for the
+        # playlist.
+        uri: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            collaborative: T::Boolean,
+            description: T.nilable(String),
+            external_urls: Spotted::ExternalURLObject,
+            followers: Spotted::FollowersObject,
+            href: String,
+            images: T::Array[Spotted::ImageObject],
+            name: String,
+            owner: Spotted::Models::PlaylistRetrieveResponse::Owner,
+            public: T::Boolean,
+            snapshot_id: String,
+            tracks: Spotted::Models::PlaylistRetrieveResponse::Tracks,
+            type: String,
+            uri: String
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Owner < Spotted::Models::PlaylistUserObject
+        OrHash =
+          T.type_alias do
+            T.any(
+              Spotted::Models::PlaylistRetrieveResponse::Owner,
+              Spotted::Internal::AnyHash
+            )
+          end
+
+        # The name displayed on the user's profile. `null` if not available.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :display_name
+
+        # The user who owns the playlist
+        sig do
+          params(display_name: T.nilable(String)).returns(T.attached_class)
+        end
+        def self.new(
+          # The name displayed on the user's profile. `null` if not available.
+          display_name: nil
+        )
+        end
+
+        sig { override.returns({ display_name: T.nilable(String) }) }
+        def to_hash
+        end
+      end
+
+      class Tracks < Spotted::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Spotted::Models::PlaylistRetrieveResponse::Tracks,
+              Spotted::Internal::AnyHash
+            )
+          end
+
+        # A link to the Web API endpoint returning the full result of the request
+        sig { returns(String) }
+        attr_accessor :href
+
+        sig { returns(T::Array[Spotted::PlaylistTrackObject]) }
+        attr_accessor :items
+
+        # The maximum number of items in the response (as set in the query or by default).
+        sig { returns(Integer) }
+        attr_accessor :limit
+
+        # URL to the next page of items. ( `null` if none)
+        sig { returns(T.nilable(String)) }
+        attr_accessor :next_
+
+        # The offset of the items returned (as set in the query or by default)
+        sig { returns(Integer) }
+        attr_accessor :offset
+
+        # URL to the previous page of items. ( `null` if none)
+        sig { returns(T.nilable(String)) }
+        attr_accessor :previous
+
+        # The total number of items available to return.
+        sig { returns(Integer) }
+        attr_accessor :total
+
+        # The tracks of the playlist.
+        sig do
+          params(
+            href: String,
+            items: T::Array[Spotted::PlaylistTrackObject::OrHash],
+            limit: Integer,
+            next_: T.nilable(String),
+            offset: Integer,
+            previous: T.nilable(String),
+            total: Integer
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # A link to the Web API endpoint returning the full result of the request
+          href:,
+          items:,
+          # The maximum number of items in the response (as set in the query or by default).
+          limit:,
+          # URL to the next page of items. ( `null` if none)
+          next_:,
+          # The offset of the items returned (as set in the query or by default)
+          offset:,
+          # URL to the previous page of items. ( `null` if none)
+          previous:,
+          # The total number of items available to return.
+          total:
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              href: String,
+              items: T::Array[Spotted::PlaylistTrackObject],
+              limit: Integer,
+              next_: T.nilable(String),
+              offset: Integer,
+              previous: T.nilable(String),
+              total: Integer
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/spotted/models/playlist_track_object.rbi

@@ -0,0 +1,101 @@
+# typed: strong
+
+module Spotted
+  module Models
+    class PlaylistTrackObject < Spotted::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Spotted::PlaylistTrackObject, Spotted::Internal::AnyHash)
+        end
+
+      # The date and time the track or episode was added. _**Note**: some very old
+      # playlists may return `null` in this field._
+      sig { returns(T.nilable(Time)) }
+      attr_reader :added_at
+
+      sig { params(added_at: Time).void }
+      attr_writer :added_at
+
+      # The Spotify user who added the track or episode. _**Note**: some very old
+      # playlists may return `null` in this field._
+      sig { returns(T.nilable(Spotted::PlaylistUserObject)) }
+      attr_reader :added_by
+
+      sig { params(added_by: Spotted::PlaylistUserObject::OrHash).void }
+      attr_writer :added_by
+
+      # Whether this track or episode is a
+      # [local file](/documentation/web-api/concepts/playlists/#local-files) or not.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :is_local
+
+      sig { params(is_local: T::Boolean).void }
+      attr_writer :is_local
+
+      # Information about the track or episode.
+      sig { returns(T.nilable(Spotted::PlaylistTrackObject::Track::Variants)) }
+      attr_reader :track
+
+      sig do
+        params(
+          track:
+            T.any(Spotted::TrackObject::OrHash, Spotted::EpisodeObject::OrHash)
+        ).void
+      end
+      attr_writer :track
+
+      sig do
+        params(
+          added_at: Time,
+          added_by: Spotted::PlaylistUserObject::OrHash,
+          is_local: T::Boolean,
+          track:
+            T.any(Spotted::TrackObject::OrHash, Spotted::EpisodeObject::OrHash)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The date and time the track or episode was added. _**Note**: some very old
+        # playlists may return `null` in this field._
+        added_at: nil,
+        # The Spotify user who added the track or episode. _**Note**: some very old
+        # playlists may return `null` in this field._
+        added_by: nil,
+        # Whether this track or episode is a
+        # [local file](/documentation/web-api/concepts/playlists/#local-files) or not.
+        is_local: nil,
+        # Information about the track or episode.
+        track: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            added_at: Time,
+            added_by: Spotted::PlaylistUserObject,
+            is_local: T::Boolean,
+            track: Spotted::PlaylistTrackObject::Track::Variants
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # Information about the track or episode.
+      module Track
+        extend Spotted::Internal::Type::Union
+
+        Variants =
+          T.type_alias { T.any(Spotted::TrackObject, Spotted::EpisodeObject) }
+
+        sig do
+          override.returns(
+            T::Array[Spotted::PlaylistTrackObject::Track::Variants]
+          )
+        end
+        def self.variants
+        end
+      end
+    end
+  end
+end

data/rbi/spotted/models/playlist_tracks_ref_object.rbi

@@ -0,0 +1,41 @@
+# typed: strong
+
+module Spotted
+  module Models
+    class PlaylistTracksRefObject < Spotted::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Spotted::PlaylistTracksRefObject, Spotted::Internal::AnyHash)
+        end
+
+      # A link to the Web API endpoint where full details of the playlist's tracks can
+      # be retrieved.
+      sig { returns(T.nilable(String)) }
+      attr_reader :href
+
+      sig { params(href: String).void }
+      attr_writer :href
+
+      # Number of tracks in the playlist.
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :total
+
+      sig { params(total: Integer).void }
+      attr_writer :total
+
+      sig { params(href: String, total: Integer).returns(T.attached_class) }
+      def self.new(
+        # A link to the Web API endpoint where full details of the playlist's tracks can
+        # be retrieved.
+        href: nil,
+        # Number of tracks in the playlist.
+        total: nil
+      )
+      end
+
+      sig { override.returns({ href: String, total: Integer }) }
+      def to_hash
+      end
+    end
+  end
+end