spotted 0.1.0

data/rbi/spotted/models/album_list_response.rbi

@@ -0,0 +1,479 @@
+# typed: strong
+
+module Spotted
+  module Models
+    class AlbumListResponse < Spotted::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Spotted::Models::AlbumListResponse, Spotted::Internal::AnyHash)
+        end
+
+      sig { returns(T::Array[Spotted::Models::AlbumListResponse::Album]) }
+      attr_accessor :albums
+
+      sig do
+        params(
+          albums: T::Array[Spotted::Models::AlbumListResponse::Album::OrHash]
+        ).returns(T.attached_class)
+      end
+      def self.new(albums:)
+      end
+
+      sig do
+        override.returns(
+          { albums: T::Array[Spotted::Models::AlbumListResponse::Album] }
+        )
+      end
+      def to_hash
+      end
+
+      class Album < Spotted::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Spotted::Models::AlbumListResponse::Album,
+              Spotted::Internal::AnyHash
+            )
+          end
+
+        # The [Spotify ID](/documentation/web-api/concepts/spotify-uris-ids) for the
+        # album.
+        sig { returns(String) }
+        attr_accessor :id
+
+        # The type of the album.
+        sig do
+          returns(
+            Spotted::Models::AlbumListResponse::Album::AlbumType::TaggedSymbol
+          )
+        end
+        attr_accessor :album_type
+
+        # The markets in which the album is available:
+        # [ISO 3166-1 alpha-2 country codes](http://en.wikipedia.org/wiki/ISO_3166-1_alpha-2).
+        # _**NOTE**: an album is considered available in a market when at least 1 of its
+        # tracks is available in that market._
+        sig { returns(T::Array[String]) }
+        attr_accessor :available_markets
+
+        # Known external URLs for this album.
+        sig { returns(Spotted::ExternalURLObject) }
+        attr_reader :external_urls
+
+        sig { params(external_urls: Spotted::ExternalURLObject::OrHash).void }
+        attr_writer :external_urls
+
+        # A link to the Web API endpoint providing full details of the album.
+        sig { returns(String) }
+        attr_accessor :href
+
+        # The cover art for the album in various sizes, widest first.
+        sig { returns(T::Array[Spotted::ImageObject]) }
+        attr_accessor :images
+
+        # The name of the album. In case of an album takedown, the value may be an empty
+        # string.
+        sig { returns(String) }
+        attr_accessor :name
+
+        # The date the album was first released.
+        sig { returns(String) }
+        attr_accessor :release_date
+
+        # The precision with which `release_date` value is known.
+        sig do
+          returns(
+            Spotted::Models::AlbumListResponse::Album::ReleaseDatePrecision::TaggedSymbol
+          )
+        end
+        attr_accessor :release_date_precision
+
+        # The number of tracks in the album.
+        sig { returns(Integer) }
+        attr_accessor :total_tracks
+
+        # The object type.
+        sig do
+          returns(Spotted::Models::AlbumListResponse::Album::Type::TaggedSymbol)
+        end
+        attr_accessor :type
+
+        # The [Spotify URI](/documentation/web-api/concepts/spotify-uris-ids) for the
+        # album.
+        sig { returns(String) }
+        attr_accessor :uri
+
+        # The artists of the album. Each artist object includes a link in `href` to more
+        # detailed information about the artist.
+        sig { returns(T.nilable(T::Array[Spotted::SimplifiedArtistObject])) }
+        attr_reader :artists
+
+        sig do
+          params(
+            artists: T::Array[Spotted::SimplifiedArtistObject::OrHash]
+          ).void
+        end
+        attr_writer :artists
+
+        # The copyright statements of the album.
+        sig { returns(T.nilable(T::Array[Spotted::CopyrightObject])) }
+        attr_reader :copyrights
+
+        sig do
+          params(copyrights: T::Array[Spotted::CopyrightObject::OrHash]).void
+        end
+        attr_writer :copyrights
+
+        # Known external IDs for the album.
+        sig { returns(T.nilable(Spotted::ExternalIDObject)) }
+        attr_reader :external_ids
+
+        sig { params(external_ids: Spotted::ExternalIDObject::OrHash).void }
+        attr_writer :external_ids
+
+        # **Deprecated** The array is always empty.
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_reader :genres
+
+        sig { params(genres: T::Array[String]).void }
+        attr_writer :genres
+
+        # The label associated with the album.
+        sig { returns(T.nilable(String)) }
+        attr_reader :label
+
+        sig { params(label: String).void }
+        attr_writer :label
+
+        # The popularity of the album. The value will be between 0 and 100, with 100 being
+        # the most popular.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :popularity
+
+        sig { params(popularity: Integer).void }
+        attr_writer :popularity
+
+        # Included in the response when a content restriction is applied.
+        sig { returns(T.nilable(Spotted::AlbumRestrictionObject)) }
+        attr_reader :restrictions
+
+        sig do
+          params(restrictions: Spotted::AlbumRestrictionObject::OrHash).void
+        end
+        attr_writer :restrictions
+
+        # The tracks of the album.
+        sig do
+          returns(T.nilable(Spotted::Models::AlbumListResponse::Album::Tracks))
+        end
+        attr_reader :tracks
+
+        sig do
+          params(
+            tracks: Spotted::Models::AlbumListResponse::Album::Tracks::OrHash
+          ).void
+        end
+        attr_writer :tracks
+
+        sig do
+          params(
+            id: String,
+            album_type:
+              Spotted::Models::AlbumListResponse::Album::AlbumType::OrSymbol,
+            available_markets: T::Array[String],
+            external_urls: Spotted::ExternalURLObject::OrHash,
+            href: String,
+            images: T::Array[Spotted::ImageObject::OrHash],
+            name: String,
+            release_date: String,
+            release_date_precision:
+              Spotted::Models::AlbumListResponse::Album::ReleaseDatePrecision::OrSymbol,
+            total_tracks: Integer,
+            type: Spotted::Models::AlbumListResponse::Album::Type::OrSymbol,
+            uri: String,
+            artists: T::Array[Spotted::SimplifiedArtistObject::OrHash],
+            copyrights: T::Array[Spotted::CopyrightObject::OrHash],
+            external_ids: Spotted::ExternalIDObject::OrHash,
+            genres: T::Array[String],
+            label: String,
+            popularity: Integer,
+            restrictions: Spotted::AlbumRestrictionObject::OrHash,
+            tracks: Spotted::Models::AlbumListResponse::Album::Tracks::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The [Spotify ID](/documentation/web-api/concepts/spotify-uris-ids) for the
+          # album.
+          id:,
+          # The type of the album.
+          album_type:,
+          # The markets in which the album is available:
+          # [ISO 3166-1 alpha-2 country codes](http://en.wikipedia.org/wiki/ISO_3166-1_alpha-2).
+          # _**NOTE**: an album is considered available in a market when at least 1 of its
+          # tracks is available in that market._
+          available_markets:,
+          # Known external URLs for this album.
+          external_urls:,
+          # A link to the Web API endpoint providing full details of the album.
+          href:,
+          # The cover art for the album in various sizes, widest first.
+          images:,
+          # The name of the album. In case of an album takedown, the value may be an empty
+          # string.
+          name:,
+          # The date the album was first released.
+          release_date:,
+          # The precision with which `release_date` value is known.
+          release_date_precision:,
+          # The number of tracks in the album.
+          total_tracks:,
+          # The object type.
+          type:,
+          # The [Spotify URI](/documentation/web-api/concepts/spotify-uris-ids) for the
+          # album.
+          uri:,
+          # The artists of the album. Each artist object includes a link in `href` to more
+          # detailed information about the artist.
+          artists: nil,
+          # The copyright statements of the album.
+          copyrights: nil,
+          # Known external IDs for the album.
+          external_ids: nil,
+          # **Deprecated** The array is always empty.
+          genres: nil,
+          # The label associated with the album.
+          label: nil,
+          # The popularity of the album. The value will be between 0 and 100, with 100 being
+          # the most popular.
+          popularity: nil,
+          # Included in the response when a content restriction is applied.
+          restrictions: nil,
+          # The tracks of the album.
+          tracks: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              id: String,
+              album_type:
+                Spotted::Models::AlbumListResponse::Album::AlbumType::TaggedSymbol,
+              available_markets: T::Array[String],
+              external_urls: Spotted::ExternalURLObject,
+              href: String,
+              images: T::Array[Spotted::ImageObject],
+              name: String,
+              release_date: String,
+              release_date_precision:
+                Spotted::Models::AlbumListResponse::Album::ReleaseDatePrecision::TaggedSymbol,
+              total_tracks: Integer,
+              type:
+                Spotted::Models::AlbumListResponse::Album::Type::TaggedSymbol,
+              uri: String,
+              artists: T::Array[Spotted::SimplifiedArtistObject],
+              copyrights: T::Array[Spotted::CopyrightObject],
+              external_ids: Spotted::ExternalIDObject,
+              genres: T::Array[String],
+              label: String,
+              popularity: Integer,
+              restrictions: Spotted::AlbumRestrictionObject,
+              tracks: Spotted::Models::AlbumListResponse::Album::Tracks
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # The type of the album.
+        module AlbumType
+          extend Spotted::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                Spotted::Models::AlbumListResponse::Album::AlbumType
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          ALBUM =
+            T.let(
+              :album,
+              Spotted::Models::AlbumListResponse::Album::AlbumType::TaggedSymbol
+            )
+          SINGLE =
+            T.let(
+              :single,
+              Spotted::Models::AlbumListResponse::Album::AlbumType::TaggedSymbol
+            )
+          COMPILATION =
+            T.let(
+              :compilation,
+              Spotted::Models::AlbumListResponse::Album::AlbumType::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Spotted::Models::AlbumListResponse::Album::AlbumType::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+
+        # The precision with which `release_date` value is known.
+        module ReleaseDatePrecision
+          extend Spotted::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                Spotted::Models::AlbumListResponse::Album::ReleaseDatePrecision
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          YEAR =
+            T.let(
+              :year,
+              Spotted::Models::AlbumListResponse::Album::ReleaseDatePrecision::TaggedSymbol
+            )
+          MONTH =
+            T.let(
+              :month,
+              Spotted::Models::AlbumListResponse::Album::ReleaseDatePrecision::TaggedSymbol
+            )
+          DAY =
+            T.let(
+              :day,
+              Spotted::Models::AlbumListResponse::Album::ReleaseDatePrecision::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Spotted::Models::AlbumListResponse::Album::ReleaseDatePrecision::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+
+        # The object type.
+        module Type
+          extend Spotted::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, Spotted::Models::AlbumListResponse::Album::Type)
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          ALBUM =
+            T.let(
+              :album,
+              Spotted::Models::AlbumListResponse::Album::Type::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Spotted::Models::AlbumListResponse::Album::Type::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+
+        class Tracks < Spotted::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Spotted::Models::AlbumListResponse::Album::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::SimplifiedTrackObject]) }
+          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 album.
+          sig do
+            params(
+              href: String,
+              items: T::Array[Spotted::SimplifiedTrackObject::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::SimplifiedTrackObject],
+                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/album_list_tracks_params.rbi

@@ -0,0 +1,86 @@
+# typed: strong
+
+module Spotted
+  module Models
+    class AlbumListTracksParams < Spotted::Internal::Type::BaseModel
+      extend Spotted::Internal::Type::RequestParameters::Converter
+      include Spotted::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Spotted::AlbumListTracksParams, 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
+
+      # 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(
+          limit: Integer,
+          market: String,
+          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,
+        # 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(
+          {
+            limit: Integer,
+            market: String,
+            offset: Integer,
+            request_options: Spotted::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/spotted/models/album_restriction_object.rbi

@@ -0,0 +1,82 @@
+# typed: strong
+
+module Spotted
+  module Models
+    class AlbumRestrictionObject < Spotted::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Spotted::AlbumRestrictionObject, Spotted::Internal::AnyHash)
+        end
+
+      # The reason for the restriction. Albums may be restricted if the content is not
+      # available in a given market, to the user's subscription type, or when the user's
+      # account is set to not play explicit content. Additional reasons may be added in
+      # the future.
+      sig do
+        returns(
+          T.nilable(Spotted::AlbumRestrictionObject::Reason::TaggedSymbol)
+        )
+      end
+      attr_reader :reason
+
+      sig do
+        params(reason: Spotted::AlbumRestrictionObject::Reason::OrSymbol).void
+      end
+      attr_writer :reason
+
+      sig do
+        params(
+          reason: Spotted::AlbumRestrictionObject::Reason::OrSymbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The reason for the restriction. Albums may be restricted if the content is not
+        # available in a given market, to the user's subscription type, or when the user's
+        # account is set to not play explicit content. Additional reasons may be added in
+        # the future.
+        reason: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          { reason: Spotted::AlbumRestrictionObject::Reason::TaggedSymbol }
+        )
+      end
+      def to_hash
+      end
+
+      # The reason for the restriction. Albums may be restricted if the content is not
+      # available in a given market, to the user's subscription type, or when the user's
+      # account is set to not play explicit content. Additional reasons may be added in
+      # the future.
+      module Reason
+        extend Spotted::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Spotted::AlbumRestrictionObject::Reason)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        MARKET =
+          T.let(:market, Spotted::AlbumRestrictionObject::Reason::TaggedSymbol)
+        PRODUCT =
+          T.let(:product, Spotted::AlbumRestrictionObject::Reason::TaggedSymbol)
+        EXPLICIT =
+          T.let(
+            :explicit,
+            Spotted::AlbumRestrictionObject::Reason::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[Spotted::AlbumRestrictionObject::Reason::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/spotted/models/album_retrieve_params.rbi

@@ -0,0 +1,59 @@
+# typed: strong
+
+module Spotted
+  module Models
+    class AlbumRetrieveParams < Spotted::Internal::Type::BaseModel
+      extend Spotted::Internal::Type::RequestParameters::Converter
+      include Spotted::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Spotted::AlbumRetrieveParams, Spotted::Internal::AnyHash)
+        end
+
+      # 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(
+          market: String,
+          request_options: Spotted::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # 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(
+          { market: String, request_options: Spotted::RequestOptions }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end