spotted 0.1.0

data/rbi/spotted/models/user_retrieve_profile_response.rbi

@@ -0,0 +1,159 @@
+# typed: strong
+
+module Spotted
+  module Models
+    class UserRetrieveProfileResponse < Spotted::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Spotted::Models::UserRetrieveProfileResponse,
+            Spotted::Internal::AnyHash
+          )
+        end
+
+      # The [Spotify user ID](/documentation/web-api/concepts/spotify-uris-ids) for this
+      # user.
+      sig { returns(T.nilable(String)) }
+      attr_reader :id
+
+      sig { params(id: String).void }
+      attr_writer :id
+
+      # The name displayed on the user's profile. `null` if not available.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :display_name
+
+      # Known public external URLs for this user.
+      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 this user.
+      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 for this user.
+      sig { returns(T.nilable(String)) }
+      attr_reader :href
+
+      sig { params(href: String).void }
+      attr_writer :href
+
+      # The user's profile image.
+      sig { returns(T.nilable(T::Array[Spotted::ImageObject])) }
+      attr_reader :images
+
+      sig { params(images: T::Array[Spotted::ImageObject::OrHash]).void }
+      attr_writer :images
+
+      # The object type.
+      sig do
+        returns(
+          T.nilable(
+            Spotted::Models::UserRetrieveProfileResponse::Type::TaggedSymbol
+          )
+        )
+      end
+      attr_reader :type
+
+      sig do
+        params(
+          type: Spotted::Models::UserRetrieveProfileResponse::Type::OrSymbol
+        ).void
+      end
+      attr_writer :type
+
+      # The [Spotify URI](/documentation/web-api/concepts/spotify-uris-ids) for this
+      # user.
+      sig { returns(T.nilable(String)) }
+      attr_reader :uri
+
+      sig { params(uri: String).void }
+      attr_writer :uri
+
+      sig do
+        params(
+          id: String,
+          display_name: T.nilable(String),
+          external_urls: Spotted::ExternalURLObject::OrHash,
+          followers: Spotted::FollowersObject::OrHash,
+          href: String,
+          images: T::Array[Spotted::ImageObject::OrHash],
+          type: Spotted::Models::UserRetrieveProfileResponse::Type::OrSymbol,
+          uri: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The [Spotify user ID](/documentation/web-api/concepts/spotify-uris-ids) for this
+        # user.
+        id: nil,
+        # The name displayed on the user's profile. `null` if not available.
+        display_name: nil,
+        # Known public external URLs for this user.
+        external_urls: nil,
+        # Information about the followers of this user.
+        followers: nil,
+        # A link to the Web API endpoint for this user.
+        href: nil,
+        # The user's profile image.
+        images: nil,
+        # The object type.
+        type: nil,
+        # The [Spotify URI](/documentation/web-api/concepts/spotify-uris-ids) for this
+        # user.
+        uri: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            display_name: T.nilable(String),
+            external_urls: Spotted::ExternalURLObject,
+            followers: Spotted::FollowersObject,
+            href: String,
+            images: T::Array[Spotted::ImageObject],
+            type:
+              Spotted::Models::UserRetrieveProfileResponse::Type::TaggedSymbol,
+            uri: String
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # The object type.
+      module Type
+        extend Spotted::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Spotted::Models::UserRetrieveProfileResponse::Type)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        USER =
+          T.let(
+            :user,
+            Spotted::Models::UserRetrieveProfileResponse::Type::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              Spotted::Models::UserRetrieveProfileResponse::Type::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/spotted/models/users/playlist_create_params.rbi

@@ -0,0 +1,107 @@
+# typed: strong
+
+module Spotted
+  module Models
+    module Users
+      class PlaylistCreateParams < Spotted::Internal::Type::BaseModel
+        extend Spotted::Internal::Type::RequestParameters::Converter
+        include Spotted::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Spotted::Users::PlaylistCreateParams,
+              Spotted::Internal::AnyHash
+            )
+          end
+
+        # The name for the new playlist, for example `"Your Coolest Playlist"`. This name
+        # does not need to be unique; a user may have several playlists with the same
+        # name.
+        sig { returns(String) }
+        attr_accessor :name
+
+        # Defaults to `false`. If `true` the playlist will be collaborative. _**Note**: to
+        # create a collaborative playlist you must also set `public` to `false`. To create
+        # collaborative playlists you must have granted `playlist-modify-private` and
+        # `playlist-modify-public`
+        # [scopes](/documentation/web-api/concepts/scopes/#list-of-scopes)._
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :collaborative
+
+        sig { params(collaborative: T::Boolean).void }
+        attr_writer :collaborative
+
+        # value for playlist description as displayed in Spotify Clients and in the Web
+        # API.
+        sig { returns(T.nilable(String)) }
+        attr_reader :description
+
+        sig { params(description: String).void }
+        attr_writer :description
+
+        # Defaults to `true`. The playlist's public/private status (if it should be added
+        # to the user's profile or not): `true` the playlist will be public, `false` the
+        # playlist will be private. To be able to create private playlists, the user must
+        # have granted the `playlist-modify-private`
+        # [scope](/documentation/web-api/concepts/scopes/#list-of-scopes). 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
+
+        sig do
+          params(
+            name: String,
+            collaborative: T::Boolean,
+            description: String,
+            public: T::Boolean,
+            request_options: Spotted::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The name for the new playlist, for example `"Your Coolest Playlist"`. This name
+          # does not need to be unique; a user may have several playlists with the same
+          # name.
+          name:,
+          # Defaults to `false`. If `true` the playlist will be collaborative. _**Note**: to
+          # create a collaborative playlist you must also set `public` to `false`. To create
+          # collaborative playlists you must have granted `playlist-modify-private` and
+          # `playlist-modify-public`
+          # [scopes](/documentation/web-api/concepts/scopes/#list-of-scopes)._
+          collaborative: nil,
+          # value for playlist description as displayed in Spotify Clients and in the Web
+          # API.
+          description: nil,
+          # Defaults to `true`. The playlist's public/private status (if it should be added
+          # to the user's profile or not): `true` the playlist will be public, `false` the
+          # playlist will be private. To be able to create private playlists, the user must
+          # have granted the `playlist-modify-private`
+          # [scope](/documentation/web-api/concepts/scopes/#list-of-scopes). For more about
+          # public/private status, see
+          # [Working with Playlists](/documentation/web-api/concepts/playlists)
+          public: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              name: String,
+              collaborative: T::Boolean,
+              description: String,
+              public: T::Boolean,
+              request_options: Spotted::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/spotted/models/users/playlist_create_response.rbi

@@ -0,0 +1,336 @@
+# typed: strong
+
+module Spotted
+  module Models
+    module Users
+      class PlaylistCreateResponse < Spotted::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Spotted::Models::Users::PlaylistCreateResponse,
+              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::Users::PlaylistCreateResponse::Owner)
+          )
+        end
+        attr_reader :owner
+
+        sig do
+          params(
+            owner: Spotted::Models::Users::PlaylistCreateResponse::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::Users::PlaylistCreateResponse::Tracks)
+          )
+        end
+        attr_reader :tracks
+
+        sig do
+          params(
+            tracks:
+              Spotted::Models::Users::PlaylistCreateResponse::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::Users::PlaylistCreateResponse::Owner::OrHash,
+            public: T::Boolean,
+            snapshot_id: String,
+            tracks:
+              Spotted::Models::Users::PlaylistCreateResponse::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::Users::PlaylistCreateResponse::Owner,
+              public: T::Boolean,
+              snapshot_id: String,
+              tracks: Spotted::Models::Users::PlaylistCreateResponse::Tracks,
+              type: String,
+              uri: String
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Owner < Spotted::Models::PlaylistUserObject
+          OrHash =
+            T.type_alias do
+              T.any(
+                Spotted::Models::Users::PlaylistCreateResponse::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::Users::PlaylistCreateResponse::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
+end

data/rbi/spotted/models/users/playlist_list_params.rbi

@@ -0,0 +1,64 @@
+# typed: strong
+
+module Spotted
+  module Models
+    module Users
+      class PlaylistListParams < Spotted::Internal::Type::BaseModel
+        extend Spotted::Internal::Type::RequestParameters::Converter
+        include Spotted::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Spotted::Users::PlaylistListParams,
+              Spotted::Internal::AnyHash
+            )
+          end
+
+        # 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
+
+        # 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.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :offset
+
+        sig { params(offset: Integer).void }
+        attr_writer :offset
+
+        sig do
+          params(
+            limit: Integer,
+            offset: Integer,
+            request_options: Spotted::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # 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
+
+        sig do
+          override.returns(
+            {
+              limit: Integer,
+              offset: Integer,
+              request_options: Spotted::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end