spotted 0.1.0

data/rbi/spotted/models/me/track_list_params.rbi

@@ -0,0 +1,88 @@
+# typed: strong
+
+module Spotted
+  module Models
+    module Me
+      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::Me::TrackListParams, 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
+end

data/rbi/spotted/models/me/track_list_response.rbi

@@ -0,0 +1,58 @@
+# typed: strong
+
+module Spotted
+  module Models
+    module Me
+      class TrackListResponse < Spotted::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Spotted::Models::Me::TrackListResponse,
+              Spotted::Internal::AnyHash
+            )
+          end
+
+        # The date and time the track was saved. Timestamps are returned in ISO 8601
+        # format as Coordinated Universal Time (UTC) with a zero offset:
+        # YYYY-MM-DDTHH:MM:SSZ. If the time is imprecise (for example, the date/time of an
+        # album release), an additional field indicates the precision; see for example,
+        # release_date in an album object.
+        sig { returns(T.nilable(Time)) }
+        attr_reader :added_at
+
+        sig { params(added_at: Time).void }
+        attr_writer :added_at
+
+        # Information about the track.
+        sig { returns(T.nilable(Spotted::TrackObject)) }
+        attr_reader :track
+
+        sig { params(track: Spotted::TrackObject::OrHash).void }
+        attr_writer :track
+
+        sig do
+          params(added_at: Time, track: Spotted::TrackObject::OrHash).returns(
+            T.attached_class
+          )
+        end
+        def self.new(
+          # The date and time the track was saved. Timestamps are returned in ISO 8601
+          # format as Coordinated Universal Time (UTC) with a zero offset:
+          # YYYY-MM-DDTHH:MM:SSZ. If the time is imprecise (for example, the date/time of an
+          # album release), an additional field indicates the precision; see for example,
+          # release_date in an album object.
+          added_at: nil,
+          # Information about the track.
+          track: nil
+        )
+        end
+
+        sig do
+          override.returns({ added_at: Time, track: Spotted::TrackObject })
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/spotted/models/me/track_remove_params.rbi

@@ -0,0 +1,56 @@
+# typed: strong
+
+module Spotted
+  module Models
+    module Me
+      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::Me::TrackRemoveParams, Spotted::Internal::AnyHash)
+          end
+
+        # A JSON array of the
+        # [Spotify IDs](/documentation/web-api/concepts/spotify-uris-ids). For example:
+        # `["4iV5W9uYEdYUVa79Axb7Rh", "1301WleyT98MSxVHPZCA6M"]`<br/>A maximum of 50 items
+        # can be specified in one request. _**Note**: if the `ids` parameter is present in
+        # the query string, any IDs listed here in the body will be ignored._
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_reader :body_ids
+
+        sig { params(body_ids: T::Array[String]).void }
+        attr_writer :body_ids
+
+        sig do
+          params(
+            body_ids: T::Array[String],
+            request_options: Spotted::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # A JSON array of the
+          # [Spotify IDs](/documentation/web-api/concepts/spotify-uris-ids). For example:
+          # `["4iV5W9uYEdYUVa79Axb7Rh", "1301WleyT98MSxVHPZCA6M"]`<br/>A maximum of 50 items
+          # can be specified in one request. _**Note**: if the `ids` parameter is present in
+          # the query string, any IDs listed here in the body will be ignored._
+          body_ids: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              body_ids: T::Array[String],
+              request_options: Spotted::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/spotted/models/me/track_save_params.rbi

@@ -0,0 +1,130 @@
+# typed: strong
+
+module Spotted
+  module Models
+    module Me
+      class TrackSaveParams < Spotted::Internal::Type::BaseModel
+        extend Spotted::Internal::Type::RequestParameters::Converter
+        include Spotted::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(Spotted::Me::TrackSaveParams, Spotted::Internal::AnyHash)
+          end
+
+        # A JSON array of the
+        # [Spotify IDs](/documentation/web-api/concepts/spotify-uris-ids). For example:
+        # `["4iV5W9uYEdYUVa79Axb7Rh", "1301WleyT98MSxVHPZCA6M"]`<br/>A maximum of 50 items
+        # can be specified in one request. _**Note**: if the `timestamped_ids` is present
+        # in the body, any IDs listed in the query parameters (deprecated) or the `ids`
+        # field in the body will be ignored._
+        sig { returns(T::Array[String]) }
+        attr_accessor :ids
+
+        # A JSON array of objects containing track IDs with their corresponding
+        # timestamps. Each object must include a track ID and an `added_at` timestamp.
+        # This allows you to specify when tracks were added to maintain a specific
+        # chronological order in the user's library.<br/>A maximum of 50 items can be
+        # specified in one request. _**Note**: if the `timestamped_ids` is present in the
+        # body, any IDs listed in the query parameters (deprecated) or the `ids` field in
+        # the body will be ignored._
+        sig do
+          returns(
+            T.nilable(T::Array[Spotted::Me::TrackSaveParams::TimestampedID])
+          )
+        end
+        attr_reader :timestamped_ids
+
+        sig do
+          params(
+            timestamped_ids:
+              T::Array[Spotted::Me::TrackSaveParams::TimestampedID::OrHash]
+          ).void
+        end
+        attr_writer :timestamped_ids
+
+        sig do
+          params(
+            ids: T::Array[String],
+            timestamped_ids:
+              T::Array[Spotted::Me::TrackSaveParams::TimestampedID::OrHash],
+            request_options: Spotted::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # A JSON array of the
+          # [Spotify IDs](/documentation/web-api/concepts/spotify-uris-ids). For example:
+          # `["4iV5W9uYEdYUVa79Axb7Rh", "1301WleyT98MSxVHPZCA6M"]`<br/>A maximum of 50 items
+          # can be specified in one request. _**Note**: if the `timestamped_ids` is present
+          # in the body, any IDs listed in the query parameters (deprecated) or the `ids`
+          # field in the body will be ignored._
+          ids:,
+          # A JSON array of objects containing track IDs with their corresponding
+          # timestamps. Each object must include a track ID and an `added_at` timestamp.
+          # This allows you to specify when tracks were added to maintain a specific
+          # chronological order in the user's library.<br/>A maximum of 50 items can be
+          # specified in one request. _**Note**: if the `timestamped_ids` is present in the
+          # body, any IDs listed in the query parameters (deprecated) or the `ids` field in
+          # the body will be ignored._
+          timestamped_ids: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              ids: T::Array[String],
+              timestamped_ids:
+                T::Array[Spotted::Me::TrackSaveParams::TimestampedID],
+              request_options: Spotted::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class TimestampedID < Spotted::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Spotted::Me::TrackSaveParams::TimestampedID,
+                Spotted::Internal::AnyHash
+              )
+            end
+
+          # The [Spotify ID](/documentation/web-api/concepts/spotify-uris-ids) for the
+          # track.
+          sig { returns(String) }
+          attr_accessor :id
+
+          # The timestamp when the track was added to the library. Use ISO 8601 format with
+          # UTC timezone (e.g., `2023-01-15T14:30:00Z`). You can specify past timestamps to
+          # insert tracks at specific positions in the library's chronological order. The
+          # API uses minute-level granularity for ordering, though the timestamp supports
+          # millisecond precision.
+          sig { returns(Time) }
+          attr_accessor :added_at
+
+          sig { params(id: String, added_at: Time).returns(T.attached_class) }
+          def self.new(
+            # The [Spotify ID](/documentation/web-api/concepts/spotify-uris-ids) for the
+            # track.
+            id:,
+            # The timestamp when the track was added to the library. Use ISO 8601 format with
+            # UTC timezone (e.g., `2023-01-15T14:30:00Z`). You can specify past timestamps to
+            # insert tracks at specific positions in the library's chronological order. The
+            # API uses minute-level granularity for ordering, though the timestamp supports
+            # millisecond precision.
+            added_at:
+          )
+          end
+
+          sig { override.returns({ id: String, added_at: Time }) }
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/spotted/models/me_retrieve_params.rbi

@@ -0,0 +1,27 @@
+# typed: strong
+
+module Spotted
+  module Models
+    class MeRetrieveParams < Spotted::Internal::Type::BaseModel
+      extend Spotted::Internal::Type::RequestParameters::Converter
+      include Spotted::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Spotted::MeRetrieveParams, 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/me_retrieve_response.rbi

@@ -0,0 +1,257 @@
+# typed: strong
+
+module Spotted
+  module Models
+    class MeRetrieveResponse < Spotted::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Spotted::Models::MeRetrieveResponse, Spotted::Internal::AnyHash)
+        end
+
+      # The [Spotify user ID](/documentation/web-api/concepts/spotify-uris-ids) for the
+      # user.
+      sig { returns(T.nilable(String)) }
+      attr_reader :id
+
+      sig { params(id: String).void }
+      attr_writer :id
+
+      # The country of the user, as set in the user's account profile. An
+      # [ISO 3166-1 alpha-2 country code](http://en.wikipedia.org/wiki/ISO_3166-1_alpha-2).
+      # _This field is only available when the current user has granted access to the
+      # [user-read-private](/documentation/web-api/concepts/scopes/#list-of-scopes)
+      # scope._
+      sig { returns(T.nilable(String)) }
+      attr_reader :country
+
+      sig { params(country: String).void }
+      attr_writer :country
+
+      # The name displayed on the user's profile. `null` if not available.
+      sig { returns(T.nilable(String)) }
+      attr_reader :display_name
+
+      sig { params(display_name: String).void }
+      attr_writer :display_name
+
+      # The user's email address, as entered by the user when creating their account.
+      # _**Important!** This email address is unverified; there is no proof that it
+      # actually belongs to the user._ _This field is only available when the current
+      # user has granted access to the
+      # [user-read-email](/documentation/web-api/concepts/scopes/#list-of-scopes)
+      # scope._
+      sig { returns(T.nilable(String)) }
+      attr_reader :email
+
+      sig { params(email: String).void }
+      attr_writer :email
+
+      # The user's explicit content settings. _This field is only available when the
+      # current user has granted access to the
+      # [user-read-private](/documentation/web-api/concepts/scopes/#list-of-scopes)
+      # scope._
+      sig do
+        returns(T.nilable(Spotted::Models::MeRetrieveResponse::ExplicitContent))
+      end
+      attr_reader :explicit_content
+
+      sig do
+        params(
+          explicit_content:
+            Spotted::Models::MeRetrieveResponse::ExplicitContent::OrHash
+        ).void
+      end
+      attr_writer :explicit_content
+
+      # Known 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 the 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 user's Spotify subscription level: "premium", "free", etc. (The subscription
+      # level "open" can be considered the same as "free".) _This field is only
+      # available when the current user has granted access to the
+      # [user-read-private](/documentation/web-api/concepts/scopes/#list-of-scopes)
+      # scope._
+      sig { returns(T.nilable(String)) }
+      attr_reader :product
+
+      sig { params(product: String).void }
+      attr_writer :product
+
+      # The object type: "user"
+      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
+      # user.
+      sig { returns(T.nilable(String)) }
+      attr_reader :uri
+
+      sig { params(uri: String).void }
+      attr_writer :uri
+
+      sig do
+        params(
+          id: String,
+          country: String,
+          display_name: String,
+          email: String,
+          explicit_content:
+            Spotted::Models::MeRetrieveResponse::ExplicitContent::OrHash,
+          external_urls: Spotted::ExternalURLObject::OrHash,
+          followers: Spotted::FollowersObject::OrHash,
+          href: String,
+          images: T::Array[Spotted::ImageObject::OrHash],
+          product: String,
+          type: String,
+          uri: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The [Spotify user ID](/documentation/web-api/concepts/spotify-uris-ids) for the
+        # user.
+        id: nil,
+        # The country of the user, as set in the user's account profile. An
+        # [ISO 3166-1 alpha-2 country code](http://en.wikipedia.org/wiki/ISO_3166-1_alpha-2).
+        # _This field is only available when the current user has granted access to the
+        # [user-read-private](/documentation/web-api/concepts/scopes/#list-of-scopes)
+        # scope._
+        country: nil,
+        # The name displayed on the user's profile. `null` if not available.
+        display_name: nil,
+        # The user's email address, as entered by the user when creating their account.
+        # _**Important!** This email address is unverified; there is no proof that it
+        # actually belongs to the user._ _This field is only available when the current
+        # user has granted access to the
+        # [user-read-email](/documentation/web-api/concepts/scopes/#list-of-scopes)
+        # scope._
+        email: nil,
+        # The user's explicit content settings. _This field is only available when the
+        # current user has granted access to the
+        # [user-read-private](/documentation/web-api/concepts/scopes/#list-of-scopes)
+        # scope._
+        explicit_content: nil,
+        # Known external URLs for this user.
+        external_urls: nil,
+        # Information about the followers of the user.
+        followers: nil,
+        # A link to the Web API endpoint for this user.
+        href: nil,
+        # The user's profile image.
+        images: nil,
+        # The user's Spotify subscription level: "premium", "free", etc. (The subscription
+        # level "open" can be considered the same as "free".) _This field is only
+        # available when the current user has granted access to the
+        # [user-read-private](/documentation/web-api/concepts/scopes/#list-of-scopes)
+        # scope._
+        product: nil,
+        # The object type: "user"
+        type: nil,
+        # The [Spotify URI](/documentation/web-api/concepts/spotify-uris-ids) for the
+        # user.
+        uri: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            country: String,
+            display_name: String,
+            email: String,
+            explicit_content:
+              Spotted::Models::MeRetrieveResponse::ExplicitContent,
+            external_urls: Spotted::ExternalURLObject,
+            followers: Spotted::FollowersObject,
+            href: String,
+            images: T::Array[Spotted::ImageObject],
+            product: String,
+            type: String,
+            uri: String
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class ExplicitContent < Spotted::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Spotted::Models::MeRetrieveResponse::ExplicitContent,
+              Spotted::Internal::AnyHash
+            )
+          end
+
+        # When `true`, indicates that explicit content should not be played.
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :filter_enabled
+
+        sig { params(filter_enabled: T::Boolean).void }
+        attr_writer :filter_enabled
+
+        # When `true`, indicates that the explicit content setting is locked and can't be
+        # changed by the user.
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :filter_locked
+
+        sig { params(filter_locked: T::Boolean).void }
+        attr_writer :filter_locked
+
+        # The user's explicit content settings. _This field is only available when the
+        # current user has granted access to the
+        # [user-read-private](/documentation/web-api/concepts/scopes/#list-of-scopes)
+        # scope._
+        sig do
+          params(filter_enabled: T::Boolean, filter_locked: T::Boolean).returns(
+            T.attached_class
+          )
+        end
+        def self.new(
+          # When `true`, indicates that explicit content should not be played.
+          filter_enabled: nil,
+          # When `true`, indicates that the explicit content setting is locked and can't be
+          # changed by the user.
+          filter_locked: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            { filter_enabled: T::Boolean, filter_locked: T::Boolean }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/spotted/models/narrator_object.rbi

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