@wwdrew/expo-spotify-sdk 0.1.0

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

@@ -0,0 +1,19 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ *  The `SPTAppRemoteLibraryState` represents a the state of an album or track in a users Spotify library.
+ */
+@protocol SPTAppRemoteLibraryState <NSObject>
+
+/// The uri of the track or album
+@property (nonatomic, strong, readonly) NSString *uri;
+/// `YES` album or track was added to the user's library, otherwise `NO`.
+@property (nonatomic, assign, readonly) BOOL isAdded;
+/// `YES` album or track can be added to the user's library, otherwise `NO`.
+@property (nonatomic, assign, readonly) BOOL canAdd;
+
+@end
+
+NS_ASSUME_NONNULL_END

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

@@ -0,0 +1,32 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// The available repeat modes.
+typedef NS_ENUM(NSUInteger, SPTAppRemotePlaybackOptionsRepeatMode) {
+    /// Repeat is off.
+    SPTAppRemotePlaybackOptionsRepeatModeOff = 0,
+
+    /// Repeats the current track.
+    SPTAppRemotePlaybackOptionsRepeatModeTrack = 1,
+
+    /// Repeats the current context.
+    SPTAppRemotePlaybackOptionsRepeatModeContext = 2,
+};
+
+/**
+ *  The `SPTAppRemotePlaybackOptions` describes a set of options used for the current playback.
+ *
+ *  @discussion Use these to determine UI states.
+ */
+@protocol SPTAppRemotePlaybackOptions <NSObject>
+
+/// `YES` if shuffle is enabled, otherwise `NO`.
+@property (nonatomic, readonly) BOOL isShuffling;
+
+/// The current repeat mode in effect.
+@property (nonatomic, readonly) SPTAppRemotePlaybackOptionsRepeatMode repeatMode;
+
+@end
+
+NS_ASSUME_NONNULL_END

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

@@ -0,0 +1,32 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ *  The `SPTAppRemotePlaybackRestrictions` describes a set of restrictions for playback in the Spotify client.
+ *
+ *  @discussion Use these to determine whether to enable or disable certain actions in the UI.
+ */
+@protocol SPTAppRemotePlaybackRestrictions <NSObject>
+
+/// `YES` if the user can skip to the next track, otherwise `NO`.
+@property (nonatomic, readonly) BOOL canSkipNext;
+
+/// `YES` if the user can skip to the previous track, otherwise `NO`.
+@property (nonatomic, readonly) BOOL canSkipPrevious;
+
+/// `YES` if the user can repeat the current track, otherwise `NO`.
+@property (nonatomic, readonly) BOOL canRepeatTrack;
+
+/// `YES` if the user can repeat the current context, otherwise `NO`.
+@property (nonatomic, readonly) BOOL canRepeatContext;
+
+/// `YES` if the user can toggle shuffle, otherwise `NO`.
+@property (nonatomic, readonly) BOOL canToggleShuffle;
+
+/// `YES` if the user can seek to specific positions, otherwise `NO`.
+@property (nonatomic, readonly) BOOL canSeek;
+
+@end
+
+NS_ASSUME_NONNULL_END

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

@@ -0,0 +1,262 @@
+#import <Foundation/Foundation.h>
+
+#import "SPTAppRemoteCommon.h"
+#import "SPTAppRemotePlaybackOptions.h"
+
+@protocol SPTAppRemotePlayerState, SPTAppRemoteContentItem, SPTAppRemotePodcastPlaybackSpeed;
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * The `SPTAppRemotePlayerStateDelegate` is used to get notifications from the Spotify app when the player state is changed.
+ */
+@protocol SPTAppRemotePlayerStateDelegate <NSObject>
+
+/**
+ * Called when the player state has been updated.
+ *
+ * @param playerState The new player state.
+ */
+- (void)playerStateDidChange:(id<SPTAppRemotePlayerState>)playerState;
+
+@end
+
+/**
+ * The `SPTAppRemotePlayerAPI` is used to interact with and control the Spotify player.
+ */
+@protocol SPTAppRemotePlayerAPI <NSObject>
+
+/// The delegate receiving player state updates
+@property (nonatomic, weak) id<SPTAppRemotePlayerStateDelegate> delegate;
+
+#pragma mark Player Control
+
+/**
+ * Asks the Spotify player to play the entity with the given identifier.
+ *
+ * @note Implement `SPTAppRemotePlayerStateDelegate` and set yourself as delegate in order to be notified when the
+ *       the track begins to play.
+ *
+ * @param entityIdentifier The unique identifier of the entity to play.
+ * @param callback         On success `result` will be `YES`.
+ *                         On error `result` will be `nil` and `error` set
+ */
+- (void)play:(NSString *)entityIdentifier callback:(nullable SPTAppRemoteCallback)callback;
+
+/**
+ * Asks the Spotify player to play the entity with the given identifier.
+ *
+ * @note Implement `SPTAppRemotePlayerStateDelegate` and set yourself as delegate in order to be notified when the
+ *       the track begins to play.
+ *
+ * @param trackUri      The track URI to play.
+ * @param asRadio       `YES` to start radio for track URI.
+ * @param callback      On success `result` will be `YES`.
+ *                      On error `result` will be `nil` and `error` set
+ */
+- (void)play:(NSString *)trackUri asRadio:(BOOL)asRadio callback:(SPTAppRemoteCallback)callback;
+
+/**
+ * Asks the Spotify player to play the provided content item.
+ *
+ * @note Implement `SPTAppRemotePlayerStateDelegate` and set yourself as delegate in order to be notified when the
+ *       the track begins to play.
+ * @note The `playable` property of the `SPTAppRemoteContentItem` indicates whether or not a content item is
+ *       playable.
+ *
+ * @param contentItem      The content item to play.
+ * @param callback         On success `result` will be `YES`.
+ *                         On error `result` will be `nil` and error set
+ */
+- (void)playItem:(id<SPTAppRemoteContentItem>)contentItem callback:(nullable SPTAppRemoteCallback)callback;
+
+/**
+ * Asks the Spotify player to play the provided content item starting at the specified index.
+ *
+ * @note Implement `SPTAppRemotePlayerStateDelegate` and set yourself as delegate in order to be notified when the
+ *       the track begins to play.
+ * @note The `playable` property of the `SPTAppRemoteContentItem` indicates whether or not a content item is
+ *       playable.
+ * @note Sending an `index` parameter that is out of bounds is undefined.
+ *
+ * @param contentItem      The content item to play.
+ * @param index            The index of the track to skip to if applicable.
+ * @param callback         On success `result` will be `YES`.
+ *                         On error `result` will be `nil` and error set
+ */
+- (void)playItem:(id<SPTAppRemoteContentItem>)contentItem skipToTrackIndex:(NSInteger) index callback:(nullable SPTAppRemoteCallback)callback;
+
+/**
+ * Asks the Spotify player to resume playback.
+ *
+ * @note Implement `SPTAppRemotePlayerStateDelegate` and set yourself as delegate in order to be notified when the
+ *       the playback resumes.
+ *
+ * @param callback On success `result` will be `YES`.
+ *                 On error `result` will be nil and error set
+ */
+- (void)resume:(nullable SPTAppRemoteCallback)callback;
+
+/**
+ * Asks the Spotify player to pause playback.
+ *
+ * @note Implement `SPTAppRemotePlayerStateDelegate` and set yourself as delegate in order to be notified when the
+ *       the playback pauses.
+ *
+ * @param callback On success `result` will be `YES`.
+ *                 On error `result` will be `nil` and error set
+ */
+- (void)pause:(nullable SPTAppRemoteCallback)callback;
+
+/**
+ * Asks the Spotify player to skip to the next track.
+ *
+ * @note Implement `SPTAppRemotePlayerStateDelegate` and set yourself as delegate in order to be notified when the
+ *       the track changes.
+ *
+ * @param callback On success `result` will be `YES`.
+ *                 On error `result` will be `nil` and error set
+ */
+- (void)skipToNext:(nullable SPTAppRemoteCallback)callback;
+
+/**
+ * Asks the Spotify player to skip to the previous track.
+ *
+ * @note Implement `SPTAppRemotePlayerStateDelegate` and set yourself as delegate in order to be notified when the
+ *       the track changes.
+ *
+ * @param callback On success `result` will be `YES`.
+ *                 On error `result` will be `nil` and `error` set
+ */
+- (void)skipToPrevious:(nullable SPTAppRemoteCallback)callback;
+
+/**
+ * Asks the Spotify player to seek to the specified position.
+ *
+ * @param position The position to seek to in milliseconds.
+ * @param callback On success `result` will be `YES`.
+ *                 On error `result` will be `nil` and `error` set
+ */
+- (void)seekToPosition:(NSInteger)position callback:(nullable SPTAppRemoteCallback)callback;
+
+/**
+ * Asks the Spotify player to seek forward 15 seconds.
+ * Note: You should only use this method if isEpisode = YES for the currently playing track
+ *
+ * @param callback On success `result` will be `YES`.
+ *                 On error `result` will be `nil` and `error` set
+ */
+- (void)seekForward15Seconds:(nullable SPTAppRemoteCallback)callback;
+
+/**
+ * Asks the Spotify player to seek backward 15 seconds.
+ * Note: You should only use this method if isEpisode = YES for the currently playing track
+ *
+ * @param callback On success `result` will be `YES`.
+ *                 On error `result` will be `nil` and `error` set
+ */
+- (void)seekBackward15Seconds:(nullable SPTAppRemoteCallback)callback;
+
+#pragma mark Playback Options
+
+/**
+ *  Asks the Spotify player to set shuffle mode.
+ *
+ *  @param shuffle  `YES` to enable shuffle, `NO` to disable.
+ *  @param callback On success `result` will be `YES`.
+ *                  On error `result` will be `nil` and `error` will be set.
+ */
+- (void)setShuffle:(BOOL)shuffle callback:(nullable SPTAppRemoteCallback)callback;
+
+/**
+ *  Asks the Spotify player to set the repeat mode.
+ *
+ *  @param repeatMode The repeat mode to set.
+ *  @param callback On success `result` will be `YES`.
+ *                  On error `result` will be `nil` and `error` will be set.
+ */
+- (void)setRepeatMode:(SPTAppRemotePlaybackOptionsRepeatMode)repeatMode callback:(nullable SPTAppRemoteCallback)callback;
+
+#pragma mark Player State
+
+/**
+ * Asks the Spotify player for the current player state.
+ *
+ * @param callback On success `result` will be an instance of `id<SPTAppRemotePlayerState>`
+ *                 On error `result` will be nil and error set
+ */
+- (void)getPlayerState:(nullable SPTAppRemoteCallback)callback;
+
+/**
+ * Subscribes to player state changes from the Spotify app.
+ *
+ * @note Implement `SPTAppRemotePlayerStateDelegate` and set yourself as delegate in order to be notified when the
+ *       the player state changes.
+ *
+ * @param callback On success `result` will be an instance of `id<SPTAppRemotePlayerState>`
+ *                 On error `result` will be nil and error set
+ */
+- (void)subscribeToPlayerState:(nullable SPTAppRemoteCallback)callback;
+
+/**
+ * Stops subscribing to player state changes from the Spotify app.
+ *
+ * @param callback On success `result` will be `YES`
+ *                 On error `result` will be `nil` and error set
+ */
+- (void)unsubscribeToPlayerState:(nullable SPTAppRemoteCallback)callback;
+
+/**
+ * Adds a track to the user's currently playing queue
+ *
+ * @param trackUri The track URI to add to the queue
+ * @param callback On success `result` will be `YES`
+ *                 On error `result` will be `nil` and error set
+ */
+- (void)enqueueTrackUri:(NSString*)trackUri callback:(nullable SPTAppRemoteCallback)callback;
+
+/**
+ * Asks the Spotify player for available podcast playback speeds
+ *
+ * @param callback On success `result` will be an `NSArray` of `SPTAppRemotePodcastPlaybackSpeed` objects
+ *                 On error `result` will be `nil` and `error` set
+ */
+- (void)getAvailablePodcastPlaybackSpeeds:(nullable SPTAppRemoteCallback)callback;
+
+/**
+ * Asks the Spotify player for the current podcast playback speed
+ *
+ * @note Podcast playback speed is seperate from other contents' playback speed. This value is only used for podcasts
+ *
+ * @param callback On success `result` will be a `SPTAppRemotePodcastPlaybackSpeed`
+ *                 On error `result` will be `nil` and `error` set
+ */
+- (void)getCurrentPodcastPlaybackSpeed:(nullable SPTAppRemoteCallback)callback;
+
+/**
+ * Set the current podcast playback speed
+ *
+ * @note This playback speed will only affect podcasts and not other types of media. If you set this
+ * when a podcast is not playing this will be the default value when a podcast does begin to play. For this reason
+ * you may get a successful callback when setting this even when a podcast is not playing and the current playback
+ * speed does not change.
+ *
+ * @note You should use `getAvailablePodcastPlaybackSpeeds:` to get a list of valid speeds to pass to this method
+ *
+ * @param speed The `SPTAppRemotePodcastPlaybackSpeed` to set as the current podcast playback speed
+ * @param callback  On success `result` will be `YES`.
+ *                  On error `result` will be `nil` and `error` set
+ */
+- (void)setPodcastPlaybackSpeed:(nonnull id<SPTAppRemotePodcastPlaybackSpeed>)speed callback:(nullable SPTAppRemoteCallback)callback;
+
+/**
+ * Asks the Spotify player for the current crossfade state.
+ *
+ * @param callback On success `result` will be an instance of `id<SPTAppRemoteCrossfadeState>`
+ *                 On error `result` will be nil and error set
+ */
+- (void)getCrossfadeState:(nullable SPTAppRemoteCallback)callback;
+
+@end
+
+NS_ASSUME_NONNULL_END

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

@@ -0,0 +1,40 @@
+#import <Foundation/Foundation.h>
+
+@protocol SPTAppRemoteTrack;
+@protocol SPTAppRemotePlaybackOptions;
+@protocol SPTAppRemotePlaybackRestrictions;
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ *  The `SPTAppRemotePlayerState` represents the state within the Spotify player.
+ */
+@protocol SPTAppRemotePlayerState <NSObject>
+
+/// The track being played in the Spotify player.
+@property (nonatomic, readonly) id<SPTAppRemoteTrack> track;
+
+/// The position of the playback in the Spotify player.
+@property (nonatomic, readonly) NSInteger playbackPosition;
+
+/// The speed of the playback in the Spotify player.
+@property (nonatomic, readonly) float playbackSpeed;
+
+/// `YES` if the Spotify player is paused, otherwise `NO`.
+@property (nonatomic, readonly, getter=isPaused) BOOL paused;
+
+/// The playback restrictions currently in effect.
+@property (nonatomic, readonly) id<SPTAppRemotePlaybackRestrictions> playbackRestrictions;
+
+/// The playback options currently in effect.
+@property (nonatomic, readonly) id<SPTAppRemotePlaybackOptions> playbackOptions;
+
+/// The title of the currently playing context (e.g. the name of the playlist).
+@property (nonatomic, readonly) NSString *contextTitle;
+
+/// The URI of the currently playing context (e.g. the URI of the playlist).
+@property (nonatomic, readonly) NSURL *contextURI;
+
+@end
+
+NS_ASSUME_NONNULL_END

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

@@ -0,0 +1,15 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * The `SPTAppRemotePodcastPlaybackSpeed` represents playback speed(s) for podcasts
+ */
+@protocol SPTAppRemotePodcastPlaybackSpeed <NSObject>
+
+/// The speed multiplier representing this podcast speed. 0.5 = half speed, 2 = twice as fast, 1 = normal playback
+@property (nonatomic, strong, readonly) NSNumber *value;
+
+@end
+
+NS_ASSUME_NONNULL_END

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

@@ -0,0 +1,52 @@
+#import "SPTAppRemoteImageRepresentable.h"
+
+@protocol SPTAppRemoteAlbum;
+@protocol SPTAppRemoteArtist;
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ *  The `SPTAppRemoteTrack` represents a track.
+ */
+@protocol SPTAppRemoteTrack <NSObject, SPTAppRemoteImageRepresentable>
+
+/// The name of the track.
+@property (nonatomic, copy, readonly) NSString *name;
+
+/// The URI of the track.
+@property (nonatomic, copy, readonly) NSString *URI;
+
+/// The duration of the track in miliseconds.
+@property (nonatomic, assign, readonly) NSUInteger duration;
+
+/// The artist of the track.
+@property (nonatomic, strong, readonly) id<SPTAppRemoteArtist> artist;
+
+/// The album of the track.
+@property (nonatomic, strong, readonly) id<SPTAppRemoteAlbum> album;
+
+/// `YES` if the user has saved the track, otherwise `NO`.
+@property (nonatomic, assign, readonly, getter=isSaved) BOOL saved;
+
+/**
+ * `YES` if the track is a podcast, video, or other audio episode, otherwise `NO`.
+ * If the track is an episode and `SPTAppRemotePlaybackRestrictions` `canSeek` is `YES` you should show
+ * 15 second skip buttons in your UI.
+ */
+@property (nonatomic, assign, readonly, getter=isEpisode) BOOL episode;
+
+/**
+ * `YES` if the track is a podcast, otherwise `NO`.
+ * If the track is a podcast and `SPTAppRemotePlaybackRestrictions` `canSeek` is `YES` you should show
+ * 15 second skip buttons in your UI as well as a podcast speed control to change playback speed.
+ */
+@property (nonatomic, assign, readonly, getter=isPodcast) BOOL podcast;
+
+/**
+ * `YES` if the track is an ad, otherwise `NO`.
+ */
+@property (nonatomic, assign, readonly, getter=isAdvertisement) BOOL advertisement;
+
+@end
+
+NS_ASSUME_NONNULL_END

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

@@ -0,0 +1,103 @@
+#import <Foundation/Foundation.h>
+
+#import "SPTAppRemoteCommon.h"
+
+@protocol SPTAppRemoteUserAPI;
+@protocol SPTAppRemoteUserCapabilities;
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * The `SPTAppRemoteUserAPIDelegate` gets notified whenever the user API receives new data from subscription events.
+ */
+@protocol SPTAppRemoteUserAPIDelegate <NSObject>
+
+/**
+ * Called when the capabilities has been updated.
+ *
+ * @note This will only be called if there is an active capabilities subscription.
+ *
+ * @param userAPI      The API that received updates.
+ * @param capabilities The new capabilities that was received.
+ */
+- (void)userAPI:(id<SPTAppRemoteUserAPI>)userAPI didReceiveCapabilities:(id<SPTAppRemoteUserCapabilities>)capabilities;
+
+@end
+
+/**
+ * The `SPTAppRemoteUserAPI` is used to get user data from, and interact with user features in, the Spotify app.
+ */
+@protocol SPTAppRemoteUserAPI <NSObject>
+
+/// The User API delegate gets notified whenever the API receives new data from subscription events.
+@property (nonatomic, weak, readwrite) id<SPTAppRemoteUserAPIDelegate> delegate;
+
+/**
+ *  Fetches the current users capabilities from the Spotify app.
+ *
+ *  @param callback A callback block that will be invoked when the fetch request has completed.
+ *                  On success `result` will be an instance of `id<SPTAppRemoteUserCapabilities>`.
+ *                  On error `result` will be `nil` and `error` will be set.
+ */
+- (void)fetchCapabilitiesWithCallback:(nullable SPTAppRemoteCallback)callback;
+
+/**
+ * Subscribes to capability changes from the Spotify app.
+ *
+ * @note Implement `SPTAppRemoteUserAPIDelegate` and set yourself as `delegate` in order to be notified when the
+ *       the capabilities changes.
+ *
+ * @param callback A callback block that will be invoked when the subscription request has completed.
+ *                 On success `result` will `YES`.
+ *                 On error `result` will be `nil` and `error` will be set.
+ */
+- (void)subscribeToCapabilityChanges:(nullable SPTAppRemoteCallback)callback;
+
+/**
+ * Stops subscribing to capability changes from the Spotify app.
+ *
+ * @param callback A callback block that will be invoked when the unsubscription request has completed.
+ *                 On success `result` will be `YES`.
+ *                 On error `result` will be `nil` and `error` will be set.
+ */
+- (void)unsubscribeToCapabilityChanges:(nullable SPTAppRemoteCallback)callback;
+
+/**
+ *  Fetches the current users library state for a given album or track uri.
+ *
+ *  @param URI      The URI of the album or track we are fetching the state for
+ *  @param callback A callback block that will be invoked when the fetch request has completed.
+ *                  On success `result` will be an instance of `id<SPTAppRemoteLibraryState>`.
+ *                  On error `result` will be `nil` and `error` will be set.
+ */
+- (void)fetchLibraryStateForURI:(NSString *)URI callback:(SPTAppRemoteCallback)callback;
+
+/**
+ *  Add item to the users library.
+ *  Currently supported uris include:
+ *                  Tracks - example: spotify:track:6rqhFgbbKwnb9MLmUQDhG6
+ *                  Albums - example: spotify:album:2VYSDvc0ZdcfkXDcYVjHs6
+ *
+ *  @param URI      The URI of the item to save
+ *  @param callback A callback block that will be invoked when the fetch request has completed.
+ *                  On success `result` will be an instance of `id<SPTAppRemoteLibraryState>` that indicates the resulting state of the entity.
+ *                  On error `result` will be `nil` and `error` will be set.
+ */
+- (void)addItemToLibraryWithURI:(NSString *)URI callback:(nullable SPTAppRemoteCallback)callback;
+
+/**
+ *  Remove item from users library.
+ *  Currently supported uris include:
+ *                  Tracks - example: spotify:track:6rqhFgbbKwnb9MLmUQDhG6
+ *                  Albums - example: spotify:album:2VYSDvc0ZdcfkXDcYVjHs6
+ *
+ *  @param URI      The URI of the item to remove
+ *  @param callback A callback block that will be invoked when the fetch request has completed.
+ *                  On success `result` will be an instance of `id<SPTAppRemoteLibraryState>` that indicates the resulting state of the entity.
+ *                  On error `result` will be `nil` and `error` will be set.
+ */
+- (void)removeItemFromLibraryWithURI:(NSString *)URI callback:(nullable SPTAppRemoteCallback)callback;
+
+@end
+
+NS_ASSUME_NONNULL_END

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

@@ -0,0 +1,15 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ *  The `SPTAppRemoteUserCapabilities` represents a set of capabilities the current user has in the Spotify app.
+ */
+@protocol SPTAppRemoteUserCapabilities <NSObject>
+
+/// `YES` if the user can play songs on demand, otherwise `NO`. This will differ for premium and non-premium users
+@property (nonatomic, assign, readonly) BOOL canPlayOnDemand;
+
+@end
+
+NS_ASSUME_NONNULL_END

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

@@ -0,0 +1,66 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ A configuration class, holding the credentials provided for your app on the Spotify Developer website.
+ See https://developer.spotify.com/my-applications/
+*/
+@interface SPTConfiguration : NSObject <NSSecureCoding>
+
+/// Your app's Client ID from developer.spotify.com
+@property (nonatomic, readonly, copy) NSString *clientID;
+
+/// Your redirect URL. This is how the Spotify app will open your application after user authorization.
+@property (nonatomic, readonly, copy) NSURL *redirectURL;
+
+/// Name of the company
+@property (nonatomic, nullable, copy) NSString *companyName;
+
+/**
+ The URL to use for attempting to swap an authorization code for an access token. You should only set this if your
+ clientID has a clientSecret and you have a backend service that holds the secret and can exchange the code and secret
+ for an access token.
+*/
+@property (nonatomic, nullable, copy) NSURL *tokenSwapURL;
+
+/**
+ The URL to use for attempting to renew an access token with a refresh token. You should only set this if your
+ clientID has a clientSecret and you have a backend service that holds the secret and can use a refresh token
+ to get a new access token.
+*/
+@property (nonatomic, nullable, copy) NSURL *tokenRefreshURL;
+
+/**
+ If requesting the `SPTAppRemoteControlScope` you can provide an optional uri to begin playing after a successful
+ authentication. To continue the user's last session set this to a blank string @"". If this value is `nil` or `SPTAppRemoteControlScope`
+ is not requested no audio will play. If Spotify is already playing it will continue playing even though a URI is provided.
+ */
+@property (nonatomic, nullable, copy) NSString *playURI;
+
+- (instancetype)init NS_UNAVAILABLE;
+
+/**
+ Designated initializer for `SPTConfiguration`
+
+ @param clientID Your client ID obtained from developer.spotify.com
+ @param redirectURL Your redirect URL for Spotify to open your app again after authorization
+ @return A newly initialized `SPTConfiguration`
+ */
+- (instancetype)initWithClientID:(NSString *)clientID
+                     redirectURL:(NSURL *)redirectURL NS_DESIGNATED_INITIALIZER;
+
+/**
+ Convenience intializer for `SPtConfiguration`
+
+ @param clientID Your client ID obtained from developer.spotify.com
+ @param redirectURL Your redirect URL for Spotify to open your app again after authorization
+ @return A newly initialized `SPTConfiguration`
+ */
++ (instancetype)configurationWithClientID:(NSString *)clientID
+                              redirectURL:(NSURL *)redirectURL NS_SWIFT_UNAVAILABLE("superfluous");
+
+@end
+
+
+NS_ASSUME_NONNULL_END

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

@@ -0,0 +1,33 @@
+#import <Foundation/Foundation.h>
+
+#import "SPTMacros.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+SPT_EXPORT NSErrorDomain const SPTLoginErrorDomain;
+
+/// Spotify error codes, use NSUnderlyingErrorKey to see the underlying error
+typedef NS_ENUM(NSUInteger, SPTErrorCode)
+{
+    /// Unknown error code
+    SPTUnknownErrorCode NS_SWIFT_NAME(unknown) = 0,
+    /// Authorization failed
+    SPTAuthorizationFailedErrorCode NS_SWIFT_NAME(authorizationFailed),
+    /// Renew session failed
+    SPTRenewSessionFailedErrorCode NS_SWIFT_NAME(renewSessionFailed),
+    /// Failed to parse the returned JSON
+    SPTJSONFailedErrorCode NS_SWIFT_NAME(jsonFailed),
+};
+
+/// Spotify-specific errors. Use NSUnderlyingErrorKey to see the underlying error
+@interface SPTError : NSError
+
++ (instancetype)errorWithCode:(SPTErrorCode)code;
+
++ (instancetype)errorWithCode:(SPTErrorCode)code description:(NSString *)description;
+
++ (instancetype)errorWithCode:(SPTErrorCode)code underlyingError:(NSError *)error;
+
+@end
+
+NS_ASSUME_NONNULL_END