LukeParke/plexjava
1
0
Fork 0
mirror of https://github.com/LukeHagar/plexjava.git synced 2025-12-06 04:20:46 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
81ecd024e790efdfa407e1e8f8f79b470cb0454d
plexjava/docs/sdks/content/README.md
speakeasybot 81ecd024e7 ## Java SDK Changes Detected: 
* `plex-api.butler.startTask()`: 
  *  `request` **Changed** **Breaking** ⚠️
  *  `error` **Changed** **Breaking** ⚠️
* `plex-api.butler.stopTask()`: 
  *  `request` **Changed** **Breaking** ⚠️
  *  `error` **Changed** **Breaking** ⚠️
* `plex-api.updater.applyUpdates()`: 
  *  `request` **Changed** **Breaking** ⚠️
  *  `error` **Changed** **Breaking** ⚠️
* `plex-api.general.getServerInfo()`: **Added**
* `plex-api.general.getIdentity()`: **Added**
* `plex-api.general.getSourceConnectionInformation()`: **Added**
* `plex-api.general.getTransientToken()`: **Added**
* `plex-api.events.getNotifications()`: **Added**
* `plex-api.events.connectWebSocket()`: **Added**
* `plex-api.preferences.getAllPreferences()`: **Added**
* `plex-api.preferences.setPreferences()`: **Added**
* `plex-api.preferences.getPreference()`: **Added**
* `plex-api.rate.setRating()`: **Added**
* `plex-api.timeline.markPlayed()`: **Added**
* `plex-api.timeline.report()`: **Added**
* `plex-api.timeline.unscrobble()`: **Added**
* `plex-api.activities.listActivities()`: **Added**
* `plex-api.activities.cancelActivity()`: **Added**
* `plex-api.butler.stopTasks()`: **Added**
* `plex-api.butler.getTasks()`: **Added**
* `plex-api.butler.startTasks()`: **Added**
* `plex-api.downloadQueue.createDownloadQueue()`: **Added**
* `plex-api.downloadQueue.getDownloadQueue()`: **Added**
* `plex-api.downloadQueue.addDownloadQueueItems()`: **Added**
* `plex-api.downloadQueue.listDownloadQueueItems()`: **Added**
* `plex-api.downloadQueue.getItemDecision()`: **Added**
* `plex-api.downloadQueue.getDownloadQueueMedia()`: **Added**
* `plex-api.downloadQueue.removeDownloadQueueItems()`: **Added**
* `plex-api.downloadQueue.getDownloadQueueItems()`: **Added**
* `plex-api.downloadQueue.restartProcessingDownloadQueueItems()`: **Added**
* `plex-api.hubs.getAllHubs()`: **Added**
* `plex-api.hubs.getContinueWatching()`: **Added**
* `plex-api.hubs.getHubItems()`: **Added**
* `plex-api.hubs.getPromotedHubs()`: **Added**
* `plex-api.hubs.getMetadataHubs()`: **Added**
* `plex-api.hubs.getPostplayHubs()`: **Added**
* `plex-api.hubs.getRelatedHubs()`: **Added**
* `plex-api.hubs.getSectionHubs()`: **Added**
* `plex-api.hubs.resetSectionDefaults()`: **Added**
* `plex-api.hubs.listHubs()`: **Added**
* `plex-api.hubs.createCustomHub()`: **Added**
* `plex-api.hubs.moveHub()`: **Added**
* `plex-api.hubs.deleteCustomHub()`: **Added**
* `plex-api.hubs.updateHubVisibility()`: **Added**
* `plex-api.search.searchHubs()`: **Added**
* `plex-api.search.voiceSearchHubs()`: **Added**
* `plex-api.library.getLibraryItems()`: **Added**
* `plex-api.library.deleteCaches()`: **Added**
* `plex-api.library.cleanBundles()`: **Added**
* `plex-api.library.ingestTransientItem()`: **Added**
* `plex-api.library.getLibraryMatches()`: **Added**
* `plex-api.library.optimizeDatabase()`: **Added**
* `plex-api.library.getRandomArtwork()`: **Added**
* `plex-api.library.getSections()`: **Added**
* `plex-api.library.addSection()`: **Added**
* `plex-api.library.stopAllRefreshes()`: **Added**
* `plex-api.library.getSectionsPrefs()`: **Added**
* `plex-api.library.refreshSectionsMetadata()`: **Added**
* `plex-api.library.getTags()`: **Added**
* `plex-api.library.deleteMetadataItem()`: **Added**
* `plex-api.library.editMetadataItem()`: **Added**
* `plex-api.library.detectAds()`: **Added**
* `plex-api.library.getAllItemLeaves()`: **Added**
* `plex-api.library.analyzeMetadata()`: **Added**
* `plex-api.library.generateThumbs()`: **Added**
* `plex-api.library.detectCredits()`: **Added**
* `plex-api.library.getExtras()`: **Added**
* `plex-api.library.addExtras()`: **Added**
* `plex-api.library.getFile()`: **Added**
* `plex-api.library.startBifGeneration()`: **Added**
* `plex-api.library.detectIntros()`: **Added**
* `plex-api.library.createMarker()`: **Added**
* `plex-api.library.matchItem()`: **Added**
* `plex-api.library.listMatches()`: **Added**
* `plex-api.library.mergeItems()`: **Added**
* `plex-api.library.listSonicallySimilar()`: **Added**
* `plex-api.library.setItemPreferences()`: **Added**
* `plex-api.library.refreshItemsMetadata()`: **Added**
* `plex-api.library.getRelatedItems()`: **Added**
* `plex-api.library.listSimilar()`: **Added**
* `plex-api.library.splitItem()`: **Added**
* `plex-api.library.addSubtitles()`: **Added**
* `plex-api.library.getItemTree()`: **Added**
* `plex-api.library.unmatch()`: **Added**
* `plex-api.library.listTopUsers()`: **Added**
* `plex-api.library.detectVoiceActivity()`: **Added**
* `plex-api.library.getAugmentationStatus()`: **Added**
* `plex-api.library.setStreamSelection()`: **Added**
* `plex-api.library.getPerson()`: **Added**
* `plex-api.library.listPersonMedia()`: **Added**
* `plex-api.library.deleteLibrarySection()`: **Added**
* `plex-api.library.getLibraryDetails()`: **Added**
* `plex-api.library.editSection()`: **Added**
* `plex-api.library.updateItems()`: **Added**
* `plex-api.library.startAnalysis()`: **Added**
* `plex-api.library.autocomplete()`: **Added**
* `plex-api.library.getCollections()`: **Added**
* `plex-api.library.getCommon()`: **Added**
* `plex-api.library.emptyTrash()`: **Added**
* `plex-api.library.getSectionFilters()`: **Added**
* `plex-api.library.getFirstCharacters()`: **Added**
* `plex-api.library.deleteIndexes()`: **Added**
* `plex-api.library.deleteIntros()`: **Added**
* `plex-api.library.getSectionPreferences()`: **Added**
* `plex-api.library.setSectionPreferences()`: **Added**
* `plex-api.library.cancelRefresh()`: **Added**
* `plex-api.library.refreshSection()`: **Added**
* `plex-api.library.getAvailableSorts()`: **Added**
* `plex-api.library.getStreamLevels()`: **Added**
* `plex-api.library.getStreamLoudness()`: **Added**
* `plex-api.library.getChapterImage()`: **Added**
* `plex-api.library.setItemArtwork()`: **Added**
* `plex-api.library.updateItemArtwork()`: **Added**
* `plex-api.library.deleteMarker()`: **Added**
* `plex-api.library.editMarker()`: **Added**
* `plex-api.library.deleteMediaItem()`: **Added**
* `plex-api.library.getPartIndex()`: **Added**
* `plex-api.library.deleteCollection()`: **Added**
* `plex-api.library.getSectionImage()`: **Added**
* `plex-api.library.deleteStream()`: **Added**
* `plex-api.library.getStream()`: **Added**
* `plex-api.library.setStreamOffset()`: **Added**
* `plex-api.library.getItemArtwork()`: **Added**
* `plex-api.library.getMediaPart()`: **Added**
* `plex-api.library.getImageFromBif()`: **Added**
* `plex-api.collections.createCollection()`: **Added**
* `plex-api.dvRs.listDvRs()`: **Added**
* `plex-api.dvRs.createDvr()`: **Added**
* `plex-api.dvRs.deleteDvr()`: **Added**
* `plex-api.dvRs.getDvr()`: **Added**
* `plex-api.dvRs.deleteLineup()`: **Added**
* `plex-api.dvRs.addLineup()`: **Added**
* `plex-api.dvRs.setDvrPreferences()`: **Added**
* `plex-api.dvRs.stopDvrReload()`: **Added**
* `plex-api.dvRs.reloadGuide()`: **Added**
* `plex-api.dvRs.tuneChannel()`: **Added**
* `plex-api.dvRs.removeDeviceFromDvr()`: **Added**
* `plex-api.dvRs.addDeviceToDvr()`: **Added**
* `plex-api.epg.computeChannelMap()`: **Added**
* `plex-api.epg.getChannels()`: **Added**
* `plex-api.epg.getCountries()`: **Added**
* `plex-api.epg.getAllLanguages()`: **Added**
* `plex-api.epg.getLineup()`: **Added**
* `plex-api.epg.getLineupChannels()`: **Added**
* `plex-api.epg.getCountriesLineups()`: **Added**
* `plex-api.epg.getCountryRegions()`: **Added**
* `plex-api.epg.listLineups()`: **Added**
* `plex-api.liveTv.getSessions()`: **Added**
* `plex-api.liveTv.getLiveTvSession()`: **Added**
* `plex-api.liveTv.getSessionPlaylistIndex()`: **Added**
* `plex-api.liveTv.getSessionSegment()`: **Added**
* `plex-api.log.writeLog()`: **Added**
* `plex-api.log.writeMessage()`: **Added**
* `plex-api.log.enablePapertrail()`: **Added**
* `plex-api.devices.getAvailableGrabbers()`: **Added**
* `plex-api.devices.listDevices()`: **Added**
* `plex-api.devices.addDevice()`: **Added**
* `plex-api.devices.discoverDevices()`: **Added**
* `plex-api.devices.removeDevice()`: **Added**
* `plex-api.devices.getDeviceDetails()`: **Added**
* `plex-api.devices.modifyDevice()`: **Added**
* `plex-api.devices.setChannelmap()`: **Added**
* `plex-api.devices.getDevicesChannels()`: **Added**
* `plex-api.devices.setDevicePreferences()`: **Added**
* `plex-api.devices.stopScan()`: **Added**
* `plex-api.devices.scan()`: **Added**
* `plex-api.devices.getThumb()`: **Added**
* `plex-api.provider.listProviders()`: **Added**
* `plex-api.provider.addProvider()`: **Added**
* `plex-api.provider.refreshProviders()`: **Added**
* `plex-api.provider.deleteMediaProvider()`: **Added**
* `plex-api.subscriptions.getAllSubscriptions()`: **Added**
* `plex-api.subscriptions.createSubscription()`: **Added**
* `plex-api.subscriptions.processSubscriptions()`: **Added**
* `plex-api.subscriptions.getScheduledRecordings()`: **Added**
* `plex-api.subscriptions.getTemplate()`: **Added**
* `plex-api.subscriptions.cancelGrab()`: **Added**
* `plex-api.subscriptions.deleteSubscription()`: **Added**
* `plex-api.subscriptions.getSubscription()`: **Added**
* `plex-api.subscriptions.editSubscriptionPreferences()`: **Added**
* `plex-api.subscriptions.reorderSubscription()`: **Added**
* `plex-api.transcoder.transcodeImage()`: **Added**
* `plex-api.transcoder.makeDecision()`: **Added**
* `plex-api.transcoder.triggerFallback()`: **Added**
* `plex-api.transcoder.transcodeSubtitles()`: **Added**
* `plex-api.transcoder.startTranscodeSession()`: **Added**
* `plex-api.playlist.listPlaylists()`: **Added**
* `plex-api.playlist.getPlaylist()`: **Added**
* `plex-api.playlist.getPlaylistItems()`: **Added**
* `plex-api.libraryPlaylists.createPlaylist()`: **Added**
* `plex-api.libraryPlaylists.uploadPlaylist()`: **Added**
* `plex-api.libraryPlaylists.deletePlaylist()`: **Added**
* `plex-api.libraryPlaylists.updatePlaylist()`: **Added**
* `plex-api.libraryPlaylists.getPlaylistGenerators()`: **Added**
* `plex-api.libraryPlaylists.clearPlaylistItems()`: **Added**
* `plex-api.libraryPlaylists.addPlaylistItems()`: **Added**
* `plex-api.libraryPlaylists.deletePlaylistItem()`: **Added**
* `plex-api.libraryPlaylists.getPlaylistGenerator()`: **Added**
* `plex-api.libraryPlaylists.getPlaylistGeneratorItems()`: **Added**
* `plex-api.libraryPlaylists.movePlaylistItem()`: **Added**
* `plex-api.libraryPlaylists.refreshPlaylist()`: **Added**
* `plex-api.playQueue.createPlayQueue()`: **Added**
* `plex-api.playQueue.getPlayQueue()`: **Added**
* `plex-api.playQueue.addToPlayQueue()`: **Added**
* `plex-api.playQueue.clearPlayQueue()`: **Added**
* `plex-api.playQueue.resetPlayQueue()`: **Added**
* `plex-api.playQueue.shuffle()`: **Added**
* `plex-api.playQueue.unshuffle()`: **Added**
* `plex-api.playQueue.deletePlayQueueItem()`: **Added**
* `plex-api.playQueue.movePlayQueueItem()`: **Added**
* `plex-api.ultraBlur.getColors()`: **Added**
* `plex-api.ultraBlur.getImage()`: **Added**
* `plex-api.status.listSessions()`: **Added**
* `plex-api.status.getBackgroundTasks()`: **Added**
* `plex-api.status.listPlaybackHistory()`: **Added**
* `plex-api.status.terminateSession()`: **Added**
* `plex-api.status.deleteHistory()`: **Added**
* `plex-api.status.getHistoryItem()`: **Added**
* `plex-api.updater.checkUpdates()`: **Added**
* `plex-api.updater.getUpdatesStatus()`: **Added**
* `plex-api.content.getCollectionItems()`: **Added**
* `plex-api.content.getMetadataItem()`: **Added**
* `plex-api.content.getAlbums()`: **Added**
* `plex-api.content.listContent()`: **Added**
* `plex-api.content.getAllLeaves()`: **Added**
* `plex-api.content.getArts()`: **Added**
* `plex-api.content.getCategories()`: **Added**
* `plex-api.content.getCluster()`: **Added**
* `plex-api.content.getSonicPath()`: **Added**
* `plex-api.content.getFolders()`: **Added**
* `plex-api.content.listMoments()`: **Added**
* `plex-api.content.getSonicallySimilar()`: **Added**
* `plex-api.content.getCollectionImage()`: **Added**
* `plex-api.libraryCollections.addCollectionItems()`: **Added**
* `plex-api.libraryCollections.deleteCollectionItem()`: **Added**
* `plex-api.libraryCollections.moveCollectionItem()`: **Added**
* `plex-api.server.getServerCapabilities()`: **Deleted** **Breaking** ⚠️
* `plex-api.server.getServerPreferences()`: **Deleted** **Breaking** ⚠️
* `plex-api.server.getAvailableClients()`: **Deleted** **Breaking** ⚠️
* `plex-api.server.getDevices()`: **Deleted** **Breaking** ⚠️
* `plex-api.server.getServerIdentity()`: **Deleted** **Breaking** ⚠️
* `plex-api.server.getMyPlexAccount()`: **Deleted** **Breaking** ⚠️
* `plex-api.server.getResizedPhoto()`: **Deleted** **Breaking** ⚠️
* `plex-api.server.getMediaProviders()`: **Deleted** **Breaking** ⚠️
* `plex-api.server.getServerList()`: **Deleted** **Breaking** ⚠️
* `plex-api.media.markPlayed()`: **Deleted** **Breaking** ⚠️
* `plex-api.media.markUnplayed()`: **Deleted** **Breaking** ⚠️
* `plex-api.media.updatePlayProgress()`: **Deleted** **Breaking** ⚠️
* `plex-api.media.getBannerImage()`: **Deleted** **Breaking** ⚠️
* `plex-api.media.getThumbImage()`: **Deleted** **Breaking** ⚠️
* `plex-api.video.getTimeline()`: **Deleted** **Breaking** ⚠️
* `plex-api.video.startUniversalTranscode()`: **Deleted** **Breaking** ⚠️
* `plex-api.activities.getServerActivities()`: **Deleted** **Breaking** ⚠️
* `plex-api.activities.cancelServerActivities()`: **Deleted** **Breaking** ⚠️
* `plex-api.butler.getButlerTasks()`: **Deleted** **Breaking** ⚠️
* `plex-api.butler.startAllTasks()`: **Deleted** **Breaking** ⚠️
* `plex-api.butler.stopAllTasks()`: **Deleted** **Breaking** ⚠️
* `plex-api.plex.getCompanionsData()`: **Deleted** **Breaking** ⚠️
* `plex-api.plex.getUserFriends()`: **Deleted** **Breaking** ⚠️
* `plex-api.plex.getGeoData()`: **Deleted** **Breaking** ⚠️
* `plex-api.plex.getHomeData()`: **Deleted** **Breaking** ⚠️
* `plex-api.plex.getServerResources()`: **Deleted** **Breaking** ⚠️
* `plex-api.plex.getPin()`: **Deleted** **Breaking** ⚠️
* `plex-api.plex.getTokenByPinId()`: **Deleted** **Breaking** ⚠️
* `plex-api.hubs.getGlobalHubs()`: **Deleted** **Breaking** ⚠️
* `plex-api.hubs.getRecentlyAdded()`: **Deleted** **Breaking** ⚠️
* `plex-api.hubs.getLibraryHubs()`: **Deleted** **Breaking** ⚠️
* `plex-api.search.performSearch()`: **Deleted** **Breaking** ⚠️
* `plex-api.search.performVoiceSearch()`: **Deleted** **Breaking** ⚠️
* `plex-api.search.getSearchResults()`: **Deleted** **Breaking** ⚠️
* `plex-api.library.getFileHash()`: **Deleted** **Breaking** ⚠️
* `plex-api.library.getRecentlyAddedLibrary()`: **Deleted** **Breaking** ⚠️
* `plex-api.library.getAllLibraries()`: **Deleted** **Breaking** ⚠️
* `plex-api.library.getLibraryDetails()`: **Deleted** **Breaking** ⚠️
* `plex-api.library.deleteLibrary()`: **Deleted** **Breaking** ⚠️
* `plex-api.library.getLibraryItems()`: **Deleted** **Breaking** ⚠️
* `plex-api.library.getLibrarySectionsAll()`: **Deleted** **Breaking** ⚠️
* `plex-api.library.getRefreshLibraryMetadata()`: **Deleted** **Breaking** ⚠️
* `plex-api.library.getSearchLibrary()`: **Deleted** **Breaking** ⚠️
* `plex-api.library.getGenresLibrary()`: **Deleted** **Breaking** ⚠️
* `plex-api.library.getCountriesLibrary()`: **Deleted** **Breaking** ⚠️
* `plex-api.library.getActorsLibrary()`: **Deleted** **Breaking** ⚠️
* `plex-api.library.getSearchAllLibraries()`: **Deleted** **Breaking** ⚠️
* `plex-api.library.getMediaMetaData()`: **Deleted** **Breaking** ⚠️
* `plex-api.library.getMediaArts()`: **Deleted** **Breaking** ⚠️
* `plex-api.library.postMediaArts()`: **Deleted** **Breaking** ⚠️
* `plex-api.library.getMediaPosters()`: **Deleted** **Breaking** ⚠️
* `plex-api.library.postMediaPoster()`: **Deleted** **Breaking** ⚠️
* `plex-api.library.getMetadataChildren()`: **Deleted** **Breaking** ⚠️
* `plex-api.library.getTopWatchedContent()`: **Deleted** **Breaking** ⚠️
* `plex-api.watchlist.getWatchList()`: **Deleted** **Breaking** ⚠️
* `plex-api.log.logLine()`: **Deleted** **Breaking** ⚠️
* `plex-api.log.logMultiLine()`: **Deleted** **Breaking** ⚠️
* `plex-api.log.enablePaperTrail()`: **Deleted** **Breaking** ⚠️
* `plex-api.playlists.createPlaylist()`: **Deleted** **Breaking** ⚠️
* `plex-api.playlists.getPlaylists()`: **Deleted** **Breaking** ⚠️
* `plex-api.playlists.getPlaylist()`: **Deleted** **Breaking** ⚠️
* `plex-api.playlists.deletePlaylist()`: **Deleted** **Breaking** ⚠️
* `plex-api.playlists.updatePlaylist()`: **Deleted** **Breaking** ⚠️
* `plex-api.playlists.getPlaylistContents()`: **Deleted** **Breaking** ⚠️
* `plex-api.playlists.clearPlaylistContents()`: **Deleted** **Breaking** ⚠️
* `plex-api.playlists.addPlaylistContents()`: **Deleted** **Breaking** ⚠️
* `plex-api.playlists.uploadPlaylist()`: **Deleted** **Breaking** ⚠️
* `plex-api.authentication.getTransientToken()`: **Deleted** **Breaking** ⚠️
* `plex-api.authentication.getSourceConnectionInformation()`: **Deleted** **Breaking** ⚠️
* `plex-api.authentication.getTokenDetails()`: **Deleted** **Breaking** ⚠️
* `plex-api.authentication.postUsersSignInData()`: **Deleted** **Breaking** ⚠️
* `plex-api.statistics.getStatistics()`: **Deleted** **Breaking** ⚠️
* `plex-api.statistics.getResourcesStatistics()`: **Deleted** **Breaking** ⚠️
* `plex-api.statistics.getBandwidthStatistics()`: **Deleted** **Breaking** ⚠️
* `plex-api.sessions.getSessions()`: **Deleted** **Breaking** ⚠️
* `plex-api.sessions.getSessionHistory()`: **Deleted** **Breaking** ⚠️
* `plex-api.sessions.getTranscodeSessions()`: **Deleted** **Breaking** ⚠️
* `plex-api.sessions.stopTranscodeSession()`: **Deleted** **Breaking** ⚠️
* `plex-api.updater.getUpdateStatus()`: **Deleted** **Breaking** ⚠️
* `plex-api.updater.checkForUpdates()`: **Deleted** **Breaking** ⚠️
* `plex-api.users.getUsers()`: **Deleted** **Breaking** ⚠️
2025-10-12 06:53:30 +00:00

895 lines
36 KiB
Markdown
Raw Blame History

# Content
(*content()*)
## Overview
The actual content of the media provider
### Available Operations
* [getCollectionItems](#getcollectionitems) - Get items in a collection
* [getMetadataItem](#getmetadataitem) - Get a metadata item
* [getAlbums](#getalbums) - Set section albums
* [listContent](#listcontent) - Get items in the section
* [getAllLeaves](#getallleaves) - Set section leaves
* [getArts](#getarts) - Set section artwork
* [getCategories](#getcategories) - Set section categories
* [getCluster](#getcluster) - Set section clusters
* [getSonicPath](#getsonicpath) - Similar tracks to transition from one to another
* [getFolders](#getfolders) - Get all folder locations
* [listMoments](#listmoments) - Set section moments
* [getSonicallySimilar](#getsonicallysimilar) - The nearest audio tracks
* [getCollectionImage](#getcollectionimage) - Get a collection's image
## getCollectionItems
Get items in a collection. Note if this collection contains more than 100 items, paging must be used.
### Example Usage
<!-- UsageSnippet language="java" operationID="getCollectionItems" method="get" path="/library/collections/{collectionId}/items" -->
```java
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.GetCollectionItemsRequest;
import dev.plexapi.sdk.models.operations.GetCollectionItemsResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
public class Application {
public static void main(String[] args) throws Exception {
PlexAPI sdk = PlexAPI.builder()
.accepts(Accepts.APPLICATION_XML)
.clientIdentifier("abc123")
.product("Plex for Roku")
.version("2.4.1")
.platform("Roku")
.platformVersion("4.3 build 1057")
.device("Roku 3")
.model("4200X")
.deviceVendor("Roku")
.deviceName("Living Room TV")
.marketplace("googlePlay")
.token(System.getenv().getOrDefault("TOKEN", ""))
.build();
GetCollectionItemsRequest req = GetCollectionItemsRequest.builder()
.collectionId(314585L)
.build();
GetCollectionItemsResponse res = sdk.content().getCollectionItems()
.request(req)
.call();
if (res.mediaContainerWithMetadata().isPresent()) {
// handle response
}
}
}
```
### Parameters
| Parameter | Type | Required | Description |
| --------------------------------------------------------------------------------- | --------------------------------------------------------------------------------- | --------------------------------------------------------------------------------- | --------------------------------------------------------------------------------- |
| `request` | [GetCollectionItemsRequest](../../models/operations/GetCollectionItemsRequest.md) | :heavy_check_mark: | The request object to use for the request. |
### Response
**[GetCollectionItemsResponse](../../models/operations/GetCollectionItemsResponse.md)**
### Errors
| Error Type | Status Code | Content Type |
| ---------------------- | ---------------------- | ---------------------- |
| models/errors/SDKError | 4XX, 5XX | \*/\* |
## getMetadataItem
Get one or more metadata items.
### Example Usage
<!-- UsageSnippet language="java" operationID="getMetadataItem" method="get" path="/library/metadata/{ids}" -->
```java
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.GetMetadataItemRequest;
import dev.plexapi.sdk.models.operations.GetMetadataItemResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import dev.plexapi.sdk.models.shared.BoolInt;
import java.lang.Exception;
import java.util.List;
public class Application {
public static void main(String[] args) throws Exception {
PlexAPI sdk = PlexAPI.builder()
.accepts(Accepts.APPLICATION_XML)
.clientIdentifier("abc123")
.product("Plex for Roku")
.version("2.4.1")
.platform("Roku")
.platformVersion("4.3 build 1057")
.device("Roku 3")
.model("4200X")
.deviceVendor("Roku")
.deviceName("Living Room TV")
.marketplace("googlePlay")
.token(System.getenv().getOrDefault("TOKEN", ""))
.build();
GetMetadataItemRequest req = GetMetadataItemRequest.builder()
.ids(List.of())
.asyncCheckFiles(BoolInt.ONE)
.asyncRefreshLocalMediaAgent(BoolInt.ONE)
.asyncRefreshAnalysis(BoolInt.ONE)
.checkFiles(BoolInt.ONE)
.skipRefresh(BoolInt.ONE)
.checkFileAvailability(BoolInt.ONE)
.asyncAugmentMetadata(BoolInt.ONE)
.augmentCount(BoolInt.ONE)
.build();
GetMetadataItemResponse res = sdk.content().getMetadataItem()
.request(req)
.call();
if (res.mediaContainerWithMetadata().isPresent()) {
// handle response
}
}
}
```
### Parameters
| Parameter | Type | Required | Description |
| --------------------------------------------------------------------------- | --------------------------------------------------------------------------- | --------------------------------------------------------------------------- | --------------------------------------------------------------------------- |
| `request` | [GetMetadataItemRequest](../../models/operations/GetMetadataItemRequest.md) | :heavy_check_mark: | The request object to use for the request. |
### Response
**[GetMetadataItemResponse](../../models/operations/GetMetadataItemResponse.md)**
### Errors
| Error Type | Status Code | Content Type |
| ---------------------- | ---------------------- | ---------------------- |
| models/errors/SDKError | 4XX, 5XX | \*/\* |
## getAlbums
Get all albums in a music section
### Example Usage
<!-- UsageSnippet language="java" operationID="getAlbums" method="get" path="/library/sections/{sectionId}/albums" -->
```java
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.GetAlbumsRequest;
import dev.plexapi.sdk.models.operations.GetAlbumsResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
public class Application {
public static void main(String[] args) throws Exception {
PlexAPI sdk = PlexAPI.builder()
.accepts(Accepts.APPLICATION_XML)
.clientIdentifier("abc123")
.product("Plex for Roku")
.version("2.4.1")
.platform("Roku")
.platformVersion("4.3 build 1057")
.device("Roku 3")
.model("4200X")
.deviceVendor("Roku")
.deviceName("Living Room TV")
.marketplace("googlePlay")
.token(System.getenv().getOrDefault("TOKEN", ""))
.build();
GetAlbumsRequest req = GetAlbumsRequest.builder()
.sectionId(817133L)
.build();
GetAlbumsResponse res = sdk.content().getAlbums()
.request(req)
.call();
if (res.mediaContainerWithMetadata().isPresent()) {
// handle response
}
}
}
```
### Parameters
| Parameter | Type | Required | Description |
| --------------------------------------------------------------- | --------------------------------------------------------------- | --------------------------------------------------------------- | --------------------------------------------------------------- |
| `request` | [GetAlbumsRequest](../../models/operations/GetAlbumsRequest.md) | :heavy_check_mark: | The request object to use for the request. |
### Response
**[GetAlbumsResponse](../../models/operations/GetAlbumsResponse.md)**
### Errors
| Error Type | Status Code | Content Type |
| ---------------------- | ---------------------- | ---------------------- |
| models/errors/SDKError | 4XX, 5XX | \*/\* |
## listContent
Get the items in a section, potentially filtering them
### Example Usage
<!-- UsageSnippet language="java" operationID="listContent" method="get" path="/library/sections/{sectionId}/all" -->
```java
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.ListContentRequest;
import dev.plexapi.sdk.models.operations.ListContentResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
public class Application {
public static void main(String[] args) throws Exception {
PlexAPI sdk = PlexAPI.builder()
.accepts(Accepts.APPLICATION_XML)
.clientIdentifier("abc123")
.product("Plex for Roku")
.version("2.4.1")
.platform("Roku")
.platformVersion("4.3 build 1057")
.device("Roku 3")
.model("4200X")
.deviceVendor("Roku")
.deviceName("Living Room TV")
.marketplace("googlePlay")
.token(System.getenv().getOrDefault("TOKEN", ""))
.build();
ListContentRequest req = ListContentRequest.builder()
.sectionId("<id>")
.build();
ListContentResponse res = sdk.content().listContent()
.request(req)
.call();
if (res.mediaContainerWithMetadata().isPresent()) {
// handle response
}
}
}
```
### Parameters
| Parameter | Type | Required | Description |
| ------------------------------------------------------------------- | ------------------------------------------------------------------- | ------------------------------------------------------------------- | ------------------------------------------------------------------- |
| `request` | [ListContentRequest](../../models/operations/ListContentRequest.md) | :heavy_check_mark: | The request object to use for the request. |
### Response
**[ListContentResponse](../../models/operations/ListContentResponse.md)**
### Errors
| Error Type | Status Code | Content Type |
| ---------------------- | ---------------------- | ---------------------- |
| models/errors/SDKError | 4XX, 5XX | \*/\* |
## getAllLeaves
Get all leaves in a section (such as episodes in a show section)
### Example Usage
<!-- UsageSnippet language="java" operationID="getAllLeaves" method="get" path="/library/sections/{sectionId}/allLeaves" -->
```java
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.GetAllLeavesRequest;
import dev.plexapi.sdk.models.operations.GetAllLeavesResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
public class Application {
public static void main(String[] args) throws Exception {
PlexAPI sdk = PlexAPI.builder()
.accepts(Accepts.APPLICATION_XML)
.clientIdentifier("abc123")
.product("Plex for Roku")
.version("2.4.1")
.platform("Roku")
.platformVersion("4.3 build 1057")
.device("Roku 3")
.model("4200X")
.deviceVendor("Roku")
.deviceName("Living Room TV")
.marketplace("googlePlay")
.token(System.getenv().getOrDefault("TOKEN", ""))
.build();
GetAllLeavesRequest req = GetAllLeavesRequest.builder()
.sectionId(633197L)
.build();
GetAllLeavesResponse res = sdk.content().getAllLeaves()
.request(req)
.call();
if (res.mediaContainerWithMetadata().isPresent()) {
// handle response
}
}
}
```
### Parameters
| Parameter | Type | Required | Description |
| --------------------------------------------------------------------- | --------------------------------------------------------------------- | --------------------------------------------------------------------- | --------------------------------------------------------------------- |
| `request` | [GetAllLeavesRequest](../../models/operations/GetAllLeavesRequest.md) | :heavy_check_mark: | The request object to use for the request. |
### Response
**[GetAllLeavesResponse](../../models/operations/GetAllLeavesResponse.md)**
### Errors
| Error Type | Status Code | Content Type |
| ---------------------- | ---------------------- | ---------------------- |
| models/errors/SDKError | 4XX, 5XX | \*/\* |
## getArts
Get artwork for a library section
### Example Usage
<!-- UsageSnippet language="java" operationID="getArts" method="get" path="/library/sections/{sectionId}/arts" -->
```java
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.GetArtsRequest;
import dev.plexapi.sdk.models.operations.GetArtsResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
public class Application {
public static void main(String[] args) throws Exception {
PlexAPI sdk = PlexAPI.builder()
.accepts(Accepts.APPLICATION_XML)
.clientIdentifier("abc123")
.product("Plex for Roku")
.version("2.4.1")
.platform("Roku")
.platformVersion("4.3 build 1057")
.device("Roku 3")
.model("4200X")
.deviceVendor("Roku")
.deviceName("Living Room TV")
.marketplace("googlePlay")
.token(System.getenv().getOrDefault("TOKEN", ""))
.build();
GetArtsRequest req = GetArtsRequest.builder()
.sectionId(859200L)
.build();
GetArtsResponse res = sdk.content().getArts()
.request(req)
.call();
if (res.mediaContainerWithArtwork().isPresent()) {
// handle response
}
}
}
```
### Parameters
| Parameter | Type | Required | Description |
| ----------------------------------------------------------- | ----------------------------------------------------------- | ----------------------------------------------------------- | ----------------------------------------------------------- |
| `request` | [GetArtsRequest](../../models/operations/GetArtsRequest.md) | :heavy_check_mark: | The request object to use for the request. |
### Response
**[GetArtsResponse](../../models/operations/GetArtsResponse.md)**
### Errors
| Error Type | Status Code | Content Type |
| ---------------------- | ---------------------- | ---------------------- |
| models/errors/SDKError | 4XX, 5XX | \*/\* |
## getCategories
Get categories in a library section
### Example Usage
<!-- UsageSnippet language="java" operationID="getCategories" method="get" path="/library/sections/{sectionId}/categories" -->
```java
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.GetCategoriesRequest;
import dev.plexapi.sdk.models.operations.GetCategoriesResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
public class Application {
public static void main(String[] args) throws Exception {
PlexAPI sdk = PlexAPI.builder()
.accepts(Accepts.APPLICATION_XML)
.clientIdentifier("abc123")
.product("Plex for Roku")
.version("2.4.1")
.platform("Roku")
.platformVersion("4.3 build 1057")
.device("Roku 3")
.model("4200X")
.deviceVendor("Roku")
.deviceName("Living Room TV")
.marketplace("googlePlay")
.token(System.getenv().getOrDefault("TOKEN", ""))
.build();
GetCategoriesRequest req = GetCategoriesRequest.builder()
.sectionId(21841L)
.build();
GetCategoriesResponse res = sdk.content().getCategories()
.request(req)
.call();
if (res.mediaContainerWithArtwork().isPresent()) {
// handle response
}
}
}
```
### Parameters
| Parameter | Type | Required | Description |
| ----------------------------------------------------------------------- | ----------------------------------------------------------------------- | ----------------------------------------------------------------------- | ----------------------------------------------------------------------- |
| `request` | [GetCategoriesRequest](../../models/operations/GetCategoriesRequest.md) | :heavy_check_mark: | The request object to use for the request. |
### Response
**[GetCategoriesResponse](../../models/operations/GetCategoriesResponse.md)**
### Errors
| Error Type | Status Code | Content Type |
| ---------------------- | ---------------------- | ---------------------- |
| models/errors/SDKError | 4XX, 5XX | \*/\* |
## getCluster
Get clusters in a library section (typically for photos)
### Example Usage
<!-- UsageSnippet language="java" operationID="getCluster" method="get" path="/library/sections/{sectionId}/cluster" -->
```java
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.GetClusterRequest;
import dev.plexapi.sdk.models.operations.GetClusterResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
public class Application {
public static void main(String[] args) throws Exception {
PlexAPI sdk = PlexAPI.builder()
.accepts(Accepts.APPLICATION_XML)
.clientIdentifier("abc123")
.product("Plex for Roku")
.version("2.4.1")
.platform("Roku")
.platformVersion("4.3 build 1057")
.device("Roku 3")
.model("4200X")
.deviceVendor("Roku")
.deviceName("Living Room TV")
.marketplace("googlePlay")
.token(System.getenv().getOrDefault("TOKEN", ""))
.build();
GetClusterRequest req = GetClusterRequest.builder()
.sectionId(138560L)
.build();
GetClusterResponse res = sdk.content().getCluster()
.request(req)
.call();
if (res.mediaContainerWithArtwork().isPresent()) {
// handle response
}
}
}
```
### Parameters
| Parameter | Type | Required | Description |
| ----------------------------------------------------------------- | ----------------------------------------------------------------- | ----------------------------------------------------------------- | ----------------------------------------------------------------- |
| `request` | [GetClusterRequest](../../models/operations/GetClusterRequest.md) | :heavy_check_mark: | The request object to use for the request. |
### Response
**[GetClusterResponse](../../models/operations/GetClusterResponse.md)**
### Errors
| Error Type | Status Code | Content Type |
| ---------------------- | ---------------------- | ---------------------- |
| models/errors/SDKError | 4XX, 5XX | \*/\* |
## getSonicPath
Get a list of audio tracks starting at one and ending at another which are similar across the path
### Example Usage
<!-- UsageSnippet language="java" operationID="getSonicPath" method="get" path="/library/sections/{sectionId}/computePath" -->
```java
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.GetSonicPathRequest;
import dev.plexapi.sdk.models.operations.GetSonicPathResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
public class Application {
public static void main(String[] args) throws Exception {
PlexAPI sdk = PlexAPI.builder()
.accepts(Accepts.APPLICATION_XML)
.clientIdentifier("abc123")
.product("Plex for Roku")
.version("2.4.1")
.platform("Roku")
.platformVersion("4.3 build 1057")
.device("Roku 3")
.model("4200X")
.deviceVendor("Roku")
.deviceName("Living Room TV")
.marketplace("googlePlay")
.token(System.getenv().getOrDefault("TOKEN", ""))
.build();
GetSonicPathRequest req = GetSonicPathRequest.builder()
.sectionId(914549L)
.startID(629990L)
.endID(687740L)
.build();
GetSonicPathResponse res = sdk.content().getSonicPath()
.request(req)
.call();
if (res.mediaContainerWithMetadata().isPresent()) {
// handle response
}
}
}
```
### Parameters
| Parameter | Type | Required | Description |
| --------------------------------------------------------------------- | --------------------------------------------------------------------- | --------------------------------------------------------------------- | --------------------------------------------------------------------- |
| `request` | [GetSonicPathRequest](../../models/operations/GetSonicPathRequest.md) | :heavy_check_mark: | The request object to use for the request. |
### Response
**[GetSonicPathResponse](../../models/operations/GetSonicPathResponse.md)**
### Errors
| Error Type | Status Code | Content Type |
| ---------------------- | ---------------------- | ---------------------- |
| models/errors/SDKError | 4XX, 5XX | \*/\* |
## getFolders
Get all folder locations of the media in a section
### Example Usage
<!-- UsageSnippet language="java" operationID="getFolders" method="get" path="/library/sections/{sectionId}/location" -->
```java
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.GetFoldersRequest;
import dev.plexapi.sdk.models.operations.GetFoldersResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
public class Application {
public static void main(String[] args) throws Exception {
PlexAPI sdk = PlexAPI.builder()
.accepts(Accepts.APPLICATION_XML)
.clientIdentifier("abc123")
.product("Plex for Roku")
.version("2.4.1")
.platform("Roku")
.platformVersion("4.3 build 1057")
.device("Roku 3")
.model("4200X")
.deviceVendor("Roku")
.deviceName("Living Room TV")
.marketplace("googlePlay")
.token(System.getenv().getOrDefault("TOKEN", ""))
.build();
GetFoldersRequest req = GetFoldersRequest.builder()
.sectionId(892532L)
.build();
GetFoldersResponse res = sdk.content().getFolders()
.request(req)
.call();
if (res.object().isPresent()) {
// handle response
}
}
}
```
### Parameters
| Parameter | Type | Required | Description |
| ----------------------------------------------------------------- | ----------------------------------------------------------------- | ----------------------------------------------------------------- | ----------------------------------------------------------------- |
| `request` | [GetFoldersRequest](../../models/operations/GetFoldersRequest.md) | :heavy_check_mark: | The request object to use for the request. |
### Response
**[GetFoldersResponse](../../models/operations/GetFoldersResponse.md)**
### Errors
| Error Type | Status Code | Content Type |
| ---------------------- | ---------------------- | ---------------------- |
| models/errors/SDKError | 4XX, 5XX | \*/\* |
## listMoments
Get moments in a library section (typically for photos)
### Example Usage
<!-- UsageSnippet language="java" operationID="listMoments" method="get" path="/library/sections/{sectionId}/moment" -->
```java
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.ListMomentsRequest;
import dev.plexapi.sdk.models.operations.ListMomentsResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
public class Application {
public static void main(String[] args) throws Exception {
PlexAPI sdk = PlexAPI.builder()
.accepts(Accepts.APPLICATION_XML)
.clientIdentifier("abc123")
.product("Plex for Roku")
.version("2.4.1")
.platform("Roku")
.platformVersion("4.3 build 1057")
.device("Roku 3")
.model("4200X")
.deviceVendor("Roku")
.deviceName("Living Room TV")
.marketplace("googlePlay")
.token(System.getenv().getOrDefault("TOKEN", ""))
.build();
ListMomentsRequest req = ListMomentsRequest.builder()
.sectionId(403239L)
.build();
ListMomentsResponse res = sdk.content().listMoments()
.request(req)
.call();
if (res.mediaContainerWithArtwork().isPresent()) {
// handle response
}
}
}
```
### Parameters
| Parameter | Type | Required | Description |
| ------------------------------------------------------------------- | ------------------------------------------------------------------- | ------------------------------------------------------------------- | ------------------------------------------------------------------- |
| `request` | [ListMomentsRequest](../../models/operations/ListMomentsRequest.md) | :heavy_check_mark: | The request object to use for the request. |
### Response
**[ListMomentsResponse](../../models/operations/ListMomentsResponse.md)**
### Errors
| Error Type | Status Code | Content Type |
| ---------------------- | ---------------------- | ---------------------- |
| models/errors/SDKError | 4XX, 5XX | \*/\* |
## getSonicallySimilar
Get the nearest audio tracks to a particular analysis
### Example Usage
<!-- UsageSnippet language="java" operationID="getSonicallySimilar" method="get" path="/library/sections/{sectionId}/nearest" -->
```java
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.GetSonicallySimilarRequest;
import dev.plexapi.sdk.models.operations.GetSonicallySimilarResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
import java.util.List;
public class Application {
public static void main(String[] args) throws Exception {
PlexAPI sdk = PlexAPI.builder()
.accepts(Accepts.APPLICATION_XML)
.clientIdentifier("abc123")
.product("Plex for Roku")
.version("2.4.1")
.platform("Roku")
.platformVersion("4.3 build 1057")
.device("Roku 3")
.model("4200X")
.deviceVendor("Roku")
.deviceName("Living Room TV")
.marketplace("googlePlay")
.token(System.getenv().getOrDefault("TOKEN", ""))
.build();
GetSonicallySimilarRequest req = GetSonicallySimilarRequest.builder()
.sectionId(525956L)
.values(List.of())
.build();
GetSonicallySimilarResponse res = sdk.content().getSonicallySimilar()
.request(req)
.call();
if (res.mediaContainerWithMetadata().isPresent()) {
// handle response
}
}
}
```
### Parameters
| Parameter | Type | Required | Description |
| ----------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------- |
| `request` | [GetSonicallySimilarRequest](../../models/operations/GetSonicallySimilarRequest.md) | :heavy_check_mark: | The request object to use for the request. |
### Response
**[GetSonicallySimilarResponse](../../models/operations/GetSonicallySimilarResponse.md)**
### Errors
| Error Type | Status Code | Content Type |
| ---------------------- | ---------------------- | ---------------------- |
| models/errors/SDKError | 4XX, 5XX | \*/\* |
## getCollectionImage
Get an image for the collection based on the items within
### Example Usage
<!-- UsageSnippet language="java" operationID="getCollectionImage" method="get" path="/library/collections/{collectionId}/composite/{updatedAt}" -->
```java
package hello.world;
import dev.plexapi.sdk.PlexAPI;
import dev.plexapi.sdk.models.operations.GetCollectionImageRequest;
import dev.plexapi.sdk.models.operations.GetCollectionImageResponse;
import dev.plexapi.sdk.models.shared.Accepts;
import java.lang.Exception;
public class Application {
public static void main(String[] args) throws Exception {
PlexAPI sdk = PlexAPI.builder()
.accepts(Accepts.APPLICATION_XML)
.clientIdentifier("abc123")
.product("Plex for Roku")
.version("2.4.1")
.platform("Roku")
.platformVersion("4.3 build 1057")
.device("Roku 3")
.model("4200X")
.deviceVendor("Roku")
.deviceName("Living Room TV")
.marketplace("googlePlay")
.token(System.getenv().getOrDefault("TOKEN", ""))
.build();
GetCollectionImageRequest req = GetCollectionImageRequest.builder()
.collectionId(474227L)
.updatedAt(759379L)
.build();
GetCollectionImageResponse res = sdk.content().getCollectionImage()
.request(req)
.call();
if (res.responseStream().isPresent()) {
// handle response
}
}
}
```
### Parameters
| Parameter | Type | Required | Description |
| --------------------------------------------------------------------------------- | --------------------------------------------------------------------------------- | --------------------------------------------------------------------------------- | --------------------------------------------------------------------------------- |
| `request` | [GetCollectionImageRequest](../../models/operations/GetCollectionImageRequest.md) | :heavy_check_mark: | The request object to use for the request. |
### Response
**[GetCollectionImageResponse](../../models/operations/GetCollectionImageResponse.md)**
### Errors
| Error Type | Status Code | Content Type |
| ---------------------- | ---------------------- | ---------------------- |
| models/errors/SDKError | 4XX, 5XX | \*/\* |
Reference in New Issue View Git Blame Copy Permalink