@wwdrew/expo-spotify-sdk 0.1.0

package/ios/SpotifySDK/SpotifyiOS.xcframework/ios-arm64/SpotifyiOS.framework/Headers/SPTAppRemote.h

@@ -0,0 +1,281 @@
+#import <Foundation/Foundation.h>
+
+@class SPTAppRemote;
+@class SPTAppRemoteConnectionParams;
+@class SPTConfiguration;
+
+@protocol SPTAppRemoteImageAPI;
+@protocol SPTAppRemotePlayerAPI;
+@protocol SPTAppRemoteUserAPI;
+@protocol SPTAppRemoteContentAPI;
+@protocol SPTAppRemoteConnectivityAPI;
+
+NS_ASSUME_NONNULL_BEGIN
+
+extern NSString * const SPTAppRemoteAccessTokenKey;
+extern NSString * const SPTAppRemoteErrorKey;
+extern NSString * const SPTAppRemoteErrorDescriptionKey;
+
+/// The severity of log messages that the App Remote should log to console.
+typedef NS_ENUM(NSUInteger, SPTAppRemoteLogLevel) {
+    /// Do not log at all.
+    SPTAppRemoteLogLevelNone  = 0,
+    /// Log debug, info and error messages.
+    SPTAppRemoteLogLevelDebug = 1,
+    /// Log info and error messages.
+    SPTAppRemoteLogLevelInfo  = 2,
+    /// Log only error messages.
+    SPTAppRemoteLogLevelError = 3,
+};
+
+/**
+ *  The `SPTAppRemoteDelegate` receives updates from the `SPTAppRemote` whenever something has
+ *  happened with the connection.
+ */
+@protocol SPTAppRemoteDelegate <NSObject>
+
+/**
+ *  Called when the App Remote has established connection with the Spotify app.
+ *
+ *  @param appRemote The transport that has connected.
+ */
+- (void)appRemoteDidEstablishConnection:(SPTAppRemote *)appRemote;
+
+/**
+ *  Called when the connection attempt made by the App Remote failed.
+ *
+ *  @param appRemote The App Remote that failed to connect.
+ *  @param error     The error that occurred.
+ */
+- (void)appRemote:(SPTAppRemote *)appRemote didFailConnectionAttemptWithError:(nullable NSError *)error;
+
+/**
+ *  Called when the App Remote has disconnected.
+ *
+ *  @note All APIs will be released by the App Remote at this point. The will no longer be usable,
+ *        and so you should release them as well.
+ *
+ *  @param appRemote The App Remote that disconnected.
+ *  @param error     The error that caused the disconnect, or `nil` if the disconnect was explicit.
+ */
+- (void)appRemote:(SPTAppRemote *)appRemote didDisconnectWithError:(nullable NSError *)error;
+
+@end
+
+/**
+ *  The `SPTAppRemote` is the main entry point for interacting with the Spotify app using the Spotify App Remote for iOS.
+ */
+@interface SPTAppRemote : NSObject
+
+#pragma mark Lifecycle
+
+/**
+ *  Convenience Initializer for a new App Remote instance
+ *
+ *  @param configuration The `SPTConfiguration` to use for client-id's and redirect URLs
+ *  @param logLevel The lowest severity to log to console.
+ *
+ *  @return A fresh new App Remote, ready to connect.
+ */
+- (instancetype)initWithConfiguration:(SPTConfiguration *)configuration logLevel:(SPTAppRemoteLogLevel)logLevel;
+
+/**
+ *  Designated Initializer for a new App Remote instance
+ *
+ *  @param configuration The `SPTConfiguration` to use for client-id's and redirect URLs
+ *  @param connectionParameters `SPTAppRemoteConnectionParams` for custom image sizes and types, and to hold the accessToken
+ *  @param logLevel The lowest severity to log to console.
+ *
+ *  @return A fresh new App Remote, ready to connect.
+ */
+- (instancetype)initWithConfiguration:(SPTConfiguration *)configuration
+                 connectionParameters:(SPTAppRemoteConnectionParams *)connectionParameters
+                             logLevel:(SPTAppRemoteLogLevel)logLevel NS_DESIGNATED_INITIALIZER;
+#pragma mark Class Methods
+
+/**
+ * Checks if the Spotify app is active on the user's device. You can use this to determine if maybe you should prompt
+ * the user to connect to Spotify (because you know they are already using Spotify if it is active). The Spotify app
+ * will be considered active if music is playing or the app is active in the background.
+ *
+ * @param completion Completion block for determining the result of the check. YES if Spotify is active, othewise NO.
+ */
++ (void)checkIfSpotifyAppIsActive:(void (^)(BOOL active))completion;
+
+/**
+ * Determine the current version of the Spotify App Remote
+ *
+ * @return The current version of the Spotify App Remote
+ */
++ (NSString *)appRemoteVersion;
+
+/**
+ * The Spotify app iTunes item identifier for use with `SKStoreProductViewController` for installing Spotify from the App Store.
+ *
+ * @return An `NSNumber` representing the Spotify iTunes item identifier to be used for the `SKStoreProductParameterITunesItemIdentifier` key
+ */
++ (NSNumber *)spotifyItunesItemIdentifier;
+
+#pragma mark Connection
+
+/**
+ * The parameters to use during connection.
+ */
+@property (nonatomic, strong, readonly) SPTAppRemoteConnectionParams *connectionParameters;
+
+/**
+ *  `YES` if the App Remote is connected to the Spotify application, otherwise `NO`.
+ *
+ *  @note Not KVO’able.
+ *
+ *  See The `SPTAppRemoteDelegate` in order to receive updates when the connection status changes.
+ */
+@property (nonatomic, assign, readonly, getter=isConnected) BOOL connected;
+
+/**
+ *  The delegate to notify for connection status changes and other events originating from the App Remote.
+ */
+@property (nonatomic, weak) id<SPTAppRemoteDelegate> delegate;
+
+/**
+ * Attempts to connect to the Spotify application.
+ *
+ * @discussion If the Spotify app is not running you will need to use authorizeAndPlayURI: to wake it up
+ */
+- (void)connect;
+
+/**
+ * Attempts to connect to the Spotify application with a given session identifier.
+ *
+ * @discussion If the Spotify app is not running you will need to use authorizeAndPlayURI: to wake it up.
+ *
+ * @discussion If `authorizeAndPlayURI` was used without a given session identifier, `connect` should be used instead of this method.
+ *
+ * @param sessionIdentifier The unique session identifier which was used when calling
+ * `authorizeAndPlayURI:asRadio:additionalScopes:sessionIdentifier:`
+ */
+- (void)connectWithSessionIdentifier:(NSUUID *)sessionIdentifier;
+
+/**
+ * Disconnect from the Spotify application
+ */
+- (void)disconnect;
+
+/**
+ * Open Spotify app to obtain access token and start playback.
+ * The passed URI will start playing unless Spotify is already playing.
+ *
+ * @param URI The URI to play. Use a blank string to attempt to play the user's last song
+ *
+ * @return `YES` if the Spotify app is installed and an authorization attempt can be made, otherwise `NO`.
+ * Note: The return `BOOL` here is not a measure of whether or not authentication succeeded, only a check if
+ * the Spotify app is installed and can attempt to handle the authorization request.
+ */
+- (BOOL)authorizeAndPlayURI:(NSString *)URI;
+
+/**
+ * Open Spotify app to obtain access token and start playback.
+ *
+ * @param playURI The URI to play. Use a blank string to attempt to play the user's last song
+ * @param asRadio `YES` to start radio for the given URI.
+ *
+ * @return `YES` if the Spotify app is installed and an authorization attempt can be made, otherwise `NO`.
+ * Note: The return `BOOL` here is not a measure of whether or not authentication succeeded, only a check if
+ * the Spotify app is installed and can attempt to handle the authorization request.
+ */
+- (BOOL)authorizeAndPlayURI:(NSString *)playURI asRadio:(BOOL)asRadio;
+
+/**
+* Open Spotify app to obtain access token and start playback.
+*
+* @param playURI The URI to play. Use a blank string to attempt to play the user's last song
+* @param asRadio `YES` to start radio for the given URI.
+* @param additionalScopes An array of scopes in addition to `app-remote-control`. Can be nil if you only need `app-remote-control`
+*
+* @return `YES` if the Spotify app is installed and an authorization attempt can be made, otherwise `NO`.
+* Note: The return `BOOL` here is not a measure of whether or not authentication succeeded, only a check if
+* the Spotify app is installed and can attempt to handle the authorization request.
+*/
+- (BOOL)authorizeAndPlayURI:(NSString *)playURI
+                    asRadio:(BOOL)asRadio
+           additionalScopes:(nullable NSArray<NSString *> *)additionalScopes;
+
+/**
+ * Open Spotify app to obtain access token and start playback.
+ *
+ * @param playURI The URI to play. Use a blank string to attempt to play the user's last song
+ * @param asRadio `YES` to start radio for the given URI.
+ * @param additionalScopes An array of scopes in addition to `app-remote-control`. Can be nil if you only need `app-remote-control`
+ * @param sessionIdentifier An optional unique identifier for this specific session, which is used for analytics purposes. Every new attempt to
+ * connect to the Spotify app should have a new identifier, but the identifier used here should then be reused for the accompanied call to
+ * `connectWithSessionIdentifier:`.
+ *
+ * @return `YES` if the Spotify app is installed and an authorization attempt can be made, otherwise `NO`.
+ * Note: The return `BOOL` here is not a measure of whether or not authentication succeeded, only a check if
+ * the Spotify app is installed and can attempt to handle the authorization request.
+*/
+- (BOOL)authorizeAndPlayURI:(NSString *)playURI
+                    asRadio:(BOOL)asRadio
+           additionalScopes:(nullable NSArray<NSString *> *)additionalScopes
+          sessionIdentifier:(nullable NSUUID *)sessionIdentifier;
+/**
+ * Parse out an access token or error description from a url passed to application:openURL:options:
+ *
+ * @param url The URL returned from the Spotify app after calling authorizeAndPlayURI
+ *
+ * @return A dictionary containing the access token or error description from the provided URL.
+ * Will return nil if the URL Scheme does not match the redirect URI provided.
+ * Use `SPTAppRemoteAccessTokenKey` and `SPTAppRemoteErrorDescriptionKey` to get the appropriate values.
+ */
+- (nullable NSDictionary<NSString *, NSString *> *)authorizationParametersFromURL:(NSURL *)url;
+
+#pragma mark APIs
+
+/**
+ *  The API used to control the Spotify player.
+ *
+ *  @note Will only be populated when the App Remote is connected. If you retain this object you must release it on
+ *        disconnect.
+ */
+@property (nullable, nonatomic, strong, readonly) id<SPTAppRemotePlayerAPI> playerAPI;
+
+/**
+ *  The API used to fetch images from the Spotify app.
+ *
+ *  @note Will only be populated when the App Remote is connected. If you retain this object you must release it on
+ *        disconnect.
+ */
+@property (nullable, nonatomic, strong, readonly) id<SPTAppRemoteImageAPI> imageAPI;
+
+/**
+ *  The API used to fetch user data from the Spotify app.
+ *
+ *  @note Will only be populated when the App Remote is connected. If you retain this object you must release it on
+ *        disconnect.
+ */
+@property (nullable, nonatomic, strong, readonly) id<SPTAppRemoteUserAPI> userAPI;
+
+/**
+ *  The API used to fetch content from the Spotify app.
+ *
+ *  @note Will only be populated when the App Remote is connected. If you retain this object you must release it on
+ *        disconnect.
+ */
+@property (nullable, nonatomic, strong, readonly) id<SPTAppRemoteContentAPI> contentAPI;
+
+/**
+ *  The API used to get connectivity data from the Spotify app.
+ *
+ *  @note Will only be populated when the App Remote is connected. If you retain this object you must release it on
+ *        disconnect.
+ */
+@property (nullable, nonatomic, strong, readonly) id<SPTAppRemoteConnectivityAPI> connectivityAPI;
+
+#pragma mark Unavailable initializers
+
+- (instancetype)init NS_UNAVAILABLE;
++ (instancetype)new NS_UNAVAILABLE;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/SpotifySDK/SpotifyiOS.xcframework/ios-arm64/SpotifyiOS.framework/Headers/SPTAppRemoteAlbum.h

@@ -0,0 +1,18 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ *  The `SPTAppRemoteAlbum` represents an Album entity.
+ */
+@protocol SPTAppRemoteAlbum <NSObject>
+
+/// The name of the album.
+@property (nonatomic, copy, readonly) NSString *name;
+
+/// The URI of the album.
+@property (nonatomic, copy, readonly) NSString *URI;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/SpotifySDK/SpotifyiOS.xcframework/ios-arm64/SpotifyiOS.framework/Headers/SPTAppRemoteArtist.h

@@ -0,0 +1,18 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ *  The `SPTAppRemoteArtist` represents an artist.
+ */
+@protocol SPTAppRemoteArtist <NSObject>
+
+/// The name of the artist.
+@property (nonatomic, copy, readonly) NSString *name;
+
+/// The URI of the artist.
+@property (nonatomic, copy, readonly) NSString *URI;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/SpotifySDK/SpotifyiOS.xcframework/ios-arm64/SpotifyiOS.framework/Headers/SPTAppRemoteCommon.h

@@ -0,0 +1,36 @@
+/**
+ * Common header definitions
+ */
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// The error domain for user facing errors that occur in the App Remote.
+extern NSString * const SPTAppRemoteErrorDomain;
+
+/// The error codes in the `SPTAppRemoteErrorDomain` domain.
+typedef NS_ENUM(NSInteger, SPTAppRemoteErrorCode) {
+    /// An unknown error.
+    SPTAppRemoteUnknownError                 =    -1,
+
+    /// The background wakeup of the Spotify app failed.
+    SPTAppRemoteBackgroundWakeupFailedError  = -1000,
+    /// The connection attempt to the Spotify app failed.
+    SPTAppRemoteConnectionAttemptFailedError = -1001,
+    /// The conncetion to the Spotify app was terminated.
+    SPTAppRemoteConnectionTerminatedError    = -1002,
+    /// The arguments supplied are invalid.
+    SPTAppRemoteInvalidArgumentsError        = -2000,
+    /// The request has failed for some reason.
+    SPTAppRemoteRequestFailedError           = -2001,
+};
+
+/**
+ *  A callback block used by many App Remote API methods.
+ *
+ *  @param result The result of the operation, or `nil` if the operation failed.
+ *  @param error  An error object, or `nil` if the operation was a success.
+ */
+typedef void (^SPTAppRemoteCallback)(id _Nullable result, NSError * _Nullable error);
+
+NS_ASSUME_NONNULL_END
+

package/ios/SpotifySDK/SpotifyiOS.xcframework/ios-arm64/SpotifyiOS.framework/Headers/SPTAppRemoteConnectionParams.h

@@ -0,0 +1,65 @@
+#import <Foundation/Foundation.h>
+
+/// Available image formats to receive from the Spotify app.
+typedef NS_ENUM(NSUInteger, SPTAppRemoteConnectionParamsImageFormat) {
+    /// Any image format is acceptable. Use this if you don't care about which image format is sent.
+    SPTAppRemoteConnectionParamsImageFormatAny = 0,
+    /// JPEG image format.
+    SPTAppRemoteConnectionParamsImageFormatJPEG,
+    /// PNG image format.
+    SPTAppRemoteConnectionParamsImageFormatPNG,
+};
+
+struct CGSize;
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * The `SPTAppRemoteconnectionParams` represents connection parameters required in order to initiate a connection
+ * with the Spotify app.
+ */
+@interface SPTAppRemoteConnectionParams : NSObject
+
+/// The access token used to authorize the user with the Spotify app.
+@property (nonatomic, copy, readwrite, nullable) NSString *accessToken;
+
+/// The desired size of received images. (0,0) acts as a wildcard and accepts any size.
+@property (nonatomic, assign, readonly) struct CGSize defaultImageSize;
+
+/// The desired image format of received images.
+@property (nonatomic, assign, readonly) SPTAppRemoteConnectionParamsImageFormat imageFormat;
+
+/**
+ *  Initialize a set of new connection parameters.
+ *
+ *  @discussion This is the designated initializer.
+ *
+ *  @param accessToken      The access token obtained after authentication.
+ *  @param defaultImageSize The desired size of received images. (0,0) acts as a wildcard and accepts any size.
+ *  @param imageFormat      The desired image format of received images.
+ *
+ *  @return A set of connection parameters ready to be used when initiating a connection to the Spotify app.
+ */
+- (instancetype)initWithAccessToken:(nullable NSString *)accessToken
+                   defaultImageSize:(struct CGSize)defaultImageSize
+                        imageFormat:(SPTAppRemoteConnectionParamsImageFormat)imageFormat NS_DESIGNATED_INITIALIZER;
+
+#pragma mark Static properties
+
+/// Version of the protocol
+@property (nonatomic, assign, readonly) NSInteger protocolVersion;
+
+/// Roles
+@property (nonatomic, copy, readonly) NSDictionary *roles;
+
+/// Authentication methods supported
+@property (nonatomic, copy, readonly) NSArray *authenticationMethods;
+
+#pragma mark Unavailable initializers
+
+- (instancetype)init NS_UNAVAILABLE;
++ (instancetype)new NS_UNAVAILABLE;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/SpotifySDK/SpotifyiOS.xcframework/ios-arm64/SpotifyiOS.framework/Headers/SPTAppRemoteConnectivityAPI.h

@@ -0,0 +1,54 @@
+#import <Foundation/Foundation.h>
+
+#import "SPTAppRemoteCommon.h"
+
+@protocol SPTAppRemoteConnectivityAPI;
+@protocol SPTAppRemoteConnectivityState;
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * The `SPTAppRemoteConnectivityAPIDelegate` gets notified whenever the connectivity API receives new data from subscription events.
+ */
+@protocol SPTAppRemoteConnectivityAPIDelegate <NSObject>
+
+/**
+ * Called when the connectivity state has been updated.
+ *
+ * @param connectivityAPI The API that received updates.
+ * @param connectivityState The new connectivity state received.
+ */
+- (void)connectivityAPI:(id<SPTAppRemoteConnectivityAPI>)connectivityAPI didReceiveNewConnectivityState:(id<SPTAppRemoteConnectivityState>)connectivityState;
+
+@end
+
+/**
+ The @c SPTAppRemoteConnectivityAPI class is used to get connectivity data from the Spotify app.
+ */
+@protocol SPTAppRemoteConnectivityAPI <NSObject>
+
+/// The delegate receiving player state updates
+@property (nonatomic, weak) id<SPTAppRemoteConnectivityAPIDelegate> delegate;
+
+/**
+ * Subscribes to connection state changes from the Spotify app.
+ *
+ * @note Implement `SPTAppRemoteConnectivityAPIDelegate` and set yourself as delegate in order to be notified when the
+ *       the connection state changes.
+ *
+ * @param callback On success `result` will be `YES`
+ *                 On error `result` will be `nil` and error set
+ */
+- (void)subscribeToConnectivityState:(nullable SPTAppRemoteCallback)callback;
+
+/**
+ * Stops subscribing to connection state changes from the Spotify app.
+ *
+ * @param callback On success `result` will be `YES`
+ *                 On error `result` will be `nil` and error set
+ */
+- (void)unsubscribeToConnectivityState:(nullable SPTAppRemoteCallback)callback;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/SpotifySDK/SpotifyiOS.xcframework/ios-arm64/SpotifyiOS.framework/Headers/SPTAppRemoteConnectivityState.h

@@ -0,0 +1,15 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ The @c SPTAppRemoteConnectivityState class represents the online/offline state of the Spotify app.
+ */
+@protocol SPTAppRemoteConnectivityState <NSObject>
+
+/// Whether the Spotify app is offline or not.
+@property (nonatomic, readonly, getter=isOffline) BOOL offline;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/SpotifySDK/SpotifyiOS.xcframework/ios-arm64/SpotifyiOS.framework/Headers/SPTAppRemoteContentAPI.h

@@ -0,0 +1,76 @@
+#import <Foundation/Foundation.h>
+#import "SPTAppRemoteCommon.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// A type representing different lists of content.
+typedef NSString * const SPTAppRemoteContentType;
+
+extern NSString * const SPTAppRemoteContentTypeDefault;
+extern NSString * const SPTAppRemoteContentTypeNavigation;
+extern NSString * const SPTAppRemoteContentTypeFitness;
+extern NSString * const SPTAppRemoteContentTypeGaming;
+
+@protocol SPTAppRemoteContentItem;
+
+/**
+ * The `SPTAppRemoteContentAPI` is used to access content from the Spotify application.
+ */
+@protocol SPTAppRemoteContentAPI <NSObject>
+
+/**
+ * Fetches the root level of content items for the current user.
+ *
+ * @note The content returned is based on the users' home feeds, and as such may vary
+ *       between different users. If the user has no network connection or Spotify is
+ *       forced offline, this method will return the user's offline content, if any.
+ *
+ *       Deprecated. Use fetchRecommendedContentItemsForType:flattenContainers:callback: instead.
+ *
+ * @param contentType A type that is used to retrieve content for a specific use-case.
+ * @param callback The callback to be called once the request is completed.
+ */
+- (void)fetchRootContentItemsForType:(SPTAppRemoteContentType)contentType
+                            callback:(nullable SPTAppRemoteCallback)callback DEPRECATED_MSG_ATTRIBUTE("Deprecated. Use fetchRecommendedContentItemsForType:flattenContainers:callback: instead.");
+
+/**
+ * Fetches the children items for the provided content item.
+ *
+ * @note The `isContainer` property of the `SPTAppRemoteContentItem`
+ *       indicates whether or not the item has any children.
+ *
+ * @param contentItem The content item to fetch the children for.
+ * @param callback The callback to be called once the request is completed.
+ */
+- (void)fetchChildrenOfContentItem:(id<SPTAppRemoteContentItem>)contentItem
+                          callback:(nullable SPTAppRemoteCallback)callback;
+
+/**
+ * Fetches a list of recommended playlists for the current user.
+ *
+ * @note The playlists returned are a mix of the user's recently played feed
+ *       as well as personal recommendations, and as such may vary between users. If the
+ *       user is offline, this method will only return the content that is available offline, if any.
+ * @note This method is only supported by Spotify clients running version 8.4.75 and above
+ *       and will fail with an `SPTAppRemoteWAMPClientNotSupportedError` otherwise.
+ *
+ * @param contentType A type that is used to retrieve content for a specific use-case.
+ * @param flattenContainers Whether or not the recommendations should be flattened into a single list or remain
+ *                          separated in containers.
+ * @param callback The callback to be called once the request is completed.
+ */
+- (void)fetchRecommendedContentItemsForType:(SPTAppRemoteContentType)contentType
+                          flattenContainers:(BOOL)flattenContainers
+                                   callback:(nullable SPTAppRemoteCallback)callback;
+
+/**
+ Fetches the content item for the provided URI.
+
+ @param URI A Spotify URI as string
+ @param callback The callback to be called once the request is completed.
+ */
+- (void)fetchContentItemForURI:(NSString *)URI callback:(nullable SPTAppRemoteCallback)callback;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/SpotifySDK/SpotifyiOS.xcframework/ios-arm64/SpotifyiOS.framework/Headers/SPTAppRemoteContentItem.h

@@ -0,0 +1,46 @@
+#import <Foundation/Foundation.h>
+#import "SPTAppRemoteImageRepresentable.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * The `SPTAppRemoteContentItem` protocol represents a track or a collection of tracks. Use the `isContainer` instance method
+ * to determine if the content item is a collection of tracks for which to grab children from.
+ */
+@protocol SPTAppRemoteContentItem <NSObject, SPTAppRemoteImageRepresentable>
+
+/// The primary title of the item.
+@property (nonatomic, copy, readonly, nullable) NSString *title;
+
+/// The secondary title of the item.
+@property (nonatomic, copy, readonly, nullable) NSString *subtitle;
+
+/// The description of the item.
+@property (nonatomic, copy, readonly, nullable) NSString *contentDescription;
+
+/// The unique identifier of the item.
+@property (nonatomic, copy, readonly) NSString *identifier;
+
+/// The playback URI of this item.
+@property (nonatomic, copy, readonly) NSString *URI;
+
+/// `YES` if the item is available offline, or if it has any child that is available offline, otherwise `NO`.
+@property (nonatomic, assign, readonly, getter=isAvailableOffline) BOOL availableOffline;
+
+/// Returns `YES` if the item is directly playable, otherwise `NO`.
+@property (nonatomic, assign, readonly, getter=isPlayable) BOOL playable;
+
+/// Returns `YES` if the item is expected to contain children, otherwise `NO`.
+@property (nonatomic, assign, readonly, getter=isContainer) BOOL container;
+
+/**
+ A list of the content item's children.
+
+ @note This is not populated for all container items as some of them are fetched
+       lazily with the `fetchChildrenOfContentItem:callback:` method.
+ */
+@property (nonatomic, strong, readonly, nullable) NSArray<id<SPTAppRemoteContentItem>> *children;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/SpotifySDK/SpotifyiOS.xcframework/ios-arm64/SpotifyiOS.framework/Headers/SPTAppRemoteCrossfadeState.h

@@ -0,0 +1,18 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ *  The `SPTAppRemoteCrossfadeState` represents the state of crossfade.
+ */
+@protocol SPTAppRemoteCrossfadeState <NSObject>
+
+/// The on/off state of crossfade.
+@property (nonatomic, readonly, getter=isEnabled) BOOL enabled;
+
+/// The duration of crossfade in milliseconds. The value is meaningless if crossfade is not enabled.
+@property (nonatomic, readonly) NSInteger duration;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/SpotifySDK/SpotifyiOS.xcframework/ios-arm64/SpotifyiOS.framework/Headers/SPTAppRemoteImageAPI.h

@@ -0,0 +1,25 @@
+#import <UIKit/UIKit.h>
+
+#import "SPTAppRemoteCommon.h"
+#import "SPTAppRemoteImageRepresentable.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * API for fetching image data from the Spotify app
+ */
+@protocol SPTAppRemoteImageAPI <NSObject>
+
+/**
+ * Fetch an image with the given ID from the Spotify app.
+ *
+ * @param imageRepresentable  The item containing the ID of the image to fetch.
+ * @param imageSize  The size of the image to fetch.
+ * @param callback On success `result` will be an instance of `UIImage`
+ *                 On error `result` will be nil and error set
+ */
+- (void)fetchImageForItem:(id<SPTAppRemoteImageRepresentable>)imageRepresentable withSize:(CGSize)imageSize callback:(nullable SPTAppRemoteCallback)callback;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/SpotifySDK/SpotifyiOS.xcframework/ios-arm64/SpotifyiOS.framework/Headers/SPTAppRemoteImageRepresentable.h

@@ -0,0 +1,16 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * The `SPTImageRepresentable` protocol represents an object that may contain an image.
+ * If something conforms to this protocol you can pass it to `SPTAppRemoteImageAPI` fetchImageForItem: method.
+ */
+@protocol SPTAppRemoteImageRepresentable <NSObject>
+
+/// The identifier of the image of the entity.
+@property (nonatomic, strong, readonly) NSString *imageIdentifier;
+
+@end
+
+NS_ASSUME_NONNULL_END