spotted 0.1.0

data/rbi/spotted/models/recommendation_get_response.rbi

@@ -0,0 +1,152 @@
+# typed: strong
+
+module Spotted
+  module Models
+    class RecommendationGetResponse < Spotted::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Spotted::Models::RecommendationGetResponse,
+            Spotted::Internal::AnyHash
+          )
+        end
+
+      # An array of recommendation seed objects.
+      sig do
+        returns(T::Array[Spotted::Models::RecommendationGetResponse::Seed])
+      end
+      attr_accessor :seeds
+
+      # An array of track objects ordered according to the parameters supplied.
+      sig { returns(T::Array[Spotted::TrackObject]) }
+      attr_accessor :tracks
+
+      sig do
+        params(
+          seeds:
+            T::Array[Spotted::Models::RecommendationGetResponse::Seed::OrHash],
+          tracks: T::Array[Spotted::TrackObject::OrHash]
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # An array of recommendation seed objects.
+        seeds:,
+        # An array of track objects ordered according to the parameters supplied.
+        tracks:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            seeds: T::Array[Spotted::Models::RecommendationGetResponse::Seed],
+            tracks: T::Array[Spotted::TrackObject]
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Seed < Spotted::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Spotted::Models::RecommendationGetResponse::Seed,
+              Spotted::Internal::AnyHash
+            )
+          end
+
+        # The id used to select this seed. This will be the same as the string used in the
+        # `seed_artists`, `seed_tracks` or `seed_genres` parameter.
+        sig { returns(T.nilable(String)) }
+        attr_reader :id
+
+        sig { params(id: String).void }
+        attr_writer :id
+
+        # The number of tracks available after min\_\* and max\_\* filters have been
+        # applied.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :after_filtering_size
+
+        sig { params(after_filtering_size: Integer).void }
+        attr_writer :after_filtering_size
+
+        # The number of tracks available after relinking for regional availability.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :after_relinking_size
+
+        sig { params(after_relinking_size: Integer).void }
+        attr_writer :after_relinking_size
+
+        # A link to the full track or artist data for this seed. For tracks this will be a
+        # link to a Track Object. For artists a link to an Artist Object. For genre seeds,
+        # this value will be `null`.
+        sig { returns(T.nilable(String)) }
+        attr_reader :href
+
+        sig { params(href: String).void }
+        attr_writer :href
+
+        # The number of recommended tracks available for this seed.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :initial_pool_size
+
+        sig { params(initial_pool_size: Integer).void }
+        attr_writer :initial_pool_size
+
+        # The entity type of this seed. One of `artist`, `track` or `genre`.
+        sig { returns(T.nilable(String)) }
+        attr_reader :type
+
+        sig { params(type: String).void }
+        attr_writer :type
+
+        sig do
+          params(
+            id: String,
+            after_filtering_size: Integer,
+            after_relinking_size: Integer,
+            href: String,
+            initial_pool_size: Integer,
+            type: String
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The id used to select this seed. This will be the same as the string used in the
+          # `seed_artists`, `seed_tracks` or `seed_genres` parameter.
+          id: nil,
+          # The number of tracks available after min\_\* and max\_\* filters have been
+          # applied.
+          after_filtering_size: nil,
+          # The number of tracks available after relinking for regional availability.
+          after_relinking_size: nil,
+          # A link to the full track or artist data for this seed. For tracks this will be a
+          # link to a Track Object. For artists a link to an Artist Object. For genre seeds,
+          # this value will be `null`.
+          href: nil,
+          # The number of recommended tracks available for this seed.
+          initial_pool_size: nil,
+          # The entity type of this seed. One of `artist`, `track` or `genre`.
+          type: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              id: String,
+              after_filtering_size: Integer,
+              after_relinking_size: Integer,
+              href: String,
+              initial_pool_size: Integer,
+              type: String
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/spotted/models/recommendation_list_available_genre_seeds_params.rbi

@@ -0,0 +1,30 @@
+# typed: strong
+
+module Spotted
+  module Models
+    class RecommendationListAvailableGenreSeedsParams < Spotted::Internal::Type::BaseModel
+      extend Spotted::Internal::Type::RequestParameters::Converter
+      include Spotted::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            Spotted::RecommendationListAvailableGenreSeedsParams,
+            Spotted::Internal::AnyHash
+          )
+        end
+
+      sig do
+        params(request_options: Spotted::RequestOptions::OrHash).returns(
+          T.attached_class
+        )
+      end
+      def self.new(request_options: {})
+      end
+
+      sig { override.returns({ request_options: Spotted::RequestOptions }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/spotted/models/recommendation_list_available_genre_seeds_response.rbi

@@ -0,0 +1,26 @@
+# typed: strong
+
+module Spotted
+  module Models
+    class RecommendationListAvailableGenreSeedsResponse < Spotted::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Spotted::Models::RecommendationListAvailableGenreSeedsResponse,
+            Spotted::Internal::AnyHash
+          )
+        end
+
+      sig { returns(T::Array[String]) }
+      attr_accessor :genres
+
+      sig { params(genres: T::Array[String]).returns(T.attached_class) }
+      def self.new(genres:)
+      end
+
+      sig { override.returns({ genres: T::Array[String] }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/spotted/models/resume_point_object.rbi

@@ -0,0 +1,47 @@
+# typed: strong
+
+module Spotted
+  module Models
+    class ResumePointObject < Spotted::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Spotted::ResumePointObject, Spotted::Internal::AnyHash)
+        end
+
+      # Whether or not the episode has been fully played by the user.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :fully_played
+
+      sig { params(fully_played: T::Boolean).void }
+      attr_writer :fully_played
+
+      # The user's most recent position in the episode in milliseconds.
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :resume_position_ms
+
+      sig { params(resume_position_ms: Integer).void }
+      attr_writer :resume_position_ms
+
+      sig do
+        params(fully_played: T::Boolean, resume_position_ms: Integer).returns(
+          T.attached_class
+        )
+      end
+      def self.new(
+        # Whether or not the episode has been fully played by the user.
+        fully_played: nil,
+        # The user's most recent position in the episode in milliseconds.
+        resume_position_ms: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          { fully_played: T::Boolean, resume_position_ms: Integer }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/spotted/models/search_retrieve_params.rbi

@@ -0,0 +1,218 @@
+# typed: strong
+
+module Spotted
+  module Models
+    class SearchRetrieveParams < Spotted::Internal::Type::BaseModel
+      extend Spotted::Internal::Type::RequestParameters::Converter
+      include Spotted::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Spotted::SearchRetrieveParams, Spotted::Internal::AnyHash)
+        end
+
+      # Your search query.
+      #
+      # You can narrow down your search using field filters. The available filters are
+      # `album`, `artist`, `track`, `year`, `upc`, `tag:hipster`, `tag:new`, `isrc`, and
+      # `genre`. Each field filter only applies to certain result types.
+      #
+      # The `artist` and `year` filters can be used while searching albums, artists and
+      # tracks. You can filter on a single `year` or a range (e.g. 1955-1960).<br /> The
+      # `album` filter can be used while searching albums and tracks.<br /> The `genre`
+      # filter can be used while searching artists and tracks.<br /> The `isrc` and
+      # `track` filters can be used while searching tracks.<br /> The `upc`, `tag:new`
+      # and `tag:hipster` filters can only be used while searching albums. The `tag:new`
+      # filter will return albums released in the past two weeks and `tag:hipster` can
+      # be used to return only albums with the lowest 10% popularity.<br />
+      sig { returns(String) }
+      attr_accessor :q
+
+      # A comma-separated list of item types to search across. Search results include
+      # hits from all the specified item types. For example: `q=abacab&type=album,track`
+      # returns both albums and tracks matching "abacab".
+      sig { returns(T::Array[Spotted::SearchRetrieveParams::Type::OrSymbol]) }
+      attr_accessor :type
+
+      # If `include_external=audio` is specified it signals that the client can play
+      # externally hosted audio content, and marks the content as playable in the
+      # response. By default externally hosted audio content is marked as unplayable in
+      # the response.
+      sig do
+        returns(
+          T.nilable(Spotted::SearchRetrieveParams::IncludeExternal::OrSymbol)
+        )
+      end
+      attr_reader :include_external
+
+      sig do
+        params(
+          include_external:
+            Spotted::SearchRetrieveParams::IncludeExternal::OrSymbol
+        ).void
+      end
+      attr_writer :include_external
+
+      # The maximum number of results to return in each item type.
+      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 result to return. Use with limit to get the next page of
+      # search results.
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :offset
+
+      sig { params(offset: Integer).void }
+      attr_writer :offset
+
+      sig do
+        params(
+          q: String,
+          type: T::Array[Spotted::SearchRetrieveParams::Type::OrSymbol],
+          include_external:
+            Spotted::SearchRetrieveParams::IncludeExternal::OrSymbol,
+          limit: Integer,
+          market: String,
+          offset: Integer,
+          request_options: Spotted::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Your search query.
+        #
+        # You can narrow down your search using field filters. The available filters are
+        # `album`, `artist`, `track`, `year`, `upc`, `tag:hipster`, `tag:new`, `isrc`, and
+        # `genre`. Each field filter only applies to certain result types.
+        #
+        # The `artist` and `year` filters can be used while searching albums, artists and
+        # tracks. You can filter on a single `year` or a range (e.g. 1955-1960).<br /> The
+        # `album` filter can be used while searching albums and tracks.<br /> The `genre`
+        # filter can be used while searching artists and tracks.<br /> The `isrc` and
+        # `track` filters can be used while searching tracks.<br /> The `upc`, `tag:new`
+        # and `tag:hipster` filters can only be used while searching albums. The `tag:new`
+        # filter will return albums released in the past two weeks and `tag:hipster` can
+        # be used to return only albums with the lowest 10% popularity.<br />
+        q:,
+        # A comma-separated list of item types to search across. Search results include
+        # hits from all the specified item types. For example: `q=abacab&type=album,track`
+        # returns both albums and tracks matching "abacab".
+        type:,
+        # If `include_external=audio` is specified it signals that the client can play
+        # externally hosted audio content, and marks the content as playable in the
+        # response. By default externally hosted audio content is marked as unplayable in
+        # the response.
+        include_external: nil,
+        # The maximum number of results to return in each item type.
+        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 result to return. Use with limit to get the next page of
+        # search results.
+        offset: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            q: String,
+            type: T::Array[Spotted::SearchRetrieveParams::Type::OrSymbol],
+            include_external:
+              Spotted::SearchRetrieveParams::IncludeExternal::OrSymbol,
+            limit: Integer,
+            market: String,
+            offset: Integer,
+            request_options: Spotted::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module Type
+        extend Spotted::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Spotted::SearchRetrieveParams::Type) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        ALBUM = T.let(:album, Spotted::SearchRetrieveParams::Type::TaggedSymbol)
+        ARTIST =
+          T.let(:artist, Spotted::SearchRetrieveParams::Type::TaggedSymbol)
+        PLAYLIST =
+          T.let(:playlist, Spotted::SearchRetrieveParams::Type::TaggedSymbol)
+        TRACK = T.let(:track, Spotted::SearchRetrieveParams::Type::TaggedSymbol)
+        SHOW = T.let(:show, Spotted::SearchRetrieveParams::Type::TaggedSymbol)
+        EPISODE =
+          T.let(:episode, Spotted::SearchRetrieveParams::Type::TaggedSymbol)
+        AUDIOBOOK =
+          T.let(:audiobook, Spotted::SearchRetrieveParams::Type::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Spotted::SearchRetrieveParams::Type::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+
+      # If `include_external=audio` is specified it signals that the client can play
+      # externally hosted audio content, and marks the content as playable in the
+      # response. By default externally hosted audio content is marked as unplayable in
+      # the response.
+      module IncludeExternal
+        extend Spotted::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Spotted::SearchRetrieveParams::IncludeExternal)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        AUDIO =
+          T.let(
+            :audio,
+            Spotted::SearchRetrieveParams::IncludeExternal::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              Spotted::SearchRetrieveParams::IncludeExternal::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end